KratosFluidDynamicsApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/.libs/libKratosFluidDynamicsCore.dylib

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: KratosMultiphysics/.libs/libKratosFluidDynamicsCore.dylib
+size: 35023520 bytes
+sha256: 655e18f7e0cd1726567ea1a7bb5eab67a8614b9fbb9447a111047717f48897d5

KratosMultiphysics/FluidDynamicsApplication/__init__.py

@@ -0,0 +1,11 @@
+from KratosFluidDynamicsApplication import *
+
+from KratosMultiphysics import _ImportApplication, python_registry_utilities
+
+application = KratosFluidDynamicsApplication()
+application_name = "KratosFluidDynamicsApplication"
+
+_ImportApplication(application, application_name)
+
+from . import python_registry_lists
+python_registry_utilities.RegisterAll("KratosMultiphysics.FluidDynamicsApplication", python_registry_lists)

KratosMultiphysics/FluidDynamicsApplication/adjoint_fluid_analysis.py

@@ -0,0 +1,106 @@
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.FluidDynamicsApplication as KFluid
+
+from KratosMultiphysics.analysis_stage import AnalysisStage
+from KratosMultiphysics.process_factory import KratosProcessFactory
+from KratosMultiphysics.FluidDynamicsApplication import python_solvers_wrapper_adjoint_fluid
+from KratosMultiphysics.FluidDynamicsApplication.fluid_dynamics_analysis import FluidDynamicsAnalysis
+
+class AdjointFluidAnalysis(AnalysisStage):
+    '''Main script for adjoint sensitivity optimization in fluid dynamics simulations.'''
+
+    def __init__(self,model,parameters):
+        super().__init__(model, parameters)
+
+        problem_data = self.project_parameters["problem_data"]
+
+        # check that old input is not provided
+        if problem_data.Has("nsteps"):
+            raise Exception("'nsteps' is no longer supported. Use 'start_time' and 'end_time' instead")
+        if problem_data.Has("start_step"):
+            raise Exception("'start_step' is no longer supported. Use 'start_time' and 'end_time' instead")
+        if problem_data.Has("end_step"):
+            raise Exception("'end_step' is no longer supported. Use 'start_time' and 'end_time' instead")
+
+        # compute delta time
+        delta_time = self._GetSolver()._ComputeDeltaTime()
+        if delta_time >= 0.0:
+            raise Exception("Adjoints are solved in reverse in time. Hence, delta_time should be negative. [ delta_time = " + str(delta_time) + "].")
+
+        # update start time and end time. Adjoints are solved reverse in time,
+        # hence we include an additional time step at the end
+        # to properly initialize initial conditions for adjoint problem
+        # and start time is also shifted by one to keep the same number
+        # of steps
+        delta_time *= -1.0
+        self.start_time = problem_data["start_time"].GetDouble() + delta_time
+        self.end_time = problem_data["end_time"].GetDouble() + delta_time
+
+        # now set start_time, end_time of the problem_data bt flipping them
+        self.project_parameters["problem_data"]["start_time"].SetDouble(self.end_time)
+        self.project_parameters["problem_data"]["end_time"].SetDouble(self.start_time)
+
+    def Initialize(self):
+        super(AdjointFluidAnalysis, self).Initialize()
+
+        # dummy time step to correctly calculate DELTA_TIME
+        self._GetSolver().main_model_part.CloneTimeStep(self.time)
+
+    def _CreateSolver(self):
+        return python_solvers_wrapper_adjoint_fluid.CreateSolver(self.model, self.project_parameters)
+
+    def KeepAdvancingSolutionLoop(self):
+        """This function specifies the stopping criteria for breaking the solution loop
+        Note that as the adjoint problem is solved backward in time, the stopping criteria is current time being larger than the start one
+        """
+        return self.time > self.start_time
+
+    def _GetOrderOfProcessesInitialization(self):
+        return ["gravity",
+                "initial_conditions_process_list",
+                "boundary_conditions_process_list",
+                "auxiliar_process_list"]
+
+    def _GetSimulationName(self):
+        return self.__class__.__name__
+
+if __name__ == '__main__':
+    from sys import argv
+
+    primal_parameter_file_name = None
+    adjoint_parameter_file_name = None
+
+    parameters = Kratos.Parameters(r'''{}''')
+
+    if len(argv) == 2:
+        adjoint_parameter_file_name = argv[1]
+    elif len(argv) == 3:
+        primal_parameter_file_name = argv[1]
+        adjoint_parameter_file_name = argv[2]
+    else:
+        err_msg =  'Unexpected amount of input arguments!\n'
+        err_msg += 'To run the primal fluid problem followed by the adjoint solution, provide both parameter files:\n'
+        err_msg += '    "python adjoint_fluid_analysis.py <primal-parameter-file>.json <adjoint-parameter-file>.json"\n'
+        err_msg += 'To run only the adjoint problem, provide only the adjoint parameter file:\n'
+        err_msg += '    "python adjoint_fluid_analysis.py <adjoint-parameter-file>.json"\n'
+        raise Exception(err_msg)
+
+    if primal_parameter_file_name is not None:
+        with open(primal_parameter_file_name,'r') as primal_parameter_file:
+            parameters.AddValue("primal_settings",Kratos.Parameters(primal_parameter_file.read()))
+    else:
+        parameters.AddEmptyValue("primal_settings")
+
+    with open(adjoint_parameter_file_name,'r') as adjoint_parameter_file:
+        parameters.AddValue("adjoint_settings", Kratos.Parameters(adjoint_parameter_file.read()))
+
+    model = Kratos.Model()
+
+    if primal_parameter_file_name is not None:
+        primal_simulation = FluidDynamicsAnalysis(model,parameters["primal_settings"])
+        primal_simulation.Run()
+
+    adjoint_model = Kratos.Model()
+    adjoint_simulation = AdjointFluidAnalysis(adjoint_model,parameters["adjoint_settings"])
+    adjoint_simulation.Run()

