Exemplo n.º 1
0
    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"])

        info = CoSimIO.Connect(connection_settings)
        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])
Exemplo n.º 2
0
    def __InnerLoop(self):
        # 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,
                               CoSimIO.DataLocation.NodeHistorical)

        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,
                               CoSimIO.DataLocation.NodeHistorical)
Exemplo n.º 3
0
    def Finalize(self):
        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 Finalize(self):
        super(StructuralMechanicsAnalysisWithCoSimIO, self).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!")
Exemplo n.º 5
0
    def ExportCouplingInterface(self, interface_config):
        model_part_name = interface_config["model_part_name"]

        info = CoSimIO.Info()
        info.SetString("connection_name", self.solver_name)
        info.SetString("identifier", model_part_name)

        CoSimIO.ExportMesh(info, self.model[model_part_name]
                           )  # TODO this can also be geometry at some point
Exemplo n.º 6
0
    def ExportCouplingInterface(self, interface_config):
        model_part_name = interface_config["model_part_name"]

        info = CoSimIO.Info()
        info.SetString("connection_name", self.connection_name)
        info.SetString("identifier", model_part_name.replace(
            ".", "-"))  # TODO chec if better solution can be found

        CoSimIO.ExportMesh(info, self.model[model_part_name]
                           )  # TODO this can also be geometry at some point
Exemplo n.º 7
0
        def _ExportMesh(info):
            model_part_name = info.GetString("identifier")

            export_info = CoSimIO.Info()
            export_info.SetString("connection_name", self.connection_name)
            export_info.SetString("identifier",
                                  model_part_name.replace(".", "-"))

            CoSimIO.ExportMesh(export_info, self.model[model_part_name])
            return CoSimIO.Info()
Exemplo n.º 8
0
    def __init__(self, settings, model, solver_name):
        super(KratosCoSimIO, self).__init__(settings, model, solver_name)

        connection_settings = CoSimIO.InfoFromParameters(self.settings)
        connection_settings.SetString("connection_name", solver_name)

        info = CoSimIO.Connect(connection_settings)
        if info.GetInt(
                "connection_status") != CoSimIO.ConnectionStatus.Connected:
            raise Exception("Connecting failed!")
Exemplo n.º 9
0
        def _ExportData(info):
            identifier = info.GetString("identifier")
            model_part = self.data_comm_settings[identifier]["model_part"]
            variable = self.data_comm_settings[identifier]["variable"]

            info = CoSimIO.Info()
            info.SetString("connection_name", self.connection_name)
            info.SetString("identifier", identifier)
            CoSimIO.ExportData(info, model_part, variable,
                               CoSimIO.DataLocation.NodeHistorical)
            return CoSimIO.Info()
Exemplo n.º 10
0
    def test_Export_Import_Data_raw_values(self):
        connection_settings = CoSimIO.Info()
        connection_settings.SetString("connection_name", "im_exp_data")
        connection_settings.SetInt("echo_level", 0)
        info = CoSimIO.Connect(connection_settings)
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Connected)

        values = [1.0, 2.5, 3.3, -9.4]

        export_info = CoSimIO.Info()
        export_info.SetString("connection_name", "im_exp_data")
        export_info.SetString("identifier", "data_exchange_1")
        CoSimIO.ExportData(export_info, values)

        RunPythonInSubProcess("import_export_data")

        import_info = CoSimIO.Info()
        import_info.SetString("connection_name", "im_exp_data")
        import_info.SetString("identifier", "data_exchange_2")
        imported_values = CoSimIO.ImportData(import_info)

        disconnect_settings = CoSimIO.Info()
        disconnect_settings.SetString("connection_name", "im_exp_data")

        info = CoSimIO.Disconnect(disconnect_settings)
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Disconnected)

        # checking the values after disconnecting to avoid deadlock
        self.assertVectorAlmostEqual(KM.Vector(values),
                                     KM.Vector(imported_values))
