Add unified-domain to solve porous flow

mirgecom/boundary.py

@@ -65,6 +65,7 @@
 from mirgecom.utils import project_from_base
 from mirgecom.viscous import viscous_facial_flux_central, viscous_flux
 from mirgecom.inviscid import inviscid_facial_flux_rusanov, inviscid_flux
+from mirgecom.gas_model import PorousFlowFluidState
 
 
 def _ldg_bnd_flux_for_grad(internal_quantity, external_quantity):
@@ -1090,6 +1091,8 @@ def state_bc(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
         # set the normal momentum to 0
         mom_bc = self._slip.momentum_bc(state_minus.momentum_density, nhat)
 
+        # this doesn't recompute the internal energy but only substracts the
+        # kinetic energy from the total energy
         energy_bc = (
             gas_model.eos.internal_energy(state_minus.cv)
             + 0.5*np.dot(mom_bc, mom_bc)/state_minus.mass_density)
@@ -1203,11 +1206,17 @@ def state_plus(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
             momentum=free_stream_density*free_stream_velocity,
             species_mass=free_stream_spec_mass)
 
+        if isinstance(state_minus, PorousFlowFluidState):
+            material_densities = state_minus.wv.material_densities
+        else:
+            material_densities = None
+
         return make_fluid_state(cv=cv_infinity, gas_model=gas_model,
                                 temperature_seed=free_stream_temperature,
                                 smoothness_mu=state_minus.smoothness_mu,
                                 smoothness_kappa=state_minus.smoothness_kappa,
-                                smoothness_beta=state_minus.smoothness_beta)
+                                smoothness_beta=state_minus.smoothness_beta,
+                                material_densities=material_densities)
 
     def state_bc(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
         """Return BC fluid state."""
@@ -1338,11 +1347,17 @@ def state_plus(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
                                     energy=total_energy,
                                     species_mass=state_minus.cv.species_mass)
 
+        if isinstance(state_minus, PorousFlowFluidState):
+            material_densities = state_minus.wv.material_densities
+        else:
+            material_densities = None
+
         return make_fluid_state(cv=cv_outflow, gas_model=gas_model,
                                 temperature_seed=state_minus.temperature,
                                 smoothness_mu=state_minus.smoothness_mu,
                                 smoothness_kappa=state_minus.smoothness_kappa,
-                                smoothness_beta=state_minus.smoothness_beta)
+                                smoothness_beta=state_minus.smoothness_beta,
+                                material_densities=material_densities)
 
     def state_bc(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
         """Return state."""
@@ -1381,11 +1396,17 @@ def state_bc(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
             momentum=state_minus.momentum_density,
             species_mass=state_minus.species_mass_density)
 
+        if isinstance(state_minus, PorousFlowFluidState):
+            material_densities = state_minus.wv.material_densities
+        else:
+            material_densities = None
+
         return make_fluid_state(cv=cv_plus, gas_model=gas_model,
                                 temperature_seed=state_minus.temperature,
                                 smoothness_mu=state_minus.smoothness_mu,
                                 smoothness_kappa=state_minus.smoothness_kappa,
-                                smoothness_beta=state_minus.smoothness_beta)
+                                smoothness_beta=state_minus.smoothness_beta,
+                                material_densities=material_densities)
 
     def temperature_bc(self, dcoll, dd_bdry, state_minus, **kwargs):
         """Get temperature value used in grad(T)."""
@@ -1484,11 +1505,17 @@ def state_plus(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
                                      momentum=rho_boundary * velocity_boundary,
                                      species_mass=species_mass_boundary)
 
