Beispiel #1
0
    def testInputOutput(self):
        with ControlledExecutionScope(self.work_folder):
            # run simulation and write to hdf5 file
            model_out = Model()
            with open("output_test_parameters.json", 'r') as parameter_file:
                project_parameters = Parameters(parameter_file.read())
            test = FluidDynamicsAnalysis(model_out, project_parameters)
            test.Run()

            # start new simulation and read from hdf5 file
            model_in = Model()
            with open("input_test_parameters.json", 'r') as parameter_file:
                project_parameters = Parameters(parameter_file.read())
            test = FluidAnalysisWithoutSolution(model_in, project_parameters)
            test.Run()
Beispiel #2
0
    def _runTest(self,settings_file_name):
        model = KM.Model()
        with open(settings_file_name,'r') as settings_file:
            settings = KM.Parameters(settings_file.read())

        # to check the results: add output settings block if needed
        if self.print_vtk_output:
            settings["output_processes"].AddValue("vtk_output", KM.Parameters(R'''[{
                "python_module" : "vtk_output_process",
                "kratos_module" : "KratosMultiphysics",
                "process_name"  : "VtkOutputProcess",
                "help"          : "This process writes postprocessing files for Paraview",
                "Parameters"    : {
                    "model_part_name"                    : "FluidModelPart.domain",
                    "output_control_type"                : "step",
                    "output_frequency"                   : 1,
                    "file_format"                        : "binary",
                    "output_precision"                   : 7,
                    "output_sub_model_parts"             : false,
                    "folder_name"                        : "vtk_output",
                    "save_output_files_in_folder"        : true,
                    "nodal_solution_step_data_variables" : ["VELOCITY","PRESSURE","MESH_DISPLACEMENT","MESH_VELOCITY"],
                    "nodal_data_value_variables"         : [],
                    "element_data_value_variables"       : [],
                    "condition_data_value_variables"     : []
                }
            }]'''))

        if self.print_gid_output:
            settings["output_processes"].AddValue("gid_output", KM.Parameters(R'''[{
            "python_module" : "gid_output_process",
            "kratos_module" : "KratosMultiphysics",
            "process_name"  : "GiDOutputProcess",
            "help"          : "This process writes postprocessing files for GiD",
            "Parameters"    : {
                "model_part_name"        : "FluidModelPart.domain",
                "output_name"            : "ale_fluid_test",
                "postprocess_parameters" : {
                    "result_file_configuration" : {
                        "gidpost_flags"       : {
                            "GiDPostMode"           : "GiD_PostBinary",
                            "WriteDeformedMeshFlag" : "WriteDeformed",
                            "WriteConditionsFlag"   : "WriteConditions",
                            "MultiFileFlag"         : "SingleFile"
                        },
                        "file_label"          : "time",
                        "output_control_type" : "step",
                        "output_frequency"    : 1.0,
                        "body_output"         : true,
                        "nodal_results"       : ["VELOCITY","PRESSURE","MESH_DISPLACEMENT","MESH_VELOCITY"]
                    }
                }
            }
            }]'''))

        analysis = FluidDynamicsAnalysis(model,settings)
        analysis.Run()