Exemplo n.º 11
0
    def __ExportImportDataOnModelPart(self, model_part, var_export, var_import,
                                      data_location):
        p = self.__RunPythonInSubProcess("import_export_data")

        connection_settings = CoSimIO.Info()
        connection_settings.SetString("my_name", "ExpImp")
        connection_settings.SetString("connect_to", "impExp")
        connection_settings.SetInt("echo_level", 0)
        info = CoSimIO.Connect(connection_settings)
        connection_name = info.GetString("connection_name")
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Connected)

        export_info = CoSimIO.Info()
        export_info.SetString("connection_name", connection_name)
        export_info.SetString("identifier", "data_exchange_1")
        CoSimIO.ExportData(export_info, model_part, var_export, data_location)

        import_info = CoSimIO.Info()
        import_info.SetString("connection_name", connection_name)
        import_info.SetString("identifier", "data_exchange_2")
        CoSimIO.ImportData(import_info, model_part, var_import, data_location)

        disconnect_settings = CoSimIO.Info()
        disconnect_settings.SetString("connection_name", connection_name)

        info = CoSimIO.Disconnect(disconnect_settings)
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Disconnected)

        self.__CheckSubProcess(p)
Exemplo n.º 12
0
    def test_Export_Import_Mesh(self):
        model = KM.Model()

        model_part = model.CreateModelPart("for_test")
        model_part_returned = model.CreateModelPart("for_test_2")

        for i in range(15):
            model_part.CreateNewNode(i + 1, i * 1.1, 1.1**i, 0.0)
        props = model_part.CreateNewProperties(0)
        for i in range(9):  # this leaves some hanging nodes
            model_part.CreateNewElement("Element2D2N", i + 1, [i + 1, i + 2],
                                        props)

        connection_settings = CoSimIO.Info()
        connection_settings.SetString("connection_name", "im_exp_mesh")
        connection_settings.SetInt("echo_level", 0)
        info = CoSimIO.Connect(connection_settings)
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Connected)

        export_info = CoSimIO.Info()
        export_info.SetString("connection_name", "im_exp_mesh")
        export_info.SetString("identifier", "mesh_exchange_1")
        CoSimIO.ExportMesh(export_info, model_part)

        RunPythonInSubProcess("import_export_mesh")

        import_info = CoSimIO.Info()
        import_info.SetString("connection_name", "im_exp_mesh")
        import_info.SetString("identifier", "mesh_exchange_2")
        CoSimIO.ImportMesh(import_info, model_part_returned)

        disconnect_settings = CoSimIO.Info()
        disconnect_settings.SetString("connection_name", "im_exp_mesh")

        info = CoSimIO.Disconnect(disconnect_settings)
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Disconnected)

        # checking the values after disconnecting to avoid deadlock
        self.assertEqual(model_part.NumberOfNodes(),
                         model_part_returned.NumberOfNodes())
        self.assertEqual(model_part.NumberOfElements(),
                         model_part_returned.NumberOfElements())

        for node_orig, node_exchanged in zip(model_part.Nodes,
                                             model_part_returned.Nodes):
            self.assertAlmostEqual(node_orig.X0, node_exchanged.X0)
            self.assertAlmostEqual(node_orig.Y0, node_exchanged.Y0)
            self.assertAlmostEqual(node_orig.Z0, node_exchanged.Z0)

        for elem_orig, elem_exchanged in zip(model_part.Elements,
                                             model_part_returned.Elements):
            self.assertEqual(len(elem_orig.GetNodes()),
                             len(elem_exchanged.GetNodes()))
            for node_orig, node_exchanged in zip(elem_orig.GetNodes(),
                                                 elem_exchanged.GetNodes()):
                self.assertAlmostEqual(node_orig.X0, node_exchanged.X0)
                self.assertAlmostEqual(node_orig.Y0, node_exchanged.Y0)
                self.assertAlmostEqual(node_orig.Z0, node_exchanged.Z0)
Exemplo n.º 13
0
    def ImportData(self, data_config):
        data_type = data_config["type"]
        if data_type == "coupling_interface_data":
            interface_data = data_config["interface_data"]
            info = CoSimIO.Info()
            info.SetString("connection_name", self.connection_name)
            info.SetString("identifier", interface_data.name)

            CoSimIO.ImportData(info, interface_data.GetModelPart(),
                               interface_data.variable,
                               GetDataLocation(interface_data.location))
        else:
            raise NotImplementedError(
                'Exporting interface data of type "{}" is not implemented for this IO: "{}"'
                .format(data_type, self._ClassName()))