+        if isinstance(state_minus, PorousFlowFluidState):
+            material_densities = state_minus.wv.material_densities
+        else:
+            material_densities = None
+
         return make_fluid_state(cv=boundary_cv, gas_model=gas_model,
                                 temperature_seed=state_minus.temperature,
                                 smoothness_mu=state_minus.smoothness_mu,
                                 smoothness_kappa=state_minus.smoothness_kappa,
-                                smoothness_beta=state_minus.smoothness_beta)
+                                smoothness_beta=state_minus.smoothness_beta,
+                                material_densities=material_densities)
 
     def state_bc(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
         """Return BC fluid state."""
@@ -1601,11 +1628,17 @@ def state_plus(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
                                      momentum=rho_boundary*velocity_boundary,
                                      species_mass=species_mass_boundary)
 
+        if isinstance(state_minus, PorousFlowFluidState):
+            material_densities = state_minus.wv.material_densities
+        else:
+            material_densities = None
+
         return make_fluid_state(cv=boundary_cv, gas_model=gas_model,
                                 temperature_seed=state_minus.temperature,
                                 smoothness_mu=state_minus.smoothness_mu,
                                 smoothness_kappa=state_minus.smoothness_kappa,
-                                smoothness_beta=state_minus.smoothness_beta)
+                                smoothness_beta=state_minus.smoothness_beta,
+                                material_densities=material_densities)
 
     def state_bc(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
         """Return BC fluid state."""
@@ -1966,11 +1999,17 @@ def state_plus(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
                                      momentum=mass*velocity,
                                      species_mass=mass*species_mass_fracs)
 
+        if isinstance(state_minus, PorousFlowFluidState):
+            material_densities = state_minus.wv.material_densities
+        else:
+            material_densities = None
+
         return make_fluid_state(cv=boundary_cv, gas_model=gas_model,
                                 temperature_seed=state_minus.temperature,
                                 smoothness_mu=state_minus.smoothness_mu,
                                 smoothness_kappa=state_minus.smoothness_kappa,
-                                smoothness_beta=state_minus.smoothness_beta)
+                                smoothness_beta=state_minus.smoothness_beta,
+                                material_densities=material_densities)
 
     def state_bc(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
         """Return BC fluid state."""
@@ -2068,8 +2107,17 @@ def state_plus(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
                                      momentum=mass*velocity,
                                      species_mass=mass*self._spec_mass_fracs)
 
+        if isinstance(state_minus, PorousFlowFluidState):
+            material_densities = state_minus.wv.material_densities
+        else:
+            material_densities = None
+
         return make_fluid_state(cv=boundary_cv, gas_model=gas_model,
-                                temperature_seed=state_minus.temperature)
+                                temperature_seed=state_minus.temperature,
+                                smoothness_mu=state_minus.smoothness_mu,
+                                smoothness_kappa=state_minus.smoothness_kappa,
+                                smoothness_beta=state_minus.smoothness_beta,
+                                material_densities=material_densities)
 
     def state_bc(self, dcoll, dd_bdry, gas_model, state_minus, **kwargs):
         """Return BC fluid state."""

mirgecom/gas_model.py

