KratosCoSimulationApplication 10.4.2__2-cp39-cp39-win_amd64.whl

KratosMultiphysics/CoSimulationApplication/MainKratosCoSim.py

@@ -0,0 +1,15 @@
+import KratosMultiphysics as KM
+from KratosMultiphysics.CoSimulationApplication.co_simulation_analysis import CoSimulationAnalysis
+
+"""
+For user-scripting it is intended that a new class is derived
+from CoSimulationAnalysis to do modifications
+Check also "kratos/python_scripts/analysis-stage.py" for available methods that can be overridden
+"""
+
+parameter_file_name = "ProjectParametersCoSim.json"
+with open(parameter_file_name,'r') as parameter_file:
+    parameters = KM.Parameters(parameter_file.read())
+
+simulation = CoSimulationAnalysis(parameters)
+simulation.Run()

KratosMultiphysics/CoSimulationApplication/__init__.py

@@ -0,0 +1,23 @@
+# Application dependent names and paths
+from KratosMultiphysics import _ImportApplication
+from KratosCoSimulationApplication import *
+application = KratosCoSimulationApplication()
+application_name = "KratosCoSimulationApplication"
+
+_ImportApplication(application, application_name)
+
+def __ModuleInitDetail():
+    """
+    Create a DataCommunicator that only contains rank zero and is undefined in other ranks
+    This is necessary for solvers that can only run in serial
+    It is defined as a function to avoid polluting the Kratos namespace with local variables.
+    """
+    import KratosMultiphysics as KM
+    if KM.IsDistributedRun():
+        from KratosMultiphysics.mpi import DataCommunicatorFactory
+        data_comm_name = "co_simulation_data_comm_rank_zero"
+        world_data_comm = KM.ParallelEnvironment.GetDataCommunicator("World")
+        ranks = [0]
+        DataCommunicatorFactory.CreateFromRanksAndRegister(world_data_comm, ranks, data_comm_name)
+
+__ModuleInitDetail()

KratosMultiphysics/CoSimulationApplication/analysis_stage_with_co_sim_io.py

