Fluid/feature python solver derivation

applications/FluidDynamicsApplication/custom_elements/vms.h

@@ -301,7 +301,8 @@ class VMS : public Element
         this->AddMomentumRHS(rRightHandSideVector, Density, N, Area);
 
         // For OSS: Add projection of residuals to RHS
-        if (rCurrentProcessInfo[OSS_SWITCH] == 1)
+        const ProcessInfo& r_const_process_info = rCurrentProcessInfo;
+        if (r_const_process_info[OSS_SWITCH] == 1)
         {
             array_1d<double, 3 > AdvVel;
             this->GetAdvectiveVel(AdvVel, N);
@@ -353,7 +354,8 @@ class VMS : public Element
          These terms are not used in OSS, as they belong to the finite element
          space and cancel out with their projections.
          */
-        if (rCurrentProcessInfo[OSS_SWITCH] != 1)
+        const ProcessInfo& r_const_process_info = rCurrentProcessInfo;
+        if (r_const_process_info[OSS_SWITCH] != 1)
         {
             double ElemSize = this->ElementSize(Area);
             double Viscosity = this->EffectiveViscosity(Density,N,DN_DX,ElemSize,rCurrentProcessInfo);

applications/FluidDynamicsApplication/python_scripts/check_and_prepare_model_process_fluid.py

@@ -1,5 +1,5 @@
-import KratosMultiphysics 
-import KratosMultiphysics.FluidDynamicsApplication 
+import KratosMultiphysics
+import KratosMultiphysics.FluidDynamicsApplication
 
 def Factory(settings, Model):
     if(type(settings) != KratosMultiphysics.Parameters):
@@ -10,52 +10,45 @@ def Factory(settings, Model):
 class CheckAndPrepareModelProcess(KratosMultiphysics.Process):
     def __init__(self, main_model_part, Parameters ):
         self.main_model_part = main_model_part
-        
+
         self.volume_model_part_name = Parameters["volume_model_part_name"].GetString()
         self.skin_name_list = Parameters["skin_parts"]
-        
-        
+
+
         #self.volume_model_part_name = Parameters["volume_model_part_name"].GetString()
         #self.list_of_inlets = Parameters["list_of_inlets"]
         #self.list_of_slip = Parameters["list_of_inlets"]
         #self.list_of_inlets = Parameters["list_of_inlets"]
-        
-        
+
+
 
     def Execute(self):
         self.volume_model_part = self.main_model_part.GetSubModelPart(self.volume_model_part_name)
-        
+
         skin_parts = []
         for i in range(self.skin_name_list.size()):
             skin_parts.append(self.main_model_part.GetSubModelPart(self.skin_name_list[i].GetString()))
-        
+
         #construct a model part which contains both the skin and the volume
         #temporarily we call it "fluid_computational_model_part"
         self.main_model_part.CreateSubModelPart("fluid_computational_model_part")
         fluid_computational_model_part= self.main_model_part.GetSubModelPart("fluid_computational_model_part")
         fluid_computational_model_part.ProcessInfo = self.main_model_part.ProcessInfo
-
-        print("adding nodes and elements to fluid_computational_model_part")
+
         for node in self.volume_model_part.Nodes:
             fluid_computational_model_part.AddNode(node,0)
         for elem in self.volume_model_part.Elements:
             fluid_computational_model_part.AddElement(elem,0)
-            
+
         #do some gymnastics to have this done fast. - create an ordered list to be added
         list_of_ids = set()
         for part in skin_parts:
             for cond in part.Conditions:
                 list_of_ids.add(cond.Id)
-                
+
         fluid_computational_model_part.AddConditions(list(list_of_ids))
-
-        print(fluid_computational_model_part)
-
-        if(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3 and self.main_model_part.GetCommunicator().TotalProcesses() == 0 ):
-            #verify that the skin is correct (no gaps and overlaps)
-            KratosMultiphysics.CheckSkinProcess(fluid_computational_model_part , KratosMultiphysics.Flags()).Execute()
 
         #verify the orientation of the skin
         throw_errors = False
         KratosMultiphysics.TetrahedralMeshOrientationCheck(fluid_computational_model_part,throw_errors).Execute()
-        
+

applications/FluidDynamicsApplication/python_scripts/fluid_dynamics_analysis.py

@@ -27,30 +27,39 @@ def __init__(self,model,parameters):
         else:
             self.is_printing_rank = True
 
-        ## Create model part and solver (but don't initialize them yet)
-        model_part_name = self.project_parameters["problem_data"]["model_part_name"].GetString()
-        self.main_model_part = Kratos.ModelPart(model_part_name)
+        # Deprecation warnings
+        solver_settings = self.project_parameters["solver_settings"]
+        if not solver_settings.Has("domain_size"):
+            Kratos.Logger.PrintInfo("FluidDynamicsAnalysis", "Using the old way to pass the domain_size, this will be removed!")
+            solver_settings.AddEmptyValue("domain_size")
+            solver_settings["domain_size"].SetInt(self.project_parameters["problem_data"]["domain_size"].GetInt())
+
+        if not solver_settings.Has("model_part_name"):
+            Kratos.Logger.PrintInfo("FluidDynamicsAnalysis", "Using the old way to pass the model_part_name, this will be removed!")
+            solver_settings.AddEmptyValue("model_part_name")
+            solver_settings["model_part_name"].SetString(self.project_parameters["problem_data"]["model_part_name"].GetString())
 
         import python_solvers_wrapper_fluid
-        self.solver = python_solvers_wrapper_fluid.CreateSolver(self.main_model_part, self.project_parameters)
+        self.solver = python_solvers_wrapper_fluid.CreateSolver(model, self.project_parameters)
+
+        self.__restart_utility = None
 
     def Initialize(self):
         '''
         Construct and initialize all classes and tools used in the simulation loop.
         '''
-        domain_size = self.project_parameters["problem_data"]["domain_size"].GetInt()
-        self.main_model_part.ProcessInfo.SetValue(Kratos.DOMAIN_SIZE, domain_size)
 
         self._SetUpRestart()
 
         if self.load_restart:
-            self.restart_utility.LoadRestart()
+            restart_utility = self._GetRestartUtility()
+            restart_utility.LoadRestart()
         else:
             self.solver.AddVariables()
             self.solver.ImportModelPart()
+            self.solver.PrepareModelPart()
             self.solver.AddDofs()
-
-        self.model.AddModelPart(self.main_model_part)
+            self.main_model_part = self.model.GetModelPart(self.project_parameters["solver_settings"]["model_part_name"].GetString())
 
         # this should let eventual derived stages modify the model after reading.
         self.ModifyInitialProperties()
@@ -83,7 +92,8 @@ def OutputSolutionStep(self):
                 process.ExecuteAfterOutputStep()
 
         if self.save_restart:
-            self.restart_utility.SaveRestart()
+            restart_utility = self._GetRestartUtility()
+            restart_utility.SaveRestart()
 
     def _SetUpListOfProcesses(self):
         '''
@@ -157,17 +167,29 @@ def _SetUpRestart(self):
             restart_settings.RemoveValue("save_restart")
             restart_settings.AddValue("input_filename", self.project_parameters["problem_data"]["problem_name"])
             restart_settings.AddValue("echo_level", self.project_parameters["problem_data"]["echo_level"])
+        else:
+            self.load_restart = False
+            self.save_restart = False
+
+    def _GetRestartUtility(self):
 
+        if self.__restart_utility is not None:
+            return self.__restart_utility
+        else:
             if self.parallel_type == "OpenMP":
                 from restart_utility import RestartUtility as Restart
             elif self.parallel_type == "MPI":
                 from trilinos_restart_utility import TrilinosRestartUtility as Restart
 
-            self.restart_utility = Restart(self.main_model_part,
-                                           self.project_parameters["restart_settings"])
-        else:
-            self.load_restart = False
-            self.save_restart = False
+            model_part_name = self.project_parameters["solver_settings"]["model_part_name"].GetString()
+            if self.model.HasModelPart(model_part_name):
+                model_part = self.model.GetModelPart(model_part_name)
+            else:
+                model_part = self.model.CreateModelPart(model_part_name)
+
+            self.__restart_utility = Restart(model_part,
+                                             self.project_parameters["restart_settings"])
+
 
 if __name__ == '__main__':
     from sys import argv