Beispiel #3
0
    def testCylinder(self):
        with ControlledExecutionScope(
                os.path.dirname(os.path.realpath(__file__))):
            # solve fluid
            model = Kratos.Model()
            with open(
                    'AdjointVMSSensitivity2DTest/mpi_cylinder_test_parameters.json',
                    'r') as parameter_file:
                project_parameters = Kratos.Parameters(parameter_file.read())
                parameter_file.close()
            primal_simulation = FluidDynamicsAnalysis(model,
                                                      project_parameters)
            primal_simulation.Run()
            Kratos.DataCommunicator.GetDefault().Barrier()

            # solve adjoint
            with open(
                    'AdjointVMSSensitivity2DTest/mpi_cylinder_test_adjoint_parameters.json',
                    'r') as parameter_file:
                project_parameters = Kratos.Parameters(parameter_file.read())
                parameter_file.close()

            adjoint_model = Kratos.Model()
            adjoint_simulation = AdjointFluidAnalysis(adjoint_model,
                                                      project_parameters)
            adjoint_simulation.Run()
            Kratos.DataCommunicator.GetDefault().Barrier()
            rank = adjoint_simulation._solver.main_model_part.GetCommunicator(
            ).MyPID()
            # remove files
            if rank == 0:
                self._remove_file(
                    "./AdjointVMSSensitivity2DTest/mpi_cylinder_test_probe1.dat"
                )
                self._remove_file(
                    "./AdjointVMSSensitivity2DTest/mpi_cylinder_test_probe2.dat"
                )
                self._remove_file(
                    "./AdjointVMSSensitivity2DTest/mpi_cylinder_test_adjoint_probe1.dat"
                )
                self._remove_file(
                    "./AdjointVMSSensitivity2DTest/mpi_cylinder_test_adjoint_probe2.dat"
                )
                self._remove_file(
                    "./AdjointVMSSensitivity2DTest/mpi_cylinder_test_adjoint_probe3.dat"
                )
                self._remove_file(
                    "./AdjointVMSSensitivity2DTest/cylinder_test.time")
                self._remove_h5_files("primal")
            self._remove_file("./AdjointVMSSensitivity2DTest/cylinder_test_" +
                              str(rank) + ".time")
            self._remove_file("./AdjointVMSSensitivity2DTest/cylinder_test_" +
                              str(rank) + ".mdpa")
    def runTest(self):
        # If required, add the output process to the test settings
        if self.print_output:
            self._AddOutput()

        # If required, add the reference values output process to the test settings
        if self.print_reference_values:
            self._AddReferenceValuesOutput()
        else:
            self._AddReferenceValuesCheck()

        # Create the test simulation
        with KratosUnittest.WorkFolderScope(self.work_folder, __file__):
            self.model = KratosMultiphysics.Model()
            simulation = FluidDynamicsAnalysis(self.model, self.parameters)
            simulation.Run()
Beispiel #5
0
    def _runTest(self, settings_file_name):
        model = km.Model()
        with open(settings_file_name, 'r') as settings_file:
            settings = km.Parameters(settings_file.read())

        # to check the results: add output settings block if needed
        if self.print_output:
            settings.AddValue(
                "output_processes",
                km.Parameters(r'''{
                "gid_output" : [{
                    "python_module" : "gid_output_process",
                    "kratos_module" : "KratosMultiphysics",
                    "process_name"  : "GiDOutputProcess",
                    "help"          : "This process writes postprocessing files for GiD",
                    "Parameters"    : {
                        "model_part_name"        : "fluid_computational_model_part",
                        "output_name"            : "interface_test",
                        "postprocess_parameters" : {
                            "result_file_configuration" : {
                                "gidpost_flags" : {
                                    "GiDPostMode"           : "GiD_PostBinary",
                                    "WriteDeformedMeshFlag" : "WriteUndeformed",
                                    "WriteConditionsFlag"   : "WriteElementsOnly",
                                    "MultiFileFlag"         : "SingleFile"
                                },
                                "file_label"          : "time",
                                "output_control_type" : "step",
                                "output_frequency"    : 1,
                                "body_output"         : true,
                                "node_output"         : false,
                                "skin_output"         : false,
                                "plane_output"        : [],
                                "nodal_results"       : ["VELOCITY","PRESSURE"],
                                "gauss_point_results" : []
                            },
                            "point_data_configuration"  : []
                        }
                    }
                }]
            }'''))

        analysis = FluidDynamicsAnalysis(model, settings)
        analysis.Run()
Beispiel #6
0
 def _RunSodShockTubeTest(self):
     # Create the test simulation
     with KratosUnittest.WorkFolderScope(self.work_folder, __file__):
         self.model = KratosMultiphysics.Model()
         simulation = FluidDynamicsAnalysis(self.model, self.parameters)
         simulation.Run()