Exemplo n.º 14
0
    def test_Connect_Disconnect(self):
        connection_settings = CoSimIO.Info()
        connection_settings.SetString("connection_name", "c_d_test")
        connection_settings.SetInt("echo_level", 0)
        info = CoSimIO.Connect(connection_settings)
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Connected)

        RunPythonInSubProcess("connect_disconnect")

        disconnect_settings = CoSimIO.Info()
        disconnect_settings.SetString("connection_name", "c_d_test")
        info = CoSimIO.Disconnect(disconnect_settings)
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Disconnected)
Exemplo n.º 15
0
    def __init__(self, settings, model, solver_name):
        super().__init__(settings, model, solver_name)

        connect_to = self.settings["connect_to"].GetString()
        if connect_to == "":
            raise Exception('"connect_to" must be specified!')

        connection_settings = CoSimIO.InfoFromParameters(self.settings)
        connection_settings.SetString("my_name", solver_name)

        info = CoSimIO.Connect(connection_settings)
        if info.GetInt(
                "connection_status") != CoSimIO.ConnectionStatus.Connected:
            raise Exception("Connecting failed!")

        self.connection_name = info.GetString("connection_name")
Exemplo n.º 16
0
    def test_InfoFromParameters(self):
        params = KM.Parameters("""{
            "some_bool"      : true,
            "the_string"     : "file",
            "another_string" : "i25mmk",
            "int_for_it"     : 12,
            "double_val"     : 0.223,
            "array_val_ign"  : [0.923, 1.8]
        }""")

        info = CoSimIO.InfoFromParameters(params)
        self.assertEqual(info.Size(), 5)
        self.assertTrue(info.Has("some_bool"))
        self.assertTrue(info.Has("the_string"))
        self.assertTrue(info.Has("another_string"))
        self.assertTrue(info.Has("int_for_it"))
        self.assertTrue(info.Has("double_val"))
        # only int, bool, double & string can be converted, others are ignored
        self.assertFalse(info.Has("array_val_ign"))

        self.assertTrue(info.GetBool("some_bool"))
        self.assertEqual(info.GetString("the_string"), "file")
        self.assertEqual(info.GetString("another_string"), "i25mmk")
        self.assertEqual(info.GetInt("int_for_it"), 12)
        self.assertAlmostEqual(info.GetDouble("double_val"), 0.223)
Exemplo n.º 17
0
    def ExportData(self, data_config):
        data_type = data_config["type"]
        if data_type == "coupling_interface_data":
            interface_data = data_config["interface_data"]
            info = CoSimIO.Info()
            info.SetString("connection_name", self.connection_name)
            info.SetString("identifier", interface_data.name)

            CoSimIO.ExportData(info, interface_data.GetModelPart(),
                               interface_data.variable,
                               GetDataLocation(interface_data.location))

        elif data_type == "control_signal":
            info = CoSimIO.Info()
            info.SetString("connection_name", self.connection_name)
            info.SetString("identifier", "run_control")
            info.SetString("control_signal", data_config["control_signal"])
            settings = data_config.get("settings")
            if settings:
                info.SetInfo("settings", CoSimIO.InfoFromParameters(settings))

            CoSimIO.ExportInfo(info)

        elif data_type == "repeat_time_step":
            info = CoSimIO.Info()
            info.SetString("connection_name", self.connection_name)
            info.SetString("identifier", "repeat_time_step_info")
            info.SetBool("repeat_time_step", data_config["repeat_time_step"])

            CoSimIO.ExportInfo(info)
        else:
            raise NotImplementedError(
                'Exporting interface data of type "{}" is not implemented for this IO: "{}"'
                .format(data_type, self._ClassName()))
Exemplo n.º 18
0
    def test_Connect_Disconnect(self):
        p = self.__RunPythonInSubProcess("connect_disconnect")

        connection_settings = CoSimIO.Info()
        connection_settings.SetString("my_name", "partner_a")
        connection_settings.SetString("connect_to", "partner_b")
        connection_settings.SetInt("echo_level", 0)
        info = CoSimIO.Connect(connection_settings)
        connection_name = info.GetString("connection_name")
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Connected)

        disconnect_settings = CoSimIO.Info()
        disconnect_settings.SetString("connection_name", connection_name)
        info = CoSimIO.Disconnect(disconnect_settings)
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Disconnected)

        self.__CheckSubProcess(p)
Exemplo n.º 19
0
    def ImportData(self, data_config):
        data_type = data_config["type"]
        if data_type == "coupling_interface_data":
            interface_data = data_config["interface_data"]
            info = CoSimIO.Info()
            info.SetString("connection_name", self.solver_name)
            info.SetString("identifier", interface_data.name)

            CoSimIO.ImportData(info, interface_data.GetModelPart(),
                               interface_data.variable,
                               GetDataLocation(interface_data.location))

        elif data_type == "time":
            time_list = CoSimIO.ImportData(self.solver_name, "time_to_co_sim")
            if len(time_list) != 1:
                raise Exception("Wrong size received!")
            data_config["time"] = time_list[0]
        else:
            raise NotImplementedError(
                'Exporting interface data of type "{}" is not implemented for this IO: "{}"'
                .format(data_type, self._ClassName()))
