All notable changes to this project will be documented in this file.
The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
-
Unified external aero recipe: adds AB-UPT surface, volume, and joint configurations calling the library model directly, configurable independent point-set sampling in
DomainMeshReader, and grouped tensor outputs for unequal surface/volume point counts. -
The unified external aerodynamics recipe adds experimental SMART surface and volume templates.
-
The unified external aerodynamics recipe adds experimental ISLA configs on DrivAerML (
isla_surface,isla_volumeandisla_volume_joint) and aschedulerconfig group. Each ISLA config reads the whole flow-domain boundary and fits one 80 GB GPU at its defaults. -
Adds the
FlipBoundaryOrientationandBoundaryCellsToPointsmesh transforms tophysicsnemo.datapipes. The first reverses the cell winding and stored normals of named boundaries, and the second adds a point-cloud boundary at drawn cells of another boundary, with those cells' fields and measures. -
Adds
physicsnemo.experimental.models.ab_upt.ABUPT, an independent implementation with interacting surface/volume anchors, reusable query contexts, input scaling and chunked forward decoding, and a finite-difference vorticity helper that undoes coordinate and velocity scaling. -
physicsnemo.mesh.sampling.sample_cells_systematicdraws a fixed number of a mesh's cells with probability proportional to their measure, with Horvitz-Thompson weights for unbiased sums. The sample is spread over the mesh, the same in every pose, bitwise the same from run to run on CPU and on CUDA, and compiles to one graph. -
KNNScorerandDensityScorerprovide reusable out-of-distribution (OOD) scoring underexperimental.uq.ood, with optional geometry descriptors. The examples keep scoring decisions in the application. Both scorers support weights-only tensor persistence. The k-nearest neighbors (kNN) scorer uses bounded distance blocks and leave-one-out reference scoring. The density scorer supports held-out calibration. -
MeanandVariancenow support opt-in tensor-aware streaming with detached state, state combination, andShardTensorreductions over declared observation axes. Existing metric constructors retain their behavior. PublicTensorAccumulatorandStatisticRulesupport custom statistics throughsummarize,merge, andresulthooks, with built-inMeanRuleandVarianceRule.SumReductiondefines the type of the completed-reduction callback, including itskeepdimargument. Fresh summaries transfer ownership to the accumulator. Variance merging reuses scratch storage while preserving both input states and rollback after failed updates. The examples cover weighted means, Gaussian process (GP) mixtures, Concrete Dropout, observables, and conformal calibration. -
Groups experimental scalar and field GP heads under
experimental.uq.gp. Both this namespace andexperimental.uqexpose the heads withoutgpytorch; constructing a head raises an installation error if it is missing. -
Adds
GeoTransolver.forward_with_geometry_featuresfor predictions and detached geometry tokens in one pass, preserving the existingforwardAPI. -
Strata depthwise conditioning convolutions automatically size vmap chunks to the 32-bit indexing limit via
DepthwiseConv(chunk_size="auto"). -
MeshDataset(cache_host=True)reads each sample once and serves repeats from memory, for fitting runs on a few samples.DomainMeshReadergainsinterior_n_points_rangeto draw the interior point count for each sample, andCenterMeshgainsstore_center_asto keep the subtracted center inglobal_data. -
Adds a Rotor37 compressor blade example with GeoTransolver (
examples/cfd/rotor37_geotransolver) -
Adds an experimental, independently implemented SMART operator with sampled geometry encoding, reusable latent contexts, and chunked field decoding.
-
Adds
physicsnemo.experimental.uq.conformal: post-hoc conformal prediction for spatio-temporal fields withPointwiseCalibrator,FunctionalBandCalibrator,RiskControlCalibrator,ConformalPredictor,CoverageAccumulator,AbsoluteErrorScore,NormalizedErrorScore,QuantileRegressionScore, andAuxScale. Custom scores subclassNonconformityScoreand register withregister_score;check_scoretests them. -
Adds
physicsnemo.experimental.nn.shell_contact: shell contact as pure functions over tensors (node-to-facet pair search with a Warp BVH broad phase and fused Warp narrow phase, crossing-aware signed gaps, edge features and tapers, penetration depths and rigid-wall clamp), andphysicsnemo.experimental.nn.geodesic_knn(k-nearest neighbourhoods of a mesh along its edges; Euclidean ones usephysicsnemo.nn.functional.knn). -
Adds
physicsnemo.experimental.models.deformer: the DeFormer network (a GeoTransolver/FLARE backbone with static kNN-attention stages and a fused kernel) and its contact-aware corrector (message passing on the structural edges and on the contact edges discovered on a predicted shape). -
Adds the DeFormer crash surrogate to
examples/structural_mechanics/crash: the time-conditional network and corrector wrappers, the three full-vehicle Yaris recipes (px_yaris_deformer,px_yaris_deformer_corrector,px_yaris_geotransolver), the body-in-white recipebiw_yaris_deformerand target-relative penetration metrics. -
Adds standalone FLARE++ attention and model APIs, with input-conditioned dynamic routing, plus a
GALE_FPPbackend for using the same mixer inside GeoTransolver. -
Adds
physicsnemo.datapipes.keysand routes every config-driven field name inphysicsnemo.datapipesthrough it, so a"."in a YAML field name ("solution.pressure") addresses a leaf inside a nestedTensorDict. NestedMeshdata no longer needs to be flattened before use. -
DistributedManager.initialize(timeout=...)accepts numeric seconds or atimedeltafor the default process-group timeout. Explicit values overridePHYSICSNEMO_DIST_TIMEOUT_S; unset or empty configuration keeps PyTorch's backend default. Invalid timeouts are rejected before initialization state changes, allowing corrected configuration to be retried. -
MeshToDomainMeshincell_centroidsmode records each source cell's complete effective measure on the interior under the mesh-owned_effective_measurepoint-data key, so integrals and weighted losses over the query points remain possible after the cells are gone. -
Unified external aero recipe: a sample can carry several prediction point sets with their own targets (
target_sources), so branch models (output_groups) and single-decoder models (output_sets) can train on volume and surface points jointly; model configs can add such a set to any dataset withextra_task. -
Unified external aero recipe:
NonDimensionalizeByMetadatagainsscale_geometryso chained instances scale the geometry once; inference re-dimensionalizes with the field maps of every instance. -
Extends the diffusion module to support flow matching. The new API surface covers three pieces:
- New losses in
physicsnemo.diffusion.metrics.lossestrain against a flow/velocity target:FlowMatchingLoss, plusWeightedFlowMatchingLossfor an element-wise weight such as a binary mask. TheirMultiDiffusionFlowMatchingLossandMultiDiffusionWeightedFlowMatchingLosscounterparts provide patch-based flow-matching training on large spatial domains.MultiDiffusionModel2DandMultiDiffusionPredictorsupport both patch-based diffusion and flow matching during training and inference. - A dedicated
RectifiedFlowNoiseSchedulerinphysicsnemo.diffusion.noise_schedulersprovides a rectified-flow schedule. - Module-wide support for flow predictors, enabled by new conversion
functions in
LinearGaussianNoiseScheduler(x0_to_flow/flow_to_x0/score_to_flow/flow_to_score) and the corresponding conversion callbacks everywhere conversions between prediction types are necessary.
- New losses in
-
Adds
physicsnemo.experimental.models.isla.ISLA(Invariant Slice Attention), an experimental mesh-native surrogate for steady boundary-value problems that takes the boundary as named meshes, andcase_scales, which gives other models ISLA's length and field scales. ISLA's outputs follow rotations, reflections and translations of the problem exactly, up to roundoff, except on some symmetric or nearly symmetric boundaries described on its documentation page. -
physicsnemo.mesh.spatialexportscanonical_frame, the principal-axis frame that a weighted point set carries with it, andframe_coordinates, the points' coordinates in that frame. -
ClusterTree.find_point_interaction_pairstakes targets of shape(R, M, D)withroot_rows, the row each root's tree reads, so one call walks a forest whose trees each use their own coordinates. -
Adds
ExponentialEulerSolver,EDMStochasticExponentialEulerSolver,DPMPlusPlus2M, andDPMPlusPlus2MUniC2tophysicsnemo.diffusion.samplers.ExponentialEulerSolversupports DDIM-like sampling for distilled few-step models, its stochastic counterpart adds EDM-style churn and configurable re-noising,DPMPlusPlus2Mprovides efficient second-order sampling, andDPMPlusPlus2MUniC2adds a UniC-2 corrector stage that raises DPM-Solver++(2M) to third order while keeping one denoiser evaluation per step. The solvers share an extended semi-linear callback API (bias_fn,bias_int_fn,slope_fn); users can select all four solvers by string key throughphysicsnemo.diffusion.samplers.sample. -
The
examples/weather/regional_weather_diffusionrecipe can train diffusion models with rectified flow matching (training.loss.type: flow_matching) and sample them in validation andinference.py. Adds thereplication_corrdiff_conusconfig and dataset for replicating the CorrDiff-ERA5-HRRR downscaling model over the contiguous US. -
ClusterTree.find_dual_interaction_pairs(source_admissible=...)marks source nodes that must never be approximated by their aggregate, such as nodes whose normals differ too much. -
ClusterTree.find_point_interaction_pairsbuilds a Barnes-Hut plan for individual target points by a single-tree walk (every point reads nearby sources exactly and distant nodes through their aggregates). For scattered targets such as volume prediction points it replacesfind_dual_interaction_pairs(expand_far_targets=True), whose criterion charges the target leaf's own extent: on a 200k-face car with 200k volume points the dual plan held 1.6e9 pairs attheta=0.5and the point plan holds 1.5e8. -
The PhysicsNeMo-Mesh API reference documents
physicsnemo.mesh.fields(RankSpecandFieldSchema) and thephysicsnemo.mesh.primitivescatalog. -
ClusterTree.mergejoins trees into one forest, whoseroot_idslist the root of each tree. Every traversal starts from all of them, so one traversal plans a tree against every tree of a forest, on either side. -
ClusterTree.from_points, the newClusterTree.from_point_groups(one tree per group of points, and their forest) andClusterTree.find_point_interaction_pairsrun in Warp kernels on CUDA by default (implementation=), with one host synchronization instead of one per tree level, and give the same trees and plans. The point plans now list each target's entries together, andcount_only=Truecounts them without making the plan. -
radius_searchaccepts points with 1 or 2 coordinates, as well as 3, with both backends. The torch backend accepts any number of coordinates, and points with more than 3 use it by default. -
ShardTensorring attention, ring kNN and ring ball query run on functional collectives; ring attention works undertorch.compileas an eager graph-break region, with uneven sequence shards and attention masks sharded like the queries. In-placedetach_on aShardTensoris supported. -
radius_searchon sharded inputs works undertorch.compile. -
Domain-parallel (rank-local) reading in the datapipes:
ZarrReader,TensorStoreZarrReader,MeshReaderandDomainMeshReaderaccept adomain_paralleldict and a 1-Ddevice_mesh; each rank reads only its rows and the dataset assemblesShard(0)ShardTensors on the device. Custom readers opt in by implementingReader._load_sample_domain_parallelwith the exportedDomainParallelConfig/resolve_leaf_placements. -
The unified external aero recipe trains with optional domain parallelism (
domain_parallelism.domain_size), reading samples sharded and running the model on ShardTensors over a domain x data-parallel device mesh. -
physicsnemo.mesh.repairaddsstitch_t_junctions, which closes the zero-width gaps where a vertex lies on another triangle's edge, andsplit_nonmanifold_edges, which pairs the triangles at each edge shared by three or more of them and drops the unpaired fins and the pillows (coincident triangles wound opposite ways). -
physicsnemo.mesh.validationaddsfind_self_intersections, which finds the pairs of crossing triangles in a 3D surface.validateruns it whencheck_self_intersection=Trueand skips meshes it does not apply to.
-
repair_meshalso removes duplicate cells and stitches T-junctions of triangle meshes by default, andsplit_nonmanifold_edges=Truealso drops fins. Its default tolerances are now relative to the mesh's size, and an explicittolerancealso sets the stitching distance, witharea_tolerancethen defaulting to its square on surfaces. -
Renames the body-in-white crash recipes
crash_geoflare_oneshotandcrash_geotransolver_oneshotofexamples/structural_mechanics/crashtobiw_yaris_geoflare_oneshotandbiw_yaris_geotransolver_oneshot: every recipe of the example now names its dataset (px_yaris_*full vehicle,biw_yaris_*body-in-white,bumper_*bumper beam). -
⚠️ BC-impact (crash example global features): the datapipe ofexamples/structural_mechanics/crashstandardizes the global features with train-split statistics stored instats/global_stats.json, which changes the inputs of the three bumper recipes. A run directory written before this change holds checkpoints but no such file:train.pyrefuses to resume it instead of recomputing the statistics and continuing on rescaled inputs, andinference.pyneeds the file. Start such runs afresh. -
⚠️ BC-impact (crash example edge statistics): the graph datapipe of the crash example divides the first sample's contribution to the edge statistics by the sample count like every other sample's, which fixes an edge-length standard deviation that collapsed to about 1e-4. Existing runs keep the values stored in their ownstatsdirectory; new runs compute the corrected ones, so their models are not interchangeable with the old runs'. -
⚠️ BC-impact (crash example frame names):inference.pyof the crash example writes the predicted frames asframe_001toframe_T(predictionkbelongs to framek + 1) instead of starting atframe_000;post_processing/compute_l2_error.pyreads the new names. -
⚠️ BC-impact (diffusion metric imports): Cleans upphysicsnemo.diffusiondependencies and imports. General-purpose metrics can no longer be imported fromphysicsnemo.diffusion.metrics. Use the following modules instead:rank_probability_score:physicsnemo.metrics.general.calibrationcrps,kcrps:physicsnemo.metrics.general.crpsStreamingStatistic,Mean,Variance:physicsnemo.metrics.general.ensemble_metricsentropy_from_counts,relative_entropy_from_counts:physicsnemo.metrics.general.entropyHistogram,cdf,histogram,normal_cdf,normal_pdf:physicsnemo.metrics.general.histogrampower_spectrum:physicsnemo.metrics.general.power_spectrumwasserstein_from_cdf,wasserstein_from_samples:physicsnemo.metrics.general.wasserstein
For example, use
from physicsnemo.metrics.general.crps import crps. ReplaceEnsembleMetricsimports withfrom physicsnemo.metrics.general.ensemble_metrics import StreamingStatistic. Removed imports emit a warning and an error with the replacement import.wasserstein_from_normalremains available through both existing import paths. -
Partitioning a graph across GPUs (
partition_graph_with_id_mapping, behindDistributedGraphand GraphCast's distributed mode) no longer loops over destination nodes in Python. A 1-million-node grid now takes well under a second instead of half a minute or more. -
ClusterTreebuilds tighter trees by default (split="morton"), so Barnes-Hut plans need 2-4x fewer interactions at the sametheta.split="midpoint"gives the previous trees. -
GLOBE's default
thetais 1.5 (was 1.0). With the new trees, DrivAerML training reaches about 40% lower validation loss in the same time. -
GLOBE's default
expand_far_targetsisTrue(wasFalse), as in its examples. -
ClusterTree.compute_source_aggregatesis 20-30x faster, andClusterTree.find_dual_interaction_pairsis up to 1.7x faster with 40% less peak memory. The plan's interactions are no longer sorted by source. -
GLOBE's
BarnesHutKernelneeds less memory to train: an 80k-face DrivAerML training step no longer runs out of memory. -
An eager GLOBE training step on 10k-face DrivAerML samples runs 2.2x faster, and
torch.compilebuilds GLOBE faster, with the same outputs. -
GLOBE's
BarnesHutKernel.forwardtakesnear_chunk_count, a number of chunks, in place ofnear_chunk_size, and no longer takessource_aggregates. -
The
source_dataandglobal_dataof GLOBE's kernel classes must hold exactly the declared fields, under nested keys: a flat key such as"grp.v"now raises aKeyErrorthat names the wrong fields. -
GLOBE returns nested output fields in sorted key order, such as
("flow", "nut")before("flow", "u"). -
The GLOBE DrivAerML example now trains for 450 epochs on one node, with the model and training configuration of the GLOBE paper's DrivAerML results.
--n-epochsand--lr-decay-epochsreplace--patience-steps, and checkpoints from earlier versions of the example do not resume. -
ClusterTree.compute_source_aggregatespacks its source data withTensorDict.pack, so source data with leaves of several dtypes now raises aTypeErrorinstead of being promoted. -
Refresh core, optional, development, and container dependency versions. Require PyTorch 2.13 or newer; use PyTorch 2.13's CUDA 12.9 wheels for the CUDA 12 backend. NATTEN extras select PyTorch 2.13 to match their prebuilt kernels. Python support remains 3.11 through 3.14.
-
Mesh connectivity sorts the vertices of its short index tuples (edges, faces, cells) with a sorting network of elementwise minima and maxima on large CUDA inputs, instead of
torch.sort. On an NVIDIA GB300, facet and boundary extraction, edge graphs, point adjacency, and manifold checks of 10M-cell meshes are 3-5x faster, butterfly subdivision 2.3x, and cell adjacency, cleaning, and the DEC Laplacian 1.2-2.1x. Results are unchanged. -
physicsnemo.mesh.fieldsis rebuilt around two types.RankSpec(rank,symmetric,parity;shape(n_spatial_dims),numel(n_spatial_dims)) is one field's transformation law;FieldSchemais an insertion-ordered mapping from dotted field names toRankSpec, parsed once at a model's boundary withFieldSchema.parse(nested groups and dotted names flatten alike) and queried with.ranks,.count(rank),FieldSchema.key(name), and.check(tensordict, label=...). Both are read-onlydicts, so a declaration serializes to JSON as written and model checkpoints can record them directly. Validation is construction, so an invalid schema cannot exist. A field is declared as aRankSpecor a mapping of values,{"rank": n}(YAML:pressure: {rank: 0}); a mapping of mappings is a nested group. Integer leaves are no longer accepted. -
Mesh geometry, curvature, sampling, mesh generation, LSQ gradients, and the PyTorch backends of the deformation functionals solve their small per-cell determinants, inverses, and least-squares problems in closed form instead of with batched
torch.linalgcalls. Vertex angles, Gaussian curvature, and quality metrics become up to 1,000x faster on GPU, and many mesh operations 4-130x faster on CPU. -
Mesh vertex angles, dual volumes, curvature, quality metrics, and cell and point normals use up to 3.4x less peak memory, and gradients through cell centroids and normals are faster on GPU. Results are unchanged up to rounding.
-
Mesh LSQ gradients (
Mesh.gradient,curl,divergence,compute_point_derivatives,compute_cell_derivatives, and the torch backend ofphysicsnemo.nn.functional.mesh_lsq_gradient) solve the float32 systems of all points or cells at once rather than one neighbor count at a time, and the derivatives of several fields share their least-squares systems. On a GB200, the gradient of a 5.1M-tet mesh is 2.4x faster and that of meshes up to 1.3M tets 3.4-3.7x faster; the derivatives of eight scalar fields on a 1M-tet mesh are 13x faster. Results are unchanged up to rounding. The intrinsic gradient of a float64 field on a float32 mesh now returns a result of float32 accuracy instead of raising a dtype error. -
GLOBE's field declarations are renamed after the schemas they hold:
output_field_ranks,boundary_source_data_ranksandglobal_data_ranksbecomeoutput_schema,boundary_source_schemasandglobal_schema(kernels:output_schema,source_schema,global_schema), each also the attribute holding the parsedFieldSchema. GLOBE raisesNotImplementedErrorfor fields it does not implement (rank 2 and above, pseudotensors) instead of silently dropping or misreading them. The GLOBE examples and the unified external-aerodynamics recipe configs are updated. -
Cell-to-cell adjacency pairs the cells of each shared facet in one vectorized pass, adjacency offsets come from a binary search instead of
bincount, and adjacencies carry their device, so cached adjacencies are reused without revalidation. Cell adjacency and the dual graph are 1.4-1.6x faster with 30% less peak memory, and synchronize CUDA 5 times instead of 38. -
Mesh adjacencies, facet extraction, manifold checks, and
fix_orientationuse up to 3x less peak memory, with unchanged results. -
physicsnemo.mesh.Mesh,DomainMesh,Adjacency,BVH,ClusterTree,DualInteractionPlan, andSourceAggregatesnow inherit directly fromTensorClassinstead of using the@tensorclassdecorator. Existing constructor defaults andMesh[m, s]runtime specialization remain available, and nested mesh types survive memmap round trips. The memmap layout is unchanged: existing.pmshand.pdmshfiles remain readable, and new files are byte-identical to those written with the decorator. -
from_pyvista(point_source="cell_centroids", manifold_dim=1)builds the dual graph of line, triangle, and tetrahedral meshes 25-30x faster, with identical output. With the defaultforce_copy=False,to_pyvistaoutput of 1D and 3D meshes now shares cell storage with theMesh, as 2D output already did. -
Mesh facet extraction, repair, merging, smoothing, subdivision, and quality metrics avoid CUDA synchronizations hidden in indexing with Python lists, blocking copies of small host tables, boolean masks, and one
.item()per count. Laplacian smoothing synchronizes at most 4 times instead of about 30, independent of the number of iterations, andremove_degenerate_cellsis about 5x faster. Results are unchanged. -
Loop and butterfly subdivision evaluate their edge rules for every edge and select with
torch.where, instead of compacting boundary and interior edges with boolean masks. Butterfly subdivision synchronizes CUDA 3 times instead of 13, Loop subdivision 9 instead of 13, and both are 10-15% faster. -
Mesh subdivision,
cell_data_to_point_data,point_data_to_cell_data, andMesh.mergeneed up to 2.9x less peak memory, with unchanged results. -
Mesh integration uses a shared
_effective_measurefield for complete cell and point measures. Cell measures fall back to geometry; point measures are explicit and independent of connectivity.Mesh.integrate_samplesevaluates point quadrature separately from existing cell and vertex-field integration. Sampling, centroid conversion, geometric transformations, subdivision, and GLOBE use the mesh-owned measure API. Point measures carry their represented dimension so geometric scaling preserves their physical units. -
Promotes the volumetric
DiffusionUNet3Dand its reusableConv3D,GroupNorm3D,UNetAttention3D, andUNetBlock3Dlayers from experimental to stable production APIs inphysicsnemo.models.diffusion_unetsandphysicsnemo.nn. The promoted APIs now carry backward-compatibility guarantees and output/checkpoint non-regression coverage. Existing experimental import paths remain as deprecated compatibility shims.Migration from 2.2.x: meshes saved with
cell_data["_measure_weights"]must be regenerated or converted once before integration:from physicsnemo.mesh.calculus import set_cell_measures if "_measure_weights" in mesh.cell_data: weights = mesh.cell_data.pop("_measure_weights") set_cell_measures(mesh, mesh.cell_areas * weights)
Replace
compose_measure_weightscalls withscale_measures. Consumers should read complete measures withcell_measuresinstead of multiplyingcell_areasbycell_measure_weights. Update stored-field mappings fromcell_data._measure_weightstocell_data._effective_measureand remove any subsequent multiplication by geometric areas. -
LSQ point gradients on large surface meshes are about 2x faster on GPU, and LSQ gradients (
Meshandphysicsnemo.nn.functional.mesh_lsq_gradient) synchronize the GPU much less often. LSQ and DEC derivatives also need less peak memory. -
Mesh.slice_pointspicks its cell-remapping algorithm by mesh shape: the full-mesh lookup table as before, or a binary search over the kept ids when the mesh has far more points than cell-vertex entries (a reader keeping a block of cells out of a mesh with hundreds of millions of vertices). Index normalization avoids allocating a full-mesh range and preserves empty slices, integer indices, and boolean masks. Point fields use ordinary indexed gathers. -
Darcy2Dsolves with multi-grid red-black successive over-relaxation instead of Jacobi iteration, converging in far fewer iterations and about 100x closer to the discrete solution at the default tolerance. Batches whose SOR solve diverges are re-solved with Gauss-Seidel.Darcy2Dnow raises aValueErrorunless0 < min_permeability <= max_permeabilityandmax_permeability / min_permeability <= 4; above that ratio the finite-difference scheme does not converge. -
Extends
LinearGaussianNoiseSchedulerwith two methods.get_linear_denoiseracceptsprediction_typeanddenoising_type, and returns bias, antiderivative, and slope callables for the new exponential and multistep solvers.snrexposes the schedule's signal-to-noise ratio, used as the multistep extrapolation coordinate byDPMPlusPlus2MandDPMPlusPlus2MUniC2. -
translate,rotate,scale, and theirDomainMeshand datapipe counterparts no longer synchronize CUDA for Python-number arguments, string axes, rotations, and scalar scales, so they return without waiting for queued GPU work.transformgainsassume_similarityandrotategainsassume_valid_axis, to skip the remaining runtime checks for general matrices and device-tensor axes. Cached normals are mapped with one small inverse instead ofsolve_exwith millions of right-hand sides, whose slow path for pivoting matrices madeRandomRotateMesh(mode="uniform")take 1.3 s on the 17.7M-triangle DrivAerML surface (6.5 ms now, on a GB300). -
The
toleranceofsample_data_at_points,find_containing_cells, andfind_all_containing_cellsis now relative. Barycentric coordinates must still be>= -tolerance, but the distance from a point to a cell's affine hull is now limited totolerancetimes the largest absolute coordinate of the mesh, instead oftolerancein mesh units. Results no longer depend on the mesh's length unit and are identical when the mesh and query points are scaled by a power of two. -
Mesh BVH queries, and with them
validate,Mesh.clean(), point containment and sampling, use up to 2.7x less peak memory. Results are unchanged. -
fix_orientationorients cells of any dimension and is 6x faster on the DrivAerML surface. Cells that fill their space, such as tetrahedra in 3D, come out with positive volumes. Its stats addn_cells_flipped, withn_faces_flippedkept as an alias, andn_non_orientable_components. -
repair_mesh(fix_orientation=True)orients every mesh except point clouds, instead of only surfaces in 3D. -
compute_mesh_statisticsreads all statistics in one device-to-host transfer instead of about 20.item()calls. -
MeshReaderandDomainMeshReadermap sample files copy-on-write, so editing a loaded sample in place no longer changes the dataset on disk. Readers on Lustre also no longer take write locks. -
Moving or copying a mesh with cached adjacencies no longer synchronizes a CUDA device.
-
BoundingBoxFiltertakes about half as long on CPU. On a GPU it synchronizes once per coordinate key, instead of once per filtered tensor. -
Every PhysicsNeMo-Mesh API page now opens with a figure, and the nine tutorials in
examples/minimal/meshare reorganized from a first mesh to ML pipelines. New sections show how to use the edge graph of a mesh, aMesh[1, n], in graph network models. -
The
perturbed_gridprimitive takesperturbation_scaleas a fraction of the grid spacing (was an absolute length), so its default no longer folds cells, even on fine grids. -
CenterMeshmaterializes the center of mass on sharded meshes so the offset stays a plain tensor. -
index_selectand integer-tensor indexing on aShardTensorexchange only the requested rows instead of all-gathering the source; no host sync, andtorch.compilesafe. -
Unified external aero recipe: when a dataset puts its targets at cell centroids, as the surface datasets do, the training loss and the metrics weight each target point by its cell's area (or volume), so they no longer depend on how finely the mesh resolves each region. Set
measure_weighted=falseto count every point alike, as before. -
The stream-based ring helpers
perform_ring_iteration_asyncandget_comm_streamare removed; useperform_ring_iteration_funcolwithwait=Falseandfinish_ring_iterationfor overlap. -
Promotes GLOBE out of
experimentaltophysicsnemo.models.globe.GLOBE, the package's only export. Legacy import shims keep the oldphysicsnemo.experimental.models.globepaths and saved checkpoints working and emit aLegacyFeatureWarning.
EnsembleMetrics, the base class ofMean,Variance, andHistogram, is renamedStreamingStatistic.EnsembleMetricsremains an alias of the same class, so existing subclasses andisinstancechecks keep working; importing it emits aLegacyFeatureWarning.weighted_multinomialandWeightedMultinomialmoved fromphysicsnemo.nn.functionaltophysicsnemo.utils. Importing them fromphysicsnemo.nn.functionalstill works but emitsLegacyFeatureWarning.- Unified external aerodynamics recipe:
training.loss_type: rmseis deprecated in favour ofrelative_mse, which names what it always computed (target-normalized relative MSE, no square root) and delegates tophysicsnemo.metrics.general.relative_error.rmsestill works and warns. - The
physicsnemo.experimental.models.globeimport path is deprecated. Import GLOBE fromphysicsnemo.models.globeinstead.
- Removes
physicsnemo.deploy, deprecated in this release. Its only callers were PhysicsNeMo's own ONNX tests, which now carry the two functions they used. Instead ofexport_to_onnx_stream, calltorch.onnx.exportwith anio.BytesIOtarget; instead ofrun_onnx_inference, run the result in anonnxruntime.InferenceSession. physicsnemo.experimental.guardrails. Scoring moved tophysicsnemo.experimental.uq.ood; thresholds and responses now live in example recipes. Replacements:GuardedGeoTransolver,attach_ood_guard,OODGuard,OODGuardConfig: callGeoTransolver.forward_with_geometry_features, pool the tokens, and score them withKNNScorer. Global-parameter bounds become an explicit input check. Seeexamples/minimal/uq/feature_scoring.py. A savedGuardedGeoTransolverkeeps its GeoTransolver weights under themodel.prefix; refit the scorer on reference features.GeometryGuardrail,GeometryDensityModel,TorchPCEDensityModel:DensityScorer(method="gmm" | "pce")on descriptors fromphysicsnemo.experimental.uq.ood.geometry.extract_features. Seeexamples/minimal/guardrails/geometry_validation.py, which also replacesload_features_from_dir.- The other geometry utilities keep their names under
physicsnemo.experimental.uq.ood.geometry;FEATURE_VERSIONis nowv1.1.
- The
physicsnemo.experimental.uq.variational_gp_headandphysicsnemo.experimental.uq.field_variational_gp_headmodules. Import the heads fromphysicsnemo.experimental.uqas before, or fromphysicsnemo.experimental.uq.gp. physicsnemo.experimental.models.globe.utilities, whose TensorDict helpers GLOBE no longer uses.physicsnemo.mesh.fields:RankSpecDict,flatten_rank_spec,rank_counts,ranks_from_tensordict, andvalidate_data_contains_ranks, replaced byFieldSchema(see Changed). Importing one of them fromphysicsnemo.meshorphysicsnemo.mesh.fieldsraises anImportErrorthat names its replacement.- Removes the opt-in
physicsnemo.compatimport-alias layer and thePHYSICSNEMO_ENABLE_COMPATenvironment variable. The layer mapped pre-v2.0 module paths onto their v2.0 locations; three minor releases later, callers should import from the current paths listed inv2.0-MIGRATION-GUIDE.md. Checkpoint loading is unaffected. - Removes
physicsnemo.utils.mesh, deprecated since 2.1 with removal scheduled for 2.2. Thevtkandstlentries leave theutils-extrasextra with it. Replacements:sdf_to_stl(field, threshold):marching_cubesfromphysicsnemo.mesh.generatereturns aMesh; save it withto_pyvistafromphysicsnemo.mesh.io, for example,to_pyvista(marching_cubes(torch.as_tensor(field), threshold)).save("out.stl").combine_vtp_files(files, out):pyvista.merge([pyvista.read(f) for f in files]).save(out).convert_tesselated_files_in_directory:pyvista.read(src).save(dst)per file; PyVista reads and writes OBJ, VTP, and STL.
from_pyvistasplits again each polygon that VTK splits wrongly, into a fan of triangles around one new point at its center, so its output can have more points than the input. A closed polygon surface used to convert with holes, repeated triangles or stray triangles.fill_holeswinds each fill like the surrounding surface, fills holes that pass through a shared vertex, leaves zero-area slits tostitch_t_junctions, and fills flat holes without folded triangles.Mesh.saveandDomainMesh.savecan write a mesh read from disk to a new path. They used to raise unlesscopy_existing=Truewas passed, because the loaded tensors are memory-mapped to the original files.- The container build compiles NATTEN from source with C++20 when no prebuilt NATTEN wheel is supplied, so it builds on PyTorch 2.15 base images, whose headers require C++20.
- The container build compiles pyg-lib from source without the uv cache, so it no longer reuses a pyg-lib wheel built against an older PyTorch, which failed to load with an undefined symbol after a base image upgrade.
Mesh.with_cellsandfix_orientationkeep the effective measure and area of each cell whose vertices are only reordered, as when flipping a winding, instead of rescaling them by float32 roundoff or raising on zero-area cells.DistributedManagernow initializes on CPU-only hosts, where PyTorch rejected its CPUdevice_idand a missing local rank raisedZeroDivisionError.cleanup()no longer raises after a failed initialization.- The GLOBE DrivAerML example integrates the friction force on the car with the right sign. Its drag coefficients were about 0.055 too low.
- The unified external aero recipe integrates force coefficients with the
right signs for DrivAerML and HighLiftAeroML. A dataset YAML now declares
where its surface normals point and which side its wall shear stress acts
on (
surface_normals_point,wall_shear_acts_on). initialize_mlflowoffline mode logs to SQLite (./mlruns/mlflow.db) instead of the file store that current MLflow rejects.docs/test_scriptsrun again on current PhysicsNeMo.physicsnemo.metrics.cae.cfd.compute_tke_spectrumno longer raisesUnboundLocalErrorwhenlengthis passed; the domain length now sets the grid spacing used for the wavenumbers.- The GLOBE DrivAerML example trains under
torch.compileagain on PyTorch 2.13 and 2.14. It and the AirfRANS example now settorch._dynamo.config.specialize_float, which avoids a Dynamo crash in GLOBE's Padé networks (pytorch/pytorch#193194). - Stabilizes PCE density scores for collinear features by fitting polynomial covariance/precision in float64. Rejects non-finite density scores before percentile decisions and isolates scorer initialization from prediction RNGs.
- Preserve unreduced ShardTensor placement dimensions in
sumandmeanwhenkeepdim=True, including independently sharded simulation and spatial axes. torch.compilewith ShardTensor: neighborhood attention (na1d/na2d/na3d) keeps its halo exchange when compiled,selecthandles a negativedim, dynamic shapes no longer fail in the spec hash, a plain DTensor operand next to a ShardTensor uses the DTensor fallback, and a plain parameter used with a ShardTensor gets a reduced gradient as in eager.- Multi-node jobs launched with
srunno longer hang inDistributedManager.initialize()when Slurm starts rank 0 on a different node from the one that ransrun. The rendezvous now uses the job step's first node. DistributedManager.initialize()works in a Slurm batch script run withoutsrun. It used to find no rendezvous address there and raise aTypeError.Mesh.get_point_to_points_adjacency(),get_facet_mesh(), andget_boundary_mesh()compile withtorch.compile(fullgraph=True, dynamic=True). Facet extraction now specializes on the cell width instead of passing a symbolic size toitertools.combinations.- Compiled code that reads
Meshgeometric properties, such ascell_areasor curvatures, no longer recompiles when the input mesh's cache differs, and no longer writes into that cache.set_cell_measuresstores a copy of the cachedcell_areas, so a measure never aliases it.physicsnemo.meshnow checks whether its own code is being traced, because since torch 2.13torch.compiler.is_compiling()is True in every thread during a compile, which made data-loading threads drop caches and skip validation. Meshgeometric properties, curvatures, and the calculus operators give correct gradients when the points require gradients, even after a read undertorch.no_grad(), and a secondbackward()on the same mesh no longer fails. Such meshes now compute these properties on every access instead of caching them.- GraphCast and MeshGraphNet run on graphs partitioned across GPUs again
(
partition_size > 1, or aDistributedGraphin place of the PyG graph), so the distributed shallow-water example works. This broke when the DGL backend was removed. partition_graph_with_id_mapping, and sopartition_graph_nodewise,partition_graph_by_coordinate_bboxandDistributedGraph, acceptint32CSC indices and rank mappings. Before, they failed with a dtype mismatch.weighted_multinomialwithreplacement=Trueaccepts more than 2^24 weights, instead of raisingtorch.multinomial's category-limit error. So DoMINO'ssample_points_on_meshnow works on meshes with over 2^24 faces.MeshDataset.close()no longer raisesAttributeErrorwith aMeshReaderorDomainMeshReader. Both readers now have aclose()method.GLOBEacceptsboundary_meshesas a TensorDict, as the DrivAerML example passes them. Before, every forward pass of that example failed.- A
GLOBEmodel built with atorch.deviceastree_build_devicecan now be saved. Before,save()raisedTypeError, because JSON cannot hold a device. - Under
torch.compile, GLOBE no longer recompiles on its second training step, nor for each new sample of a similar size. Each of these recompiles took minutes at DrivAerML sizes. - The GLOBE examples' requirements no longer downgrade PyVista and Matplotlib below the versions PhysicsNeMo requires.
signed_distance_field, inphysicsnemo.nn.functionalandphysicsnemo.mesh.spatial, supports backpropagation: the signed distance is differentiable with respect to the mesh vertices and the query points. Before,backwardraised because the Warp op had no autograd formula. The hit points and hit faces carry no gradients.- With
max_points, the Warp backend ofradius_searchleaves the.gradof batched points and queries unset in the forward pass. Before, it set them to zeros. Mesh.clean(),clean_mesh,merge_duplicate_points, andvalidate()find every duplicate point in clusters of more than 100 coincident points. Before, some duplicates were missed and stayed in the cleaned mesh.Mesh.mergetreats a list of one mesh like a longer list. It checks its input and stacksglobal_dataalong a new dimension. Before, it returned a copy of the mesh.Mesh.padandMesh.pad_to_next_powerplace padding cells on a padding point when they also pad points. Before, padding cells touched the last real point and changed results there, such ascell_data_to_point_data.DomainMesh.rotate,scale, andtransformwork when the meshes of a domain differ in float dtype, such as a float64 interior with float32 boundaries, where they raised before.repair_meshalso removes the degenerate cells that its merge of duplicate points creates. Before, its output could failvalidate().fill_holesworks on meshes with point or cell data, where it raised before. The new points and faces hold NaN in floating-point fields and 0 in others.compute_mesh_statisticsreports the mean and standard deviation of the edge lengths of all cells. Before, the mean averaged each cell's shortest and longest edge, and the standard deviation covered only the longest edges.is_manifold()rejects triangle surfaces pinched at a vertex, such as two closed surfaces that share a single vertex.get_boundary_edgesreturns edges, not triangles, for meshes of four or more manifold dimensions.Mesh.with_datagiven a dict no longer shares nested data groups with the source mesh, so changing the result leaves the source unchanged.cell_data_to_point_dataandpoint_data_to_cell_dataraise, unlessoverwrite_keys=True, when a field has the name of a data group in the destination or the reverse. Before, they silently dropped data.- Cleaning or repairing a mesh with no cells keeps its point data fields, now empty, so the result can be merged with other meshes.
get_point_to_points_adjacency()returns no neighbors for meshes of vertex cells, where it raised before.MeshandDomainMeshsubclasses that add fields no longer need their own__init__with TensorDict 0.15, whose tensorclass subclasses inherit the parent's__init__. The base__init__accepts and stores the fields that a subclass declares, and still raisesTypeErrorfor any other keyword.- Linear subdivision of tetrahedral meshes keeps the orientation of every child cell. Before, half of the children came out inverted.
- The
unit_square,rectangle,structured_grid,l_shape,cube_volume,torus,hemisphere,disk,planeandtetbeamprimitives have positively oriented cells and outward or +z normals. Before, their cells were inverted or their normals pointed the wrong way.planealso raisesValueErrorfor a zero or non-finite normal, where it used to return the +z plane. - Meshes with
int32connectivity give the same results asint64ones in Butterfly and Loop subdivision, edge lookups andrefit_mesh_to_implicit. Before, large meshes could get wrong Butterfly midpoints and edge matches, Loop subdivision raised on open surfaces, andrefit_mesh_to_implicitcould leave boundary vertices off the surface. - Loop subdivision of
float64meshes computes its vertex weights infloat64. Before, it computed them infloat32, which limited the new vertex positions tofloat32precision. - A mesh saved with cached adjacencies now loads in a new Python process.
Before,
Mesh.loadraised unlessphysicsnemo.mesh.neighborswas already imported. - Intrinsic cell gradients on curves in 3D now lie along each cell's own direction. Before, they crashed on open curves and were projected onto the wrong tangent on closed curves.
- Intrinsic point gradients on manifold meshes no longer depend on the winding
of the cells, at any angle between them, so they are correct on
get_boundary_meshoutput and on the Möbius strip. Consistently wound meshes give the same results as before. - Curvature of a curve whose two edges at a vertex both start or both end
there, as
get_boundary_meshproduces, is now correct. Before, the angle at such a vertex was wrong, so a right-angled corner had zero curvature. - DEC gradients, divergences, and Laplacians of a float32 field on a float64
mesh now return float64 results instead of raising. DEC gradients and
Laplacians of tensor fields, and LSQ cell gradients, no longer fail on meshes
without cells, and
flathandles fields with several trailing dimensions. - Intrinsic LSQ gradients no longer raise on float32 point clouds or on 16-bit
curves, and raise a
TypeErrorfor integer fields instead of truncating the result. On surfaces in four or more dimensions they are now correct at points with two neighbors, and DEC intrinsic gradients of curves in 3D are now correct at their endpoints. - Derivatives of intrinsic gradients with respect to the points are no longer NaN on straight curves in 3D, or flat surfaces in 4D, that lie along the axes. On curves in 3D and surfaces in 4D, only first derivatives are exact.
- DEC gradients of planar triangle meshes are no longer NaN at the vertices of
zero-area triangles, such as those
Mesh.padadds. DEC divergences are now correct on float32 meshes a few millimetres across in metres. Mesh.cleannow sums the point measures of merged points, so integrals by point quadrature no longer change.DefaultCollatorwith astack_dimpast the batch dimensions of the samples stacks each tensor withtorch.stack, without TensorDict behaviour that 0.15 deprecates. The batch'sbatch_sizenow matches its tensors, and samples with non-tensor data no longer fail to collate.physicsnemo.meshno longer raises small lengths, areas and volumes to a fixed floor, which distorted results on float32 meshes in meters a few millimeters across. Area-weighted aggregation,partition_cellscentroids, support volumes, the DEC Laplacian, the sharp, Gaussian, and mean curvatures, and triangle circumcenters now give the same results at any scale.sample_random_points_on_cellswith a smallalphano longer places some points outside their cells.- In float32,
sdf_polygon_2dno longer gives NaN distances for a polygon with a repeated vertex or NaN gradients on its edges, andmesh_implicit_domainnow meshes float32 polygons such as a square. - The API reference again shows the docstrings of
Mesh,DomainMesh, and the other tensorclasses inphysicsnemo.mesh. TensorDict 0.14 replaced them with generated signatures. - Meshes with explicit measures integrate correctly after
get_facet_mesh,get_boundary_mesh,to_edge_graph,extrude,project,embedandpad. Before, facets and extruded cells inherited the parent's measure,projectkept the old one,embedraised on centroid point clouds, and padding cells got NaN measures that made a laterscaleraise.extrudenow raises on dimensional point measures instead of copying them to the extruded points. DomainMesh.apply_to_meshesleaves each boundary mesh on the device the function returns it on. Before, the boundaries went back to the domain's device.rotatewith a Python angle rotates float64 meshes at float64 precision. Before, it computed the rotation in float32.rotaterotates float64 meshes about a vector axis at float64 precision. Before, it rounded the axis to float32, so points on the axis moved.rotate,scale, andtransformwith a square matrix work on float16 and bfloat16 meshes, and keep their dtype. Before, they raised an error.- Loop subdivision keeps float16 and bfloat16 points in their dtype, and no longer overflows on float16 meshes far from the origin. Before, it returned float32 points.
cell_areas,cell_normals, and Butterfly subdivision compute in at least float32 and cast back once, so float16 results that fit in float16 are finite. Before, their cross products, determinants, and sums of positions overflowed float16 toinfornan, andscalegave finite areas only if they were cached before the call.sample_random_points_on_cellswithalphaother than 1 works on float16 and bfloat16 meshes on CPU. Before, it raised an error.- Anisotropic maps with a small overall scale are no longer taken for similarities. Before, transforming by one kept wrong cached point normals, and scaled point measures instead of raising.
pad_to_next_powerpads to the smallest power that fits. Before, a size that already was such a power could be padded to the next one, and some non-integer powers raised.- The GLOBE examples no longer pin TensorDict 0.12, which conflicted with PhysicsNeMo's own requirement.
delaunay_mesh_2drecovers boundary segments that cross several triangles. Before, it raised on simple polygons, even rectilinear ones, and blamed float64 degeneracy or crossing segments.signed_distance_fieldaccepts non-contiguous query points and vertices, such as a transposed tensor, which used to raise a Warp error.- The mesh
signed_distance_fieldkeeps the orientation of the near-degenerate faces it repairs. Before, the repair could flip a thin face, so points outside a watertight mesh got a negative distance. knnwith the cuML backend,find_nearest_cellsandmatch_pointsreturn empty results for an empty query set on CUDA, as they do on CPU, instead of raising a CUDA error.match_pointsalso returns no matches for an empty target.- Mesh transforms and projections keep the dtype of each vector and tensor field. A float32 field on float64 points, as VTK files often store them, raised a dtype error.
- The GLOBE AirfRANS example casts its meshes to float32. Since
from_pyvistabegan keeping float64 points, preprocessing failed on every sample. DomainMeshReadergainsboundary_subsample("both","cells","points") to choose which subsample applies to the in-file boundaries. Composing the cell and point subsamples on a triangulated boundary kept only the cells whose three vertices all survived the point cut, aboutN / 27of theNrequested. The default keeps the composed behavior.- The
hemisphereandconeprimitives have a single pole or apex vertex, so the cone is closed. Before, the vertex was repeated around the ring, leaving zero-area triangles. tetrahedron_surfaceedges have lengthside_length, andsphere_icosahedralwithsubdivisions=0honorsradius.sphere_volumeandcylinder_volumetetrahedra fill the solid without overlap. With VTK 9.7, their Delaunay tetrahedra overlapped and left gaps.lumpy_ballraisesValueErrorwhennoise_amplitudefolds its surface so far that the tetrahedra would overlap.text_1d_2doutlines are closed loops; before, each ended in a zero-length edge.text_2d_2dfills curved glyphs fully: thin rings such as U+25CB lost part of their area.text_2d_2dfills glyphs with slanted edges, such as 'A' and 'V', without flat triangles or hanging vertices, sotext_2d_3dof ordinary text is watertight. It also leaves the counter of a nested glyph empty: '®' was 3% too large.cone,diskandplanework when torch's default dtype is float64, where they raised before.- Unified external aero recipe: GLOBE-volume trains on all the requested vehicle surface cells, not about 4% of them.
- Seeded
DomainMeshReadersubsamples select the same rows from Zarr stores as from memmap files. Before, boundaries read in full, and interiors read withdrop_interior_cells, could differ between the two formats. from_pyvista(point_source="cell_centroids")places the centroid of every linear cell at the mean of its vertices, asMesh.cell_centroidsdoes. Before, polygons, pyramids, prisms and polyhedra got other points, and even a regular pentagon was off-center.to_pyvistaexports vertex-cell meshes, and empty line and triangle meshes, with their cell data. Before, the export failed.to_zarrraises aTypeErrornaming any field it cannot store, such as a bfloat16 field, before it writes anything. Before, it left a partial store that loaded without those fields.to_zarrraises aValueErrorbefore it writes anything when a field key or boundary name is one that zarr cannot store, such as one that is empty or contains/. Before, such a name could come back as another key, or leave a store that would not load.from_zarrloads the stores thatto_zarrwrites for subclasses ofMeshandDomainMesh, as their base class, andto_zarrraises aTypeErroron a subclass with fields of its own. Before,from_zarrrefused these stores.from_zarr,MeshReaderandDomainMeshReaderkeep the cell shape of a zarr mesh with zero cells. Before, such a mesh came back as a point cloud.- With domain-parallel reading,
MeshReaderandDomainMeshReaderalso keep the cell shape and cell data of a mesh with zero cells. Before, such a mesh came back as a point cloud, so computing its normals or merging it with other boundaries raised. to_pyvistaexports empty meshes with vector or tensor fields, where it raised before, andfrom_pyvistareads complex arrays of one value with shape(1,), where it raised or dropped a dimension before.from_pyvistawithpoint_source="cell_centroids"joins two cells of different dimensions by the same dual-graph edges whatever the order of the cells. Before, these edges depended on it.from_zarr,MeshReaderandDomainMeshReaderraise on a zarr store thatto_zarrdid not write or did not finish. Before, a store cut short by a full disk, for example, loaded without its missing fields.from_zarrloads scalar uint64 fields, where it raised before.Mesh.drawwith matplotlib colors 2D curves by their scalars and honorsalpha_edges. It also draws 1D meshes in view, vertex cells as colored markers, and integer vector scalars, where it failed before.Mesh.drawwith matplotlib fits the view to every mesh drawn onaxand, in 2D, keeps limits the caller fixed; before, it showed only the last mesh. Meshes far from the origin no longer shrink to a speck in the view.Mesh.drawwith PyVista letsbackend_optionsset the edge color, line width and scalar bar, where it raised before.- GLOBE DrivAerML postprocessing reports correct Cd, Cl, and Cs on subsampled surfaces. Before, they shrank with the fraction of cells kept.
- The unified external aero recipe documents how surface subsampling affects force integration.
ClusterTree.find_dual_interaction_pairsreturned an empty plan if any point had a NaN coordinate, and failed on plans with more than 2^31 interactions.ClusterTree.from_pointsno longer keeps the autograd graph of its inputs.- With
expand_far_targets=Trueandleaf_size > 1,ClusterTree.find_dual_interaction_pairsstill approximated some targets by their leaf's centroid. - Unified external aero recipe: the final epoch is always checkpointed,
resumed runs keep the epoch-mode learning-rate schedule (older checkpoints
resume one epoch behind), and fp16 runs save and restore
GradScalerstate. - Checkpoint loading resolves model weights at the selected training checkpoint's filename index, preventing resumes that mix epochs. Missing required weights raise before any model or training state is restored. Distributed loads validate on every rank using rank 0's file lookup.
fix_orientationno longer leaves opposite windings across sharp creases, such as the edges of a cube.Mesh.is_manifold()no longer raises on a tetrahedral mesh with a degenerate cell.- Mesh slicing reuses integer indices across connectivity, fields, and caches to avoid repeated CUDA synchronization for the same boolean mask. Point slicing skips mask processing when the output has no cells because the input has no cells or the point selection is empty.
- DEC gradients (
gradient(method="dec")) of tetrahedral meshes read triangle faces as edges and were wrong at most vertices, and on 1D meshes they raised. They now use the edges of every cell and are exact for linear fields on segments, triangles and tetrahedra.to_edge_graph()works on 1D meshes, andget_facet_mesh(manifold_codimension=0)returns the deduplicated cells. - Meshes from
slice_cellsandsubdivideget their own data containers, so adding or removing a field on them no longer changes the source mesh. - Triangle areas use direct area components and a rescaled norm, preserving thin faces and their quadrature measures without Gram cancellation or overflow or underflow in the norm.
- Vertex angles of nearly flat triangles in 2D and nearly flat tetrahedra are now accurate. A 2D triangle with an angle near pi used to get angles of 0, 0, and 0, which also threw off Gaussian curvature and quality metrics.
- Gaussian curvature of curves in 3D is now correct: a unit circle with 1,000 segments had a curvature of 499 instead of 1.
- Small angles from
stable_angle_between_vectors, volumes of thin tetrahedra in 4D or more, and FEM cotangent weights of thin cells keep their accuracy in float32. The first two used to come out as 0. - FEM cotangent weights of long, thin but well-shaped cells are accurate in any vertex order. A tetrahedron with one edge 5,000 times longer than the others used to get the weights of a degenerate cell.
- Vertex angles of triangles in 3D are correct in float16 and at any
coordinate scale, and
stable_angle_between_vectorsis correct in float16. Both used to return NaN or wrong angles there. - On CUDA, LSQ gradients of rank-deficient stencils, such as those of a flat
surface, are now minimum-norm solutions, as on CPU. They used to be NaN,
wrong by orders of magnitude, or a
LinAlgError. - On CUDA,
sample_data_at_pointsnext to a degenerate cell no longer raisesLinAlgError. Degenerate cells contain no sample points on any device, andcompute_circumcentersreturns their centroid instead of NaN or infinity. - Edge flips in
mesh_implicit_domainwork at any coordinate scale; below about 1e-13 they were silently skipped. - The PyTorch Sobolev deformation accepts float32 cells of any size, and the StVK strain energy has finite gradients for degenerate reference cells.
- Unified external aero recipe: near-wall SDF normals no longer flip inward from float32 roundoff. Stored signed distances are unchanged.
- Fixes mesh dtype handling: preserves integer-coordinate precision, normalizes
connectivity safely, and rejects integer
.to()casts. Floating-point and complex casts preserve the source mesh. - Fixed an issue in
Natten2DSelfAttentionandRopeNatten2DSelfAttentionwithqk_norm=TruemixingLayerNormfp32 Q/K outputs with autocasted V dtypes. - Normalizes cell, point, transformed, and partition-cluster mesh normals robustly across floating-point dtypes and scales. Zero vectors remain zero, small nonzero vectors retain unit length, and large finite vectors avoid norm overflow.
- Datapipe transforms, collators, readers, and the unified external aero
recipe no longer silently skip or mis-handle nested
TensorDictfields (membership was tested against top-leveltd.keys(), andNormalizeMeshFields.inverse_tdmatched leaves by their last name only). from_pyvistaandto_pyvistaround-trip nestedMeshdata keys, and GLOBE accepts a nestedglobal_data_ranksdeclaration.- Fixes out-of-bounds reads in the
Darcy2Dmulti-grid solver fornr_multigrids >= 3that could return huge or NaN pressure fields, and corrects the coarse-node coordinates used by bilinear upsampling for reduction factors greater than 2. Darcy2Dpermeability fields are random per sample again: theinit_uniform_random_4dandinit_uniform_random_2dkernels seeded every thread from only its first launch index, so all samples in a batch shared four random Fourier coefficients (#2035).init_uniform_random_2dalso negatedmin_value, which made theKelvinHelmholtz2Dperturbations constant.Darcy2Dsolves the Darcy equation it documents: the Jacobi update divided thegrad(k) . grad(u)term by2 dxinstead of4 dx**2, effectively dropping it (#2036). Generated pressure fields change; thedarcynormaliser in thedarcy_fno,darcy_transolveranddarcy_nested_fnosexamples is updated to match, anddarcy_nested_fnosdatasets must be regenerated.- The
Darcy2Dconvergence check no longer reports a diverged (NaN) solve as converged. Module.savenow writes.mdluscheckpoints atomically (transfer to a temporary sibling name, then rename into place), so a process killed mid-write no longer leaves an unloadable truncated checkpoint. Also fixeslegacy_format=True, which failed withFileNotFoundErroron current fsspec versions.save_checkpointnow also writes training state and plain PyTorch weights atomically, so an interrupted save no longer leaves a truncated checkpoint. Withepoch=None, all files of a save share one index, soload_checkpointrestores weights and training state from the same save.RandomRotateMeshdefaults tomode="axis_aligned"whenaxesis given. Unified external aero recipe translation configs pass tensor bounds sotorch.distributions.Uniforminstantiates.RenameMeshFieldsandDropMeshFieldsalso apply to aDomainMesh's domain-levelglobal_data.sample_data_at_pointsandfind_containing_cellsfind on-surface points of float32 surface meshes in large length units. A torus scaled to|x| ~ 1300(millimeters) previously found 0.4% of its on-surface points and returned NaN for the rest, because float32 rounding (about1.2e-7 * |x|) exceeded the absolute1e-6distance tolerance.BVH.from_meshandClusterTree.from_pointscompute Morton codes for 1-3 spatial dimensions by spreading each coordinate's bits with a few shift-and-mask steps. CUDA no longer materializes every bit as int64 (about 1 kB per point, 55 GB at 50M cells); temporaries are about 72 B per point in 3D, and the step is about 4x faster on large inputs. Codes are unchanged.sample_data_at_points,find_containing_cells, andfind_all_containing_cellsno longer miss the containing cell when a query point has more than 32 BVH candidate cells (for example, near a vertex shared by many triangles, or with a prebuilt BVH withleaf_size > 1). The BVH candidate search used by these functions no longer caps candidates per point.- Fixes
VPNoiseScheduler.sigma_invat extreme noise levels. In particular, convertingsigma=0no longer returns a slightly negative diffusion time. radius_searchwithimplementation="torch"no longer returns point 0's coordinates in unused neighbor slots whenmax_pointsexceeds the number of points. Those slots now stay zero, as with the warp backend, so point 0 no longer receives their gradient.- Eleven PhysicsNeMo-Mesh API pages that listed no functions now document them,
and the pages of tensorclasses such as
Meshno longer list every TensorDict method. - PhysicsNeMo-Mesh examples that raised an error, and claims that the code contradicts, are corrected across the API reference, READMEs, and docstrings. The corrected claims include the sign of the Laplacian and the dimensions that each calculus operator supports.
- The transient conjugate heat transfer tank filling example trains again, on
one GPU or several. Before, its
train.pystopped with aTypeErrorbefore the first step. - Importing
physicsnemo.domain_parallelno longer breakstorch.compilefor the whole process when nothing has importedtorch._dynamobefore it. MeshReaderandDomainMeshReaderimplementclose(), soMeshDataset.close()works on the mesh path.- Coordinated subsampling in the zarr readers picks its reference key in the configured order rather than set order, so the rows read are deterministic.
ShardTensorfixes for domain parallelism: redistribute no longer grows an unbounded planner cache for fixed shapes (step time was climbing with step count),scatter_tensorreturns a shard that owns its storage, stream recording on wrapped tensors works, and severaltorch.compiletracing issues are resolved.torch.unbindon aPartialShardTensorresolves the pending reduction before slicing instead of silently dropping it.- Fixed autocasting bugs for some attention operations in domain parallelism.
- Backward through
ShardTensor.to_local()adopts the gradient's shard order along with its placements, so a sharded primal with a replicated cotangent no longer trips aDTensorSpecassertion.
- CI and the Docker image no longer trust the compromised eMudhra emSign root
CA (advisory). uv is now 0.13.5 in
CI and the Dockerfile, the image upgrades
ca-certificatesand requirespip>=26.2.2andcertifi>=2026.10.19, and the lockfiles pincertifi2026.10.23 andvirtualenv21.14.13. The GPU CI bootstrap installs the Hugging Face CLI with uv instead of Ubuntu's apt pip, andinstall-cisetscheck-latestso it uses the patched CPython releases.
- Requires TensorDict 0.15.3 or later (
tensordict[zarr]>=0.15.3,<0.16.0). Building, copying, and moving small meshes takes 20-50% less time on CPU. TensorDict'storch.compilefixes since 0.15.0 also stop compiled code from recompiling when aMeshholds the same fields in another order. - Drops
onnx,torchvisionandpandasfrom the required dependencies.pandasis now optional viadatapipes-extrasormodel-extras.
- Allows installation on all Python 3.14 patch releases while continuing to exclude Python 3.15 and later.
- Pins install CI to the interpreter provisioned by
setup-pythonand verifies the runtime version, preventinguvfrom silently selecting another Python. - Keeps tensorclass mesh API annotations introspectable under Python 3.14's deferred annotation evaluation.
- Adds
ShardTensorsupport for GeoTransolver and FLARE models. - Adds zarr save/load for
MeshandDomainMeshvia tensordict's zarr storage backend:physicsnemo.mesh.io.to_zarr/from_zarr, with training-appropriate chunking and zstd compression.MeshReaderandDomainMeshReadertransparently read zarr stores alongside.pmsh/.pdmsh(opt in viapattern). Requires optionalzarr >= 3and a tensordict release with the zarr backend. - Adds configurable activation checkpointing to Transolver, FLARE, and GeoTransolver. Transolver and FLARE support interleaved block checkpointing; GeoTransolver supports checkpointing context construction, per-stream input projections, GALE or GALE_FA blocks, and output projections.
- Promotes GeoTransolver out of
experimentaltophysicsnemo.models.geotransolver.GeoTransolver, together with the FLARE model (physicsnemo.models.flare.FLARE) and the reusable GALE and FLARE attention layers (physicsnemo.nn.GALE,physicsnemo.nn.GALEBlock,physicsnemo.nn.FLARE). The embedded OOD guard is decoupled from the model. Wrap a constructed GeoTransolver withphysicsnemo.experimental.guardrails.embedded.GuardedGeoTransolver(orattach_ood_guard) to enable out-of-distribution guarding. PhysicsNeMo removes theguard_configmodel argument. Legacy import shims keep the pre-movephysicsnemo.experimentalimport paths working and emit aLegacyFeatureWarningpointing to the new locations. - Adds
zenith_azimuth_anglesandzenith_azimuth_angles_from_timestamptophysicsnemo.utils.zenith_angle, returning(sin_zenith, cos_zenith, sin_azimuth, cos_azimuth)alongside the existingcos_zenith_angle/cos_zenith_angle_from_timestamphelpers. The azimuth follows the north-clockwise convention. - Adds
physicsnemo.nn.shrink_and_perturb_, an in-place shrink-and-perturb weight re-initialization for warm-starting from pretrained weights. - Adds dimension-generic volume mesh generation for implicit domains to
physicsnemo.mesh.generate.mesh_implicit_domainmeshes{x : phi(x) < 0}, clipped to the bounding box (box faces are honored as a boundary, so that external-flow "box minus obstacle" domains work directly), for any implicit function (signed-distance functions, level sets, or neural fields). - Adds compile-safe subclassing extension points to
domain_parallel.ShardTensor(_extra_inner_tensors,__subclass_flatten_context__/__subclass_unflatten__,_stable_inner_sentinel, and a DTensor-style__metadata_guard__), so a subclass can carry extra inner tensors and opaque metadata throughtorch.compilewithout re-implementing the flatten protocol. Base behavior unchanged. - Adds
ShardTensor._subclass_propagated_attrs: attribute names base__torch_function__copies from an op input onto its eager op-result, re-classing it to the subclass. Skipped under compile; empty by default. - Adds
install_aot_plain_tangent_coercion(run on import): rebuilds a plain backward cotangent into aShardTensorwhen a boundary crosses a Dynamo graph break, instead of AOTAutograd raising "guessed its metadata incorrectly".__coerce_same_metadata_as_tangent__now also coerces down to a plain tensor at a replicated boundary. - Adds
domain_parallel.shard_utils.halo_scatter: atorch.compile-safe halo scatter-correction primitive forShard(0)ShardTensors with a borrowed-ghost overlay.halo_scatter_correctfuses the fold-to-owner / refresh-ghost exchanges into a self-adjointcustom_op(correct forward and backward underaot_eagerand inductor), with routing passed as a packed graph-input tensor so it survives graph breaks;register_halo_scatter_handlerswires it ontoscatter_add/index_add. The row transport is a pluggable backend (select_halo_backend,PHYSICSNEMO_HALO_BACKEND): a portablefuncolpath and an intra-node symmetric-memory (CUDA-IPC) path. - Extends
halo_scatterwithpack_halo_routing(cap=)fixed-shape routing (for compileddynamic=Falseruns), an in-placescatter_add_/index_add_dispatch handler, and node-locality routing inselect_halo_backend(single-node uses symm-mem, multi-node falls back tofuncol). - Adds a
ShardTensor.grad_dtypeproperty override (returns the local tensor's dtype) so a newer-PyTorchgrad_dtyperead during Dynamo fake conversion doesn't fall back to a non-leaf DTensor and break compile. Mirrors thegrad_fn/is_leaf/gradshields. - Adds
integrate_momentandMesh.integrate_momentfor measure-weighted outer-product moments. Mesh integration APIs now acceptnan_policy. - Adds per-cell measure weights that are preserved through cell subsampling and consumed by mesh integration routines and GLOBE.
- Adds a
global_shapeargument toShardTensor.from_local, enabling the no-communicationsharding_shapes="chunk"path. - Adds exact-boundary quality mesh generation to
physicsnemo.mesh.tessellation:fill_interiortakes a closed codimension-one boundaryMesh(2D edge loops today; loops in any order and orientation, with holes, multiple components, and nested islands resolved automatically) and fills the interior with quality simplices via constrained Delaunay triangulation with Ruppert refinement — every input vertex is preserved bit-identically, every output triangle meets the guaranteed minimum-angle bound, output is aMeshwith provenancepoint_data, deterministic, with optional bound-preserving ODT smoothing. The contract is dimension-generic;n = 3raisesNotImplementedErrorpending exact boundary recovery. Also addspolygon_interior_point, which returns a point strictly inside a simple polygon. - Adds
rectilinear_grid_divergence,rectilinear_grid_curl, andrectilinear_grid_laplaciantophysicsnemo.nn.functional, with Torch and fused Warp implementations for periodic, nonuniform rectilinear grids. - Adds triangle-surface remeshing with NVIDIA Warp on CPU and CUDA, including
remesh,Mesh.remesh, topology cleanup, barycentric point-data transfer, direct or attached linear-resolution-field control, and advanced tensor-level tuning. - Adds coverage reporting on PRs — an informational
Coverage %check plus a ready-to-enable Codecov integration. - Adds differentiable mesh morphing: Torch-backed dense
displace_points/Mesh.displaceand Torch/NVIDIA Warp compact sparse-controlmorph_points/Mesh.morph/DomainMesh.morph. - Adds differentiable Sobolev mesh deformation through
sobolev_deform_pointsandMesh.sobolev_deform. A matrix-free, uniform-mass P1 Helmholtz solve smooths dense per-vertex displacements and their adjoints, with optional fixed-point constraints. Torch and CUDA Warp backends provide explicit implicit-adjoint differentiation. - Adds thin-plate-spline radial-basis deformation through
radial_basis_function_deform_points,Mesh.radial_basis_function_deform, andDomainMesh.radial_basis_function_deform. PyTorch performs the differentiable coefficient solve. Torch and fused NVIDIA Warp backends evaluate the field. - Adds differentiable lattice free-form deformation with Torch and NVIDIA Warp
backends: dimension-generic
free_form_deform_points/Mesh.free_form_deform/DomainMesh.free_form_deformwith Bernstein (classic FFD) and locally supported uniform cubic B-spline bases, plus node-interpolatinglinear,cubic_hermite, andquintic_hermitemodes. - Adds fixed-topology
simplex_strain_energy,simplex_measure_energy,total_measure_energy,simplex_inversion_energy,closed_surface_volume_energy, andsurface_bending_energytophysicsnemo.nn.functional, with mesh-aware wrappers inphysicsnemo.mesh.deformation. Torch supports higher-order derivatives, and Warp provides first-order GPU kernels. - Adds differentiable nearest-surface shrinkwrap through
shrinkwrap_pointsandMesh.shrinkwrap. Torch provides the reference search, NVIDIA Warp acceleratesfloat32nearest-face queries on CPU and CUDA. Both backends replay the selected projection with PyTorch autograd. Triangulated examples demonstrate weighted panel conformance and partial design-region projection onto a shape-optimization constraint. - Adds
uniform_grid_divergence,uniform_grid_curl, anduniform_grid_laplaciantophysicsnemo.nn.functional, with Torch and fused Warp implementations for periodic Cartesian grids. - Adds the experimental Strata weather-emulation models —
physicsnemo.experimental.models.strata.StrataandStrataTransformer3D— plus the continuous / stereographic RoPE helpersbuild_rope_cos_sin_1d_continuous,build_axial_rope_cos_sin_2d_continuous,stereographic_projection, andspherical_centroidinphysicsnemo.experimental.nn. - Adds Point-Transformer local vector-attention blocks to
physicsnemo.nn. - Adds an
is_causaloption toTimmSelfAttentioninphysicsnemo.nnfor causal self-attention. - FSDP2 checkpoint support: full save/load round-trip for
torch.distributed.fsdpv2 models, including DTensor edge cases, cross-mesh reloads, and optimizer state loading. - Migrated the StormCast example from DDP + Domain Parallel to FSDP2 +
Domain Parallel. StormCast previously used
FullyShardedDataParallelwithShardingStrategy.NO_SHARD(equivalent to DDP) alongside domain parallelism; it now uses the FSDP2fully_shardAPI, producing 2D-mesh DTensor parameters whenuse_shard_tensoris enabled. - Adds tensor-returning
Mesh.gradient,Mesh.divergence,Mesh.curl, andMesh.laplacianconvenience methods tophysicsnemo.mesh, mirroringMesh.integrate(each returns a tensor and accepts a data key or a raw tensor, with adata_source="points"|"cells"kwarg selecting vertex or cell-centered fields). This gives the discrete differential operators a consistent, discoverable surface onMesh; previously divergence/curl/ laplacian were reachable only as free functions inphysicsnemo.mesh.calculus. Addscompute_divergence_cells_lsqandcompute_curl_cells_lsqfree functions (cell-centered LSQ analogues); DEC operators and the cotangent Laplacian remain vertex-only and raiseNotImplementedErrorfor cell data. - Adds
farthest_point_samplingtophysicsnemo.nn.functional, a greedy farthest-point sampling (FPS) functional for point clouds. - Adds
FourierPositionalEmbeddingtophysicsnemo.nn, a deterministic axis-wise (NeRF-style) Fourier positional embedding for continuous coordinates with no learnable parameters. - Adds radiation transport example (
examples/nuclear_engineering/radiation_transport) - Adds agent skills structure, and initial skill for 'discoverability'.
- Adds the experimental AeroJEPA model
(
physicsnemo.experimental.models.aerojepa.AeroJEPA), a joint-embedding predictive architecture for 3D aerodynamic fields composing context and target encoders, a query-token field decoder, and a JEPA predictor head, together with its SIGReg, token-latent, and reconstruction loss family. The generic point-cloud tokenizer and the batch/mask/k-NN helpers are added underphysicsnemo.experimental.nn; the local point-transformer attention blocks it composes come fromphysicsnemo.nn. - Adds the AeroJEPA SuperWing tutorial recipe
(
examples/cfd/external_aerodynamics/aerojepa), an end-to-end Hydra-driven workflow covering dataset download, normalization, JEPA training, chunked inference, field-error plots, and CL/CD post-processing. - Adds xDeepONet to experimental models
(
physicsnemo.experimental.models.xdeeponet.DeepONet). A single dimension-generic (2D/3D) DeepONet that accepts a spatial or MLP branch, an optional trunk, and an optional second branch asnn.Moduleinputs (dependency injection). Six forward-call conventions cover trunked, trunkless, packed/auto-padded, and xFNO-style time-axis-extend modes. Supports multi-channel output, multiple decoder types (MLP, Conv, temporal projection), composable Fourier / UNet / Conv spatial branches (SpatialBranch), and coordinate features. - Adds
FNO4DWrapperto the xdeeponet package: a thin wrapper around the libraryphysicsnemo.models.fno.FNO(dimension=4) that adds autoregressive time-axis extension over(B, X, Y, Z, T, C)inputs (predict aK-step forecast horizon viatarget_times). Usephysicsnemo.models.fno.FNO(dimension=4)directly when the time-axis extension is not needed. 3D FNO / Conv-FNO / U-FNO operators are expressed asDeepONet(trunk=None, dimension=3)with a Fourier/UNet/ConvSpatialBranch. - Adds
Sinelementwise sine activation tophysicsnemo.nn, registered inACT2FNso it can be looked up by name (get_activation("sin")). - Adds active-learning recipe for external-aerodynamics surrogates
(
examples/cfd/external_aerodynamics/active_learning_aero/). Iteratively fine-tunes a GP-augmented GeoTransolver onto an out-of-distribution target class by scoring unlabeled candidates with a joint UQ signal (GP-vs-integrated-drag disagreement + GP posterior std) and selecting the top-kper round. Built on thephysicsnemo.active_learningprotocols andphysicsnemo.experimental.uq.VariationalGPHead, with a layered structure (generic AL driver / GP-UQ recipe / aero adapter) designed for reuse on other UQ-based regression problems. - Adds
FieldVariationalGPHeadtophysicsnemo.experimental.uq, a pointwise independent multitask variational GP head for per-point, multi-channel field uncertainty. It is the field sibling ofVariationalGPHead(which pools a geometry to one embedding and predicts a scalar): it keeps the point dimension and returns one Gaussian posterior per point per channel, so a single forward pass yields the field prediction, the total predictive variance and the epistemic-only variance — no ensembling or MC-Dropout. Backbone-agnostic (it consumes only a(..., input_dim)feature tensor), with an optional DKL MLP, a Matérn ARD kernel (5/2 by default), float64 GP internals, anl2_radialfeature normalization that preserves the radial out-of-distribution cue, and an optional heteroscedastic observation-noise MLP. Includes a surface field-GP training recipe for GeoTransolver (examples/cfd/external_aerodynamics/transformer_models/src/train_field_gp.py). - Adds a
return_point_featuresforward flag tophysicsnemo.models.geotransolver.GeoTransolver, which additionally returns the per-point latents computed just before the output projection. These are the features a pointwise head such asFieldVariationalGPHeadconsumes. - Adds
LatentNoveltyQueryStrategyto the active-learning aero recipe, a third acquisition strategy that ranks unlabeled samples by their average kNN cosine distance in the encoder's learned geometry latent — reusing the sameOODGuard(physicsnemo.experimental.guardrails.embedded) that flags out-of-distribution inputs at inference time. The guard is calibrated on the currently labeled set each round; round 1 falls back to class-balanced random because the calibration buffer is empty. New publicOODGuard.score_geometry()method exposes the raw per-sample geometry-latent kNN distance as a continuous score for downstream consumers (e.g. AL acquisition) without the boolean thresholding / warning emission ofOODGuard.check(). - Adds rotary position embedding (RoPE) modules to
phyiscsnemo.nnand integrates support for 2D RoPE in the neighborhood attention backend ofDiTlayers. - Adds support for RoPE, dynamic invalid-region masking, and a new
ConvDetokenizerinphyiscsnemo.models.DiT. Invalid regions are supplied per forward call via theinvalid_maskargument ofDiT.forward(a per-sample, batch-variable pixel mask, domain-parallel safe), replacing flagged tokens with a learned mask token. - Adds an inference script (
src/infer.py+conf/infer.yaml) to the Unified External Aero Recipe (examples/cfd/external_aerodynamics/unified_external_aero_recipe), with integrated aerodynamic force/moment coefficients (src/forces.py: CD/CL/CS/CMR/CMP/CMY). The script is model/dataset-agnostic, writes one native.pdmshDomainMeshper sample (carrying physical-unitpred_<field>/true_<field>), reports training-space metrics (matching the training/validation loop), and reuses the trainer's dataloader / collate / metric tooling (refactored intodatasets.pyandutils.py). - Adds
physicsnemo.mesh.spatial.signed_distance_field, aMesh-typed wrapper over the Warp-backedphysicsnemo.nn.functional.signed_distance_fieldop (CPU and CUDA), returning(sdf, hit_points, hit_faces)per query. The sign comes from Warp's angle-weighted pseudo-normal (robust at sharp/non-convex edges) or, withuse_sign_winding_number=True, its generalized winding number (robust on non-watertight meshes). (Near-)degenerate faces, which the Warp mesh query would otherwise skip, are repaired into equivalent thin-but-valid triangles before the query. Supersedes and removes the private datapipes implementation (physicsnemo.datapipes.transforms._sdf_torch/_sdf_triton); the public datapipes SDF transform delegates here. - Added an iterable style dataset to physicsnemo datapipes, for on-the-fly gpu simulations.
- DPS guidance now supports non-uniform guidance strength: the
std_yandgammaarguments ofphysicsnemo.diffusion.guidance.ModelConsistencyDPSGuidance/DataConsistencyDPSGuidanceand theirphysicsnemo.diffusion.multi_diffusioncounterparts accept tensors as well as floats. A tensor assigns a different measurement-noise level / SDA scaling to each observation component, e.g. per-channel ((1, C, 1, 1)) or pointwise (full observation shape). Passing floats keeps the previous uniform behavior unchanged. - Adds
relative_mseandrelative_l2(target-normalized regression errors,relative_l2 = sqrt(relative_mse)) tophysicsnemo.metrics.general(relative_error.py), with optional elementweightsanddim-based reduction matchinggeneral.mse. physicsnemo.metrics.general.msemse/rmsegain an optionalweightsargument for a masked/weighted mean (backward-compatible;weights=Nonereproduces the prior unweighted result).- Adds a kinetic Monte Carlo (KMC) surrogate example
(
examples/kinetic_monte_carlo): a probabilistic autoregressive surrogate (ParticleGeoTransolver) that emulates a KMC event stream, predicting the next event (the new particle's features and inter-event delay) from the current particle population, an optional background mesh, and the simulation time. Independent rollouts form an ensemble for uncertainty quantification. - Adds an FP-DDM domain-decomposition example (
examples/tcad/fp_ddm): an overlapping Schwarz method for steady 2-D thermal problems with a physics-informed PhysicsNeMo FNO local solver, a matrix-free finite-volume reference solver, and a numerical plane-stress elasticity baseline.
- Splits the monolithic
physicsnemo.diffusion.noise_schedulers.noise_schedulersandphysicsnemo.diffusion.samplers.solversmodules into one module per class, named after the schedule or solver it defines, with theNoiseSchedulerandSolverprotocols in abase.pyof their respective sub-package. Implementations are unchanged and every class is still re-exported fromphysicsnemo.diffusion.noise_schedulersandphysicsnemo.diffusion.samplers, so the public import paths stay the same. The two old module paths remain as deprecated shims that re-export the same classes and raise aDeprecationWarningon import, so existing code keeps working. Import fromphysicsnemo.diffusion.noise_schedulersandphysicsnemo.diffusion.samplersinstead. physicsnemo.nn.functional.signed_distance_fieldnow returns a 3-tuple(sdf, hit_points, hit_faces)—hit_facesis the int64 index of the triangle holding each closest point. Queries with no triangle withinmax_distnow returnNaNdistance/hit point and a-1face index (previously the out-of-band results were undefined: the kernel read from an uninitialized face index). Mesh-index range validation on CUDA inputs is now a device-side assert instead of a host-synchronizing check, so the op is safe on a sync-free prefetch stream; the eagerValueErroris kept on CPU.- Optimizes the production container build by consolidating related filesystem operations, using BuildKit bind and cache mounts, and separating custom, declared, and project dependency installation. Reduces total physicsnemo layers by around 78%.
GeoTransolver.forward'sreturn_embedding_statesandreturn_point_featuresare now keyword-only. They share a return signature, so a positionalTruedid not say which was meant. Callers already passing them by keyword are unaffected.ShardTensor.redistributenow computes receive shapes analytically when sharding shapes are known, skipping the shape-negotiationall_to_allcollective (falls back to the collective only when shapes are unavailable).- PhysicsNeMo-Mesh tensor-valued gradients now consistently use the documented
derivative-first layout
(entity, spatial_dimension, *value_shape)across LSQ, intrinsic LSQ, and DEC. Earlier LSQ releases returned(entity, *value_shape, spatial_dimension)instead; migrate a stored legacy gradient withlegacy_gradient.movedim(-1, 1). Divergence and curl values are unchanged. - xDeepONet
SpatialBranch(physicsnemo.experimental.models.xdeeponet.SpatialBranch) now supports mixed-precision (AMP/autocast) training: FFT-based spectral convolutions are evaluated in float32 internally (cuFFT lacks complex-half support) while the rest of the branch uses autocast. This is a no-op under full precision, so fp32 outputs are unchanged. Also fixes a stale module docstring that referenced removed trunk/MLP-branch builder helpers. physicsnemo.mesh.remeshing.remeshnow raisesNotImplementedErrorfor non-2D-in-3D inputs (the remeshing implementation is surface-only) instead of failing confusingly downstream, and its docstring reflects that restriction.physicsnemo.mesh.spatial:BVH.from_meshandClusterTree.from_pointsnow share a single morton-LBVH node-topology builder (spatial/_lbvh.py), removing ~80 lines of duplicated build logic; construction output is byte-identical.BVH.from_meshnow defaults toleaf_size=1(was 8), matchingClusterTree.from_pointsand measured to be more performant across platforms (smaller leaves yield fewer candidate cells per query). Containment / nearest-cell query results are unchanged. Adds the first direct unit tests forClusterTree(construction invariants, aggregates, dual-tree cover).physicsnemo.meshperformance: eliminated host-device syncs on hot paths. Cached topological adjacencies now store theAdjacencyobject directly instead of reconstructing it (which re-ran its syncing__post_init__validation) on every lookup — making cached adjacency lookups ~120x faster on GPU (~335us → ~3us for a 10k-point sphere); the BVH leaf-hit expansion drops two per-traversal-level syncs; and the Laplacian smoother reuses its per-iteration buffers in place instead of reallocating them.physicsnemo.mesh.Mesh.slice_cellsnow acceptsNone/Ellipsis(keep all cells, return self), matching its type hint andslice_points;gaussian_curvature_cellsreuses the cachedgaussian_curvature_verticesproperty instead of recomputing it.physicsnemo.mesh.Meshconvenience methods now directly reuse shared canonical functions, removing duplicate implementation bodies and docstrings. This includes geometric, deformation (including radial-basis-function deformation), calculus, topology, visualization, and validation operations.physicsnemo.mesh:drawandvalidateare now the canonical standalone names matchingMesh.drawandMesh.validate. Thedraw_meshandvalidate_meshremain as pending-deprecation compatibility names.Mesh.validateandDomainMesh.validateshare the canonical validation option order, preserve the historical positionaltoleranceargument, and expose the newcheck_self_intersectionoption as keyword-only.physicsnemo.mesh:validate(check_self_intersection=True)now raisesNotImplementedError(the check is unimplemented) instead of silently returning aNonesentinel that masquerades as "no self-intersections found".Mesh.strip_cachesandDomainMesh.strip_cachesnow accept akeepargument for retaining selected cache entries while clearing the rest.Mesh.with_pointsandMesh.with_cellsprovide cache-aware coordinate and connectivity replacement for operations that preserve point or cell indexing, while data-only mesh transforms now preserve valid geometry and topology caches throughMesh.with_data.physicsnemo.meshquality metrics now use a normalized aspect ratio of longest edge to minimum altitude. The metric is dimensionless and scale-invariant for simplices of every manifold dimension, and a regular simplex now hasaspect_ratio=1andquality_score=1. This intentionally corrects the previous erroneous aspect-ratio and quality-score values.Mesh.quality_metricsandMesh.statisticsagain use explicit property getters so their class-facing documentation describes argument-free property access. Configurable statistics tolerance remains available through the standalonecompute_mesh_statisticsfunction.- Performance improvements in the diffusion module: reduced peak memory of
DPS-guided diffusion sampling most notably for multi-diffusion at large
domains. A guided
sample()loop run undertorch.no_grad()now detaches the state between solver steps, so the guidance autograd graph is no longer accumulated across the sampling trajectory (sampled outputs are unchanged; usetorch.no_grad(), nottorch.inference_mode()). Also expands CI test coverage and adds an API documentation page forphysicsnemo.diffusion.multi_diffusion. - Performance improvements in IO prefetching and GPU preprocessing in physicsnemo datapipes.
⚠️ BC-impact (DPS guidance): a customnormcallback passed tophysicsnemo.diffusion.guidance.ModelConsistencyDPSGuidance/DataConsistencyDPSGuidance(and theirphysicsnemo.diffusion.multi_diffusioncounterparts) must now return an elementwise loss (same shape as its inputs) instead of a per-batch-element reduced scalar of shape(B,). Migration: drop the reduction from yournorm, e.g. return(y_pred - y_true).abs().pow(2)rather than(y_pred - y_true).pow(2).reshape(B, -1).sum(dim=1). ForDataConsistencyDPSGuidance(and itsmulti_diffusioncounterpart) thenormcallback now also receives the unmasked(x_0, y)and the mask is applied to its output (mask * norm(x_0, y)), where it previously received the pre-masked(mask * x_0, mask * y); the two agree for the built-inLpnorms, but a customnormthat relies on unobserved entries being zeroed before the call may differ. The integernormselector (e.g.norm=2) is unaffected.Mesh.transformandcompute_cotan_weights_femnow use the non-checkingtorch.linalg.inv_ex/solve_exsolvers, and build their index tensors on device. The checked solvers read a status code back to the host on every call, which synchronizes on CUDA; removing that and the index-tensor uploads takesMesh.transformon a cached codimension-one mesh from three host synchronizations to one, andcompute_cotan_weights_femfrom six to three. As a consequence,Mesh.transform(..., assume_invertible=True)no longer raises when the matrix is in fact singular: it propagates NaN caches instead, as its docstring now documents. The defaultassume_invertible=Nonestill tests the determinant and is unaffected.physicsnemo.experimental.uq.VariationalGPHeadnow takesn_trainas a required keyword-only argument, along with every argument afterinput_dim. It was annotated optional while the constructor raised onNone, so callers that already pass it by keyword are unaffected. It also gainsmatern_nu, which was previously hardcoded to 2.5 (still the default).
physicsnemo.mesh.calculus.integrate_cell_dataandintegrate_point_dataare deprecated in favor ofintegrate(..., data_source="cells"|"points"). Compatibility wrappers remain available for this release and emitLegacyFeatureWarning.
MeshReader/DomainMeshReadersample discovery no longer usespathlib.Path.glob, which can silently drop entries under filesystem metadata-server load (Lustre), causing training to proceed on a subset of the dataset.- Unified external aerodynamics volume datasets now preserve in-file boundaries
by default, so GLOBE can resolve
boundaries.vehicleduring collation. Point-based volume model templates explicitly opt into the existing boundary-dropping reader optimization. compute_cotan_weights_fem, and the calculus, curvature, and smoothing routines built on it such asMesh.laplacian, no longer fail on degenerate cells in float32. The Gram-matrix regularization is now scale-free, so it also covers cells with no extent — including the null cells thatMesh.padandMesh.pad_to_next_powerinsert — and flat cells at large coordinate values, both of which previously raised a singular-matrix_LinAlgErrorfromtorch.linalg.inv. Weights for non-degenerate cells are unchanged bit for bit.- Multinomial index sampling now uses one shared
weighted_multinomialfunctional across datapipes, DoMINO, and remeshing. Its core API followstorch.multinomial, adds allocation-free integer input for uniform populations, and supports sampling with or without replacement. Exact sampling without replacement usestorch.randpermor a chunked exponential race, with an explicit low-memory Poisson-gap approximation for uniform sampling. This removes thetorch.multinomial2^24category limit for sampling without replacement, consolidates duplicated Poisson index samplers, and fixes incorrect chunk-local indices and biased per-chunk quotas in DoMINO. - Unified external aerodynamics recipe: the aggregate metrics reported for
vector fields under the bare field name (e.g.
wss_l2, likewise_l1/_mae) were computed on per-point vector magnitudes, so direction errors were invisible — a prediction with the correct magnitude but wrong direction at every point scored 0. The bare-name aggregate is now computed over all components jointly (whole-field relative norms, Frobenius forl2). The broken magnitude-only aggregate is not retained under a separate key. Per-component metrics (wss_x_l2, ...) were always direction-sensitive and are unchanged, and training/checkpoints are unaffected (the training objective goes throughLossCalculator, not this metric path) — only reported aggregate vector metrics were misleading. - Unified external aerodynamics recipe: model templates can now carry
known-good training overrides (
train.yaml's_self_merges before the model template; all existing templates resolve identically). The GLOBE example now uses the recipe's defaultcompileand learning-rate settings — both measured equivalent or better than the previously documented overrides on the DrivAerML surface case — and no longer setstraining.field_weights={pressure: 1.0, wss: 100.0}, which was redundant withNormalizeMeshFieldsnormalization and starved the pressure field of gradient signal (~2x worse converged pressure L2 at equal WSS L2). ShardTensornow survivestorch.compile/ AOTAutograd for tensor-subclass users:__tensor_unflatten__no longer forcesrequires_gradon the reconstructed inner (matching DTensor, so the inner/wrapper flags cannot disagree and tripassert_metadata_equnder a Dynamo graph-break re-fake), and__coerce_same_metadata_as_tangent__is subclass-friendly — it accepts a subclass's nested flatten context, treats empty andNonesharding-shape maps as equal, and rebuilds a differingShardTensor-subclass tangent via that type's own__tensor_unflatten__instead of returningNone(the plain-tensor /DTensorcross-typeNoneconvention is preserved).ShardTensor.to_local()(and op-result forwards feeding it) is now differentiable undertorch.compile/ AOTAutograd. Previously the compiled backward was silently dropped (zero / missing gradient): ShardTensor's__torch_function__eager fallback converts toDTensorthroughautograd.Functions that AOTAutograd traces through, severing the primal's gradient connection during the joint trace. Under tracing, unpatched ops now pass through to__torch_dispatch__(mirroringDTensor, which defines no__torch_function__), keeping the graph differentiable while eager behavior and registered shard patches are unchanged.- Datapipe contiguous-block subsampling now wraps cyclically, giving boundary and interior elements equal inclusion probability.
- Cell-subsampled GLOBE inputs now retain their effective integration measure, preventing area-weighted outputs and gradients from collapsing.
SetGlobalFieldnow writes injected fields to the domain-levelglobal_dataof aDomainMesh, in addition to the existing per-sub-mesh broadcast. Previously, code readingDomainMesh.global_datanever saw the injected fields.physicsnemo.mesh.io.from_pyvista(..., force_copy=True)now copies attached point, cell, and global data as well as geometry. The matching newto_pyvista(..., force_copy=True)option prevents exported PyVista geometry and data from mutating the sourceMeshthrough shared CPU storage.physicsnemo.mesh.io.from_pyvistanow supports native line/poly-line grids, pixels, triangle strips, and pentagonal/hexagonal prisms, and selects explicit dimensions from mixedUnstructuredGridinputs while preserving selected parent data. Explicit 1D conversion still derives the unique edge graph when no native lines exist. Connectivity and attached-data invariants are validated before VTK filters run. Unsupported higher-order topology is rejected pending globally conforming tessellation, while explicit vertex point-cloud conversion remains available without interpreting that topology. Centroid conversion rejects parents that cannot preserve cell-data alignment.physicsnemo.mesh.sampling.sample_data_at_pointsnow handles integer and boolean fields by returningfloat64, so NaN sentinels and non-integral interpolation or multi-cell means are representable (subject to the usualfloat64precision limits). Point-data interpolation now promotes field and geometry dtypes consistently, and accumulation uses fewer full-sized temporaries and CUDA host synchronizations.Mesh.point_data_to_cell_datanow handles integer and boolean point fields by returningfloat64, instead of raisingmean(): could not infer output dtype. A mean of integers is generally non-integral, so it is computed in floating point (subject to the usualfloat64precision limits). This matchesMesh.cell_data_to_point_data, which already promoted discrete fields the same way; floating-point and complex fields are unaffected.physicsnemo.mesh.projections.extrudenow produces a conforming (crack-free) simplicial complex for multi-cell inputs. Each prism was previously tessellated using the per-cell local vertex order, so adjacent cells that listed a shared edge's endpoints in different orders split the shared quad face along opposite diagonals; the resulting non-manifold volume leaked interior crack faces intoget_boundary_mesh(boundary edges shared by 4 faces — e.g. an extruded L-shape or any multi-column grid, which also brokerepair.fix_orientation). Parent-cell vertices are now sorted into a global order before tessellation (the Freudenthal-Kuhn subdivision), a no-op for already-sorted inputs.physicsnemo.mesh.generate.marching_cubesnow acceptsbfloat16fields by converting them tofloat32before crossing the NumPy boundary.physicsnemo.mesh.projections.extrudenow returns consistently oriented cells for full-dimensional (codimension-0) output.physicsnemo.mesh.remeshing.remeshnow preserves the input mesh's device and floating dtype instead of dropping them to CPU/float32.physicsnemo.mesh.io.to_pyvistanow preserves supported dtypes for attached point, cell, and global data instead of narrowing every array tofloat32. Reduced-precision floating-point values are promoted only as needed for VTK.physicsnemo.mesh.io.from_pyvistaandto_pyvistanow preservefloat64point coordinates instead of unconditionally narrowing geometry tofloat32, which could collapse small features on meshes with large coordinate offsets. Existingfloat32geometry remainsfloat32.physicsnemo.mesh:Mesh.to(<float dtype>)andDomainMesh.to(<float dtype>)raisedTypeError: cells must have an int-like dtypebecause the cast was applied to the integercellstensor. A floating/complex dtype is now applied only to floating tensors; the integercells(and any integer data) are preserved. Device moves are unchanged.physicsnemo.mesh: fixed several silent-wrong-result bugs —slice_cellscarried stale point-level and non-local (gaussian_curvature) caches onto the sliced mesh; the intrinsic LSQ gradient returned all-zeros for codimension >= 2 manifolds (now estimates the tangent space via local PCA);smooth_laplacianreturned stale geometry caches after its in-place point update;transformpropagated an incorrect point-normals cache under anisotropic/shear maps; and the derived-mesh methods (compute_point_derivatives,compute_cell_derivatives,cell_data_to_point_data,point_data_to_cell_data) aliased the source mesh's mutable_cache.physicsnemo.mesh.spatial.ClusterTree.compute_source_aggregatesnow normalizes with its call-time area weights instead of the weights used when constructing the tree, preserving correct aggregates when weights change.physicsnemo.mesh: fixed crash / data-integrity bugs —project(...)withtransform_point_data/transform_cell_data=Truemutated the input mesh in place; visualization andto_pyvistacrashed on autograd-tracked tensors (now detached before.numpy()); and integer/bool data crashed (safe_epson an integer dtype) or truncated via integer division during facet/scatter aggregation (now computed in a floating dtype).physicsnemo.mesh: averaging a complex point or cell field no longer silently returnsfloat64with the imaginary part discarded. Complex tensors are not "floating point" bytorch's definition, so facet/scatter aggregation promoted them like an integer field, corruptingMesh.cell_data_to_point_data,Mesh.get_facet_mesh(bothdata_sourcesettings), andrepair.merge_duplicate_points. A"mean"still requires real weights, because its divisor is clamped away from zero andclamprejects complex dtypes; a"sum"accepts complex weights and promotes to the common dtype of the values and the weights.physicsnemo.meshMorton-code quantization now handles empty inputs, tiny extents, half-precision coordinates, and one-dimensional endpoints correctly.physicsnemo.mesh: fixed Loop subdivision pulling open boundaries inward (now applies the boundary/crease mask); subdivision zero-filling integer/boolpoint_dataat new edge vertices (now inherits a parent label); non-deterministic orientation flips and over-counted component sizes inrepair.fix_orientation; random point sampling drawing barycentric weights in float32 for float64 meshes; andMesh.mergenot validatingpoint_data/global_datakey consistency.- Fixed
DefaultTrainingLoopreadingDistributedManager.deviceat the class level (apropertydescriptor) instead ofDistributedManager().device, which left the loop's device set to apropertyobject under an initializedDistributedManager(physicsnemo/active_learning/loop.py). - Replaced three plain-string regex / docstring literals containing invalid
escape sequences with raw-string equivalents
(
physicsnemo/utils/logging/launch.py,physicsnemo/metrics/general/calibration.py,physicsnemo/metrics/general/crps.py); these wereSyntaxWarnings today and becomeSyntaxErrors in Python 3.16. - Various test cleanups to remove self-inflicted warnings in CI output:
disabled pytest collection for
TestModelA/TestModelBhelpers intest/core/test_registry.pyvia__test__ = False; migratedtest/nn/module/test_interpolation.pyto call the non-deprecatedgrid_to_point_interpolationand added a dedicated test for the deprecation alias; scoped alr_scheduler.step()-before-optimizer.step()UserWarningfilter to a single test intest/optim/test_combined_optimizer.py; guarded theDistributedManager.initialize()calls intest/utils/test_checkpoint.pywithis_initialized(); and suppressed the import-timeExperimentalFeatureWarningintest/datapipes/healda/test_features.pyviawarnings.catch_warnings(). - Fixed
physicsnemo.utils.get_checkpoint_dirreturning paths with\separators on Windows (e.g..\checkpoints_model), which was inconsistent with the/-based paths used elsewhere in the checkpoint utilities and broke thetest_get_checkpoint_dirCI test on Windows. The function now always joins with/, working uniformly for local paths andfsspecURIs (msc://, etc.) across operating systems.
- Raises the minimum TensorDict version to
tensordict[zarr]>=0.14.0, restoring the stabletensordictdistribution while retaining Zarr support and upstream bug fixes. - Removes
pyacvdfrom themesh-extrasoptional dependencies. Remeshing now uses NVIDIA Warp. - Updates the minimum supported
warp-langversion to 1.14.0.
- Adds GLOBE model (
physicsnemo.experimental.models.globe.model.GLOBE), including new variant that uses a dual tree traversal algorithm to reduce the complexity of the kernel evaluations from O(N^2) to O(N). - Adds GLOBE AirFRANS example case (
examples/cfd/external_aerodynamics/globe/airfrans) - Adds GLOBE DrivAerML example case (
examples/cfd/external_aerodynamics/globe/drivaer) - Adds drop-test dynamics recipe.
- Adds concrete dropout uncertainty quantification for GeoTransolver. Learnable
per-layer dropout rates enable MC-Dropout inference for uncertainty
estimates. Disabled by default (
concrete_dropout: false). - Adds automatic support for
FSDPand/orShardTensormodels in checkpoint save/load functionality - PhysicsNeMo-Mesh now supports conversion from PyVista/VTK/VTU meshes that may contain polyhedral cells.
- In PhysicsNeMo-Mesh, adds
Mesh.to_point_cloud(),.to_edge_graph(), and.to_dual_graph()methods. These allow Mesh conversion to 0D point clouds, 1D edge graphs, and 1D dual graphs, respectively, when connectivity information is not needed. - Adds
physicsnemo.mesh.generatesubpackage withmarching_cubesfor isosurface extraction from 3D scalar fields, returning aMeshobject. Supports the NVIDIA Warp backend. - Adds a type system to PhysicsNeMo-Mesh, allowing annotation of Mesh dimensions
using notation like
Mesh[2, 3]for a 2D manifold in 3D space. - Adds adjacency caching to PhysicsNeMo-Mesh
Meshobjects, allowing efficient reuse of neighbor information. - Adds
DomainMeshclass for grouping an interior mesh with named boundary meshes and domain-level metadata, with passthrough geometric transforms (translate, rotate, scale, transform) and data operations. - Allows selective per-field transformation of
Meshobjects:transform_point_data,transform_cell_data, andtransform_global_datanow acceptbool | TensorDict(or plaindictfor convenience). - Adds
physicsnemo.mesh.remeshingsubpackage withpartition_cells()for creating Voronoi regions around seed points. BVH-accelerated. - Added support for 1D, 2D, and 3D neighborhood attention (natten) via
physicsnemo.nn.functionalinterface, with fullShardTensorsupport. - Added derivative functionals in
physicsnemo.nn.functionalforuniform_grid_gradient,rectilinear_grid_gradient,spectral_grid_gradient,meshless_fd_derivatives,mesh_lsq_gradient, andmesh_green_gauss_gradient. - Adds
physicsnemo.symmodule for symbolic PDE residual computation (PhysicsInformer). Users define PDEs via SymPy and select a gradient method (autodiff,finite_difference,spectral,meshless_finite_difference,least_squares); spatial derivatives are computed automatically using thenn.functional.derivativesfunctionals. - Ports all physics-informed examples (LDC PINNs, Darcy, Stokes MGN, DoMINO,
datacenter, xaeronet, MHD/SWE PINO) to the new
physicsnemo.syminterface, replacing the separatephysicsnemo-sympackage dependency. Geometry is now handled viaphysicsnemo.meshand PyVista. - Added geometry functionals in
physicsnemo.nn.functionalformesh_poisson_disk_sample,mesh_to_voxel_fraction, andsigned_distance_field. - Added rendering functionals in
physicsnemo.nn.functionalfor isosurface, mesh, volume, LIC, point cloud, wireframe, and RGBA transfer rendering, with Warp kernels for rendering and PyTorch fallbacks for transfer functions. - Adds embedded OOD guardrail
OODGuardatphysicsnemo.experimental.guardrails.embedded, optionally wired intoGeoTransolvervia a newguard_configconstructor argument. The guard calibrates per-channel global bounds and a geometry-latent kNN threshold during training, and emits warnings on out-of-distribution inputs at inference. - In PhysicsNeMo-Mesh,
physicsnemo.mesh.geometrynow publicly exposesstable_angle_between_vectorsandcompute_triangle_angles(previously only available via the privatephysicsnemo.mesh.curvature._utils). - PhysicsNeMo Datapipes enables reproducability through
torch.generatorutilities. - PhysicsNeMo Datapipes now supports
physicsnemo.mesh.Meshandphysicsnemo.mesh.DomainMeshobjects for deserialization, with transformations and utilities for mesh-based datasets. - PhysicsNeMo Datapipes now support
MultiDatasetconstruction, allowing on-the-fly construction of multi-source composite datasets that can be sampled and processed efficiently and coherently as one dataset. - PhysicsNeMo Datapipes also support random augmentations for
mesh-based datapipes, leveraging
torch.distributionsfor broad random distribution support. Mesh and DomainMesh datasets allow random translation, scaling, and rotation of mesh data in coherent ways, compatible with reproducability features of physicsnemo datapipes. - Adds a new unified training recipe for external aerodynamics that supports training on multiple datasets (DrivaerML, ShiftSUV, HighLiftAeroML, or more, bring your own, mix and match), supports training several different models (Domino, Transolver, GeoTransolver, Flare, GeoTransolver with Flare-attention, bring your own!). Leverages mesh datasets and non-dimensionalization to enable dataset mixing and matching at runtime. Train with surface or volume data.
- Adds a new
physicsnemo.diffusion.multi_diffusionsubpackage that scales 2D diffusion models to large domains via patch-based training and inference. ProvidesMultiDiffusionModel2D(wraps a base model and handles state patching, conditioning preprocessing, positional-embedding injection, and per-patch output fusion), theMultiDiffusionMSEDSMLoss/MultiDiffusionWeightedMSEDSMLosslosses for patch-based DSM training, andMultiDiffusionPredictorfor sampling (plugs straight intosample()/get_denoiser()and the standard solvers). Patching primitives (BasePatching2D,GridPatching2D,RandomPatching2D) are exposed under the same subpackage and aretorch.compile-friendly withfullgraph=True.MultiDiffusionPredictorsupports memory-efficient inference on large domains viachunk_sizeanduse_checkpointing. The subpackage also ships patch-local DPS guidance:MultiDiffusionDPSScorePredictor(drop-in score predictor that plugs into the standard sampling stack),MultiDiffusionDataConsistencyDPSGuidancefor inpainting and sparse data assimilation, andMultiDiffusionModelConsistencyDPSGuidancefor generic patch-local observation operators. Use these instead of the globalDPSScorePredictorto run guided sampling on domains that would otherwise OOM. - Adds
"epsilon"as a supported prediction type throughout the diffusion framework, alongside the existing"x0"and"score"modes. A newPredictorType = Literal["x0", "score", "epsilon"]alias inphysicsnemo.diffusion.baseis wired through losses (MSEDSMLoss,WeightedMSEDSMLoss, and the multi-diffusion losses), preconditioners, samplers / solvers, DPS guidance, and noise schedulers, enabling end-to-end training and sampling of epsilon-parameterized models. Losses gain anepsilon_to_x0_fnkwarg used for the epsilon-to-x0 conversion required during DSM training. - Added support for Batched radius search, which enables Domino and GeoTransolver with local features and batch size > 1.
- Added the underfill recipe.
- Improved crash recipe with configurable stats directory.
physicsnemo.mesh.sampling.find_nearest_cellsuses a KNN-backed implementation, and no longer accepts thebvh=,chunk_size=,max_rounds=, ormax_candidates_per_point=parameters.⚠️ BC-impact (deep imports): internalphysicsnemo.nn.functionalmodules were reorganized by category. Public top-level functional imports are unchanged, but code importing internal module paths directly (for examplephysicsnemo.nn.functional.knnorphysicsnemo.nn.functional.radius_search) should migrate tophysicsnemo.nn.functional.neighbors.*.- Consolidated Warp interpolation kernels for grid-to-point and point-to-grid backends, and added missing kernel/helper docstrings.
- In PhysicsNeMo-Mesh, dual-mesh primitives gained closed-form fast paths
for triangle meshes embedded in 3D.
compute_circumcentersis up to ~10000x faster (e.g. 11 s -> ~1 ms on a 360 K-triangle AirFRANS mesh, RTX 4090) by replacing batchedtorch.linalg.lstsqover (2, 3) systems with a closed-form cross product, andcompute_vertex_anglesis up to ~15x faster on the same meshes by replacing the dimension-agnostic Gram-determinant formula with anatan2(||cross||, dot)formulation. Anything that depends on these (Gaussian curvature, FEM Laplacian, cotangent weights, Voronoi areas, smoothing) inherits the speedup. Seeperf.mdfor the full audit. - In PhysicsNeMo-Mesh, BVH construction is faster on GPU.
_compute_morton_codeshas a CUDA-specific fused-bits path that eliminates then_bitssequential kernel launches of the previous bit-loop (5-8x speedup on small / medium meshes), andBVH.from_meshreuses the cachedMesh.cell_centroidsinstead of recomputing. End-to-endBVH.from_meshis ~2x faster on a 162 K-tetcube_volumemesh. - In PhysicsNeMo-Mesh, the topology-dedup APIs
(
categorize_facets_by_count,find_edges_in_reference,remove_duplicate_cells,build_adjacency_from_pairs) gained optionalindex_bound/n_targetsparameters. When the caller passes a strict upper bound (typicallymesh.n_pointsormesh.n_cells), the implicittensor.max().item()GPU sync is avoided and the dedup uses a packed int64 unique (via the new internalunique_index_tuples) and a single composite-key argsort. End-to-endget_boundary_edgesandcell_to_cells_adjacencyare ~2x faster on practical-size unstructured meshes (e.g. 360 K-triangle AirFRANS). ⚠️ BC-impact (deep imports): in PhysicsNeMo-Mesh,stable_angle_between_vectorsandcompute_triangle_anglesmoved fromphysicsnemo.mesh.curvature._utilstophysicsnemo.mesh.geometry._angles. The old private path is no longer available; use thephysicsnemo.mesh.geometryre-export instead.⚠️ BC-impact (pre-release rename): in PhysicsNeMo-Mesh,DomainMesh.applywas renamed toDomainMesh.apply_to_meshes. The original name shadowed the recursiveTensor -> Tensorapplymethod that@tensorclassauto-injects, breaking duck-type symmetry withMesh.applyfor any code that handled both classes. After the rename,dm.apply(tensor_fn)works as expected (recurses through every leaf tensor ininterior,boundaries, andglobal_data); the original Mesh-to-Mesh broadcast is nowdm.apply_to_meshes(mesh_fn). Early adopters of the unreleasedDomainMeshAPI should rename their.apply(...)callsites to.apply_to_meshes(...).- Refactored the patching utilities under
physicsnemo.diffusion.multi_diffusion.patching. Patching and fusion operations are now more performant andtorch.compile-friendly (e.g.fullgraph=True,error_on_recompile=True). - Refactored the
examples/geophysics/diffusion_fwifull-waveform inversion example to use the consolidatedphysicsnemo.diffusionAPI (preconditioners, samplers, losses, DPS guidance) and removed the recipe-local copies of these utilities underutils/. - Refactored the
examples/generative/topodiffrecipe to use the consolidatedphysicsnemo.diffusionAPI (MSEDSMLosswithprediction_type="epsilon",sample(),DPSScorePredictor) plus a recipe-local DDPM scheduler, solver, and classifier guidance. Removed the now-unusedDiffusion,DatasetTopoDiff, andload_data_topodiffabstractions fromphysicsnemo.models.topodiff. - Significantly expanded CI test coverage for
physicsnemo.diffusion, including new tests for samplers, solvers, preconditioners, losses, DPS guidance, multi-diffusion, and patching utilities, plus combined-workflow and from-checkpoint round-trip tests. Most tests run withfullgraph=Trueanderror_on_recompileto catchtorch.compileregressions. - Internal weight initialization in the distributed AFNO layers and the
EarthAttentionblocks ofphysicsnemo.nn.module.attention_layersnow dispatches totorch.nn.init.trunc_normal_directly instead of going through frozen in-tree copies of the pre-PyTorch-2.12 inverse-CDF implementation. PyTorch 2.12 reimplementedtrunc_normal_as a rejection-sampling loop on top ofnormal_()(see pytorch/pytorch#174997), so seeded from-scratch initialization consumes the RNG stream differently on 2.12+ vs older versions. Existing trained checkpoints are unaffected (loading bypasses init). Forward-accuracy reference outputs forAFNO,ModAFNO,Transolver,FLARE, andPanguwere regenerated against the new algorithm. Rather than wiring per-model skips,test.common.validate_forward_accuracynow uniformly skips ontorch < 2.12(the reference data is locked to that floor via a single_REFERENCE_DATA_MIN_TORCHconstant; bump it when a PyTorch release next changes an init/RNG algorithm any forward-accuracy model depends on, and regenerate the.pthfiles at the same time).
physicsnemo.utils.meshis deprecated and will be removed in v2.2.0. For isosurface extraction, usephysicsnemo.mesh.generate.marching_cubesinstead ofsdf_to_stl. For VTP/OBJ/STL file conversion (combine_vtp_files,convert_tesselated_files_in_directory), use VTK or PyVista directly.physicsnemo.nn.module.utils.trunc_normal_(and its submodule pathphysicsnemo.nn.module.utils.weight_init.trunc_normal_) is deprecated and will be removed in v2.2.0. It is now a thin wrapper aroundtorch.nn.init.trunc_normal_that emits aDeprecationWarningon call, replacing the frozen in-tree copy of the legacy inverse-CDF implementation. Usetorch.nn.init.trunc_normal_directly.- Deprecates the CorrDiff example (
examples/weather/corrdiff), which no longer receives maintenance, bug fixes, or new features. Use the regional high-resolution weather model example (examples/weather/regional_weather_diffusion) instead. That example unifies regional diffusion-based weather models, and covers the CorrDiff downscaling setting alongside other diffusion-based settings.
- The legacy in-tree
trunc_normal_implementation that lived inphysicsnemo/models/afno/distributed/layers.py(_trunc_normal_/_no_grad_trunc_normal_) is removed. These names were private; all in-tree call sites now usetorch.nn.init.trunc_normal_.
- Fixed functional benchmark plot fallback labeling so unlabeled ASV results use the same key ordering as the benchmark runner.
- Fixed graph break caused by
FunctionSpecdispatch (max(key=)is not supported bytorch.compile) - Fixed bug in Pangu, FengWu attention window shift for asymmetric longitudes
- Fixed a bug in
mesh.sampling.find_nearest_cells, where a mixup between L2 and L-inf norms could cause slightly incorrect nearest-neighbor assignments in highly skewed meshes. - Fixed TensorDict key-ordering bug in GLOBE's Barnes-Hut kernel that caused
incorrect results when
tensordict >= 0.12reordered leaves during TensorDict construction from dict literals mixing plain and nested keys. - In PhysicsNeMo-Mesh,
from_pyvistanow correctly handlesUnstructuredGridinputs in newerpyvistaversions, looking up cell-type buckets incells_dictwithnp.uint8(pv.CellType.X)keys rather than theIntEnumvalue, and skipping non-numeric VTK arrays (strings, objects) when copying point / cell / field data into theMeshTensorDicts instead of failing the conversion. - In PhysicsNeMo-Mesh, the
Meshconstructor now preserves data whenpoint_data/cell_data/global_dataare passed as a non-dictMapping(notably PyVista'sDataSetAttributes). Previously, withtensordict >= 0.12, the@tensorclass(tensor_only=True)auto-init silently wrapped such Mappings asNonTensorDataand dropped every key, so e.g.Mesh(cell_data=pv_mesh.cell_data, ...)produced an emptycell_data.Mesh.__post_init__now detects this wrapping and unwraps the original Mapping before coercing toTensorDict. Thetensor_onlyfast path is preserved, so internal Mesh constructions (slicing, transforms,from_pyvista) keep their full speed. Backed by new direct- construction regression tests, acell_data/global_datamemmap round-trip test, and a committed.pmshgolden fixture that locks the on-disk format against silent breakage in future changes. - In PhysicsNeMo-Mesh,
safe_eps(dtype)is now capped attorch.finfo(dtype).eps, which fixes a float16 corner case where the previoustiny ** 0.25floor exceeded machine epsilon and could corrupt fp16 mesh quantities. Ad-hoc+ 1e-10denominators insmooth_laplacianandcompute_quality_metricshave been replaced with the dtype-aware.clamp(min=safe_eps(dtype))to avoid silently zeroing fp16 weights. - Fixed a silent bug in loading state from checkpoint for
FSDP-backed models with
use_orig_params=Falseand channels last memory format. - Fixed issues with physicsnemo.nn.functional's
radius_searchthat caused crashes when used with torch.compile. - Fixed the sinusoidal positional embeddings formula in
SongUNetandMultiDiffusionModel2Dso it now follows the standardsin / cosconvention. Affected reference data was regenerated. - Constructing a
Mesh(orDomainMesh) inside atorch.compile-traced function no longer raisesAttributeError/KeyErroror silently produces wrong output. The breakage came from two regressions intensordict >= 0.12.0(PRpytorch/tensordict#1552), where the@tensorclassinit wrapper's bypass branch silently skipped both field-default normalization and__post_init__undertorch.compile. We pintensordict < 0.12until the upstream fix (pytorch/tensordict#1708,pytorch/tensordict#1709) ships, and add a regression test (test/mesh/mesh/test_compile.py) that constructs aMeshinsidetorch.compileand reads cached properties, so the same bug cannot return on a future pin bump unnoticed.
- Increments minimum viable PyTorch version to
torch>=2.5.0to support FSDP better - Upper-bounds
tensordict < 0.12to avoid thetorch.compileregressions intensordict >= 0.12.0(see corresponding entry under Fixed).
- Refactored diffusion preconditioners in
physicsnemo.diffusion.preconditionersrelying on a new abstract base classBaseAffinePreconditionerfor preconditioning schemes using affine transformations. Existing preconditioners (VPPrecond,VEPrecond,iDDPMPrecond,EDMPrecond) reimplemented based on this new interface. - New
physicsnemo.experimental.nn.symmetrymodule that implements building blocks that preserve 2D and 3D rotational equivariance using a grid-based layout for efficient GPU parallelization, and an emphasis on compacteinsumoperations. - Flare attention support for both Transolver and GeoTransolver models.
- PhysicsNemo v2.0 contains significant reorganization of tools. Please see the v2.0-MIGRATION-GUIDE.md to understand what has changed and why.
- DiT (Diffusion Transformer) has been moved from
physicsnemo.experimental.models.dittophysicsnemo.models.dit.
- Shape mistmatch bug in the Lennard Jones example
- CUDA backend is now selected via orthogonal
cu12/cu13extras rather than being hardcoded to CUDA 13. Feature extras (nn-extras,utils-extras, etc.) are now CUDA-agnostic and can be combined with either backend, e.g.pip install "nvidia-physicsnemo[cu13,nn-extras]". When neithercu12norcu13is specified, PyTorch is installed from PyPI using its default build (currently CUDA 12.8 on Linux). For development withuv, useuv sync --extra cu13(or--extra cu12) to select the backend.
- Added mixture_of_experts for weather example in physicsnemo.examples.weather.
⚠️ Warning: - It uses experimental DiT model subject to future API changes. Added some modifications to DiT architecture in physicsnemo.experimental.models.dit. Added learnable option to PositionalEmbedding in physicsnemo.models.diffusion.layers. - Added lead-time aware training support to the StormCast example.
- Add a device aware kNN method to physicsnemo.utils.neighbors. Works with CPU or GPU by dispatching to the proper optimized library, and torch.compile compatible.
- Added additional testing of the DoMINO datapipe.
- Examples: added a new example for full-waveform inversion using diffusion
models. Accessible in
examples/geophysics/diffusion_fwi. - Domain Parallelism: Domain Parallelism is now available for kNN, radius_search, and torch.nn.functional.pad.
- Unified recipe for crash modeling, supporting Transolver and MeshGraphNet, and three transient schemes.
- Added a check to
stochastic_samplerthat helps handle theEDMPrecondmodel, which has a specific.forward()signature - Examples: added a new example for reservoir simulation using X-MeshGraphNet.
Accessible in
examples/reservoir_simulation - Added abstract interfaces for constructing active learning workflows, contained
under the
physicsnemo.active_learningnamespace. A preliminary example of how to compose and define an active learning workflow is provided inexamples/active_learning. Themoonsexample provides a minimal (pedagogical) composition that is meant to illustrate how to define the necessary parts of the workflow. - Added a new example for temporal interpolation of weather forecasts using ModAFNO.
Accessible in
examples/weather/temporal_interpolation.
- Migrated Stokes MGN example to PyTorch Geometric.
- Migrated Lennard Jones example to PyTorch Geometric.
- Migrated physicsnemo.utils.sdf.signed_distance_field to a static return, torch-only interface. It also now works on distributed meshes and input fields.
- Refactored DiTBlock to be more modular
- Added NATTEN 2D neighborhood attention backend for DiTBlock
- Migrated blood flow example to PyTorch Geometric.
- Refactored DoMINO model code and examples for performance optimizations and improved readability.
- Migrated HydroGraphNet example to PyTorch Geometric.
- Support for saving and loading nested
physicsnemo.Modules. It is now possible to create nested modules withm = Module(submodule, ...), and save and load them withModule.saveandModule.from_checkpoint.⚠️ Warning: - The modules have to bephysicsnemo.Modules, and nottorch.nn.Modules. - Support passing custom tokenizer, detokenizer, and attention
Modules in experimental DiT architecture - Improved Transolver training recipe's configuration for checkpointing and normalization.
- Bumped
multi-storage-clientversion to 0.33.0 with rust client. - Improved configuration for DLWP Healpix (checkpoint directory) and GraphCast (W&B settings).
- Set
skip_scaleto Python float in U-Net to ensure compilation works. - Ensure stream dependencies are handled correctly in physicsnemo.utils.neighbors
- Fixed the issue with incorrect handling of files with consecutive runs of
combine_stl_solids.pyin the X-MGN recipe. - Fixed the
RuntimeError: Worker data receiving interruptederror in the datacenter example.
- Diffusion Transformer (DiT) model. The DiT model can be accessed in
physicsnemo.experimental.models.dit.DiT.⚠️ Warning: - Experimental feature subject to future API changes. - Improved documentation for diffusion models and diffusion utils.
- Safe API to override
__init__'s arguments saved in checkpoint file withModule.from_checkpoint("chkpt.mdlus", override_args=set(...)). - PyTorch Geometric MeshGraphNet backend.
- Functionality in DoMINO to take arbitrary number of
scalarorvectorglobal parameters and encode them usingclass ParameterModel - TopoDiff model and example.
- Added ability for DoMINO model to return volume neighbors.
- Added functionality in DoMINO recipe to introduce physics residual losses.
- Diffusion models, metrics, and utils: implementation of Student-t
distribution for EDM-based diffusion models (t-EDM). This feature is adapted
from the paper Heavy-Tailed Diffusion Models, Pandey et al..
This includes a new EDM preconditioner (
tEDMPrecondSuperRes), a loss function (tEDMResidualLoss), and a new option in corrdiffdiffusion_step.⚠️ This is an experimental feature that can be accessed through thephysicsnemo.experimentalmodule; it might also be subjected to API changes without notice. - Bumped Ruff version from 0.0.290 to 0.12.5. Replaced Black with
ruff-format. - Domino improvements with Unet attention module and user configs
- Hybrid MeshGraphNet for modeling structural deformation
- Enabled TransformerEngine backend in the
transolvermodel. - Inference code for x-meshgraphnet example for external aerodynamics.
- Added a new example for external_aerodynamics: training
transolveron irregular mesh data for DrivaerML surface data. - Added a new example for external aerodynamics for finetuning pretrained models.
- Diffusion utils:
physicsnemo.utils.generativerenamed intophysicsnemo.utils.diffusion - Diffusion models: in CorrDiff model wrappers (
EDMPrecondSuperResolutionandUNet), the argumentsprofile_modeandamp_modecannot be overriden byfrom_checkpoint. They are now properties that can be dynamically changed after the model instantiation with, for example,model.amp_mode = Trueandmodel.profile_mode = False. - Updated healpix data module to use correct
DistributedSamplertarget for test data loader - Existing DGL-based vortex shedding example has been renamed to
vortex_shedding_mgn_dgl. Added newvortex_shedding_mgnexample that uses PyTorch Geometric instead. - HEALPixLayer can now use earth2grid HEALPix padding ops, if desired
- Migrated Vortex Shedding Reduced Mesh example to PyTorch Geometric.
- CorrDiff example: fixed bugs when training regression
UNet. - Diffusion models: fixed bugs related to gradient checkpointing on non-square images.
- Diffusion models: created a separate class
Attentionfor clarity and modularity. UpdatedUNetBlockaccordingly to use theAttentionclass instead of custom attention logic. This will update the model architecture forSongUNet-based diffusion models. Changes are not BC-breaking and are transparent to the user. ⚠️ BC-breaking: refactored the automatic mixed precision (AMP) API in layers and models defined inphysicsnemo/models/diffusion/for improved usability. Note: it is now, not only possible, but required to explicitly setmodel.amp_mode = Truein order to use the model in atorch.autocastclause. This applies to allSongUNet-based models.- Diffusion models: fixed and improved API to enable fp16 forward pass in
UNetandEDMPrecondSuperResolutionmodel wrappers; fp16 forward pass can now be toggled/untoggled by settingmodel.use_fp16 = True. - Diffusion models: improved API for Apex group norm.
SongUNet-based models will automatically perform conversion of the input tensors totorch.channels_lastmemory format whenmodel.use_apex_gnisTrue. New warnings are raised when attempting to use Apex group norm on CPU. - Diffusion utils: systematic compilation of patching operations in
stochastic_samplerfor improved performance. - CorrDiff example: added option for Student-t EDM (t-EDM) in
train.pyandgenerate.py. When training a CorrDiff diffusion model, this feature can be enabled with the hydra overrides++training.hp.distribution=student_tand++training.hp.nu_student_t=<nu_value>. For generation, this feature can be enabled with similar overrides:++generation.distribution=student_tand++generation.nu_student_t=<nu_value>. - CorrDiff example: the parameters
P_meanandP_std(used to compute the noise levelsigma) are now configurable. They can be set with the hydra overrides++training.hp.P_mean=<P_mean_value>and++training.hp.P_std=<P_std_value>for training (and similar ones withtraining.hpreplaced bygenerationfor generation). - Diffusion utils: patch-based inference and lead time support with deterministic sampler.
- Existing DGL-based XAeroNet example has been renamed to
xaeronet_dgl. Added newxaeronetexample that uses PyTorch Geometric instead. - Updated the deforming plate example to use the Hybrid MeshGraphNet model.
⚠️ BC-breaking: Refactored thetransolvermodel to improve readability and performance, and extend to more use cases.- Diffusion models: improved lead time support for
SongUNetPosLtEmbdandEDMLoss. Lead-time embeddings can now be used with/without positional embeddings. - Diffusion models: consolidate
ApexGroupNormandGroupNorminmodels/diffusion/layers.pywith a factoryget_group_normthat can be used to instantiate either one of them.get_group_normis now the recommended way to instantiate a GroupNorm layer inSongUNet-based and other diffusion models. - Physicsnemo models: improved checkpoint loading API in
Module.from_checkpointthat now exposes astrictparameter to raise error on missing/unexpected keys, similar to that used intorch.nn.Module.load_state_dict. - Migrated Hybrid MGN and deforming plate example to PyTorch Geometric.
- Bug fixes in DoMINO model in sphere sampling and tensor reshaping
- Bug fixes in DoMINO utils random sampling and test.py
- Optimized DoMINO config params based on DrivAer ML
- Fixed an inadvertent change to the deterministic sampler 2nd order correction
- Bug Fix in Domino model ball query layer
- Fixed bug models/unet/unet.py: setting num_conv_layers=1 gives errors
- Added ReGen score-based data assimilation example
- General purpose patching API for patch-based diffusion
- New positional embedding selection strategy for CorrDiff SongUNet models
- Added Multi-Storage Client to allow checkpointing to/from Object Storage
- Added a new aerodynamics example using DoMINO to compute design sensitivities (e.g., drag adjoint) with respect to underlying input geometry.
- Simplified CorrDiff config files, updated default values
- Refactored CorrDiff losses and samplers to use the patching API
- Support for non-square images and patches in patch-based diffusion
- ERA5 download example updated to use current file format convention and restricts global statistics computation to the training set
- Support for training custom StormCast models and various other improvements for StormCast
- Updated CorrDiff training code to support multiple patch iterations to amortize
regression cost and usage of
torch.compile - Refactored
physicsnemo/models/diffusion/layers.pyto optimize data type casting workflow, avoiding unnecessary casting under autocast mode - Refactored Conv2d to enable fusion of conv2d with bias addition
- Refactored GroupNorm, UNetBlock, SongUNet, SongUNetPosEmbd to support usage of Apex GroupNorm, fusion of activation with GroupNorm, and AMP workflow.
- Updated SongUNetPosEmbd to avoid unnecessary HtoD Memcpy of
pos_embd - Updated
from_checkpointto accommodate conversion between Apex optimized ckp and non-optimized ckp - Refactored CorrDiff NVTX annotation workflow to be configurable
- Refactored
ResidualLossto support patch-accumlating training for amortizing regression costs - Explicit handling of Warp device for ball query and sdf
- Merged SongUNetPosLtEmb with SongUNetPosEmb, add support for batch>1
- Add lead time embedding support for
positional_embedding_selector. Enable arbitrary positioning of probabilistic variables - Enable lead time aware regression without CE loss
- Bumped minimum PyTorch version from 2.0.0 to 2.4.0, to minimize
support surface for
physicsnemo.distributedfunctionality.
- Made
nvidia.dalian optional dependency
- Added version checks to ensure compatibility with older PyTorch for distributed utilities and ShardTensor
EntryPointerror that occured during physicsnemo checkpoint loading
- DoMINO model architecture, datapipe and training recipe
- Added matrix decomposition scheme to improve graph partitioning
- DrivAerML dataset support in FIGConvNet example.
- Retraining recipe for DoMINO from a pretrained model checkpoint
- Prototype support for domain parallelism of using ShardTensor (new).
- Enable DeviceMesh initialization via DistributedManager.
- Added Datacenter CFD use case.
- Add leave-in profiling utilities to physicsnemo, to easily enable torch/python/nsight profiling in all aspects of the codebase.
- Refactored StormCast training example
- Enhancements and bug fixes to DoMINO model and training example
- Enhancement to parameterize DoMINO model with inlet velocity
- Moved non-dimensionaliztion out of domino datapipe to datapipe in domino example
- Updated utils in
physicsnemo.launch.loggingto avoid unnecessarywandbandmlflowimports - Moved to experiment-based Hydra config in Lagrangian-MGN example
- Make data caching optional in
MeshDatapipe - The use of older
importlib_metadatalibrary is removed
- ProcessGroupConfig is tagged for future deprecation in favor of DeviceMesh.
- Update pytests to skip when the required dependencies are not present
- Bug in data processing script in domino training example
- Fixed NCCL_ASYNC_ERROR_HANDLING deprecation warning
- Remove the numpy dependency upper bound
- Moved pytz and nvtx to optional
- Update the base image for the Dockerfile
- Introduce Multi-Storage Client (MSC) as an optional dependency.
- Introduce
wraptas an optional dependency, needed when using ShardTensor's automatic domain parallelism
- Graph Transformer processor for GraphCast/GenCast.
- Utility to generate STL from Signed Distance Field.
- Metrics for CAE and CFD domain such as integrals, drag, and turbulence invariances and spectrum.
- Added gradient clipping to StaticCapture utilities.
- Bistride Multiscale MeshGraphNet example.
- FIGConvUNet model and example.
- The Transolver model.
- The XAeroNet model.
- Incoporated CorrDiff-GEFS-HRRR model into CorrDiff, with lead-time aware SongUNet and cross entropy loss.
- Option to offload checkpoints to further reduce memory usage
- Added StormCast model training and simple inference to examples
- Multi-scale geometry features for DoMINO model.
- Refactored CorrDiff training recipe for improved usability
- Fixed timezone calculation in datapipe cosine zenith utility.
- Refactored EDMPrecondSRV2 preconditioner and fixed the bug related to the metadata
- Extended the checkpointing utility to store metadata.
- Corrected missing export of loggin function used by transolver model
- Graph Transformer processor for GraphCast/GenCast.
- Utility to generate STL from Signed Distance Field.
- Metrics for CAE and CFD domain such as integrals, drag, and turbulence invariances and spectrum.
- Added gradient clipping to StaticCapture utilities.
- Bistride Multiscale MeshGraphNet example.
- Refactored CorrDiff training recipe for improved usability
- Fixed timezone calculation in datapipe cosine zenith utility.
- Code logging for CorrDiff via Wandb.
- Augmentation pipeline for CorrDiff.
- Regression output as additional conditioning for CorrDiff.
- Learnable positional embedding for CorrDiff.
- Support for patch-based CorrDiff training and generation (stochastic sampling only)
- Enable CorrDiff multi-gpu generation
- Diffusion model for fluid data super-resolution (CMU contribution).
- The Virtual Foundry GraphNet.
- A synthetic dataloader for global weather prediction models, demonstrated on GraphCast.
- Sorted Empirical CDF CRPS algorithm
- Support for history, cos zenith, and downscaling/upscaling in the ERA5 HDF5 dataloader.
- An example showing how to train a "tensor-parallel" version of GraphCast on a Shallow-Water-Equation example.
- 3D UNet
- AeroGraphNet example of training of MeshGraphNet on Ahmed body and DrivAerNet datasets.
- Warp SDF routine
- DLWP HEALPix model
- Pangu Weather model
- Fengwu model
- SwinRNN model
- Modulated AFNO model
- Raise
PhysicsNeMoUndefinedGroupErrorwhen querying undefined process groups - Changed Indexing error in
examples/cfd/swe_nonlinear_pinoforphysicsnemoloss function - Safeguarding against uninitialized usage of
DistributedManager
- Remove mlflow from deployment image
- Fixed bug in the partitioning logic for distributing graph structures intended for distributed message-passing.
- Fixed bugs for corrdiff diffusion training of
EDMv1andEDMv2 - Fixed bug when trying to save DDP model trained through unified recipe
- Update DALI to CUDA 12 compatible version.
- Update minimum python version to 3.10
- The citation file.
- Link to the CWA dataset.
- ClimateDatapipe: an improved datapipe for HDF5/NetCDF4 formatted climate data
- Performance optimizations to CorrDiff.
- Physics-Informed Nonlinear Shallow Water Equations example.
- Warp neighbor search routine with a minimal example.
- Strict option for loading PhysicsNeMo checkpoints.
- Regression only or diffusion only inference for CorrDiff.
- Support for organization level model files on NGC file system
- Physics-Informed Magnetohydrodynamics example.
- Updated Ahmed Body and Vortex Shedding examples to use Hydra config.
- Added more config options to FCN AFNO example.
- Moved posiitonal embedding in CorrDiff from the dataloader to network architecture
physicsnemo.models.diffusion.preconditioning.EDMPrecondSR. UseEDMPecondSRV2instead.
- Pickle dependency for CorrDiff.
- Consistent handling of single GPU runs in DistributedManager
- Output location of objects downloaded with NGC file system
- Bug in scaling the conditional input in CorrDiff deterministic sampler
- Updated DGL build in Dockerfile
- Updated default base image
- Moved Onnx from optional to required dependencies
- Optional Makani dependency required for SFNO model.
- Distributed process group configuration mechanism.
- DistributedManager utility to instantiate process groups based on a process group config.
- Helper functions to faciliate distributed training with shared parameters.
- Brain anomaly detection example.
- Updated Frechet Inception Distance to use Wasserstein 2-norm with improved stability.
- Molecular Dynamics example.
- Improved usage of GraphPartition, added more flexible ways of defining a partitioned graph.
- Physics-Informed Stokes Flow example.
- Profiling markers, benchmarking and performance optimizations for CorrDiff inference.
- Unified weather model training example.
- MLFLow logging such that only proc 0 logs to MLFlow.
- FNO given seperate methods for constructing lift and spectral encoder layers.
- The experimental SFNO
- Removed experimental SFNO dependencies
- Added CorrDiff dependencies (cftime, einops, pyspng, nvtx)
- Made tqdm a required dependency
- Added Stokes flow dataset
- An experimental version of SFNO to be used in unified training recipe for weather models
- Added distributed FFT utility.
- Added ruff as a linting tool.
- Ported utilities from PhysicsNeMo Launch to main package.
- EDM diffusion models and recipes for training and sampling.
- NGC model registry download integration into package/filesystem.
- Denoising diffusion tutorial.
- The AFNO input argument
img_sizetoinp_shape - Integrated the network architecture layers from PhysicsNeMo-Sym.
- Updated the SFNO model, and the training and inference recipes.
- Fixed physicsnemo.Module
from_checkpointto work from custom model classes
- Updated the base container to PyTorch 23.10.
- Updated examples to use Pydantic v2.
- Added ability to compute CRPS(..., dim: int = 0).
- Added EFI for arbitrary climatological CDF.
- Added Kernel CRPS implementation (kcrps)
- Added distributed utilities to create process groups and orthogonal process groups.
- Added distributed AFNO model implementation.
- Added distributed utilities for communication of buffers of varying size per rank.
- Added distributed utilities for message passing across multiple GPUs.
- Added instructions for docker build on ARM architecture.
- Added batching support and fix the input time step for the DLWP wrapper.
- Updating file system cache location to physicsnemo folder
- Fixed physicsnemo uninstall in CI docker image
- Handle the tar ball extracts in a safer way.
- Updated the base container to latest PyTorch 23.07.
- Update DGL version.
- Updated require installs for python wheel
- Added optional dependency list for python wheel
- Added a workaround fix for the CUDA graphs error in multi-node runs
- Update
certifipackage version
- Added a CHANGELOG.md
- Added build support for internal DGL
- 4D Fourier Neural Operator model
- Ahmed body dataset
- Unified Climate Datapipe
- DGL install changed from pypi to source
- Updated SFNO to add support for super resolution, flexible checkpoining, etc.
- Fixed issue with torch-harmonics version locking
- Fixed the PhysicsNeMo editable install
- Fixed AMP bug in static capture
- Fixed security issues with subprocess and urllib in
filesystem.py
- Updated the base container to latest PyTorch base container which is based on torch 2.0
- Container now supports CUDA 12, Python 3.10
- Initial public release.