KratosMultiphysics/FluidDynamicsApplication/adjoint_fluid_solver.py

@@ -0,0 +1,184 @@
+# Importing the Kratos Library
+import KratosMultiphysics
+# from KratosMultiphysics.python_solver import PythonSolver
+
+import KratosMultiphysics.FluidDynamicsApplication as KratosCFD
+from KratosMultiphysics.FluidDynamicsApplication.fluid_solver import FluidSolver
+
+def CreateSolver(model, custom_settings):
+    return AdjointFluidSolver(model, custom_settings)
+
+class AdjointFluidSolver(FluidSolver):
+
+    def __init__(self, model, settings):
+        super(AdjointFluidSolver,self).__init__(model, settings)
+
+        # Overwrite the default buffer size in base FluidSolver
+        # TODO: CHECK WHY THE DEFAULT BUFFER SIZE IS 2 IF THE DEFAULT TIME SCHEME IS BOSSAK
+        self.min_buffer_size = 2
+
+    def AddDofs(self):
+        dofs_to_add = []
+        dofs_to_add.append("ADJOINT_FLUID_VECTOR_1_X")
+        dofs_to_add.append("ADJOINT_FLUID_VECTOR_1_Y")
+        dofs_to_add.append("ADJOINT_FLUID_VECTOR_1_Z")
+        dofs_to_add.append("ADJOINT_FLUID_SCALAR_1")
+        KratosMultiphysics.VariableUtils.AddDofsList(dofs_to_add, self.main_model_part)
+
+        KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Adjoint fluid solver DOFs added correctly.")
+
+    def GetDofsList(self):
+        dofs_list = []
+        dofs_list.append("ADJOINT_FLUID_VECTOR_1_X")
+        dofs_list.append("ADJOINT_FLUID_VECTOR_1_Y")
+        if self.settings["domain_size"].GetInt() == 3:
+            dofs_list.append("ADJOINT_FLUID_VECTOR_1_Z")
+        dofs_list.append("ADJOINT_FLUID_SCALAR_1")
+
+        return dofs_list
+
+    def InitializeSolutionStep(self):
+        self._GetSolutionStrategy().InitializeSolutionStep()
+        self.GetResponseFunction().InitializeSolutionStep()
+        self.GetSensitivityBuilder().InitializeSolutionStep()
+
+    def Predict(self):
+        self._GetSolutionStrategy().Predict()
+
+    def SolveSolutionStep(self):
+        return self._GetSolutionStrategy().SolveSolutionStep()
+
+    def FinalizeSolutionStep(self):
+        self._GetSolutionStrategy().FinalizeSolutionStep()
+        self.GetResponseFunction().FinalizeSolutionStep()
+
+        self.GetSensitivityBuilder().UpdateSensitivities()
+        self.GetSensitivityBuilder().FinalizeSolutionStep()
+
+    def Check(self):
+        self._GetSolutionStrategy().Check()
+
+    def _ReplaceElementsAndConditions(self):
+        ## Get number of nodes and domain size
+        elem_num_nodes = self._GetElementNumNodes()
+        cond_num_nodes = self._GetConditionNumNodes()
+        domain_size = self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]
+
+        ## If there are no elements and/or conditions, default to triangles/tetra meshes to avoid breaking the ReplaceElementsAndConditionsProcess
+        ## This only affects the input name (if there are no elements or conditions to replace, nothing is replaced).
+        if elem_num_nodes == 0:
+            elem_num_nodes = domain_size + 1
+        if cond_num_nodes == 0:
+            cond_num_nodes = domain_size
+
+        ## Complete the element name
+        # TODO: EXPORT THE ADJOINT FOLLOWING THE CONVENTION. ONCE THIS IS DONE WE CAN USE THE FUNCTION IN THE BASE CLASS
+        if (self.element_name is not None):
+            new_elem_name = f"{self.element_name}{int(domain_size)}D{int(elem_num_nodes)}N"
+        else:
+            raise Exception("There is no element name. Define the self.element_name string variable in your derived solver.")
+
+        ## Complete the condition name
+        if (self.condition_name is not None):
+            new_cond_name = self.condition_name + str(int(domain_size)) + "D" + str(int(cond_num_nodes)) + "N"
+        else:
+            raise Exception("There is no condition name. Define the self.condition_name string variable in your derived solver.")
+
+        ## Set the element and condition names in the Json parameters
+        self.settings.AddValue("element_replace_settings", KratosMultiphysics.Parameters("""{}"""))
+        self.settings["element_replace_settings"].AddEmptyValue("element_name").SetString(new_elem_name)
+        self.settings["element_replace_settings"].AddEmptyValue("condition_name").SetString(new_cond_name)
+
+        ## Call the replace elements and conditions process
+        KratosMultiphysics.ReplaceElementsAndConditionsProcess(self.main_model_part, self.settings["element_replace_settings"]).Execute()
+
+    def _ComputeDeltaTime(self):
+        """This function returns the delta time
+        Note that the adjoint fluid analysis does not support the automatic time stepping
+        Also note that as it requires to go backwards in time, here we return minus the user time step
+        """
+        if self.settings["time_stepping"]["automatic_time_step"].GetBool():
+            raise Exception("Automatic time stepping is not supported by adjoint fluid solver.")
+
+        delta_time = self.settings["time_stepping"]["time_step"].GetDouble()
+        if delta_time > 0.0:
+            # Expected positive time_step is reversed to advance backwards in time
+            delta_time *= -1.0
+        else:
+            # TODO: Remove this check after the backwards compatibility period
+            # In order to keep backwards compatibility, we throw a warning if a negative time_step is provided
+            KratosMultiphysics.Logger.PrintWarning("Setting a negative 'time_step' is no longer needed by 'AdjointFluidSolver'.")
+
+        return delta_time
+
+    def _SetNodalProperties(self):
+        # Get density and dynamic viscostity from the properties of the first element
+        for el in self.main_model_part.Elements:
+            rho = el.Properties.GetValue(KratosMultiphysics.DENSITY)
+            if rho <= 0.0:
+                raise Exception("DENSITY set to {0} in Properties {1}, positive number expected.".format(rho,el.Properties.Id))
+            dyn_viscosity = el.Properties.GetValue(KratosMultiphysics.DYNAMIC_VISCOSITY)
+            if dyn_viscosity <= 0.0:
+                raise Exception("DYNAMIC_VISCOSITY set to {0} in Properties {1}, positive number expected.".format(dyn_viscosity,el.Properties.Id))
+            kin_viscosity = dyn_viscosity / rho
+            break
+        else:
+            raise Exception("No fluid elements found in the main model part.")
+        # Transfer the obtained properties to the nodes
+        KratosMultiphysics.VariableUtils().SetVariable(KratosMultiphysics.DENSITY, rho, self.main_model_part.Nodes)
+        KratosMultiphysics.VariableUtils().SetVariable(KratosMultiphysics.VISCOSITY, kin_viscosity, self.main_model_part.Nodes)
+
+    def GetResponseFunction(self):
+        if not hasattr(self, '_response_function'):
+            self._response_function = self.__CreateResponseFunction()
+        return self._response_function
+
+    def __CreateResponseFunction(self):
+        domain_size = self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]
+        response_type = self.settings["response_function_settings"]["response_type"].GetString()
+        if response_type == "drag":
+            if domain_size == 2:
+                response_function = KratosCFD.DragResponseFunction2D(
+                    self.settings["response_function_settings"]["custom_settings"],
+                    self.main_model_part)
+            elif domain_size == 3:
+                response_function = KratosCFD.DragResponseFunction3D(
+                    self.settings["response_function_settings"]["custom_settings"],
+                    self.main_model_part)
+            else:
+                raise Exception("Invalid DOMAIN_SIZE: " + str(domain_size))
+        elif response_type == "norm_square":
+            response_function = KratosCFD.VelocityPressureNormSquareResponseFunction(
+                self.settings["response_function_settings"]["custom_settings"],
+                self.model)
+        else:
+            raise Exception("Invalid response_type: " + response_type + ". Available response functions: \'drag\'.")
+        return response_function
+
+    def GetSensitivityBuilder(self):
+        if not hasattr(self, '_sensitivity_builder'):
+            self._sensitivity_builder = self.__CreateSensitivityBuilder()
+        return self._sensitivity_builder
+
+    def __CreateSensitivityBuilder(self):
+        response_function = self.GetResponseFunction()
+        time_scheme_settings = self.settings["scheme_settings"]
+        time_scheme_type = time_scheme_settings["scheme_type"].GetString()
+
+        domain_size = self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]
+        # the schemes used in fluid supports SLIP conditions which rotates element/condition
+        # matrices based on nodal NORMAL. Hence, the consistent adjoints also need to
+        # rotate adjoint element/condition matrices accordingly and to compute derivatives
+        # of rotation matrices as well. Therefore, following schemes are used.
+        if (time_scheme_type == "steady"):
+            self.sensitivity_builder_scheme = KratosCFD.SimpleSteadySensitivityBuilderScheme(domain_size, domain_size + 1)
+        elif (time_scheme_type == "bossak"):
+            self.sensitivity_builder_scheme = KratosCFD.VelocityBossakSensitivityBuilderScheme(time_scheme_settings["alpha_bossak"].GetDouble(), domain_size, domain_size + 1)
+
+        sensitivity_builder = KratosMultiphysics.SensitivityBuilder(
+            self.settings["sensitivity_settings"],
+            self.main_model_part,
+            response_function,
+            self.sensitivity_builder_scheme
+            )
+        return sensitivity_builder