@@ -0,0 +1,136 @@
+import KratosMultiphysics as KM
+from KratosMultiphysics.analysis_stage import AnalysisStage
+
+default_data_comm = KM.ParallelEnvironment.GetDefaultDataCommunicator()
+if default_data_comm.IsDistributed():
+    from KratosMultiphysics.CoSimulationApplication import MPIExtension
+
+from KratosMultiphysics.CoSimulationApplication import CoSimIO
+
+import sys
+
+def FlushAll():
+    sys.stdout.flush()
+    KM.Logger.Flush()
+
+def CreateAnalysisStageWithCoSimIO(BaseAnalysisStage):
+    # concept from https://stackoverflow.com/a/1334242
+
+    class AnalysisStageWithCoSimIO(BaseAnalysisStage):
+        '''Adds coupling functionality with CoSimIO to an AnalysisStage'''
+
+        def __init__(self, model, parameters):
+            if not issubclass(BaseAnalysisStage, AnalysisStage):
+                raise Exception(f'Given baseclass "{BaseAnalysisStage}" does not inherit from AnalysisStage!')
+
+            super().__init__(model, parameters)
+
+            # To avoid many prints
+            severity = KM.Logger.Severity.WARNING
+            if self.echo_level > 0:
+                severity = KM.Logger.Severity.INFO
+            KM.Logger.GetDefaultOutput().SetSeverity(severity)
+
+            if self.echo_level > 0: FlushAll()
+
+        def Initialize(self):
+            super().Initialize()
+
+            self.co_sim_settings = self.project_parameters["co_sim_settings"]
+            self.is_strong_coupling = self.co_sim_settings["is_strong_coupling"].GetBool()
+
+            connection_settings = CoSimIO.InfoFromParameters(self.project_parameters["co_sim_settings"]["io_settings"])
+
+            if default_data_comm.IsDistributed():
+                info = MPIExtension.CoSimIO.ConnectMPI(connection_settings, default_data_comm)
+            else:
+                info = CoSimIO.Connect(connection_settings)
+
+            if self.echo_level > 0: FlushAll()
+
+            self.connection_name = info.GetString("connection_name")
+            if info.GetInt("connection_status") != CoSimIO.ConnectionStatus.Connected:
+                raise Exception("Connecting failed!")
+
+            self.communication_settings = self.co_sim_settings["communication_settings"]
+
+            # Exporting meshes to CoSimulation
+            for model_part_name in self.communication_settings["export_meshes"].GetStringArray():
+                info = CoSimIO.Info()
+                info.SetString("connection_name", self.connection_name)
+                info.SetString("identifier", model_part_name.replace(".", "-"))
+
+                CoSimIO.ExportMesh(info, self.model[model_part_name])
+
+            if self.echo_level > 0: FlushAll()
+
+        def RunSolutionLoop(self):
+            """This function executes the solution loop of the AnalysisStage
+            It can be overridden by derived classes
+            """
+            while self.KeepAdvancingSolutionLoop():
+                self.time = self._GetSolver().AdvanceInTime(self.time)
+                self.InitializeSolutionStep()
+                self._GetSolver().Predict()
+
+                if self.is_strong_coupling:
+                    repeat_time_step = True
+                    while repeat_time_step:
+                        self.__InnerLoop()
+                        info = CoSimIO.Info()
+                        info.SetString("connection_name", self.connection_name)
+                        info.SetString("identifier", "repeat_time_step_info")
+                        repeat_time_step_info = CoSimIO.ImportInfo(info)
+                        repeat_time_step = repeat_time_step_info.GetBool("repeat_time_step")
+                else:
+                    self.__InnerLoop()
+
+                self.FinalizeSolutionStep()
+                self.OutputSolutionStep()
+
+        def Finalize(self):
+            super().Finalize()
+
+            disconnect_settings = CoSimIO.Info()
+            disconnect_settings.SetString("connection_name", self.connection_name)
+            info = CoSimIO.Disconnect(disconnect_settings)
+            if info.GetInt("connection_status") != CoSimIO.ConnectionStatus.Disconnected:
+                raise Exception("Disconnecting failed!")
+
+        def _GetSimulationName(self):
+            return super()._GetSimulationName() + " with CoSimIO"
+
+        def __InnerLoop(self):
+            if self.echo_level > 0: FlushAll()
+
+            # Import fields
+            for field_settings in self.communication_settings["import_fields"]:
+                identifier = field_settings["identifier"].GetString()
+                model_part_name = field_settings["model_part_name"].GetString()
+                model_part = self.model[model_part_name]
+                variable_name = field_settings["variable_name"].GetString()
+                variable = KM.KratosGlobals.GetVariable(variable_name)
+
+                info = CoSimIO.Info()
+                info.SetString("connection_name", self.connection_name)
+                info.SetString("identifier", identifier)
+                CoSimIO.ImportData(info, model_part, variable, KM.Globals.DataLocation.NodeHistorical)
+
+            if self.echo_level > 0: FlushAll()
+
+            self._GetSolver().SolveSolutionStep()
+
+            # Export fields
+            for field_settings in self.communication_settings["export_fields"]:
+                identifier = field_settings["identifier"].GetString()
+                model_part_name = field_settings["model_part_name"].GetString()
+                model_part = self.model[model_part_name]
+                variable_name = field_settings["variable_name"].GetString()
+                variable = KM.KratosGlobals.GetVariable(variable_name)
+
+                info = CoSimIO.Info()
+                info.SetString("connection_name", self.connection_name)
+                info.SetString("identifier", identifier)
+                CoSimIO.ExportData(info, model_part, variable, KM.Globals.DataLocation.NodeHistorical)
+
+    return AnalysisStageWithCoSimIO

KratosMultiphysics/CoSimulationApplication/base_classes/co_simulation_convergence_accelerator.py

