BROKEN: different models in python for hybrid and mhd

Author: UCaromel

pyphare/pyphare/pharein/__init__.py

@@ -54,6 +54,12 @@
     sys.path = sys.path + pythonpath
 
 
+def add_vector_string(path, val):
+    import pybindlibs.dictator as pp
+
+    pp.add_vector_string(path, list(val))
+
+
 def NO_GUI():
     """prevents issues when command line only and no desktop etc"""
     import matplotlib as mpl
@@ -76,13 +82,15 @@ def populateDict():
 
     initialize.general.populateDict(sim)
 
-    if not sim.init_options:
-        sim.init_options = ["hybrid"]
+    if not sim.model_options:
+        sim.model_options = ["HybridModel"]
 
-    if "hybrid" in sim.init_options:
+    if "HybridModel" in sim.model_options:
         initialize.hybrid.populateDict(sim)
-    if "mhd" in sim.init_options:
+    if "MHDModel" in sim.model_options:
         initialize.mhd.populateDict(sim)
 
-    if not ("hybrid" in sim.init_options or "mhd" in sim.init_options):
+    if not ("HybridModel" in sim.model_options or "MHDModel" in sim.model_options):
         raise ValueError("Unknown simulation type")
+
+    add_vector_string("simulation/models", sim.model_options)

pyphare/pyphare/pharein/diagnostics.py

@@ -216,7 +216,7 @@ def to_dict(self):
 
 
 def population_in_model(population):
-    return population in [p for p in global_vars.sim.model.populations]
+    return population in [p for p in global_vars.sim.maxwellian_fluid_model.populations]
 
 
 class FluidDiagnostics_(Diagnostics):

pyphare/pyphare/pharein/initialize/general.py

@@ -1,13 +1,12 @@
 import os
 
 import numpy as np
+import pybindlibs.dictator as pp
 from pyphare.core.phare_utilities import is_scalar
 from pyphare.pharein.load_balancer import LoadBalancer
 from pyphare.pharein.simulation import deserialize as deserialize_sim
 from pyphare.pharein.simulation import serialize as serialize_sim
 