KratosMultiphysics/FluidDynamicsApplication/adjoint_monolithic_solver.py

@@ -0,0 +1,224 @@
+# Importing the Kratos Library
+import KratosMultiphysics
+from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning
+
+# Import applications
+import KratosMultiphysics.FluidDynamicsApplication as KratosCFD
+
+# Import base class file
+from KratosMultiphysics.FluidDynamicsApplication.adjoint_fluid_solver import AdjointFluidSolver
+
+class StabilizedAdjointFormulation(object):
+    """Helper class to define stabilization-dependent parameters."""
+    def __init__(self,settings):
+        self.element_name = None
+        self.element_integrates_in_time = False
+        self.element_has_nodal_properties = False
+        self.process_data = {}
+
+        if settings.Has("element_type"):
+            formulation = settings["element_type"].GetString()
+            if formulation == "vms":
+                self._SetUpClassicAdjointVMS(settings)
+            elif formulation == "qsvms":
+                self._SetUpAdjointQSVMS(settings)
+        else:
+            print(settings)
+            raise RuntimeError("Argument \'element_type\' not found in stabilization settings.")
+
+    def SetProcessInfo(self,model_part):
+        for variable,value in self.process_data.items():
+            model_part.ProcessInfo[variable] = value
+
+    def _SetUpClassicAdjointVMS(self,settings):
+        IssueDeprecationWarning('StabilizedAdjointFormulation', 'Please use the "qsvms" formulation instead of "vms" formulation')
+        default_settings = KratosMultiphysics.Parameters(r"""{
+            "element_type": "vms",
+            "use_orthogonal_subscales": false,
+            "dynamic_tau" : 0.0
+        }""")
+
+        # if non-newtonian, there are some extra options
+        if settings.Has("non_newtonian_fluid_parameters"):
+            raise Exception("Adjoints are not yet supported for HerschelBulkleyVMS")
+
+        self.element_name = 'VMSAdjointElement'
+
+        settings.ValidateAndAssignDefaults(default_settings)
+
+        # set the nodal material properties flag
+        self.element_has_nodal_properties = True
+
+        self.process_data[KratosMultiphysics.DYNAMIC_TAU] = settings["dynamic_tau"].GetDouble()
+        use_oss = settings["use_orthogonal_subscales"].GetBool()
+        self.process_data[KratosMultiphysics.OSS_SWITCH] = int(use_oss)
+
+    def _SetUpAdjointQSVMS(self,settings):
+        default_settings = KratosMultiphysics.Parameters(r"""{
+            "element_type": "qsvms",
+            "use_orthogonal_subscales": false,
+            "dynamic_tau": 0.0,
+            "element_manages_time_integration": false
+        }""")
+        settings.ValidateAndAssignDefaults(default_settings)
+
+        if settings["element_manages_time_integration"].GetBool() == False:
+            self.element_name = "QSVMSAdjoint"
+            self.element_integrates_in_time = False
+        else:
+            raise Exception("Only bossak time integrations is supported with adjoints")
+
+        self.process_data[KratosMultiphysics.DYNAMIC_TAU] = settings["dynamic_tau"].GetDouble()
+        use_oss = settings["use_orthogonal_subscales"].GetBool()
+        self.process_data[KratosMultiphysics.OSS_SWITCH] = int(use_oss)
+
+def CreateSolver(main_model_part, custom_settings):
+    return AdjointMonolithicSolver(main_model_part, custom_settings)
+
+class AdjointMonolithicSolver(AdjointFluidSolver):
+    @classmethod
+    def GetDefaultParameters(cls):
+        # default settings string in json format
+        default_settings = KratosMultiphysics.Parameters("""
+        {
+            "solver_type" : "adjoint_monolithic_solver",
+            "model_part_name": "",
+            "domain_size": -1,
+            "scheme_settings" : {
+                "scheme_type" : "bossak"
+            },
+            "response_function_settings" : {
+                "response_type" : "drag"
+            },
+            "sensitivity_settings" : {},
+            "model_import_settings" : {
+                "input_type"     : "mdpa",
+                "input_filename" : "unknown_name"
+            },
+            "enforce_element_and_conditions_replacement": true,
+            "material_import_settings": {
+                "materials_filename": ""
+            },
+            "linear_solver_settings" : {
+                "solver_type" : "amgcl"
+            },
+            "volume_model_part_name" : "volume_model_part",
+            "skin_parts"  : [""],
+            "no_skin_parts"  : [""],
+            "echo_level"  : 0,
+            "time_stepping"               : {
+                "automatic_time_step" : false,
+                "time_step"           : -0.1
+            },
+            "consider_periodic_conditions": false,
+            "assign_neighbour_elements_to_conditions": true,
+            "formulation": {
+                "element_type": "qsvms"
+            }
+        }""")
+
+        default_settings.AddMissingParameters(super().GetDefaultParameters())
+        return default_settings
+
+    def __init__(self, model, custom_settings):
+        super().__init__(model,custom_settings)
+        self.element_has_nodal_properties = True
+
+        self._SetFormulation()
+
+        KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Construction of AdjointMonolithicSolver finished.")
+
+    def AddVariables(self):
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.MESH_VELOCITY)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.ACCELERATION)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.PRESSURE)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NORMAL)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosCFD.ADJOINT_FLUID_VECTOR_1)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosCFD.ADJOINT_FLUID_VECTOR_2)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosCFD.ADJOINT_FLUID_VECTOR_3)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosCFD.AUX_ADJOINT_FLUID_VECTOR_1)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosCFD.ADJOINT_FLUID_SCALAR_1)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VISCOSITY)
+        # TODO: Remove when old VMS elements are removed.
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.ADVPROJ)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DIVPROJ)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DENSITY)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.BODY_FORCE)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.EXTERNAL_PRESSURE)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.SHAPE_SENSITIVITY)
+        self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NORMAL_SENSITIVITY)
+
+        if self.settings["consider_periodic_conditions"].GetBool() == True:
+            self.main_model_part.AddNodalSolutionStepVariable(KratosCFD.PATCH_INDEX)
+
+        KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Adjoint fluid solver variables added correctly.")
+
+    def Initialize(self):
+        # If the solver requires an instance of the stabilized formulation class, set the process info variables
+        if hasattr(self, 'formulation'):
+            self.formulation.SetProcessInfo(self.GetComputingModelPart())
+
+        # Construct and set the solution strategy
+        solution_strategy = self._GetSolutionStrategy()
+        solution_strategy.SetEchoLevel(self.settings["echo_level"].GetInt())
+
+        # clear RELAXED_ACCELERATION if it is a steady adjoint problem
+        scheme_type = self.settings["scheme_settings"]["scheme_type"].GetString()
+        if (scheme_type == "steady"):
+            KratosMultiphysics.VariableUtils().SetNonHistoricalVariableToZero(KratosMultiphysics.RELAXED_ACCELERATION, self.main_model_part.Nodes)
+
+        # Initialize the strategy and adjoint utilities
+        solution_strategy.Initialize()
+        self.GetResponseFunction().Initialize()
+        self.GetSensitivityBuilder().Initialize()
+
+        domain_size = self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]
+        KratosMultiphysics.NormalCalculationUtils().CalculateOnSimplex(self.main_model_part.Conditions, domain_size)
+        KratosMultiphysics.NormalCalculationUtils().CalculateNormalShapeDerivativesOnSimplex(self.main_model_part.Conditions, domain_size)
+
+        KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Solver initialization finished.")
+
+    def _CreateScheme(self):
+        response_function = self.GetResponseFunction()
+        scheme_type = self.settings["scheme_settings"]["scheme_type"].GetString()
+        domain_size = self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]
+
+        # the schemes used in fluid supports SLIP conditions which rotates element/condition
+        # matrices based on nodal NORMAL. Hence, the consistent adjoints also need to
+        # rotate adjoint element/condition matrices accordingly. Therefore, following
+        # schemes are used.
+        if scheme_type == "bossak":
+            scheme = KratosCFD.VelocityBossakAdjointScheme(self.settings["scheme_settings"], response_function, domain_size, domain_size + 1)
+        elif scheme_type == "steady":
+            scheme = KratosCFD.SimpleSteadyAdjointScheme(response_function, domain_size, domain_size + 1)
+        else:
+            raise Exception("Invalid scheme_type: " + scheme_type)
+        return scheme
+
+    def _CreateSolutionStrategy(self):
+        computing_model_part = self.GetComputingModelPart()
+        time_scheme = self._GetScheme()
+        builder_and_solver = self._GetBuilderAndSolver()
+        calculate_reaction_flag = False
+        reform_dof_set_at_each_step = False
+        calculate_norm_dx_flag = False
+        move_mesh_flag = False
+        return KratosMultiphysics.ResidualBasedLinearStrategy(
+            computing_model_part,
+            time_scheme,
+            builder_and_solver,
+            calculate_reaction_flag,
+            reform_dof_set_at_each_step,
+            calculate_norm_dx_flag,
+            move_mesh_flag)
+
+    def _SetFormulation(self):
+        self.formulation = StabilizedAdjointFormulation(self.settings["formulation"])
+        self.element_name = self.formulation.element_name
+        self.element_has_nodal_properties = self.formulation.element_has_nodal_properties
+
+        # TODO: at the moment, qs_vms with SLIP adjoints are not supported, only no slip is supported
+        #       because AdjointMonolithicWallCondition is based on nodal nu, where as QSVMS is based on
+        #       CLs. There need to update navier_stokes_wall_condition.h with adjoints
+        self.condition_name = "AdjointMonolithicWallCondition"

