[DSL] Update model code to NDSL v2025.10.00-dirty

GEOSagcm_GridComp/GEOSphysics_GridComp/.gitignore

@@ -4,3 +4,4 @@
 /@GEOSradiation_GridComp
 /GEOSradiation_GridComp
 /GEOSradiation_GridComp@
+**/build/*

GEOSagcm_GridComp/GEOSphysics_GridComp/GEOSmoist_GridComp/pyMoist/.gitignore

@@ -13,3 +13,4 @@ sandbox/
 .gt4py_cache/
 .gt_cache_*/
 .translate*/
+**/build/

GEOSagcm_GridComp/GEOSphysics_GridComp/GEOSmoist_GridComp/pyMoist/pyMoist/GFDL_1M/driver/driver.py

@@ -84,7 +84,10 @@ def __init__(
         # generate saturation specific humidity tables
         # -----------------------------------------------------------------------
 
-        self.sat_tables = get_tables(stencil_factory.backend)
+        self.sat_tables = get_tables(
+            stencil_factory.backend,
+            stencil_factory.config.dace_config,
+        )
 
         # -----------------------------------------------------------------------
         # initialize stencils

GEOSagcm_GridComp/GEOSphysics_GridComp/GEOSmoist_GridComp/pyMoist/pyMoist/GFDL_1M/driver/sat_tables.py

@@ -2,6 +2,7 @@
 
 from ndsl.boilerplate import get_factories_single_tile
 from ndsl.constants import X_DIM, Y_DIM, Z_DIM
+from ndsl.dsl.dace.dace_config import DaceConfig
 from ndsl.dsl.gt4py import FORWARD, PARALLEL, GlobalTable, K, computation, exp, interval, log, log10
 from ndsl.dsl.typing import Float, FloatField, Int
 from pyMoist.GFDL_1M.driver.constants import constants
@@ -189,7 +190,7 @@ class GFDL_driver_tables:
     Reference Fortran: gfdl_cloud_microphys.F90: qsmith_init.py
     """
 
-    def __init__(self, backend):
+    def __init__(self, backend, dace_config: DaceConfig):
         table_compute_domain = (1, 1, constants.LENGTH)
 
         stencil_factory, quantity_factory = get_factories_single_tile(
@@ -213,7 +214,7 @@ def __init__(self, backend):
         # Cancel multi-node compile for tables
         # TODO: this should come for free with the rewrite of the gt:X stencils
         #       compilation mode
-        if MPI.COMM_WORLD.Get_rank() != 0:
+        if not dace_config.do_compile:
             MPI.COMM_WORLD.Barrier()
 
         compute_qs_table_1 = stencil_factory.from_origin_domain(
@@ -258,7 +259,7 @@ def __init__(self, backend):
             self._table4,
         )
 
-        if MPI.COMM_WORLD.Get_rank() == 0:
+        if dace_config.do_compile:
             MPI.COMM_WORLD.Barrier()
 
         self.table1 = self._table1.view[0, 0, :]
@@ -277,8 +278,8 @@ def __init__(self, backend):
 }
 
 
-def get_tables(backend):
+def get_tables(backend, dace_config):
     if _cached_table["driver_qsat"] is None:
-        _cached_table["driver_qsat"] = GFDL_driver_tables(backend)
+        _cached_table["driver_qsat"] = GFDL_driver_tables(backend, dace_config)
 
     return _cached_table["driver_qsat"]

GEOSagcm_GridComp/GEOSphysics_GridComp/GEOSmoist_GridComp/pyMoist/pyMoist/UW/compute_uwshcu.py

@@ -7512,37 +7512,31 @@ def __init__(
         self.stop_cin = self.quantity_factory.zeros([X_DIM, Y_DIM], "n/a", dtype=bool)
         self.stop_buoyancy_sort = self.quantity_factory.zeros([X_DIM, Y_DIM], "n/a", dtype=bool)
 
-        self.ntracers_quantity_factory = self.make_ntracers_quantity_factory(
-            self.quantity_factory,
+        self.quantity_factory.add_data_dimensions(
+            {
+                "ntracers": constants.NCNST,
+            }
         )
 
         # Create tracer fields
-        self.trsrc = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, "ntracers"], "n/a")
-        self.trsrc_o = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, "ntracers"], "n/a")
-        self.tre = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, "ntracers"], "n/a")
-        self.trmin = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, "ntracers"], "n/a")
-        self.sstr0 = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
-        self.tr0 = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
-        self.tr0_o = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
-        self.sstr0_o = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
-        self.trten = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
-        self.tr0_s = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
-        self.tr0_inoutvar = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
-        self.tr0_inout = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
-        self.trflx = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a")
-        self.tru = self.ntracers_quantity_factory.zeros([X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a")
-        self.tru_emf = self.ntracers_quantity_factory.zeros(
-            [X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a"
-        )
-        self.xflx_ndim = self.ntracers_quantity_factory.zeros(
-            [X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a"
-        )
-        self.trflx_d = self.ntracers_quantity_factory.zeros(
-            [X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a"
-        )
-        self.trflx_u = self.ntracers_quantity_factory.zeros(
-            [X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a"
-        )
+        self.trsrc = self.quantity_factory.zeros([X_DIM, Y_DIM, "ntracers"], "n/a")
+        self.trsrc_o = self.quantity_factory.zeros([X_DIM, Y_DIM, "ntracers"], "n/a")
+        self.tre = self.quantity_factory.zeros([X_DIM, Y_DIM, "ntracers"], "n/a")
+        self.trmin = self.quantity_factory.zeros([X_DIM, Y_DIM, "ntracers"], "n/a")
+        self.sstr0 = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
+        self.tr0 = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
+        self.tr0_o = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
+        self.sstr0_o = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
+        self.trten = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
+        self.tr0_s = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
+        self.tr0_inoutvar = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
+        self.tr0_inout = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_DIM, "ntracers"], "n/a")
+        self.trflx = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a")
+        self.tru = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a")
+        self.tru_emf = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a")
+        self.xflx_ndim = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a")
+        self.trflx_d = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a")
+        self.trflx_u = self.quantity_factory.zeros([X_DIM, Y_DIM, Z_INTERFACE_DIM, "ntracers"], "n/a")
 
         self.saturation_vapor_pressure_table = get_saturation_vapor_pressure_table(
             self.stencil_factory.backend

GEOSagcm_GridComp/GEOSphysics_GridComp/GEOSmoist_GridComp/pyMoist/pyMoist/aer_activation.py

@@ -1,5 +1,3 @@
-import copy
-
 from gt4py.cartesian.gtscript import PARALLEL, computation, exp, float64, interval, log, sqrt
 
 import pyMoist.constants as constants
@@ -326,28 +324,33 @@ def __init__(
             raise NotImplementedError("Non NN Aerosol not implemented")
 
         # Temporary buffers
-        nmodes_quantity_factory = AerActivation.make_nmodes_quantity_factory(quantity_factory)
-        self._nact = nmodes_quantity_factory.zeros(
+        quantity_factory.add_data_dimensions(
+            **{
+                "n_modes": constants.N_MODES,
+            }
+        )
+
+        self._nact = quantity_factory.zeros(
             [X_DIM, Y_DIM, Z_DIM, "n_modes"],
             units="n/a",
             dtype=Float,
         )
-        self._ni = nmodes_quantity_factory.zeros(
+        self._ni = quantity_factory.zeros(
             [X_DIM, Y_DIM, Z_DIM, "n_modes"],
             units="n/a",
             dtype=Float,
         )
-        self._rg = nmodes_quantity_factory.zeros(
+        self._rg = quantity_factory.zeros(
             [X_DIM, Y_DIM, Z_DIM, "n_modes"],
             units="n/a",
             dtype=Float,
         )
-        self._sig0 = nmodes_quantity_factory.zeros(
+        self._sig0 = quantity_factory.zeros(
             [X_DIM, Y_DIM, Z_DIM, "n_modes"],
             units="n/a",
             dtype=Float,
         )
-        self._bibar = nmodes_quantity_factory.zeros(
+        self._bibar = quantity_factory.zeros(
             [X_DIM, Y_DIM, Z_DIM, "n_modes"],
             units="n/a",
             dtype=Float,
@@ -359,16 +362,6 @@ def __init__(
             compute_dims=[X_DIM, Y_DIM, Z_DIM],
         )
 
-    @staticmethod
-    def make_nmodes_quantity_factory(ijk_quantity_factory: QuantityFactory):
-        nmodes_quantity_factory = copy.deepcopy(ijk_quantity_factory)
-        nmodes_quantity_factory.set_extra_dim_lengths(
-            **{
-                "n_modes": constants.N_MODES,
-            }
-        )
-        return nmodes_quantity_factory
-
     def __call__(
         self,
         aero_dgn: FloatField_NModes,

GEOSagcm_GridComp/GEOSphysics_GridComp/GEOSmoist_GridComp/pyMoist/pyMoist/interface/mapl/memory_factory.py

@@ -8,9 +8,15 @@
 from MAPLpyish import MAPLBridge, MAPLState
 
 from ndsl import QuantityFactory, ndsl_log
+from ndsl.dsl.gt4py_utils import is_gpu_backend
+from ndsl.optional_imports import cupy as cp
 from pyMoist.interface.f_py_conversion import FortranPythonConversion
 
 
+if cp is None:
+    cp = np
+
+
 class MAPLMemoryRepository:
     """A factory capable of accessing memory handlded by MAPL and formatting it
     for direct use in DSL application."""
@@ -32,11 +38,12 @@ def __init__(self, state: MAPLState, quantity_factory: QuantityFactory) -> None:
         self._quantity_factory = quantity_factory
         self._state = state
         self._bridge = MAPLBridge()
+        self._quantity_factory.backend
         self._f_py_converter = FortranPythonConversion(
             self._quantity_factory.sizer.nx,
             self._quantity_factory.sizer.ny,
             self._quantity_factory.sizer.nz,
-            self._quantity_factory._numpy,
+            cp if is_gpu_backend(self._quantity_factory.backend) else np,
         )
         self._fortran_pointers: dict[str, MAPLMemoryRepository.FortranMemory] = {}
 

GEOSagcm_GridComp/GEOSphysics_GridComp/GEOSmoist_GridComp/pyMoist/pyMoist/interface/python_bridge.py

@@ -29,7 +29,6 @@ def init(
         self.rank = MPI.COMM_WORLD.Get_rank()
         self.backend = backend
         self.flags = moist_flags_f_to_python(pyMoist_flags)
-        print(f"Moist Flags:\n{self.flags}")
         # For Fortran<->NumPy conversion
         if is_gpu_backend(self.backend):
             numpy_module = cp