feat: use SpatialConstant naming in get_pde_as_diff_op

Author: alexfikl

sumpy/kernel.py

@@ -840,7 +840,7 @@ def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
         from sumpy.expansion.diff_op import laplacian, make_identity_diff_op
 
         w = make_identity_diff_op(self.dim)
-        k = sym.Symbol(self.helmholtz_k_name)
+        k = sym.SpatialConstant(self.helmholtz_k_name).as_sympy()
         return laplacian(w) + k**2 * w
 
 
@@ -936,7 +936,7 @@ def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
         from sumpy.expansion.diff_op import laplacian, make_identity_diff_op
 
         w = make_identity_diff_op(self.dim)
-        lam = sym.Symbol(self.yukawa_lambda_name)
+        lam = sym.SpatialConstant(self.yukawa_lambda_name).as_sympy()
         return laplacian(w) - lam**2 * w
 
 
@@ -1498,7 +1498,7 @@ def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
         from sumpy.expansion.diff_op import laplacian, make_identity_diff_op
 
         w = make_identity_diff_op(self.dim)
-        k = sym.Symbol(self.darcy_impermeability_name)
+        k = sym.SpatialConstant(self.darcy_impermeability_name).as_sympy()
 
         return laplacian(laplacian(w) - k**2 * w)
 
@@ -1772,7 +1772,7 @@ def get_args(self):
     def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
         from sumpy.expansion.diff_op import diff, laplacian, make_identity_diff_op
 
-        alpha = sym.Symbol(self.heat_alpha_name)
+        alpha = sym.SpatialConstant(self.heat_alpha_name).as_sympy()
         w = make_identity_diff_op(self.dim - 1, time_dependent=True)
         t_mi = (*([0] * (self.dim - 1)), 1)
 
@@ -1845,8 +1845,8 @@ def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
             make_identity_diff_op,
         )
 
-        mu = sym.Symbol(self.viscosity_mu_name)
-        nu = sym.Symbol(self.poisson_ratio_name)
+        mu = sym.SpatialConstant(self.viscosity_mu_name).as_sympy()
+        nu = sym.SpatialConstant(self.poisson_ratio_name).as_sympy()
         u = make_identity_diff_op(self.dim, self.dim)
 
         return mu * laplacian(u) + mu / (1 - 2 * nu) * gradient(divergence(u))
@@ -1912,8 +1912,8 @@ def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
             make_identity_diff_op,
         )
 
-        mu = sym.Symbol(self.viscosity_mu_name)
-        nu = sym.Symbol(self.poisson_ratio_name)
+        mu = sym.SpatialConstant(self.viscosity_mu_name).as_sympy()
+        nu = sym.SpatialConstant(self.poisson_ratio_name).as_sympy()
         u = make_identity_diff_op(self.dim, self.dim)
 
         return mu * laplacian(u) + mu / (1 - 2 * nu) * gradient(divergence(u))
@@ -1970,7 +1970,7 @@ def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
             make_identity_diff_op,
         )
 
-        mu = sym.Symbol(self.viscosity_mu_name)
+        mu = sym.SpatialConstant(self.viscosity_mu_name).as_sympy()
         u_and_p = make_identity_diff_op(self.dim, self.dim + 1)
         u = u_and_p[:self.dim]
         p = u_and_p[self.dim]
@@ -2029,7 +2029,7 @@ def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
             make_identity_diff_op,
         )
 
-        mu = sym.Symbol(self.viscosity_mu_name)
+        mu = sym.SpatialConstant(self.viscosity_mu_name).as_sympy()
         u_and_p = make_identity_diff_op(self.dim, self.dim + 1)
         u = u_and_p[:self.dim]
         p = u_and_p[self.dim]
@@ -2097,8 +2097,8 @@ def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
             make_identity_diff_op,
         )
 