@@ -426,7 +426,6 @@ def make_fluid_state(cv, gas_model,
         # FIXME per previous review, think of a way to de-couple wall and fluid.
         # ~~~ we need to squeeze wall_eos in gas_model because this is easily
         # accessible everywhere in the code
-
         tau = gas_model.decomposition_progress(material_densities)
         wv = PorousWallVars(
             material_densities=material_densities,
@@ -437,25 +436,45 @@ def make_fluid_state(cv, gas_model,
             tortuosity=gas_model.wall_eos.tortuosity(tau=tau)
         )
 
-        temperature = gas_model.get_temperature(cv=cv, wv=wv,
-            tseed=temperature_seed)
-
-        pressure = gas_model.get_pressure(cv, wv, temperature)
+        pressure = None
+        temperature = None
 
         if limiter_func:
-            cv = limiter_func(cv=cv, wv=wv, pressure=pressure,
-                              temperature=temperature, dd=limiter_dd)
+            rv = limiter_func(cv=cv, wv=wv, temperature_seed=temperature_seed,
+                              gas_model=gas_model, dd=limiter_dd)
+            if isinstance(rv, np.ndarray):
+                cv, pressure, temperature = rv
+            else:
+                cv = rv
 
-        dv = MixtureDependentVars(
-            temperature=temperature,
-            pressure=pressure,
-            speed_of_sound=gas_model.eos.sound_speed(cv, temperature),
-            smoothness_mu=smoothness_mu,
-            smoothness_kappa=smoothness_kappa,
-            smoothness_d=smoothness_d,
-            smoothness_beta=smoothness_beta,
-            species_enthalpies=gas_model.eos.species_enthalpies(cv, temperature),
-        )
+        if temperature is None:
+            temperature = gas_model.get_temperature(cv=cv, wv=wv,
+                                                    tseed=temperature_seed)
+        if pressure is None:
+            pressure = gas_model.get_pressure(cv, wv, temperature)
+
+        from mirgecom.eos import MixtureEOS
+        if isinstance(gas_model.eos, MixtureEOS):
+            dv = MixtureDependentVars(
+                temperature=temperature,
+                pressure=pressure,
+                speed_of_sound=gas_model.eos.sound_speed(cv, temperature),
+                smoothness_mu=smoothness_mu,
+                smoothness_kappa=smoothness_kappa,
+                smoothness_d=smoothness_d,
+                smoothness_beta=smoothness_beta,
+                species_enthalpies=gas_model.eos.species_enthalpies(cv, temperature)
+            )
+        else:
+            dv = GasDependentVars(
+                temperature=temperature,
+                pressure=pressure,
+                speed_of_sound=gas_model.eos.sound_speed(cv, temperature),
+                smoothness_mu=smoothness_mu,
+                smoothness_kappa=smoothness_kappa,
+                smoothness_d=smoothness_d,
+                smoothness_beta=smoothness_beta
+            )
 
         tv = gas_model.transport.transport_vars(cv=cv, dv=dv, wv=wv,
             eos=gas_model.eos, wall_eos=gas_model.wall_eos)
@@ -513,7 +532,7 @@ def project_fluid_state(dcoll, src, tgt, state, gas_model, limiter_func=None,
     cv_sd = op.project(dcoll, src, tgt, state.cv)
 
     temperature_seed = None
-    if state.is_mixture:
+    if state.is_mixture or isinstance(gas_model, PorousFlowModel):
         temperature_seed = op.project(dcoll, src, tgt, state.dv.temperature)
 
     if entropy_stable:
@@ -769,7 +788,7 @@ def make_operator_fluid_states(
     ]
 
     tseed_interior_pairs = None
-    if volume_state.is_mixture:
+    if volume_state.is_mixture or isinstance(gas_model, PorousFlowModel):
         # If this is a mixture, we need to exchange the temperature field because
         # mixture pressure (used in the inviscid flux calculations) depends on
         # temperature and we need to seed the temperature calculation for the

mirgecom/inviscid.py

@@ -57,17 +57,27 @@
     ConservedVars
 )
 from mirgecom.utils import normalize_boundaries
+from mirgecom.gas_model import PorousFlowFluidState
 
 from arraycontext import outer
 from meshmode.dof_array import DOFArray
 
 
-def inviscid_flux(state):
+def inviscid_flux(state, gas_model=None):
     r"""Compute the inviscid flux vectors from fluid conserved vars *cv*.
 
-    The inviscid fluxes are
-    $(\rho\vec{V},(\rho{E}+p)\vec{V},\rho(\vec{V}\otimes\vec{V})
-    +p\mathbf{I}, \rho{Y_s}\vec{V})$
+    The inviscid fluxes for pure-fluids and porous flows are, respectively,
+    $$
+    \begin{bmatrix}(\rho{v})_{j}\\
+    \left(\rho{E}+p\right){v}_{j}\\
+    \left((\rho{v})_{j}{v}_{i}+p\delta_{ij}\right)\\
+    (\rho{Y})_{\alpha}{v}_{j}\end{bmatrix}
+    \text{ and }
+    \begin{bmatrix}(\epsilon \rho{v})_{j}\\
+    \left(\epsilon \rho{E}+\epsilon p\right){v}_{j}\\
+    \left((\epsilon \rho{v})_{j}{v}_{i}+p\delta_{ij}\right)\\
+    (\epsilon \rho{Y})_{\alpha}{v}_{j}\end{bmatrix} \text{ .}
+    $$
 
     .. note::
 
@@ -82,6 +92,12 @@ def inviscid_flux(state):
 
         Full fluid conserved and thermal state.
 
+    gas_model: :class:`~mirgecom.gas_model.GasModel`
+
+        Physical gas model including equation of state, transport,
+        and kinetic properties as required by fluid state.
+        Only necessary for porous media flows using the unified-domain.
+
     Returns
     -------
     :class:`~mirgecom.fluid.ConservedVars`
@@ -90,11 +106,25 @@ def inviscid_flux(state):
         conservation equation.
     """
     mass_flux = state.momentum_density
-    energy_flux = state.velocity * (state.energy_density + state.pressure)
+
+    # only the gas part goes into the energy flux
+    if isinstance(state, PorousFlowFluidState):
+        gas_energy = state.mass_density*(
+            gas_model.eos.get_internal_energy(
+                temperature=state.temperature,
+                species_mass_fractions=state.cv.species_mass_fractions)
+            + 0.5*np.dot(state.velocity, state.velocity)
+        )
+        energy_flux = state.velocity * (gas_energy
+                                        + state.wv.void_fraction*state.pressure)
+    else:
+        energy_flux = state.velocity * (state.energy_density + state.pressure)
+
     mom_flux = (
         state.mass_density * np.outer(state.velocity, state.velocity)
         + np.eye(state.dim)*state.pressure
     )
+
     species_mass_flux = \
         state.velocity*state.species_mass_density.reshape(-1, 1)
 
@@ -146,10 +176,36 @@ def inviscid_facial_flux_rusanov(state_pair, gas_model, normal):
     actx = state_pair.int.array_context
     lam = actx.np.maximum(state_pair.int.wavespeed, state_pair.ext.wavespeed)
     from mirgecom.flux import num_flux_lfr
-    return num_flux_lfr(f_minus_normal=inviscid_flux(state_pair.int)@normal,
-                        f_plus_normal=inviscid_flux(state_pair.ext)@normal,
-                        q_minus=state_pair.int.cv,
-                        q_plus=state_pair.ext.cv, lam=lam)
+
+    # Use only the gas energy in penalization terms
+    # TODO think of a better way to generalize this for different fluxes??
+    if isinstance(state_pair.int, PorousFlowFluidState):
+        gas_energy_int = state_pair.int.mass_density*(
+            gas_model.eos.get_internal_energy(
+                temperature=state_pair.int.temperature,
+                species_mass_fractions=state_pair.int.cv.species_mass_fractions)
+            + 0.5*np.dot(state_pair.int.velocity, state_pair.int.velocity)
+        )
+        q_minus = state_pair.int.cv.replace(energy=gas_energy_int)
+
+        gas_energy_ext = state_pair.ext.mass_density*(
+            gas_model.eos.get_internal_energy(
+                temperature=state_pair.ext.temperature,
+                species_mass_fractions=state_pair.ext.cv.species_mass_fractions)
+            + 0.5*np.dot(state_pair.ext.velocity, state_pair.ext.velocity)
+        )
+        q_plus = state_pair.ext.cv.replace(energy=gas_energy_ext)
+
+        return num_flux_lfr(
+            f_minus_normal=inviscid_flux(state_pair.int, gas_model=gas_model)@normal,
+            f_plus_normal=inviscid_flux(state_pair.ext, gas_model=gas_model)@normal,
+            q_minus=q_minus, q_plus=q_plus, lam=lam)
+
+    return num_flux_lfr(
+        f_minus_normal=inviscid_flux(state_pair.int, gas_model=gas_model)@normal,
+        f_plus_normal=inviscid_flux(state_pair.ext, gas_model=gas_model)@normal,
+        q_minus=state_pair.int.cv,
+        q_plus=state_pair.ext.cv, lam=lam)
 
 
 def inviscid_facial_flux_hll(state_pair, gas_model, normal):