@@ -0,0 +1,66 @@
+# Importing the Kratos Library
+import KratosMultiphysics as KM
+
+# CoSimulation imports
+import KratosMultiphysics.CoSimulationApplication.co_simulation_tools as cs_tools
+import KratosMultiphysics.CoSimulationApplication.colors as colors
+
+class CoSimulationConvergenceAccelerator:
+    """Baseclass for the convergence acceleratos used for CoSimulation
+    Relaxes the solution to increase the speed of convergence in a (strongly) coupled simulation
+
+    Note that the interface matches the convergence accelerators in the KratosCore such that they can be used interchangeable
+    ("kratos/solving_strategies/convergence_accelerators/convergence_accelerator.h")
+    """
+    def __init__(self, settings):
+        self.settings = settings
+        self.settings.RecursivelyValidateAndAssignDefaults(self._GetDefaultParameters())
+
+        self.echo_level = self.settings["echo_level"].GetInt()
+
+    def Initialize(self):
+        pass
+
+    def Finalize(self):
+        pass
+
+    def InitializeSolutionStep(self):
+        pass
+
+    def FinalizeSolutionStep(self):
+        pass
+
+    def InitializeNonLinearIteration(self):
+        pass
+
+    def FinalizeNonLinearIteration(self):
+        pass
+
+    def PrintInfo(self):
+        '''Function to print Info abt the Object
+        Can be overridden in derived classes to print more information
+        '''
+        cs_tools.cs_print_info("Convergence Accelerator", colors.bold(self._ClassName()))
+
+    def Check(self):
+        cs_tools.cs_print_warning("Convergence Accelerator", "The convergence accelerators do not yet implement Check!")
+
+    def UpdateSolution(self, residual, iteration_guess):
+        # TODO this should update the solution in place, otherwise not compatible with the conv-acc in the FSI-App
+        # => would probably not be compatible with any C++ Conv-Acc
+        raise NotImplementedError('"UpdateSolution" has to be implemented in the derived class!')
+
+    @classmethod
+    def SupportsDistributedData(cls):
+        return False
+
+    @classmethod
+    def _ClassName(cls):
+        return cls.__name__
+
+    @classmethod
+    def _GetDefaultParameters(cls):
+        return KM.Parameters("""{
+            "type"       : "UNSPECIFIED",
+            "echo_level" : 0
+        }""")

KratosMultiphysics/CoSimulationApplication/base_classes/co_simulation_convergence_criteria.py

@@ -0,0 +1,56 @@
+# Importing the Kratos Library
+import KratosMultiphysics as KM
+
+# CoSimulation imports
+import KratosMultiphysics.CoSimulationApplication.co_simulation_tools as cs_tools
+import KratosMultiphysics.CoSimulationApplication.colors as colors
+
+class CoSimulationConvergenceCriteria:
+    """Baseclass for the convergence criteria used for CoSimulation
+    Checks if convergence was achieved in a (strongly) coupled simulation
+    """
+    def __init__(self, settings):
+        self.settings = settings
+        self.settings.RecursivelyValidateAndAssignDefaults(self._GetDefaultParameters())
+
+        self.echo_level = self.settings["echo_level"].GetInt()
+
+    def Initialize(self):
+        pass
+
+    def Finalize(self):
+        pass
+
+    def InitializeSolutionStep(self):
+        pass
+
+    def FinalizeSolutionStep(self):
+        pass
+
+    def InitializeNonLinearIteration(self):
+        pass
+
+    def FinalizeNonLinearIteration(self):
+        pass
+
+    def IsConverged(self, residual, current_data):
+        raise NotImplementedError('"IsConverged" has to be implemented in the derived class!')
+
+    def PrintInfo(self):
+        cs_tools.cs_print_info("Convergence Criteria", colors.bold(self._ClassName()))
+
+    def Check(self):
+        cs_tools.cs_print_warning("Convergence Criteria", colors.bold(self._ClassName()), 'does not implement "Check"')
+
+    @classmethod
+    def _ClassName(cls):
+        return cls.__name__
+
+    @classmethod
+    def _GetDefaultParameters(cls):
+        return KM.Parameters("""{
+            "type"       : "UNSPECIFIED",
+            "solver"     : "UNSPECIFIED",
+            "data_name"  : "UNSPECIFIED",
+            "echo_level" : 0
+        }""")