nrpy 2.0.2__tar.gz → 2.0.3__tar.gz

{nrpy-2.0.2 → nrpy-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrpy
-Version: 2.0.2
+Version: 2.0.3
 Summary: Python/SymPy-based code generation for numerical relativity... and beyond!
 Home-page: https://github.com/nrpy/nrpy
 Author: Zachariah Etienne

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/c_codegen.py

@@ -7,13 +7,10 @@ Authors: Zachariah B. Etienne; zachetie **at** gmail **dot* com
 """
 
 import logging
-from pathlib import Path
-import hashlib
-import pickle
+
 import re  # Regular expressions can be toxic due to edge cases -- we use them sparingly
 import sys
-from typing import List, Union, Dict, Any, Optional, Sequence, Tuple, cast
-from appdirs import user_cache_dir  # type: ignore
+from typing import List, Union, Dict, Any, Optional, Sequence, Tuple
 import sympy as sp
 import nrpy.finite_difference as fin
 import nrpy.params as par
@@ -55,7 +52,6 @@ class CCodeGen:
         automatically_read_gf_data_from_memory: bool = False,
         enforce_c_parameters_must_be_defined: bool = False,
         enable_fd_functions: bool = False,
-        cache_enable: bool = True,
         mem_alloc_style: str = "210",
         upwind_control_vec: Union[List[sp.Symbol], sp.Symbol] = sp.Symbol("unset"),
         symbol_to_Rational_dict: Optional[Dict[sp.Basic, sp.Rational]] = None,
@@ -122,7 +118,6 @@ class CCodeGen:
         )
         self.enforce_c_parameters_must_be_defined = enforce_c_parameters_must_be_defined
         self.enable_fd_functions = enable_fd_functions
-        self.cache_enable = cache_enable
         self.mem_alloc_style = mem_alloc_style
         self.upwind_control_vec = upwind_control_vec
         self.symbol_to_Rational_dict = symbol_to_Rational_dict
@@ -224,10 +219,10 @@ def c_codegen(
     :return: A string containing the generated C code.
 
     >>> x, y, z = sp.symbols("x y z", real=True)
-    >>> print(c_codegen(x**2 + sp.sqrt(y) - sp.sin(x*z), "double blah", include_braces=False, verbose=False, cache_enable=False))
+    >>> print(c_codegen(x**2 + sp.sqrt(y) - sp.sin(x*z), "double blah", include_braces=False, verbose=False))
     double blah = ((x)*(x)) + sqrt(y) - sin(x*z);
     <BLANKLINE>
-    >>> print(c_codegen(x**5 + x**3 + x - 1/x, "REAL_SIMD_ARRAY blah", include_braces=False, verbose=False, enable_simd=True, cache_enable=False))
+    >>> print(c_codegen(x**5 + x**3 + x - 1/x, "REAL_SIMD_ARRAY blah", include_braces=False, verbose=False, enable_simd=True))
     const double dbl_Integer_1 = 1.0;
     const REAL_SIMD_ARRAY _Integer_1 = ConstSIMD(dbl_Integer_1);
     <BLANKLINE>
@@ -236,7 +231,7 @@ def c_codegen(
     <BLANKLINE>
     REAL_SIMD_ARRAY blah = FusedMulAddSIMD(MulSIMD(x, x), x, FusedMulAddSIMD(MulSIMD(MulSIMD(MulSIMD(x, x), x), x), x, SubSIMD(x, DivSIMD(_Integer_1, x))));
     <BLANKLINE>
-    >>> print(c_codegen(x**5 + x**3 + sp.sin(x**3), "REAL_SIMD_ARRAY blah", enable_simd=True, cache_enable=True))
+    >>> print(c_codegen(x**5 + x**3 + sp.sin(x**3), "REAL_SIMD_ARRAY blah", enable_simd=True))
     /*
      *  Original SymPy expression:
      *  "REAL_SIMD_ARRAY blah = x**5 + x**3 + sin(x**3)"
@@ -246,7 +241,7 @@ def c_codegen(
     REAL_SIMD_ARRAY blah = AddSIMD(tmp0, FusedMulAddSIMD(MulSIMD(MulSIMD(MulSIMD(x, x), x), x), x, SinSIMD(tmp0)));
     }
     <BLANKLINE>
-    >>> print(c_codegen(x**5 + x**3 + sp.sin(x**3), "REAL_SIMD_ARRAY blah", enable_simd=True, cache_enable=True))
+    >>> print(c_codegen(x**5 + x**3 + sp.sin(x**3), "REAL_SIMD_ARRAY blah", enable_simd=True))
     /*
      *  Original SymPy expression:
      *  "REAL_SIMD_ARRAY blah = x**5 + x**3 + sin(x**3)"
@@ -258,26 +253,6 @@ def c_codegen(
     <BLANKLINE>
     """
     CCGParams = CCodeGen(**kwargs)
-    cache_dir = Path(user_cache_dir("nrpy"))
-    cache_file = Path("does_not_exist")
-    if CCGParams.cache_enable:
-        try:
-            pickle_expr = pickle.dumps(sympyexpr)
-            pickle_prms = pickle.dumps(CCGParams.__dict__)
-            pickle_vars = pickle.dumps(output_varname_str)
-            pickle_kwgs = pickle.dumps(kwargs)
-            cache_dir.mkdir(parents=True, exist_ok=True)
-            cache_file = cache_dir / (
-                hashlib.sha256(
-                    pickle_expr + pickle_prms + pickle_vars + pickle_kwgs
-                ).hexdigest()
-                + ".nrpycache"
-            )
-            if cache_file.exists():
-                with open(cache_file, "rb") as file:
-                    return cast(str, pickle.load(file))
-        except pickle.PicklingError:
-            pass
 
     # Step 1: Initialize
     #  commentblock: comment block containing the input SymPy string,
@@ -587,14 +562,6 @@ def c_codegen(
     if CCGParams.include_braces:
         final_Ccode_output_str += "}\n"
 
-    if CCGParams.cache_enable:
-        try:
-            if "does_not_exist" not in str(cache_file):
-                with open(cache_file, "wb") as file:
-                    pickle.dump(final_Ccode_output_str, file)
-        except pickle.PicklingError:
-            pass
-
     # Step 7: Return result string
     return final_Ccode_output_str
 

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/equations/general_relativity/BSSN_RHSs.py

@@ -9,6 +9,7 @@ Author: Zachariah B. Etienne
 # Step 1.a: import all needed modules from NRPy+:
 from typing import Dict, List
 import sympy as sp  # SymPy: The Python computer algebra package upon which NRPy+ depends
+
 import nrpy.params as par  # NRPy+: Parameter interface
 import nrpy.grid as gri
 import nrpy.indexedexp as ixp  # NRPy+: Symbolic indexed expression (e.g., tensors, vectors, etc.) support
@@ -33,6 +34,8 @@ class BSSNRHSs:
     def __init__(
         self, CoordSystem: str = "Cartesian", enable_rfm_precompute: bool = False
     ):
+        enable_T4munu = par.parval_from_str("enable_T4munu")
+
         # Step 1.c: Given the chosen coordinate system, set up
         #           corresponding reference metric and needed
         #           reference metric quantities
@@ -310,7 +313,7 @@ class BSSNRHSs:
                 self.Lambdabar_rhsU[i] += -sp.Rational(4, 3) * alpha * gammabarUU[i][j] * trK_dD[j]
 
         # Step 7: Add T4munu if enable_T4munu
-        if par.parval_from_str("enable_T4munu"):
+        if enable_T4munu:
             if "T4UU00" not in gri.glb_gridfcs_dict:
                 _ = gri.register_gridfunctions_for_single_rank2(
                     "T4UU",
@@ -372,9 +375,10 @@ class BSSNRHSs_dict(Dict[str, BSSNRHSs]):
 
     def __getitem__(self, CoordSystem_in: str) -> BSSNRHSs:
         if CoordSystem_in not in self:
+            enable_T4munu = par.parval_from_str("enable_T4munu")
+
             # In case [CoordSystem]_rfm_precompute is passed:
             CoordSystem = CoordSystem_in.replace("_rfm_precompute", "")
-            enable_T4munu = par.parval_from_str("enable_T4munu")
             print(
                 f"Setting up BSSN_RHSs for CoordSystem = {CoordSystem}, enable_T4munu={enable_T4munu}."
             )

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/equations/general_relativity/BSSN_constraints.py

@@ -9,6 +9,7 @@ Author: Zachariah B. Etienne
 # Step 1: Initialize needed Python/NRPy+ modules
 from typing import Dict
 import sympy as sp  # SymPy: The Python computer algebra package upon which NRPy+ depends
+
 import nrpy.params as par  # NRPy+: Parameter interface
 import nrpy.indexedexp as ixp  # NRPy+: Symbolic indexed expression (e.g., tensors, vectors, etc.) support
 import nrpy.grid as gri  # NRPy+: Functions having to do with numerical grids
@@ -29,6 +30,8 @@ class BSSNconstraints:
         CoordSystem: str = "Cartesian",
         enable_rfm_precompute: bool = False,
     ) -> None:
+        register_MU_gridfunctions = par.parval_from_str("register_MU_gridfunctions")
+
         # Step 1.b: Given the chosen coordinate system, set up
         #           corresponding reference metric and needed
         #           reference metric quantities
@@ -52,10 +55,7 @@ class BSSNconstraints:
             _ = gri.register_gridfunctions(
                 "MSQUARED", group="AUX", gf_array_name="diagnostic_output_gfs"
             )
-        if (
-            par.parval_from_str("register_MU_gridfunctions")
-            and "MU" not in gri.glb_gridfcs_dict
-        ):
+        if register_MU_gridfunctions and "MU" not in gri.glb_gridfcs_dict:
             _ = gri.register_gridfunctions_for_single_rank1(
                 "MU", group="AUX", gf_array_name="diagnostic_output_gfs"
             )
@@ -181,7 +181,7 @@ class BSSNconstraints_dict(Dict[str, BSSNconstraints]):
             CoordSystem = CoordSystem_in.replace("_rfm_precompute", "")
             enable_T4munu = par.parval_from_str("enable_T4munu")
             print(
-                f"Setting up BSSN_quantities for CoordSystem = {CoordSystem}, enable_T4munu={enable_T4munu}."
+                f"Setting up BSSN_constraints for CoordSystem = {CoordSystem}, enable_T4munu={enable_T4munu}."
             )
             self.__setitem__(
                 CoordSystem, BSSNconstraints(CoordSystem, enable_rfm_precompute=False)

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/equations/general_relativity/BSSN_quantities.py

@@ -42,20 +42,18 @@ class BSSNQuantities:
 
         #   Check to see if this function has already been called.
         #   If so, do not register the gridfunctions again!
-        BSSN_quantities_gfs_are_registered = False
-        for gf in gri.glb_gridfcs_dict.values():
-            if "hDD00" in gf.name:
-                self.hDD = ixp.declarerank2("hDD", symmetry="sym01")
-                self.aDD = ixp.declarerank2("aDD", symmetry="sym01")
-                self.lambdaU = ixp.declarerank1("lambdaU")
-                self.vetU = ixp.declarerank1("vetU")
-                self.betU = ixp.declarerank1("betU")
-                self.trK, self.cf, self.alpha = sp.symbols(
-                    "trK cf alpha"
-                )  # , real=True)  # no tensor gridfunction is real=True. Do this for consistency.
-                BSSN_quantities_gfs_are_registered = True
-
-        if not BSSN_quantities_gfs_are_registered:
+        LeaveRicciSymbolic = par.parval_from_str("LeaveRicciSymbolic")
+
+        if any("hDD00" in gf.name for gf in gri.glb_gridfcs_dict.values()):
+            self.hDD = ixp.declarerank2("hDD", symmetry="sym01")
+            self.aDD = ixp.declarerank2("aDD", symmetry="sym01")
+            self.lambdaU = ixp.declarerank1("lambdaU")
+            self.vetU = ixp.declarerank1("vetU")
+            self.betU = ixp.declarerank1("betU")
+            self.trK, self.cf, self.alpha = sp.symbols(
+                "trK cf alpha"
+            )  # , real=True)  # no tensor gridfunction is real=True. Do this for consistency.
+        else:
             # Step 2.a: Register indexed quantities, using ixp.register_... functions
             self.hDD = gri.register_gridfunctions_for_single_rank2(
                 "hDD", symmetry="sym01", f_infinity=0.0, wavespeed=1.0
@@ -80,12 +78,23 @@ class BSSNQuantities:
                 wavespeed=[1.0, 1.0, sp.sqrt(2.0)],
             )
 
+        if LeaveRicciSymbolic and not any(
+            "RbarDD00" in gf.name for gf in gri.glb_gridfcs_dict.values()
+        ):
+            self.RbarDD = gri.register_gridfunctions_for_single_rank2(
+                "RbarDD",
+                symmetry="sym01",
+                group="AUXEVOL",
+                gf_array_name="auxevol_gfs",
+            )
+        else:
+            self.RbarDD = ixp.declarerank2("RbarDD", symmetry="sym01")
+
         # fmt: off
         # Step 3: Define all basic conformal BSSN tensors
         #        gammabarDD,AbarDD,LambdabarU,betaU,BU
         #        in terms of BSSN gridfunctions.
         # Step 3.a: Defines gammabarDD, AbarDD, LambdabarU, betaU, BU
-
         rfm = refmetric.reference_metric[
             CoordSystem + "_rfm_precompute" if enable_rfm_precompute else CoordSystem
         ]
@@ -379,16 +388,8 @@ class BSSNQuantities:
                     self.DGammaU[i] += self.gammabarUU[j][k] * self.DGammaUDD[i][j][k]
 
         # If we wish to leave Ricci symbolic, there's no point continuing to define RbarDD symbolically:
-        if par.parval_from_str("LeaveRicciSymbolic"):
-            Rbar_is_gf = False
-            for gf in gri.glb_gridfcs_dict.values():
-                if "RbarDD00" in gf.name:
-                    self.RbarDD = ixp.declarerank2("RbarDD", symmetry="sym01")
-                    Rbar_is_gf = True
-            if not Rbar_is_gf:
-                self.RbarDD = gri.register_gridfunctions_for_single_rank2(
-                    "RbarDD", symmetry="sym01", group="AUXEVOL", gf_array_name="auxevol_gfs"
-                )
+        if LeaveRicciSymbolic:
+            pass
         else:
             # Step 7.c.iii: Define \Delta_{ijk} = \bar{\gamma}_{im} \Delta^m_{jk}
             DGammaDDD = ixp.zerorank3()

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/equations/general_relativity/g4munu_conversions.py

@@ -15,6 +15,7 @@ import nrpy.indexedexp as ixp  # NRPy+: Symbolic indexed expression (e.g., tenso
 from nrpy.equations.general_relativity.BSSN_to_ADM import BSSN_to_ADM
 from nrpy.equations.general_relativity.ADM_to_BSSN import ADM_to_BSSN
 from nrpy.equations.general_relativity.BSSN_quantities import BSSN_quantities
+from nrpy.helpers.cached_functions import cached_simplify
 
 
 # g_{mu nu} in terms of BSSN (if inputvars=="BSSN") or ADM (if inputvars=="ADM") variables.
@@ -180,7 +181,7 @@ def g4DD_to_ADM(
 
     # Step 4.b: alpha = sqrt(beta^2 - g_{00}):
     alpha = (
-        sp.sqrt(sp.simplify(beta_squared) - g4DD[0][0])
+        sp.sqrt(cached_simplify(beta_squared) - g4DD[0][0])
         if not g4DD_is_input_into_this_function
         else sp.sqrt(beta_squared - g4DD[0][0])
     )

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/equations/general_relativity/psi4_tetrads.py

@@ -16,6 +16,7 @@ import nrpy.indexedexp as ixp  # NRPy+: Symbolic indexed expression (e.g., tenso
 import nrpy.reference_metric as refmetric  # NRPy+: Reference metric support
 from nrpy.equations.general_relativity.BSSN_quantities import BSSN_quantities
 from nrpy.equations.general_relativity.BSSN_to_ADM import BSSN_to_ADM
+from nrpy.helpers.cached_functions import cached_simplify
 
 # Step 1.b: Declare free parameter
 # use_metric_to_construct_unit_normal=False: consistent with WeylScal4 ETK thorn.
@@ -72,12 +73,12 @@ class Psi4Tetrads:
         #           BSSN.ADM_in_terms_of_BSSN;
         #           simplify detgamma & gammaUU expressions,
         #           which expedites Psi4 codegen.
-        detgamma = sp.simplify(BtoA.detgamma)
+        detgamma = cached_simplify(BtoA.detgamma)
         gammaUU = ixp.zerorank2()
         for i in range(3):
             for j in range(i, 3):
                 # The simplify() here is SLOW, so we try to use it sparingly.
-                gammaUU[i][j] = gammaUU[j][i] = sp.simplify(BtoA.gammaUU[i][j])
+                gammaUU[i][j] = gammaUU[j][i] = cached_simplify(BtoA.gammaUU[i][j])
 
         # Step 2.c: Define v1U and v2U
         v1UCart = [-y, x, sp.sympify(0)]
@@ -90,7 +91,7 @@ class Psi4Tetrads:
         # Step 2.e.i: Simplify expressions for d xx^j / d x_Cart^i:
         for i in range(3):
             for j in range(3):
-                Jac_dUrfm_dDCartUD[i][j] = sp.simplify(Jac_dUrfm_dDCartUD[i][j])
+                Jac_dUrfm_dDCartUD[i][j] = cached_simplify(Jac_dUrfm_dDCartUD[i][j])
 
         # Step 2.f: Transform v1U and v2U from the Cartesian to the xx^i basis
         v1U = ixp.zerorank1()
@@ -119,9 +120,9 @@ class Psi4Tetrads:
         #             Drat. Simplification with certain versions of SymPy & coord systems results in a hang. Let's just
         #             evaluate the expressions so the most trivial optimizations can be performed.
         for a in range(3):
-            v1U[a] = v1U[a].doit()  # sp.simplify(v1U[a])
-            v2U[a] = v2U[a].doit()  # sp.simplify(v2U[a])
-            v3U[a] = v3U[a].doit()  # sp.simplify(v3U[a])
+            v1U[a] = v1U[a].doit()  # cached_simplify(v1U[a])
+            v2U[a] = v2U[a].doit()  # cached_simplify(v2U[a])
+            v3U[a] = v3U[a].doit()  # cached_simplify(v3U[a])
 
         # Step 2.h: Define omega_{ij}
         omegaDD = ixp.zerorank2()

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/equations/special_functions/spin_weighted_spherical_harmonics.py

@@ -11,6 +11,7 @@ Authors: Brandon Clark
 """
 from typing import cast, Dict
 import sympy as sp  # SymPy: The Python computer algebra package upon which NRPy+ depends
+from nrpy.helpers.cached_functions import cached_simplify
 
 
 def Y(
@@ -67,7 +68,7 @@ def Y(
             * (2 * l + 1)
             / (4 * sp.pi * sp.factorial(l + s) * sp.factorial(l - s))
         )
-        * sp.simplify(negative_one**m * sp.sin(th / 2) ** (2 * l) * Sum),
+        * cached_simplify(negative_one**m * sp.sin(th / 2) ** (2 * l) * Sum),
     )
 
 

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/examples/two_blackholes_collide.py

@@ -53,8 +53,8 @@ default_BH1_z_posn = +0.5
 default_BH2_z_posn = -0.5
 enable_rfm_precompute = True
 MoL_method = "RK4"
-fd_order = 4
-radiation_BC_fd_order = 2
+fd_order = 8
+radiation_BC_fd_order = 8
 enable_simd = True
 separate_Ricci_and_BSSN_RHS = True
 boundary_conditions_desc = "outgoing radiation"
@@ -307,9 +307,9 @@ print("Finished constructing MoL C functions.")
 xxCart.register_CFunction__Cart_to_xx_and_nearest_i0i1i2(CoordSystem)
 xxCart.register_CFunction_xx_to_Cart(CoordSystem)
 progress.register_CFunction_progress_indicator()
-# print("Started constructing SWm2SH functions.")
-# swm2sh.register_CFunction_spin_weight_minus2_sph_harmonics(maximum_l=8)
-# print("Finished constructing SWm2SH functions.")
+print("Started constructing SWm2SH functions.")
+swm2sh.register_CFunction_spin_weight_minus2_sph_harmonics(maximum_l=8)
+print("Finished constructing SWm2SH functions.")
 
 #########################################################
 # STEP 3: Generate header files, register C functions and

nrpy-2.0.3/nrpy/helpers/cached_functions.py

@@ -0,0 +1,106 @@
+"""
+Cache-enable versions of functions that are
+* normally slow, and
+* called with the same inputs many times during a development cycle.
+
+Author: Zachariah B. Etienne
+        zachetie **at** gmail **dot* com
+"""
+import hashlib
+import pickle
+from pathlib import Path
+from typing import cast, Any
+from appdirs import user_cache_dir  # type: ignore
+import sympy as sp
+import nrpy.params as par
+
+
+def get_hash(unique_id: str) -> str:
+    """
+    Generate a hash string for a given unique ID.
+
+    :param unique_id: A unique identifier to be hashed.
+    :return: The hash string.
+    """
+    return hashlib.sha256(unique_id.encode("utf-8")).hexdigest()
+
+
+def cache_file(unique_id: str) -> Path:
+    """
+    Generate a cache file path using a unique ID.
+
+    :param unique_id: A unique identifier to be used for generating the file path.
+    :return: The cache file path.
+    """
+
+    if not Path(user_cache_dir("nrpy")).exists():
+        Path(user_cache_dir("nrpy")).mkdir(parents=True, exist_ok=True)
+    return Path(user_cache_dir("nrpy")) / f"{get_hash(unique_id)}.nrpycache"
+
+
+def NRPy_params_checksum() -> str:
+    return get_hash(
+        str(pickle.dumps({k: v for k, v in sorted(par.glb_params_dict.items())}))
+    )
+
+
+def is_cached(unique_id: str) -> bool:
+    """
+    Check if the file with the given unique ID exists in cache.
+
+    :param unique_id: A unique identifier to check for.
+    :return: True if the file exists, False otherwise.
+    """
+    return cache_file(unique_id).exists()
+
+
+def read_cached(unique_id: str) -> Any:
+    """
+    Read the cached data associated with a unique ID.
+
+    :param unique_id: A unique identifier to read data for.
+    :return: The data read from the cache file.
+    """
+    # print(f"Reading " + str(unique_id[:80]).replace("\n", ""))
+    with open(cache_file(unique_id), "rb") as file:
+        # print(f"Reading cached file {file.name}.")
+        return pickle.load(file)
+
+
+def write_cached(unique_id: str, data: Any) -> None:
+    """
+    Write data to the cache file associated with a unique ID.
+
+    :param unique_id: A unique identifier to write data for.
+    :param data: The data to be written to the cache.
+    """
+    # print(f"Writing " + str(unique_id[:80]).replace("\n", ""))
+    with open(cache_file(unique_id), "wb") as file:
+        # print(f"Writing cached file {file.name}.")
+        pickle.dump(data, file)
+
+
+def cached_simplify(expr: sp.Basic) -> sp.Expr:
+    """
+    Simplify a given sympy expression using a cache to speed up repeated simplifications.
+
+    :param expr: Sympy expression to be simplified.
+    :return: Simplified sympy expression.
+    """
+    if expr == sp.sympify(0):
+        return cast(sp.Expr, sp.sympify(0))
+    cache_dir = Path(user_cache_dir("nrpy"))
+    try:
+        pickle_expr = pickle.dumps(expr)
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        cache_fle = cache_dir / (hashlib.sha256(pickle_expr).hexdigest() + ".nrpycache")
+        if cache_fle.exists():
+            with open(cache_fle, "rb") as file:
+                return cast(sp.Expr, pickle.load(file))
+        else:
+            simplified = sp.simplify(expr)
+            with open(cache_fle, "wb") as file:
+                pickle.dump(simplified, file)
+            return cast(sp.Expr, simplified)
+    except pickle.PicklingError:
+        return cast(sp.Expr, sp.simplify(expr))

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/helpers/cse_preprocess_postprocess.py

@@ -15,7 +15,6 @@ import sympy as sp  # SymPy: The Python computer algebra package upon which NRPy
 from nrpy.helpers.expr_tree import ExprTree
 
 
-# @profile
 def cse_preprocess(
     expr_list: Union[
         sp.Basic,

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/helpers/generic.py

@@ -1,12 +1,13 @@
 """
 Generic helper functions used throughout NRPy+.
 """
-from typing import List, Any
+from typing import List, Any, cast
 import subprocess
 import hashlib
 import lzma
 import base64
 from difflib import ndiff
+from nrpy.helpers.cached_functions import is_cached, read_cached, write_cached
 
 
 #
@@ -74,7 +75,9 @@ def clang_format(
       return 0;
     }
     """
-
+    unique_id = __name__ + c_code_str + clang_format_options
+    if is_cached(unique_id):
+        return cast(str, read_cached(unique_id))
     with subprocess.Popen(
         ["clang-format", clang_format_options],
         stdin=subprocess.PIPE,
@@ -86,6 +89,7 @@ def clang_format(
 
         # If the process exited without errors, return the formatted code
         if process.returncode == 0:
+            write_cached(unique_id, stdout.decode())
             return stdout.decode()
 
         raise RuntimeError(f"Error using clang-format: {stderr.decode()}")

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/infrastructures/BHaH/general_relativity/BSSN_C_codegen_library.py

@@ -165,7 +165,6 @@ def register_CFunction_rhs_eval(
         read_xxs=not enable_rfm_precompute,
         OMP_collapse=OMP_collapse,
     )
-
     cfc.register_CFunction(
         include_CodeParameters_h=True,
         includes=includes,

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy/reference_metric.py

@@ -5,6 +5,7 @@ import sympy as sp
 import nrpy.indexedexp as ixp
 import nrpy.params as par
 from nrpy.helpers.generic import superfast_uniq
+from nrpy.helpers.cached_functions import cached_simplify
 
 # grid_physical_size is set based entirely on CoordSystem. So it is a rfm parameter not a grid parameter.
 par.register_param(bool, __name__, "enable_grid_physical_size", True)
@@ -297,7 +298,7 @@ class ReferenceMetric:
                 for k in range(3):
                     if self.SymPySimplifyExpressions:
                         #                    ghatDDdD[i][j][k] = sp.trigsimp(sp.diff(ghatDD[i][j], xx[k])) # FIXME: BAD: MUST BE SIMPLIFIED OR ANSWER IS INCORRECT! Must be some bug in sympy...
-                        self.ghatDDdD[i][j][k] = sp.simplify(
+                        self.ghatDDdD[i][j][k] = cached_simplify(
                             sp.diff(self.ghatDD[i][j], self.xx[k])
                         )  # FIXME: BAD: MUST BE SIMPLIFIED OR ANSWER IS INCORRECT! Must be some bug in sympy...
                     else:

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrpy
-Version: 2.0.2
+Version: 2.0.3
 Summary: Python/SymPy-based code generation for numerical relativity... and beyond!
 Home-page: https://github.com/nrpy/nrpy
 Author: Zachariah Etienne

{nrpy-2.0.2 → nrpy-2.0.3}/nrpy.egg-info/SOURCES.txt

@@ -42,6 +42,7 @@ nrpy/examples/two_blackholes_collide.py
 nrpy/examples/wave_equation_cartesian.py
 nrpy/examples/wave_equation_curvilinear.py
 nrpy/helpers/__init__.py
+nrpy/helpers/cached_functions.py
 nrpy/helpers/cse_preprocess_postprocess.py
 nrpy/helpers/expr_tree.py
 nrpy/helpers/functional.py