KratosFSIApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/FSIApplication/Conformant_OneSideMap.py

@@ -0,0 +1,36 @@
+
+# Importing the Kratos Library
+from KratosMultiphysics import *
+
+# Import applications
+from KratosMultiphysics.FSIApplication import *
+
+def AddVariables(fluid_model_part, structure_model_part):
+    fluid_model_part.AddNodalSolutionStepVariable(PRESSURE)
+    fluid_model_part.AddNodalSolutionStepVariable(DISPLACEMENT)
+    fluid_model_part.AddNodalSolutionStepVariable(IS_INTERFACE)
+
+    structure_model_part.AddNodalSolutionStepVariable(PRESSURE)
+    structure_model_part.AddNodalSolutionStepVariable(DISPLACEMENT)
+    structure_model_part.AddNodalSolutionStepVariable(IS_INTERFACE)
+
+    print("variables for the mesh solver added correctly")
+
+
+class Conformant_OneSideMap:
+
+    def __init__(self, fluid_model_part_nodes, structure_model_part_nodes):
+        self.FluidToStructureMapper = SharedPointsMapper(fluid_model_part_nodes, structure_model_part_nodes, 1e-9)
+        self.StructureToFluidMapper = SharedPointsMapper(structure_model_part_nodes, fluid_model_part_nodes, 1e-9)
+
+    def StructureToFluid_VectorMap(self, VectorVar_Origin, VectorVar_Destination):
+        (self.StructureToFluidMapper).VectorMap(VectorVar_Origin, VectorVar_Destination)
+
+    def StructureToFluid_ScalarMap(self, ScalarVar_Origin, ScalarVar_Destination):
+        (self.StructureToFluidMapper).ScalarMap(ScalarVar_Origin, ScalarVar_Destination)
+
+    def FluidToStructure_VectorMap(self, VectorVar_Origin, VectorVar_Destination):
+        (self.FluidToStructureMapper).VectorMap(VectorVar_Origin, VectorVar_Destination)
+
+    def FluidToStructure_ScalarMap(self, ScalarVar_Origin, ScalarVar_Destination):
+        (self.FluidToStructureMapper).ScalarMap(ScalarVar_Origin, ScalarVar_Destination)

KratosMultiphysics/FSIApplication/__init__.py

@@ -0,0 +1,6 @@
+from KratosMultiphysics import _ImportApplication
+from KratosFSIApplication import *
+application = KratosFSIApplication()
+application_name = "KratosFSIApplication"
+
+_ImportApplication(application, application_name)

KratosMultiphysics/FSIApplication/convergence_accelerator_factory.py