Exemplo n.º 20
0
    def ExportData(self, data_config):
        data_type = data_config["type"]
        if data_type == "coupling_interface_data":
            interface_data = data_config["interface_data"]
            info = CoSimIO.Info()
            info.SetString("connection_name", self.solver_name)
            info.SetString("identifier", interface_data.name)

            CoSimIO.ExportData(info, interface_data.GetModelPart(),
                               interface_data.variable,
                               GetDataLocation(interface_data.location))

        elif data_type == "control_signal":
            control_signal_key = data_config["signal"]
            CoSimIO.SendControlSignal(self.solver_name,
                                      data_config["identifier"],
                                      control_signal_key)

        elif data_type == "time":
            current_time = data_config["time"]
            CoSimIO.ExportData(self.solver_name, "time_from_co_sim",
                               [current_time])

        elif data_type == "convergence_signal":
            if data_config["is_converged"]:
                control_signal_key = CoSimIO.ControlSignal.ConvergenceAchieved
            else:
                control_signal_key = CoSimIO.ControlSignal.Dummy
            info = CoSimIO.Info()
            info.SetString("connection_name", self.solver_name)
            CoSimIO.SendControlSignal(info, control_signal_key)
        else:
            raise NotImplementedError(
                'Exporting interface data of type "{}" is not implemented for this IO: "{}"'
                .format(data_type, self._ClassName()))
    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:
                is_converged = False
                while not is_converged:
                    self.__InnerLoop()
                    info = CoSimIO.Info()
                    info.SetString("connection_name", self.connection_name)
                    is_converged_info = CoSimIO.IsConverged(info)
                    is_converged = is_converged_info.GetBool("is_converged")
            else:
                self.__InnerLoop()

            self.FinalizeSolutionStep()
            self.OutputSolutionStep()
Exemplo n.º 22
0
    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()
Exemplo n.º 23
0
    def test_Export_Import_Data_raw_values(self):
        p = self.__RunPythonInSubProcess("import_export_data")

        connection_settings = CoSimIO.Info()
        connection_settings.SetString("my_name", "ExpImp")
        connection_settings.SetString("connect_to", "impExp")
        connection_settings.SetInt("echo_level", 0)
        info = CoSimIO.Connect(connection_settings)
        connection_name = info.GetString("connection_name")
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Connected)

        values = CoSimIO.DoubleVector([1.0, 2.5, 3.3, -9.4])

        export_info = CoSimIO.Info()
        export_info.SetString("connection_name", connection_name)
        export_info.SetString("identifier", "data_exchange_1")
        CoSimIO.ExportData(export_info, values)

        import_info = CoSimIO.Info()
        import_info.SetString("connection_name", connection_name)
        import_info.SetString("identifier", "data_exchange_2")
        imported_values = CoSimIO.DoubleVector()
        CoSimIO.ImportData(import_info, imported_values)

        disconnect_settings = CoSimIO.Info()
        disconnect_settings.SetString("connection_name", connection_name)

        info = CoSimIO.Disconnect(disconnect_settings)
        self.assertEqual(info.GetInt("connection_status"),
                         CoSimIO.ConnectionStatus.Disconnected)

        # checking the values after disconnecting to avoid deadlock
        self.assertVectorAlmostEqual(values, imported_values)

        self.__CheckSubProcess(p)
Exemplo n.º 24
0
 def _InitializeSolutionStep(info):
     self.InitializeSolutionStep()
     return CoSimIO.Info()
Exemplo n.º 25
0
 def _Predict(info):
     self._GetSolver().Predict()
     return CoSimIO.Info()
Exemplo n.º 26
0
 def _AdvanceInTime(info):
     current_time = info.GetDouble("current_time")
     self.time = self._GetSolver().AdvanceInTime(current_time)
     return CoSimIO.Info()
Exemplo n.º 27
0
 def _FinalizeSolutionStep(info):
     self.FinalizeSolutionStep()
     return CoSimIO.Info()
Exemplo n.º 28
0
 def _OutputSolutionStep(info):
     self.OutputSolutionStep()
     return CoSimIO.Info()