KratosMultiphysics/FluidDynamicsApplication/apply_boussinesq_force_process.py

@@ -0,0 +1,44 @@
+import KratosMultiphysics
+import KratosMultiphysics.FluidDynamicsApplication as KratosFluid
+
+def Factory(settings, Model):
+    if(type(settings) != KratosMultiphysics.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyBoussinesqForceProcess(Model, settings["Parameters"])
+
+class ApplyBoussinesqForceProcess(KratosMultiphysics.Process):
+
+    def __init__(self, Model, settings):
+
+        KratosMultiphysics.Process.__init__(self)
+
+        # Check the default values
+        default_settings = KratosMultiphysics.Parameters( """
+        {
+            "model_part_name" : "CHOOSE_FLUID_MODELPART_NAME",
+            "gravity" : [0.0,0.0,0.0],
+            "ambient_temperature" : 273.0
+        }  """ )
+
+        # Note: if the thermal expansion coefficient is not provided, it is computed as 
+        # 1/AMBIENT_TEMPERATURE which is the usual assumption for perfect gases.
+        if (settings.Has("thermal_expansion_coefficient")):
+            default_settings.AddEmptyValue("thermal_expansion_coefficient").SetDouble(0.0)
+
+        settings.ValidateAndAssignDefaults(default_settings)
+
+        # Get the fluid model part from the Model container
+        self.fluid_model_part = Model[settings["model_part_name"].GetString()]
+
+        # Save the ambient temperature in the fluid model part ProcessInfo
+        ambient_temperature = settings["ambient_temperature"].GetDouble()
+        self.fluid_model_part.ProcessInfo.SetValue(KratosMultiphysics.AMBIENT_TEMPERATURE, ambient_temperature)
+
+        # Set the Boussinesq force process
+        self.BoussinesqForceProcess = KratosFluid.BoussinesqForceProcess(self.fluid_model_part, settings)
+
+    def ExecuteInitialize(self):
+        self.BoussinesqForceProcess.ExecuteInitialize()
+
+    def ExecuteInitializeSolutionStep(self):
+        self.BoussinesqForceProcess.ExecuteInitializeSolutionStep()

KratosMultiphysics/FluidDynamicsApplication/apply_compressible_navier_stokes_boundary_conditions_process.py

@@ -0,0 +1,7 @@
+import KratosMultiphysics
+from KratosMultiphysics.FluidDynamicsApplication import ApplyCompressibleNavierStokesBoundaryConditionsProcess
+
+def Factory(settings, Model):
+    if not isinstance(settings, KratosMultiphysics.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyCompressibleNavierStokesBoundaryConditionsProcess(Model, settings["Parameters"])

KratosMultiphysics/FluidDynamicsApplication/apply_distance_modification_process.py

@@ -0,0 +1,50 @@
+import KratosMultiphysics
+import KratosMultiphysics.FluidDynamicsApplication as KratosFluid
+import math
+
+def Factory(settings, Model):
+    if(type(settings) != KratosMultiphysics.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyDistanceModificationProcess(Model, settings["Parameters"])
+
+class ApplyDistanceModificationProcess(KratosMultiphysics.Process):
+
+    def __init__(self, Model, settings):
+
+        msg  = "The python distance modification process is deprecated.\n"
+        msg += "Please use (or implement) the \'distance_modification_settings\' in the \'solver_settings\'.\n"
+        KratosMultiphysics.Logger.PrintWarning("ApplyDistanceModificationProcess",msg)
+
+        KratosMultiphysics.Process.__init__(self)
+
+        default_parameters = KratosMultiphysics.Parameters( """
+        {
+            "model_part_name"                        : "CHOOSE_FLUID_MODELPART_NAME",
+            "distance_threshold"                     : 0.01,
+            "continuous_distance"                    : true,
+            "check_at_each_time_step"                : false,
+            "avoid_almost_empty_elements"            : true,
+            "deactivate_full_negative_elements"      : true,
+            "recover_original_distance_at_each_step" : false
+        }  """ )
+
+        settings.ValidateAndAssignDefaults(default_parameters);
+
+        self.fluid_model_part = Model[settings["model_part_name"].GetString()]
+        self.DistanceModificationProcess = KratosFluid.DistanceModificationProcess(self.fluid_model_part, settings)
+
+
+    def ExecuteInitialize(self):
+        self.DistanceModificationProcess.ExecuteInitialize()
+
+
+    def ExecuteBeforeSolutionLoop(self):
+        self.DistanceModificationProcess.ExecuteBeforeSolutionLoop()
+
+
+    def ExecuteInitializeSolutionStep(self):
+        self.DistanceModificationProcess.ExecuteInitializeSolutionStep()
+
+
+    def ExecuteFinalizeSolutionStep(self):
+        self.DistanceModificationProcess.ExecuteFinalizeSolutionStep()