@@ -0,0 +1,83 @@
+
+# Importing the Kratos Library
+import KratosMultiphysics
+
+# Import applications
+import KratosMultiphysics.FSIApplication as KratosFSI
+
+import KratosMultiphysics.kratos_utilities as KratosUtilities
+have_trilinos = KratosUtilities.CheckIfApplicationsAvailable("TrilinosApplication")
+is_distributed = KratosMultiphysics.DataCommunicator.GetDefault().IsDistributed()
+if have_trilinos and is_distributed:
+    try:
+        import KratosMultiphysics.TrilinosApplication as KratosTrilinos
+    except Exception as e:
+        raise Exception("Trying to create a Trilinos convergence accelerator, but TrilinosApplication could not be found.")
+
+have_linear_solvers = KratosUtilities.CheckIfApplicationsAvailable("LinearSolversApplication")
+if have_linear_solvers:
+    import KratosMultiphysics.LinearSolversApplication as KratosLinearSolvers
+
+def CreateConvergenceAccelerator(configuration):
+
+    if(type(configuration) != KratosMultiphysics.Parameters):
+        raise Exception("Input is expected to be provided as a Kratos Parameters object.")
+
+    convergence_accelerator_type = configuration["solver_type"].GetString()
+
+    if(convergence_accelerator_type == "constant_relaxation"):
+        return KratosFSI.ConstantRelaxationConvergenceAccelerator(configuration)
+
+    elif(convergence_accelerator_type == "Relaxation"):
+        return KratosFSI.AitkenConvergenceAccelerator(configuration)
+
+    elif(convergence_accelerator_type == "MVQN"):
+        return KratosFSI.MVQNFullJacobianConvergenceAccelerator(configuration)
+
+    elif(convergence_accelerator_type == "MVQN_randomized_SVD"):
+        if not have_linear_solvers:
+            err_msg = "MVQN with randomized SVD Jacobian requires the \'LinearSolversApplication\'."
+            raise Exception(err_msg)
+        bdc_svd = KratosLinearSolvers.EigenDenseBDCSVD()
+        col_piv_qr = KratosLinearSolvers.EigenDenseColumnPivotingHouseholderQRDecomposition()
+        return KratosFSI.MVQNRandomizedSVDConvergenceAccelerator(col_piv_qr, bdc_svd, configuration)
+
+    elif(convergence_accelerator_type == "MVQN_recursive"):
+        return KratosFSI.MVQNRecursiveJacobianConvergenceAccelerator(configuration)
+
+    elif(convergence_accelerator_type == "IBQN_MVQN"):
+        return KratosFSI.IBQNMVQNConvergenceAccelerator(configuration)
+
+    elif(convergence_accelerator_type == "IBQN_MVQN_randomized_SVD"):
+        if not have_linear_solvers:
+            err_msg = "MVQN with randomized SVD Jacobian requires the \'LinearSolversApplication\'."
+            raise Exception(err_msg)
+        bdc_svd = KratosLinearSolvers.EigenDenseBDCSVD()
+        col_piv_qr = KratosLinearSolvers.EigenDenseColumnPivotingHouseholderQRDecomposition()
+        return KratosFSI.IBQNMVQNRandomizedSVDConvergenceAccelerator(col_piv_qr, bdc_svd, configuration)
+
+    else:
+        raise Exception("Convergence accelerator not found. Asking for : " + convergence_accelerator_type)
+
+    return convergence_accelerator
+
+def CreateTrilinosConvergenceAccelerator(interface_model_part, epetra_communicator, configuration):
+
+    if (type(interface_model_part) != KratosMultiphysics.ModelPart):
+        raise Exception("First input in Trilinos convergence accelerator factory is expceted to be provided as a Kratos ModelPart object.")
+
+    if(type(configuration) != KratosMultiphysics.Parameters):
+        raise Exception("Third input in Trilinos convergence accelerator factory is expected to be provided as a Kratos Parameters object.")
+
+    convergence_accelerator_type = configuration["solver_type"].GetString()
+
+    if(convergence_accelerator_type == "Relaxation"):
+        return KratosTrilinos.TrilinosAitkenConvergenceAccelerator(configuration)
+
+    elif(convergence_accelerator_type == "MVQN_recursive"):
+        return KratosTrilinos.TrilinosMVQNRecursiveJacobianConvergenceAccelerator(interface_model_part, epetra_communicator, configuration)
+
+    else:
+        raise Exception("Trilinos convergence accelerator not found. Asking for : " + convergence_accelerator_type)
+
+    return convergence_accelerator

KratosMultiphysics/FSIApplication/fsi_analysis.py

