Using processes to customize a simulation

Using Kratos::Process to customize a simulation

Kratos offers many ways of customizing the behavior of simulations. One way is to use Kratos::Process, either from

• KratosCore
• Kratos-Application
• user defined

Adding a process in a simulation is straight-forward, it has to be added to the list of processes in the ProjectParameters.json.

Adding processes in the simulation

In the following it is shown how to add processes from different locations (KratosCore, Kratos-Application or user-defined) to a simulation in ProjectParameters.json. Further information can be found in the description of the AnalysisStage.

"processes" : {
    "from_kratos_core" : [{
        "python_module" : "assign_vector_variable_process",
        "kratos_module" : "KratosMultiphysics",
        "Parameters"    : {
            # ...
        }
    }],
    "from_kratos_application" : [{
        "python_module" : "compute_body_fitted_drag_process",
        "kratos_module" : "KratosMultiphysics.FluidDynamicsApplication",
        "Parameters"    : {
            # ...
        }
    }],
    "user_defined" : [{
        "python_module" : "user_defined_process_script",
        "Parameters"    : {
            # ...
        }
    }]
}

Note: In order for the user-defined process to work, it has to be available on the PYTHONPATH of the system. This can e.g. be the current working directory.

Creating a user-defined process

Following is an example containing the functions a python-process can implement. This can be used as a basis for implementing a user-defined process.

In order to see where the functions are being called, one can check the AnalysisStage.

Since most applications have adapted the AnalysisStage from the KratosCore, it is very easy to use a different application, one does not have to re-learn how the things are working.

import KratosMultiphysics as KM

def Factory(settings, model):
    if not isinstance(settings, KM.Parameters):
        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
    return DummyPythonProcess(model, settings["Parameters"])

## All the processes python should be derived from "Process"
class DummyPythonProcess(KM.Process):
    """This class is a dummy-process that shows how the functions that can be implemented
    in order to customize the behavior

    Public member variables:
    model -- the container of the different model parts.
    settings -- Kratos parameters containing process settings.
    """

    def __init__(self, model, settings):
        """ The default constructor of the class

        Keyword arguments:
        self -- It signifies an instance of a class.
        Model -- the container of the different model parts.
        settings -- Kratos parameters containing process settings.
        """
        KM.Process.__init__(self) # calling the baseclass constructor

        default_settings = KM.Parameters("""{
            "default_setting_bool"     : true,
            "default_setting_int"      : 5,
            "default_setting_double"   : -1.45,
            "default_setting_string"   : "dummy",
            "default_setting_array"    : [1.0, 2.5, 4.8],
            "default_setting_subparam" : {
                "level_1" : 123
            }
        }""")

        # Add missing settings that the user did not provide but that
        # are necessary for this process
        settings.ValidateAndAssignDefaults(default_settings)
        # Alternative:
        # settings.RecursivelyValidateAndAssignDefaults(default_settings)

    def ExecuteInitialize(self):
        """ This method is executed at the begining to initialize the process

        Keyword arguments:
        self -- It signifies an instance of a class.
        """
        pass

    def Check(self):
        """ This method verifies that the input is correct

        Keyword arguments:
        self -- It signifies an instance of a class.
        """
        pass

    def ExecuteBeforeSolutionLoop(self):
        """ This method is executed just before the solution-loop

        Keyword arguments:
        self -- It signifies an instance of a class.
        """
        pass

    def ExecuteInitializeSolutionStep(self):
        """ This method is executed in order to initialize the current step

        Keyword arguments:
        self -- It signifies an instance of a class.
        """
        pass

    def ExecuteBeforeOutputStep(self):
        """ This method is executed before writing the output (if output
        is being written in this step)

        Keyword arguments:
        self -- It signifies an instance of a class.
        """
        pass

    def ExecuteAfterOutputStep(self):
        """ This method is executed after writing the output (if output
        is being written in this step)

        Keyword arguments:
        self -- It signifies an instance of a class.
        """
        pass

    def ExecuteFinalizeSolutionStep(self):
        """ This method is executed in order to finalize the current step

        Keyword arguments:
        self -- It signifies an instance of a class.
        """
        pass

    def ExecuteFinalize(self):
        """ This method is executed after the computations, at the end of the solution-loop

        Keyword arguments:
        self -- It signifies an instance of a class.
        """
        pass

Note: Unused functions can be deleted, it is not necessary to have an empty implementation.