def SolvePrimalProblem(kratos_parameters):
    test = FluidDynamicsAnalysis(Kratos.Model(), kratos_parameters)
    test.Run()

    return test
Beispiel #8
0
    def _run_test(self, primal_parameter_file_name,
                  adjoint_parameter_file_name):
        model = km.Model()
        settings = km.Parameters(r'''{}''')

        with open(primal_parameter_file_name, 'r') as primal_parameter_file:
            settings.AddValue("primal_settings",
                              km.Parameters(primal_parameter_file.read()))

        with open(adjoint_parameter_file_name, 'r') as adjoint_parameter_file:
            settings.AddValue("adjoint_settings",
                              km.Parameters(adjoint_parameter_file.read()))

        # Add hdf5 output to the primal problem
        settings["primal_settings"]["processes"][
            "auxiliar_process_list"].Append(
                km.Parameters(r'''{
            "kratos_module" : "KratosMultiphysics.HDF5Application",
            "python_module" : "single_mesh_primal_output_process",
            "Parameters" : {
                "model_part_name" : "MainModelPart",
                "file_settings" : {
                    "file_name" : "primal_output-<time>",
                    "file_access_mode" : "truncate"
                },
                "model_part_output_settings" : {
                    "prefix" : "/ModelData"
                },
                "nodal_solution_step_data_settings" : {
                    "list_of_variables": ["VELOCITY", "ACCELERATION", "PRESSURE"]
                },
                "output_time_settings" : {
                    "step_frequency": 1
                }
            }
        }'''))

        # to check the results: add output settings block if needed
        if self.print_output:
            settings["adjoint_settings"].AddValue(
                "output_processes",
                km.Parameters(r'''{
                "gid_output" : [{
                    "python_module" : "gid_output_process",
                    "kratos_module" : "KratosMultiphysics",
                    "process_name"  : "GiDOutputProcess",
                    "help"          : "This process writes postprocessing files for GiD",
                    "Parameters"    : {
                        "model_part_name"        : "MainModelPart",
                        "output_name"            : "interface_test",
                        "postprocess_parameters" : {
                            "result_file_configuration" : {
                                "gidpost_flags" : {
                                    "GiDPostMode"           : "GiD_PostBinary",
                                    "WriteDeformedMeshFlag" : "WriteUndeformed",
                                    "WriteConditionsFlag"   : "WriteElementsOnly",
                                    "MultiFileFlag"         : "SingleFile"
                                },
                                "file_label"          : "time",
                                "output_control_type" : "step",
                                "output_interval"     : 1,
                                "body_output"         : true,
                                "node_output"         : false,
                                "skin_output"         : false,
                                "plane_output"        : [],
                                "nodal_results"       : ["VELOCITY","PRESSURE","ADJOINT_FLUID_VECTOR_1","ADJOINT_FLUID_SCALAR_1","SHAPE_SENSITIVITY"],
                                "gauss_point_results" : []
                            },
                            "point_data_configuration"  : []
                        }
                    }
                }]
            }'''))

        primal_analysis = FluidDynamicsAnalysis(model,
                                                settings["primal_settings"])
        primal_analysis.Run()
        adjoint_model = km.Model()
        adjoint_analysis = AdjointFluidAnalysis(adjoint_model,
                                                settings["adjoint_settings"])
        adjoint_analysis.Run()
        self._remove_h5_files("primal_output")
Beispiel #9
0
from __future__ import print_function, absolute_import, division  #makes KratosMultiphysics backward compatible with python 2.6 and 2.7

import KratosMultiphysics as Kratos
from KratosMultiphysics.FluidDynamicsApplication.fluid_dynamics_analysis import FluidDynamicsAnalysis

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 fluid_dynamics_analysis.py"\n'
        err_msg += '- With custom parameter file:\n'
        err_msg += '    "python fluid_dynamics_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 = Kratos.Parameters(parameter_file.read())

    model = Kratos.Model()
    simulation = FluidDynamicsAnalysis(model, parameters)
    simulation.Run()
        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()