@@ -0,0 +1,204 @@
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.analysis_stage import AnalysisStage
+from KratosMultiphysics.FSIApplication import python_solvers_wrapper_fsi
+
+class FsiAnalysis(AnalysisStage):
+    '''Main script for FSI simulations using the FSI family of python solvers.'''
+
+    def Initialize(self):
+        '''
+        Construct and initialize all classes and tools used in the simulation loop.
+        '''
+        self._SetUpRestart()
+
+        if self.load_restart:
+            fluid_restart_utility = self._GetFluidRestartUtility()
+            structure_restart_utility = self._GetStructureRestartUtility()
+            fluid_restart_utility.LoadRestart()
+            structure_restart_utility.LoadRestart()
+        else:
+
+            # Modelers
+            self._CreateModelers()
+            self._ModelersSetupGeometryModel()
+            self._ModelersPrepareGeometryModel()
+            self._ModelersSetupModelPart()
+
+            self._GetSolver().ImportModelPart()
+            self._GetSolver().PrepareModelPart()
+            self._GetSolver().AddDofs()
+            self.fluid_main_model_part = self.model.GetModelPart(
+                self.project_parameters["solver_settings"]["fluid_solver_settings"]["model_part_name"].GetString())
+            self.structure_main_model_part = self.model.GetModelPart(
+                self.project_parameters["solver_settings"]["structure_solver_settings"]["model_part_name"].GetString())
+
+        # This should let eventual derived stages modify the model after reading.
+        self.ModifyInitialProperties()
+        self.ModifyInitialGeometry()
+
+        # Initialize the user-provided processes
+        self._AnalysisStage__CreateListOfProcesses() # Why name mangling?
+        for process in self._GetListOfProcesses():
+            process.ExecuteInitialize()
+
+        self._GetSolver().Initialize()
+        self.Check()
+
+        self.ModifyAfterSolverInitialize()
+
+        for process in self._GetListOfProcesses():
+            process.ExecuteBeforeSolutionLoop()
+
+        ## Stepping and time settings
+        self.end_time = self.project_parameters["problem_data"]["end_time"].GetDouble()
+
+        fluid_is_restarted = self.fluid_main_model_part.ProcessInfo[Kratos.IS_RESTARTED]
+        structure_is_restarted = self.structure_main_model_part.ProcessInfo[Kratos.IS_RESTARTED]
+        is_restarted = fluid_is_restarted and structure_is_restarted
+
+        if is_restarted:
+            fluid_time = self.fluid_main_model_part.ProcessInfo[Kratos.TIME]
+            structure_time = self.structure_main_model_part.ProcessInfo[Kratos.TIME]
+            if (abs(fluid_time - structure_time) > 1.0e-12):
+                err_msg = 'Fluid restarting time is:' + str(fluid_time) + '\n'
+                err_msg += 'Structure restarting time is:' + \
+                    str(structure_time) + '\n'
+                err_msg += 'Restarting time must coincide between subdomains.\n'
+                raise Exception(err_msg)
+            self.time = fluid_time
+        else:
+            self.time = self.project_parameters["problem_data"]["start_time"].GetDouble()
+            self.fluid_main_model_part.ProcessInfo[Kratos.TIME] = self.time
+            self.structure_main_model_part.ProcessInfo[Kratos.TIME] = self.time
+
+        ## If the echo level is high enough, print the complete list of settings used to run the simulation
+        if self.echo_level > 1:
+            with open("ProjectParametersOutput.json", 'w') as parameter_output_file:
+                parameter_output_file.write(self.project_parameters.PrettyPrintJsonString())
+
+        Kratos.Logger.PrintInfo(self._GetSimulationName(), "Analysis -START-")
+
+    def InitializeSolutionStep(self):
+
+        # Since no substepping is implemented yet, structure and fluid step/time must match
+        step_fluid = self.fluid_main_model_part.ProcessInfo[Kratos.STEP]
+        step_structure = self.structure_main_model_part.ProcessInfo[Kratos.STEP]
+        if step_fluid != step_structure:
+            err_msg =  'Fluid step: '+ str(step_fluid) + '\n'
+            err_msg += 'Structure step: '+ str(step_structure) + '\n'
+            err_msg += 'No substepping has been implemented yet. Fluid and structure step must match.'
+            raise Exception(err_msg)
+
+        Kratos.Logger.PrintInfo(self._GetSimulationName(),"STEP = ", step_fluid)
+        Kratos.Logger.PrintInfo(self._GetSimulationName(),"TIME = ", self.time)
+
+        self.ApplyBoundaryConditions() #here the processes are called
+        self.ChangeMaterialProperties() #this is normally empty
+        self._GetSolver().InitializeSolutionStep()
+
+    def OutputSolutionStep(self):
+        super().OutputSolutionStep()
+
+        if self.save_restart:
+            fluid_restart_utility = self._GetFluidRestartUtility()
+            structure_restart_utility = self._GetStructureRestartUtility()
+            fluid_restart_utility.SaveRestart()
+            structure_restart_utility.SaveRestart()
+
+    def _CreateSolver(self):
+        return python_solvers_wrapper_fsi.CreateSolver(self.model, self.project_parameters)
+
+    def _GetSimulationName(self):
+        return self.project_parameters["problem_data"]["problem_name"].GetString()
+
+    def _GetOrderOfProcessesInitialization(self):
+        return ["structure_constraints_process_list",
+                "structure_contact_process_list",
+                "structure_loads_process_list",
+                "fluid_gravity",
+                "fluid_initial_conditions_process_list",
+                "fluid_boundary_conditions_process_list",
+                "fluid_auxiliar_process_list"]
+
+    def _GetOrderOfOutputProcessesInitialization(self):
+        return ["gid_output","vtk_output"]
+
+    def _SetUpRestart(self):
+        """Initialize self.restart_utility as a RestartUtility instance and check if we need to initialize the problem from a restart file."""
+        has_restart = self.project_parameters.Has("restart_settings")
+
+        if has_restart:
+            raise Exception("FSI restart not implemented yet.")
+        else:
+
+            self.load_restart = False
+            self.save_restart = False
+
+    def _GetFluidRestartUtility(self):
+
+        if self.__fluid_restart_utility is not None:
+            return self.__fluid_restart_utility
+        else:
+            if self.parallel_type == "OpenMP":
+                from restart_utility import RestartUtility as Restart
+            elif self.parallel_type == "MPI":
+                from KratosMultiphysics.mpi.distributed_restart_utility import DistributedRestartUtility as Restart
+            model_part_name = self.project_parameters["fluid_solver_settings"]["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.__fluid_restart_utility = Restart(
+                model_part,
+                self.project_parameters["fluid_solver_settings"]["restart_settings"])
+
+    def _GetStructureRestartUtility(self):
+
+        if self.__structure_restart_utility is not None:
+            return self.__structure_restart_utility
+        else:
+            if self.parallel_type == "OpenMP":
+                from restart_utility import RestartUtility as Restart
+            elif self.parallel_type == "MPI":
+                from KratosMultiphysics.mpi.distributed_restart_utility import DistributedRestartUtility as Restart
+
+            model_part_name = self.project_parameters["structure_solver_settings"]["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.__structure_restart_utility = Restart(
+                model_part,
+                self.project_parameters["structure_solver_settings"]["restart_settings"])
+
+#TODO: Remove this when the backwards compatibility period is over
+class FSIAnalysis(FsiAnalysis):
+    def __init__(self, model, project_parameters):
+        Kratos.Logger.PrintWarning("FSIAnalysis", "\'FSIAnalysis\' is deprecated. Use the \'FsiAnalysis\' one instead.")
+
+if __name__ == '__main__':
+    from sys import argv
+
+    if len(argv) > 2:
+        err_msg =  'Too many input arguments!\n'
+        err_msg += 'Use this script in the following way:\n'
+        err_msg += '- With default parameter file (assumed to be called "ProjectParameters.json"):\n'
+        err_msg += '    "python fsi_analysis.py"\n'
+        err_msg += '- With custom parameter file:\n'
+        err_msg += '    "python fsi_analysis.py <my-parameter-file>.json"\n'
+        raise Exception(err_msg)
+
+    if len(argv) == 2: # ProjectParameters is being passed from outside
+        parameter_file_name = argv[1]
+    else: # using default name
+        parameter_file_name = "ProjectParameters.json"
+
+    with open(parameter_file_name,'r') as parameter_file:
+        parameters = KratosMultiphysics.Parameters(parameter_file.read())
+
+    model = KratosMultiphysics.Model()
+    simulation = FSIAnalysis(model, parameters)
+    simulation.Run()