Exemplo n.º 29
0
    def Initialize(self):
        super().Initialize()

        connection_settings = CoSimIO.InfoFromParameters(
            self.project_parameters["co_sim_settings"]["io_settings"])

        info = CoSimIO.Connect(connection_settings)
        self.connection_name = info.GetString("connection_name")
        if info.GetInt(
                "connection_status") != CoSimIO.ConnectionStatus.Connected:
            raise Exception("Connecting failed!")

        ## specifying which fields belong to which identifier when im-/exporting data
        self.data_comm_settings = {}
        for field_settings in chain(
                self.project_parameters["co_sim_settings"]
            ["communication_settings"]["export_fields"],
                self.project_parameters["co_sim_settings"]
            ["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)
            self.data_comm_settings[identifier] = {
                "model_part": model_part,
                "variable": variable
            }

        # declaring in place the functions that are registered by the CoSimIO
        def _ImportData(info):
            identifier = info.GetString("identifier")
            model_part = self.data_comm_settings[identifier]["model_part"]
            variable = self.data_comm_settings[identifier]["variable"]

            info = CoSimIO.Info()
            info.SetString("connection_name", self.connection_name)
            info.SetString("identifier", identifier)
            CoSimIO.ImportData(info, model_part, variable,
                               CoSimIO.DataLocation.NodeHistorical)
            return CoSimIO.Info()

        def _ExportData(info):
            identifier = info.GetString("identifier")
            model_part = self.data_comm_settings[identifier]["model_part"]
            variable = self.data_comm_settings[identifier]["variable"]

            info = CoSimIO.Info()
            info.SetString("connection_name", self.connection_name)
            info.SetString("identifier", identifier)
            CoSimIO.ExportData(info, model_part, variable,
                               CoSimIO.DataLocation.NodeHistorical)
            return CoSimIO.Info()

        def _ExportMesh(info):
            model_part_name = info.GetString("identifier")

            export_info = CoSimIO.Info()
            export_info.SetString("connection_name", self.connection_name)
            export_info.SetString("identifier",
                                  model_part_name.replace(".", "-"))

            CoSimIO.ExportMesh(export_info, self.model[model_part_name])
            return CoSimIO.Info()

        def _AdvanceInTime(info):
            current_time = info.GetDouble("current_time")
            self.time = self._GetSolver().AdvanceInTime(current_time)
            return CoSimIO.Info()

        def _InitializeSolutionStep(info):
            self.InitializeSolutionStep()
            return CoSimIO.Info()

        def _Predict(info):
            self._GetSolver().Predict()
            return CoSimIO.Info()

        def _SolveSolutionStep(info):
            self._GetSolver().SolveSolutionStep()
            return CoSimIO.Info()

        def _FinalizeSolutionStep(info):
            self.FinalizeSolutionStep()
            return CoSimIO.Info()

        def _OutputSolutionStep(info):
            self.OutputSolutionStep()
            return CoSimIO.Info()

        register_info = CoSimIO.Info()
        register_info.SetString("connection_name", self.connection_name)

        register_info.SetString("function_name", "ImportData")
        CoSimIO.Register(register_info, _ImportData)

        register_info.SetString("function_name", "ExportData")
        CoSimIO.Register(register_info, _ExportData)

        register_info.SetString("function_name", "ExportMesh")
        CoSimIO.Register(register_info, _ExportMesh)

        register_info.SetString("function_name", "AdvanceInTime")
        CoSimIO.Register(register_info, _AdvanceInTime)

        register_info.SetString("function_name", "InitializeSolutionStep")
        CoSimIO.Register(register_info, _InitializeSolutionStep)

        register_info.SetString("function_name", "Predict")
        CoSimIO.Register(register_info, _Predict)

        register_info.SetString("function_name", "SolveSolutionStep")
        CoSimIO.Register(register_info, _SolveSolutionStep)

        register_info.SetString("function_name", "FinalizeSolutionStep")
        CoSimIO.Register(register_info, _FinalizeSolutionStep)

        register_info.SetString("function_name", "OutputSolutionStep")
        CoSimIO.Register(register_info, _OutputSolutionStep)
Exemplo n.º 30
0
 def RunSolutionLoop(self):
     # running remote controlled simulation
     # deliberately not calling baseclass as this is the remote controlled case
     run_info = CoSimIO.Info()
     run_info.SetString("connection_name", self.connection_name)
     CoSimIO.Run(run_info)