-import pybindlibs.dictator as pp
-
 
 def _patch_data_ids(restart_file_dir):
     """

pyphare/pyphare/pharein/initialize/hybrid.py

@@ -16,7 +16,7 @@ def populateDict(sim):
     add_double("simulation/algo/ohm/hyper_resistivity", sim.hyper_resistivity)
     add_string("simulation/algo/ohm/hyper_mode", sim.hyper_mode)
 
-    init_model = sim.model
+    init_model = sim.maxwellian_fluid_model
     modelDict = init_model.model_dict
 
     if init_model.nbr_populations() < 0:

pyphare/pyphare/pharein/initialize/mhd.py

@@ -21,7 +21,7 @@ def populateDict(sim):
 
     add_string("simulation/mhd_state/name", "mhd_state")
 
-    init_model = sim.model
+    init_model = sim.mhd_model
     modelDict = init_model.model_dict
 
     addInitFunction(

pyphare/pyphare/pharein/maxwellian_fluid_model.py

@@ -91,7 +91,7 @@ def __init__(self, bx=None, by=None, bz=None, **kwargs):
         if should_validate:
             self.validate(global_vars.sim)
 
-        global_vars.sim.set_model(self)
+        global_vars.sim.set_maxwellian_fluid_model(self)
 
     # ------------------------------------------------------------------------------
 

pyphare/pyphare/pharein/mhd_model.py

@@ -0,0 +1,57 @@
+from . import global_vars
+
+
+class MHDModel(object):
+    def defaulter(self, input, value):
+        if input is not None:
+            import inspect
+
+            params = list(inspect.signature(input).parameters.values())
+            assert len(params)
+            param_per_dim = len(params) == self.dim
+            has_vargs = params[0].kind == inspect.Parameter.VAR_POSITIONAL
+            assert param_per_dim or has_vargs
+            return input
+        if self.dim == 1:
+            return lambda x: value + x * 0
+        if self.dim == 2:
+            return lambda x, y: value
+        if self.dim == 3:
+            return lambda x, y, z: value
+
+    def __init__(
+        self, density=None, vx=None, vy=None, vz=None, bx=None, by=None, bz=None, p=None
+    ):
+        if global_vars.sim is None:
+            raise RuntimeError("A simulation must be declared before a model")
+
+        if global_vars.sim.model is not None:
+            raise RuntimeError("A model is already created")
+
+        self.dim = global_vars.sim.ndim
+
+        density = self.defaulter(density, 1.0)
+        vx = self.defaulter(vx, 1.0)
+        vy = self.defaulter(vy, 0.0)
+        vz = self.defaulter(vz, 0.0)
+        bx = self.defaulter(bx, 1.0)
+        by = self.defaulter(by, 0.0)
+        bz = self.defaulter(bz, 0.0)
+        p = self.defaulter(p, 1.0)
+
+        self.model_dict = {}
+
+        self.model_dict.update(
+            {
+                "density": density,
+                "vx": vx,
+                "vy": vy,
+                "vz": vz,
+                "bx": bx,
+                "by": by,
+                "bz": bz,
+                "p": p,
+            }
+        )
+
+        global_vars.sim.set_mhd_model(self)

pyphare/pyphare/pharein/simulation.py

@@ -1,11 +1,12 @@
 import os
+from copy import deepcopy
+
 import numpy as np
 
-from ..core import phare_utilities
-from . import global_vars
 from ..core import box as boxm
+from ..core import phare_utilities
 from ..core.box import Box
-from copy import deepcopy
+from . import global_vars
 
 # ------------------------------------------------------------------------------
 
@@ -957,7 +958,9 @@ def __init__(self, **kwargs):
         self.ndim = compute_dimension(self.cells)
 
         self.diagnostics = {}
-        self.model = None
+        self.uniform_model = None
+        self.maxwellian_fluid_model = None
+        self.mhd_model = None
         self.electrons = None
         self.load_balancer = None
 
@@ -1065,12 +1068,26 @@ def count_diagnostics(self, type_name):
 
     # ------------------------------------------------------------------------------
 
-    def set_model(self, model):
+    def set_uniform_model(self, mhd_model):
+        """
+
+        :meta private:
+        """
+        self.uniform_model = mhd_model
+
+    def set_maxwellian_fluid_model(self, maxwellian_fluid_model):
         """
 
         :meta private:
         """
-        self.model = model
+        self.maxwellian_fluid_model = maxwellian_fluid_model
+
+    def set_mhd_model(self, mhd_model):
+        """
+
+        :meta private:
+        """
+        self.mhd_model = mhd_model
 
     def set_electrons(self, electrons):
         """
@@ -1089,14 +1106,17 @@ def serialize(sim):
     :meta private:
     """
     # pickle cannot handle simulation objects
-    import dill
     import codecs
 
+    import dill
+
     return codecs.encode(dill.dumps(de_numpify_simulation(deepcopy(sim))), "hex")
 
 
 def deserialize(hex):
     """:meta private:"""
-    import dill, codecs
+    import codecs
+
+    import dill
 
     return re_numpify_simulation(dill.loads(codecs.decode(hex, "hex")))

pyphare/pyphare/pharein/uniform_model.py

@@ -11,7 +11,7 @@ def __init__(self, b=(1.0, 0.0, 0.0), e=(0.0, 0.0, 0.0), **kwargs):
         if global_vars.sim.model is not None:
             raise RuntimeError("A model is already created")
 
-        global_vars.sim.set_model(self)
+        global_vars.sim.set_uniform_model(self)
 
         if len(b) != 3 or (not isinstance(b, tuple) and not isinstance(b, list)):
             raise ValueError("invalid B")

src/amr/messengers/mhd_messenger_info.hpp

@@ -21,7 +21,7 @@ namespace amr
         std::string modelPressure;
 
         VecFieldNames modelMomentum;
-        VecFieldNames modelTotalEnergy;
+        std::string modelTotalEnergy;
 
         VecFieldNames modelElectric;
         VecFieldNames modelCurrent;