-        mu = sym.Symbol(self.viscosity_mu_name)
-        k = sym.Symbol(self.darcy_impermeability_name)
+        mu = sym.SpatialConstant(self.viscosity_mu_name).as_sympy()
+        k = sym.SpatialConstant(self.darcy_impermeability_name).as_sympy()
 
         u_and_p = make_identity_diff_op(self.dim, self.dim + 1)
         u = u_and_p[:self.dim]
@@ -2168,8 +2168,8 @@ def get_pde_as_diff_op(self) -> LinearPDESystemOperator:
             make_identity_diff_op,
         )
 
-        mu = sym.Symbol(self.viscosity_mu_name)
-        k = sym.Symbol(self.darcy_impermeability_name)
+        mu = sym.SpatialConstant(self.viscosity_mu_name).as_sympy()
+        k = sym.SpatialConstant(self.darcy_impermeability_name).as_sympy()
 
         u_and_p = make_identity_diff_op(self.dim, self.dim + 1)
         u = u_and_p[:self.dim]

sumpy/test/test_misc.py

@@ -625,8 +625,8 @@ def test_as_scalar_pde_elasticity():
 
 def test_as_scalar_pde_brinkman():
     dim = 3
-    mu = sym.Symbol("mu")
-    k = sym.Symbol("k")
+    mu = sym.SpatialConstant("mu").as_sympy()
+    k = sym.SpatialConstant("k").as_sympy()
 
     # NOTE: momentum + incompressibility equations
     diff_op = make_identity_diff_op(dim, dim + 1)
@@ -670,7 +670,7 @@ def test_elasticity_pickle():
 
 def test_to_fourier_matrix_scalar() -> None:
     ks = sym.make_sym_vector("k", 3)
-    lam = sym.Symbol("lam")
+    lam = sym.SpatialConstant("lam").as_sympy()
 
     # LaplaceKernel
     kernel = LaplaceKernel(2)
@@ -698,9 +698,9 @@ def test_to_fourier_matrix_scalar() -> None:
 @pytest.mark.parametrize("dim", [2, 3])
 def test_to_fourier_matrix_stokes(dim: int) -> None:
     ks = sym.make_sym_vector("k", dim)
-    mu = sym.Symbol("mu")
+    mu = sym.SpatialConstant("mu").as_sympy()
 
-    kernel = StokesletSystemKernel(dim=dim, viscosity_mu_name=mu.name)
+    kernel = StokesletSystemKernel(dim=dim, viscosity_mu_name="mu")
     pde = kernel.get_pde_as_diff_op()
 
     k_sqr = sum(k**2 for k in ks)
@@ -731,13 +731,13 @@ def test_to_fourier_matrix_stokes(dim: int) -> None:
 @pytest.mark.parametrize("dim", [2, 3])
 def test_to_fourier_matrix_elasticity(dim: int) -> None:
     ks = sym.make_sym_vector("k", dim)
-    mu = sym.Symbol("mu")
-    nu = sym.Symbol("nu")
+    mu = sym.SpatialConstant("mu").as_sympy()
+    nu = sym.SpatialConstant("nu").as_sympy()
     mn = mu / (1 - 2 * nu)
 
     kernel = ElasticitySystemKernel(dim,
-                                    viscosity_mu_name=mu.name,
-                                    poisson_ratio_name=nu.name)
+                                    viscosity_mu_name="mu",
+                                    poisson_ratio_name="nu")
     pde = kernel.get_pde_as_diff_op()
 
     k_sqr = sum(k**2 for k in ks)
@@ -766,8 +766,8 @@ def test_to_fourier_matrix_elasticity(dim: int) -> None:
 @pytest.mark.parametrize("dim", [2, 3])
 def test_to_fourier_matrix_brinkman(dim: int) -> None:
     ks = sym.make_sym_vector("k", dim)
-    mu = sym.Symbol("mu")
-    kappa = sym.Symbol("k")
+    mu = sym.SpatialConstant("mu").as_sympy()
+    kappa = sym.SpatialConstant("k").as_sympy()
 
     kernel = BrinkmanletSystemKernel(dim,
                                      viscosity_mu_name=mu.name,