KratosShallowWaterApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/ShallowWaterApplication/__init__.py

@@ -0,0 +1,7 @@
+# Application dependent names and paths
+from KratosMultiphysics import _ImportApplication
+from KratosShallowWaterApplication import *
+application = KratosShallowWaterApplication()
+application_name = "KratosShallowWaterApplication"
+
+_ImportApplication(application, application_name)

KratosMultiphysics/ShallowWaterApplication/apply_absorbing_boundary_process.py

@@ -0,0 +1,63 @@
+import KratosMultiphysics as KM
+import KratosMultiphysics.ShallowWaterApplication as SW
+from KratosMultiphysics.ShallowWaterApplication.utilities.wave_factory import WaveTheoryFactory
+
+def Factory(settings, model):
+    if not isinstance(settings, KM.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyAbsorbingBoundaryProcess(model, settings["Parameters"])
+
+class ApplyAbsorbingBoundaryProcess(KM.Process):
+    """ApplyAbsorbingBoundaryProcess
+
+    This process sets the DISTANCE variable from every
+    node to the nearest boundary condition
+    """
+
+    @staticmethod
+    def GetDefaultParameters():
+        return KM.Parameters("""{
+            "computing_model_part_name" : "",
+            "absorbing_boundary_name"   : "",
+            "r_squared_threshold"       : 0.99,
+            "relative_distance"         : 2.0,
+            "relative_damping"          : 2.0,
+            "wave_specifications"       : {}
+        }""")
+
+    def __init__(self, model, settings):
+        """The constructor of the ApplyAbsorbingBoundaryProcess"""
+
+        KM.Process.__init__(self)
+
+        self.settings = settings
+        self.settings.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.model_part = model.GetModelPart(self.settings["computing_model_part_name"].GetString())
+        self.boundary_part = model.GetModelPart(self.settings["absorbing_boundary_name"].GetString())
+        self.distance_process = SW.CalculateDistanceToBoundaryProcess(self.model_part, self.boundary_part, self.settings["r_squared_threshold"].GetDouble())
+
+        variables_names = KM.SpecificationsUtilities.GetDofsListFromConditionsSpecifications(self.boundary_part)
+        self.variables_to_fix = []
+        for variable_name in variables_names:
+            if variable_name.startswith("VELOCITY") or variable_name.startswith("MOMENTUM"):
+                variable = KM.KratosGlobals.GetVariable(variable_name)
+                self.variables_to_fix.append(variable)
+
+    def Check(self):
+        """Check the correctness of the input."""
+        self.distance_process.Check()
+
+    def ExecuteBeforeSolutionLoop(self):
+        """Calculate the distances and the damping parameters."""
+        self.distance_process.ExecuteBeforeSolutionLoop()
+
+        wave = WaveTheoryFactory(self.boundary_part, self.settings["wave_specifications"])
+        absorbing_distance = wave.wavelength * self.settings["relative_distance"].GetDouble()
+        dissipation_factor = wave.frequency * self.settings["relative_damping"].GetDouble()
+
+        self.model_part.ProcessInfo.SetValue(SW.ABSORBING_DISTANCE, absorbing_distance)
+        self.model_part.ProcessInfo.SetValue(SW.DISSIPATION, dissipation_factor)
+
+        for variable in self.variables_to_fix:
+            KM.VariableUtils().ApplyFixity(variable, True, self.boundary_part.Nodes)

KratosMultiphysics/ShallowWaterApplication/apply_slip_process.py

@@ -0,0 +1,40 @@
+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 ApplySlipProcess(model, settings["Parameters"])
+
+class ApplySlipProcess(KM.Process):
+    """ApplySlipProcess
+
+    This process sets the SLIP flag and computes the
+    NORMAL variable on the selected model part
+    """
+    def __init__(self, model, settings):
+        """The constructor of the ApplySlipProcess
+
+        Keyword arguments:
+        self -- It signifies an instance of a class.
+        model -- The model to be used
+        settings -- The ProjectParameters used
+        """
+        KM.Process.__init__(self)
+
+        default_parameters = KM.Parameters("""{
+                "model_part_name" : "PLEASE_CHOOSE_MODEL_PART_NAME",
+                "recompute_normals" : false
+            }""")
+        settings.ValidateAndAssignDefaults(default_parameters)
+
+        self.model_part = model[settings["model_part_name"].GetString()]
+        self.recompute_normals = settings["recompute_normals"].GetBool()
+
+    def ExecuteInitialize(self):
+        domain_size = self.model_part.ProcessInfo[KM.DOMAIN_SIZE]
+        KM.NormalCalculationUtils().CalculateOnSimplex(self.model_part, domain_size)
+        KM.VariableUtils().SetFlag(KM.SLIP, True, self.model_part.Nodes)
+
+    def ExecuteInitializeSolutionStep(self):
+        if self.recompute_normals:
+            self.ExecuteInitialize()

KratosMultiphysics/ShallowWaterApplication/automatic_dirichlet_conditions_process.py

@@ -0,0 +1,117 @@
+import KratosMultiphysics as KM
+import KratosMultiphysics.ShallowWaterApplication as SW
+
+def Factory(settings, model):
+    if not isinstance(settings, KM.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return AutomaticDirichletConditionsProcess(model, settings["Parameters"])
+
+## This process fix the variables at the skin
+class AutomaticDirichletConditionsProcess(KM.Process):
+
+    def __init__(self, model, settings):
+
+        KM.Process.__init__(self)
+
+        default_settings = KM.Parameters("""
+            {
+                "model_part_name"             : "main_model_part",
+                "scalar_variables_list"       : [],
+                "scalar_value"                : 0.0,
+                "scalar_constraint"           : true,
+                "vector_variables_list"       : [],
+                "vector_value"                : [0.0, 0.0, 0.0],
+                "vector_constraint"           : [true, true, true],
+                "auxiliary_model_part_name"   : "skin_model_part",
+                "auxiliary_condition_name"    : "Condition",
+                "skin_parts_to_exclude"       : [],
+                "allow_outwards_flow_on_land" : true,
+                "sea_water_level"             : 0.0
+            }
+            """
+            )
+        settings.ValidateAndAssignDefaults(default_settings)
+        self.settings = settings
+        self.model = model
+
+        self._CheckIfParameterIsRelativeSubModelPartName(self.settings["auxiliary_model_part_name"])
+        for item in self.settings["skin_parts_to_exclude"]:
+            self._CheckIfParameterIsRelativeSubModelPartName(item)
+
+    def ExecuteInitialize(self):
+        model_part_name = self.settings["model_part_name"].GetString()
+        model_part = self.model[model_part_name]
+
+        skin_detection_settings = KM.Parameters()
+        skin_detection_settings.AddValue("name_auxiliar_model_part", self.settings["auxiliary_model_part_name"])
+        skin_detection_settings.AddValue("name_auxiliar_condition", self.settings["auxiliary_condition_name"])
+        skin_detection_settings.AddValue("list_model_parts_to_assign_conditions", self.settings["skin_parts_to_exclude"])
+        KM.SkinDetectionProcess2D(model_part, skin_detection_settings).Execute()
+
+        skin_model_part_name = model_part_name + '.' + self.settings["auxiliary_model_part_name"].GetString()
+        skin_model_part = self.model[skin_model_part_name]
+
+        # We remove the new interface condition from the bondaries with other conditions
+        for name in self.settings["skin_parts_to_exclude"].GetStringArray():
+            skin_to_exclude = model_part_name + '.' + name
+            self.model[skin_to_exclude].RemoveConditionsFromAllLevels(KM.INTERFACE)
+            KM.VariableUtils().SetFlag(KM.INTERFACE, False, self.model[skin_to_exclude].Nodes)
+        skin_model_part.RemoveNodes((KM.INTERFACE).AsFalse())
+
+        # Here we exclude the interface which will has an outward flow
+        if self.settings["allow_outwards_flow_on_land"].GetBool():
+            dimension = 2
+            KM.NormalCalculationUtils().CalculateOnSimplex(skin_model_part, dimension)
+            KM.ComputeNonHistoricalNodalGradientProcess(model_part, SW.TOPOGRAPHY, SW.TOPOGRAPHY_GRADIENT, KM.NODAL_AREA).Execute()
+            SW.ShallowWaterUtilities().IdentifySolidBoundary(skin_model_part, self.settings["sea_water_level"].GetDouble(), KM.SOLID)
+            skin_model_part.RemoveNodes((KM.SOLID).AsFalse())
+            skin_model_part.RemoveConditionsFromAllLevels((KM.SOLID).AsFalse())
+        else:
+            KM.VariableUtils().SetFlag(KM.SOLID, True, skin_model_part.Nodes)
+            KM.VariableUtils().SetFlag(KM.SOLID, True, skin_model_part.Conditions)
+
+        self.processes = []
+
+        from KratosMultiphysics.assign_scalar_variable_process import AssignScalarVariableProcess
+        for variable in self.settings["scalar_variables_list"].GetStringArray():
+            scalar_settings = KM.Parameters()
+            scalar_settings.AddEmptyValue("model_part_name").SetString(skin_model_part_name)
+            scalar_settings.AddEmptyValue("variable_name").SetString(variable)
+            scalar_settings.AddValue("value", self.settings["scalar_value"])
+            scalar_settings.AddValue("constrained", self.settings["scalar_constraint"])
+            self.processes.append(AssignScalarVariableProcess(self.model, scalar_settings))
+
+        from KratosMultiphysics.assign_vector_variable_process import AssignVectorVariableProcess
+        for variable in self.settings["vector_variables_list"].GetStringArray():
+            vector_settings = KM.Parameters()
+            vector_settings.AddEmptyValue("model_part_name").SetString(skin_model_part_name)
+            vector_settings.AddEmptyValue("variable_name").SetString(variable)
+            vector_settings.AddValue("value", self.settings["vector_value"])
+            vector_settings.AddValue("constrained", self.settings["vector_constraint"])
+            self.processes.append(AssignVectorVariableProcess(self.model, vector_settings))
+
+    def ExecuteBeforeSolutionLoop(self):
+        for process in self.processes:
+            process.ExecuteBeforeSolutionLoop()
+
+    def ExecuteInitializeSolutionStep(self):
+        for process in self.processes:
+            process.ExecuteInitializeSolutionStep()
+
+    def ExecuteFinalizeSolutionStep(self):
+        for process in self.processes:
+            process.ExecuteFinalizeSolutionStep()
+
+    @staticmethod
+    def _CheckIfParameterIsRelativeSubModelPartName(param):
+        name = param.GetString()
+        search = name.find('.')
+        if search != -1:
+            items = name.split('.')
+            msg = "AutomaticDirichletConditionsProcess"
+            msg += 'Please, specify the sub model part with the relative name\n'
+            msg += '\tWrite : \"' + items[-1] + '\"\n'
+            msg += '\tinstead of : \"' +  name + '\"\n'
+            param.SetString(name)
+            # The parameters are passed by value, we shall throw an error
+            raise Exception(msg)

KratosMultiphysics/ShallowWaterApplication/benchmarks/base_benchmark_process.py

@@ -0,0 +1,119 @@
+# Importing the Kratos Library
+import KratosMultiphysics as KM
+import KratosMultiphysics.ShallowWaterApplication as SW
+
+from KratosMultiphysics.kratos_utilities import GenerateVariableListFromInput
+
+def Factory(settings, model):
+    if not isinstance(settings, KM.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return BaseBenchmarkProcess(model, settings["Parameters"])
+
+class BaseBenchmarkProcess(KM.Process):
+    """The base class for the benchmarks."""
+
+    def __init__(self, model, settings ):
+        """The constructor of the BaseBenchmarkProcess.
+
+        It is intended to be called from the constructor of deriving classes.
+        """
+
+        super().__init__()
+
+        self.model = model
+        self.settings = settings
+
+        default_settings = KM.Parameters("""
+            {
+                "model_part_name"      : "model_part",
+                "variables_list"       : [],
+                "exact_variables_list" : [],
+                "error_variables_list" : [],
+                "benchmark_settings"   : {}
+            }
+            """
+            )
+        default_settings["benchmark_settings"] = self._GetBenchmarkDefaultSettings()
+        self.settings.RecursivelyValidateAndAssignDefaults(default_settings)
+
+        self.model_part = self.model[self.settings["model_part_name"].GetString()]
+        self.variables = GenerateVariableListFromInput(self.settings["variables_list"])
+        self.exact_variables = GenerateVariableListFromInput(self.settings["exact_variables_list"])
+        self.error_variables = GenerateVariableListFromInput(self.settings["error_variables_list"])
+
+
+    def ExecuteInitialize(self):
+        """Set the topography and the initial conditions."""
+        KM.Timer.Start("Benchmark/Initial state")
+        time = self.model_part.ProcessInfo[KM.TIME]
+        for node in self.model_part.Nodes:
+            if self._Topography(node):
+                node.SetSolutionStepValue(SW.TOPOGRAPHY, self._Topography(node))
+            node.SetSolutionStepValue(SW.HEIGHT, self._Height(node, time))
+            node.SetSolutionStepValue(KM.VELOCITY, self._Velocity(node, time))
+            node.SetSolutionStepValue(KM.MOMENTUM, self._Momentum(node, time))
+            node.SetSolutionStepValue(SW.FREE_SURFACE_ELEVATION, self._FreeSurfaceElevation(node, time))
+        KM.Timer.Stop("Benchmark/Initial state")
+
+
+    def ExecuteBeforeOutputStep(self):
+        """Compute the exact values of the benchmark and the error of the simulation."""
+        KM.Timer.Start("Benchmark/Exact values")
+        time = self.model_part.ProcessInfo[KM.TIME]
+        for (variable, exact_variable, error_variable) in zip(self.variables, self.exact_variables, self.error_variables):
+
+            if variable == SW.HEIGHT:
+                exact_value_function = self._Height
+            elif variable == KM.VELOCITY:
+                exact_value_function = self._Velocity
+            elif variable == KM.MOMENTUM:
+                exact_value_function = self._Momentum
+            elif variable == SW.FREE_SURFACE_ELEVATION:
+                exact_value_function = self._FreeSurfaceElevation
+
+            for node in self.model_part.Nodes:
+                exact_value = exact_value_function(node, time)
+                fem_value = node.GetSolutionStepValue(variable)
+
+                node.SetValue(exact_variable, exact_value)
+                node.SetValue(error_variable, fem_value - exact_value)
+        KM.Timer.Stop("Benchmark/Exact values")
+
+
+    def Check(self):
+        """Check if the input values have physical sense."""
+
+        if len(self.variables) != len(self.exact_variables):
+            raise Exception("The input variables list does not match the input exact variables list")
+
+        if len(self.variables) != len(self.error_variables):
+            raise Exception("The input variables list does not match the input error variables list")
+
+        for (var, exact, error) in zip(self.variables, self.exact_variables, self.error_variables):
+            if KM.KratosGlobals.GetVariableType(var.Name()) != KM.KratosGlobals.GetVariableType(exact.Name()):
+                msg = var.Name() + " variable type does not match the " + exact.Name() + " variable type"
+                raise Exception(msg)
+
+            if KM.KratosGlobals.GetVariableType(var.Name()) != KM.KratosGlobals.GetVariableType(error.Name()):
+                msg = var.Name() + " variable type does not match the " + error.Name() + " variable type"
+                raise Exception(msg)
+
+
+    @classmethod
+    def _GetBenchmarkDefaultSettings(cls):
+        raise Exception("Calling the base class of the benchmark. Please, implement the custom benchmark settings")
+
+    def _Topography(self, coordinates):
+        return 0
+
+    def _Height(self, coordinates, time):
+        raise Exception("Calling the base class of the benchmark. Please, implement the custom benchmark")
+
+    def _Velocity(self, coordinates, time):
+        raise Exception("Calling the base class of the benchmark. Please, implement the custom benchmark")
+
+    def _Momentum(self, coordinates, time):
+        return [self._Height(coordinates, time)*v for v in self._Velocity(coordinates, time)]
+
+    def _FreeSurfaceElevation(self, coordinates, time):
+        return self._Topography(coordinates) + self._Height(coordinates, time)

KratosMultiphysics/ShallowWaterApplication/benchmarks/dam_break_benchmark.py

@@ -0,0 +1,128 @@
+import KratosMultiphysics as KM
+
+from KratosMultiphysics.ShallowWaterApplication.benchmarks.base_benchmark_process import BaseBenchmarkProcess
+
+# Other imports
+from math import sqrt
+import scipy.optimize as opt
+
+def Factory(settings, model):
+    if not isinstance(settings, KM.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return DamBreakBenchmark(model, settings["Parameters"])
+
+class DamBreakBenchmark(BaseBenchmarkProcess):
+    """Dam break benchark.
+
+    O. Delestre, C. Lucas, P.-A. Ksinant, F. Darboux, C. Laguerre, T.N.T. Vo, F. James, S. Cordier
+    SWASHES: a compilation of Shallow Water Analytic Solutions for Hydraulic and Environmental Studies
+    International Journal for Numerical Methods in Fluids, Wiley, 2013, 72 (3), pp.269-300
+    """
+
+    def __init__(self, model, settings ):
+        """Constructor of the benchmark.
+
+        The base class validates the settings and sets the model_part, the variables and the benchmark_settings
+        """
+
+        super().__init__(model, settings)
+
+        self.dam = self.settings["benchmark_settings"]["dam_position"].GetDouble()
+        self.hl = self.settings["benchmark_settings"]["left_height"].GetDouble()
+        self.hr = self.settings["benchmark_settings"]["right_height"].GetDouble()
+        self.g = self.model_part.ProcessInfo[KM.GRAVITY_Z]
+
+        self.cm = self.__cm()
+
+
+    def Check(self):
+        """This method checks if the input values have physical sense."""
+
+        super().Check()
+        label = "DamBreakBenchmark. "
+        if self.g <= 0:
+            msg = label + "Gravity must be a positive value. Please, check the definition of GRAVITY_Z component in the ProcessInfo."
+            raise Exception(msg)
+        elif self.hr < 0:
+            msg = label + "Right height must be non-negative. Please, check the Parameters."
+            raise Exception(msg)
+        elif self.hl < 0:
+            msg = label + "Left height must be non-negative. Please, check the Parameters."
+            raise Exception(msg)
+
+
+    @classmethod
+    def _GetBenchmarkDefaultSettings(cls):
+        return KM.Parameters("""
+            {
+                "dam_position"  : 5.0,
+                "left_height"   : 2.0,
+                "right_height"  : 1.0
+            }
+            """
+            )
+
+
+    def _Height(self, coordinates, time):
+        x = coordinates.X
+
+        xa = self.__xa(time)
+        xb = self.__xb(time)
+        xc = self.__xc(time)
+
+        if x < xa:
+            return self.hl
+        elif x < xb:
+            return 4 / 9 / self.g * (sqrt(self.g * self.hl) - 0.5*(x - self.dam) / time)**2
+        elif x < xc:
+            return self.cm**2 / self.g
+        else:
+            return self.hr
+
+
+    def _Velocity(self, coordinates, time):
+        x = coordinates.X
+
+        xa = self.__xa(time)
+        xb = self.__xb(time)
+        xc = self.__xc(time)
+
+        if x < xa:
+            return [0.0, 0.0, 0.0]
+        elif x < xb:
+            return [2 / 3 * ((x - self.dam) / time + sqrt(self.g * self.hl)), 0.0, 0.0]
+        elif x < xc:
+            return [2 * (sqrt(self.g * self.hl) - self.cm), 0.0, 0.0]
+        else:
+            return [0.0, 0.0, 0.0]
+
+
+    def __xa(self, t):
+        return self.dam - t * sqrt(self.g * self.hl)
+
+
+    def __xb(self, t):
+        return self.dam + t * (2*sqrt(self.g * self.hl) - 3 * self.cm)
+
+
+    def __xc(self, t):
+        if self.hr > 0:
+            return self.dam + t * 2 * self.cm**2 * (sqrt(self.g*self.hl) - self.cm) / (self.cm**2 - self.g * self.hr)
+        else:
+            return self.__xb(t)
+
+
+    def __cm(self):
+        if self.hr > 0:
+            cm0 = sqrt(self.g * 0.5 * (self.hl + self.hr))
+            cm = opt.newton(self.__cm_residual, cm0)
+            return cm
+        else:
+            return 0.0
+
+
+    def __cm_residual(self,cm):
+        hl = self.hl
+        hr = self.hr
+        g  = self.g
+        return -8*g*hr*cm**2*(sqrt(g*hl)-cm)**2 + (cm**2-g*hr)**2 * (cm**2+g*hr)