Beispiel #11
0
class TestSerializer(KratosUnittest.TestCase):
    def _prepare_test(self):
        # Define a model and load the parameters
        self.pre_serialized_model = KratosMultiphysics.Model()
        with open(
                GetFilePath(
                    "auxiliar_files_for_python_unittest/parameters_files/test_serializer.json"
                ), 'r') as parameter_file:
            parameters = KratosMultiphysics.Parameters(parameter_file.read())
        file_name = parameters["solver_settings"]["model_import_settings"][
            "input_filename"].GetString()
        parameters["solver_settings"]["model_import_settings"][
            "input_filename"].SetString(GetFilePath(file_name))
        # First the model is initialized
        self.pre_serialized_simulation = FluidDynamicsAnalysis(
            self.pre_serialized_model, parameters)
        self.pre_serialized_simulation.Initialize()

        # Before serializing the model, main model part is set to RESTARTED
        self.main_model_part_name = parameters["solver_settings"][
            "model_part_name"].GetString()
        self.pre_serialized_model.GetModelPart(
            self.main_model_part_name).ProcessInfo.SetValue(
                KratosMultiphysics.IS_RESTARTED, True)
        serialized_model = KratosMultiphysics.StreamSerializer()
        serialized_model.Save("ModelSerialization", self.pre_serialized_model)

        with open(
                GetFilePath(
                    "auxiliar_files_for_python_unittest/parameters_files/test_serializer.json"
                ), 'r') as parameter_file:
            self.project_parameters = KratosMultiphysics.Parameters(
                parameter_file.read())
        # Parameters are read again and input type set to use_input_model_part since the serialized model already has the mdpa loaded
        self.project_parameters["solver_settings"]["model_import_settings"][
            "input_type"].SetString("use_input_model_part")

        # Deserialize and store the new model
        self.current_model = KratosMultiphysics.Model()
        serialized_model.Load("ModelSerialization", self.current_model)

    def _check_results(self):
        pre_serialized_model_part = self.pre_serialized_model.GetModelPart(
            self.main_model_part_name)
        pre_serialized_pressure_results = [
            node.GetSolutionStepValue(KratosMultiphysics.PRESSURE)
            for node in pre_serialized_model_part.Nodes
        ]
        pre_serialized_velocity_results = [
            node.GetSolutionStepValue(KratosMultiphysics.VELOCITY)
            for node in pre_serialized_model_part.Nodes
        ]

        serialized_model_part = self.current_model.GetModelPart(
            self.main_model_part_name)
        serialized_pressure_results = [
            node.GetSolutionStepValue(KratosMultiphysics.PRESSURE)
            for node in serialized_model_part.Nodes
        ]
        serialized_velocity_results = [
            node.GetSolutionStepValue(KratosMultiphysics.VELOCITY)
            for node in serialized_model_part.Nodes
        ]

        # Comparing results before and after serializing
        for pre_serialized_result, serialized_result in zip(
                pre_serialized_pressure_results, serialized_pressure_results):
            self.assertAlmostEqual(pre_serialized_result, serialized_result)
        for pre_serialized_result, serialized_result in zip(
                pre_serialized_velocity_results, serialized_velocity_results):
            for value_pre_seralized, value_serialized in zip(
                    pre_serialized_result, serialized_result):
                self.assertAlmostEqual(value_pre_seralized, value_serialized)

    @KratosUnittest.skipUnless(dependencies_are_available,
                               "FluidDynamicsApplication is not available")
    def test_serializer_fluid_analysis(self):
        self._prepare_test()
        # Solving simulation before serializing to later check the results
        self.pre_serialized_simulation.RunSolutionLoop()
        self.pre_serialized_simulation.Finalize()
        # Solving simulation after serializing
        self.serialized_simulation = FluidDynamicsAnalysis(
            self.current_model, self.project_parameters)
        self.serialized_simulation.Run()
        self._check_results()