def __init__(self, model, settings):
KratosMultiphysics.Process.__init__(self)
## Settings string in json format
default_parameters = KratosMultiphysics.Parameters("""
{
"model_part_name" : "model_part",
"formulation" : "reduced_variables",
"variables" : "free_surface",
"interval" : [0.0, 1e30],
"wave_length" : 10.0,
"wave_period" : 10.0,
"wave_height" : 1.0
}
""")
# Overwrite the default settings with user-provided parameters
settings.ValidateAndAssignDefaults(default_parameters)
self.model_part = model[settings["model_part_name"].GetString()]
self.interval = KratosMultiphysics.IntervalUtility(settings)
self.formulation = self.__formulation[
settings["formulation"].GetString()]
self.variables = self.__variables[settings["variables"].GetString()]
# Definition of pi number
import math
# Wave parameters
wave_height = settings["wave_height"].GetDouble()
wave_period = settings["wave_period"].GetDouble()
wave_length = settings["wave_length"].GetDouble()
# Creation of the parameters for the c++ process
free_surface_parameters = KratosMultiphysics.Parameters("""{}""")
free_surface_parameters.AddEmptyValue("amplitude").SetDouble(
0.5 * wave_height)
free_surface_parameters.AddEmptyValue("period").SetDouble(wave_period)
free_surface_parameters.AddEmptyValue("phase_shift").SetDouble(0.0)
free_surface_parameters.AddEmptyValue("vertical_shift").SetDouble(0.0)
velocity_parameters = KratosMultiphysics.Parameters("""{}""")
velocity_parameters.AddEmptyValue("amplitude").SetDouble(
math.pi * wave_height / wave_period)
velocity_parameters.AddEmptyValue("period").SetDouble(wave_period)
velocity_parameters.AddEmptyValue("phase_shift").SetDouble(
wave_period / 4)
velocity_parameters.AddEmptyValue("vertical_shift").SetDouble(0.0)
if self.variables == Shallow.Variables.VELOCITY_VARIABLE:
velocity_parameters.AddEmptyValue("phase_shift").SetDouble(0.0)
self.free_surface_process = Shallow.ApplySinusoidalFunctionToScalar(
self.model_part, Shallow.FREE_SURFACE_ELEVATION,
free_surface_parameters)
self.velocity_process = Shallow.ApplySinusoidalFunctionToScalar(
self.model_part, Shallow.FREE_SURFACE_ELEVATION,
velocity_parameters)
self.variables_utility = Shallow.ShallowWaterVariablesUtility(
self.model_part)
def FinalizeSolutionStep(self):
super(ShallowWaterSolver, self).FinalizeSolutionStep()
epsilon = max(self.advection_epsilon,
self.main_model_part.ProcessInfo[SW.DRY_HEIGHT])
SW.ShallowWaterUtilities().UpdatePrimitiveVariables(
self.main_model_part, epsilon)
SW.ShallowWaterUtilities().ComputeAccelerations(self.main_model_part)
def Initialize(self):
# The time step utility needs the NODAL_H
KM.FindNodalHProcess(self.GetComputingModelPart()).Execute()
self.EstimateDeltaTimeUtility = SW.EstimateDtShallow(self.GetComputingModelPart(), self.settings["time_stepping"])
# Creating the solution strategy for the mesh stage
self.conv_criteria = KM.DisplacementCriteria(self.settings["relative_tolerance"].GetDouble(),
self.settings["absolute_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.echo_level)
self.time_scheme = SW.ResidualBasedIncrementalUpdateWettingScheme(self._GetWettingModel())
# domain_size = self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]
# self.time_scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip(domain_size, # DomainSize
# domain_size+1) # BlockSize
self.builder_and_solver = KM.ResidualBasedBlockBuilderAndSolver(self.linear_solver)
self.solver = KM.ResidualBasedNewtonRaphsonStrategy(self.GetComputingModelPart(),
self.time_scheme,
self.linear_solver,
self.conv_criteria,
self.builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
self.main_model_part.ProcessInfo.SetValue(KM.DYNAMIC_TAU, self.settings["dynamic_tau"].GetDouble())
(self.solver).SetEchoLevel(max(0, self.echo_level-1))
(self.solver).Check()
(self.solver).Initialize()
KM.Logger.PrintInfo("::[ShallowWaterBaseSolver]::", "Mesh stage solver initialization finished")
def _WriteAverageError(self):
elapsed_time = time.time() - self.start_time
case_data = [
self.settings["analysis_label"].GetString(),
self.model_part.NumberOfNodes(),
self.model_part.NumberOfElements(),
self.model_part.ProcessInfo[KM.DELTA_TIME],
self.model_part.ProcessInfo[KM.TIME], elapsed_time
]
if not self.integrate_over_all_the_domain:
low_corner = KM.Point(self.settings["low_corner"].GetVector())
high_corner = KM.Point(self.settings["high_corner"].GetVector())
for variable in self.variables:
if self.integrate_over_all_the_domain:
value = SW.ShallowWaterUtilities().ComputeL2NormNonHistorical(
self.model_part, variable)
else:
value = SW.ShallowWaterUtilities().ComputeL2NormNonHistorical(
self.model_part, variable, low_corner, high_corner)
case_data.append(value)
case_idx = self.dset.len()
self.dset.resize((case_idx + 1, ))
self.dset[case_idx] = tuple(case_data)
def ExecuteBeforeSolutionLoop(self):
# Transferring the nodal variables
if self.use_topographic_model_part:
for variable in self.nodal_variables:
self.topography_utility.TransferVariable(variable)
for variable in self.nonhistorical_variables:
self.topography_utility.TransferNonHistoricalVariable(variable)
# Moving the mesh according to the specified options
if self.deform_mesh:
SW.ShallowWaterUtilities().SetMeshZCoordinate(
self.computing_model_part, self.free_surface_variable)
if self.use_topographic_model_part:
SW.ShallowWaterUtilities().SetMeshZCoordinate(
self.topographic_model_part, self.topography_variable)
else:
SW.ShallowWaterUtilities().SetMeshZCoordinateToZero(
self.computing_model_part)
KM.VariableUtils().SetNonHistoricalVariableToZero(
KM.DISPLACEMENT, self.computing_model_part.Nodes)
if self.use_topographic_model_part:
SW.ShallowWaterUtilities().SetMeshZCoordinateToZero(
self.topographic_model_part)
KM.VariableUtils().SetNonHistoricalVariableToZero(
KM.DISPLACEMENT, self.topographic_model_part.Nodes)
def ExecuteInitializeSolutionStep(self):
if self._IsInInterval():
# Set the free surface if needed
if self.variables == SW.Variables.FREE_SURFACE_VARIABLE or self.variables == SW.Variables.FREE_SURFACE_AND_VELOCITY:
self.free_surface_process.ExecuteInitializeSolutionStep()
# Set the velocity if needed
if self.variables == SW.Variables.VELOCITY_VARIABLE or self.variables == SW.Variables.FREE_SURFACE_AND_VELOCITY:
self.velocity_process.ExecuteInitializeSolutionStep()
# Compute the free surface
SW.ShallowWaterUtilities().ComputeHeightFromFreeSurface(self.model_part)
# Compute the momentum if needed
if self.formulation == SW.Formulation.CONSERVED_VARIABLES:
SW.ShallowWaterUtilities().ComputeMomentum(self.model_part)
# Fix the free surface if needed
if self.variables == SW.Variables.FREE_SURFACE_VARIABLE or self.variables == SW.Variables.FREE_SURFACE_AND_VELOCITY:
KM.VariableUtils().ApplyFixity(SW.HEIGHT, True, self.model_part.Nodes)
# Fix the velocity or the momentum if needed
if self.variables == SW.Variables.VELOCITY_VARIABLE or self.variables == SW.Variables.FREE_SURFACE_AND_VELOCITY:
if self.formulation == SW.Formulation.REDUCED_VARIABLES:
KM.VariableUtils().ApplyFixity(KM.VELOCITY, True, self.model_part.Nodes)
if self.formulation == SW.Formulation.CONSERVED_VARIABLEs:
KM.VariableUtils().ApplyFixity(KM.MOMENTUM, True, self.model_part.Nodes)
def ExecuteInitializeSolutionStep(self):
if self._IsInInterval():
set_free_surface = self.variables == SW.Variables.FreeSurfaceVariable or self.variables == SW.Variables.FreeSurfaceAndVelocity
set_velocity = self.variables == SW.Variables.VelocityVariable or self.variables == SW.Variables.FreeSurfaceAndVelocity
# Set the free surface if needed
if set_free_surface:
self.free_surface_process.ExecuteInitializeSolutionStep()
SW.ShallowWaterUtilities().ComputeHeightFromFreeSurface(
self.model_part)
if self.fix_dofs:
KM.VariableUtils().ApplyFixity(SW.HEIGHT, True,
self.model_part.Nodes)
# Set the velocity if needed
if set_velocity:
self.velocity_process.ExecuteInitializeSolutionStep()
if self.formulation == SW.Formulation.ConservativeVariables:
SW.ShallowWaterUtilities().ComputeMomentum(self.model_part)
if self.fix_dofs:
if self.formulation == SW.Formulation.PrimitiveVariables:
KM.VariableUtils().ApplyFixity(KM.VELOCITY_X, True,
self.model_part.Nodes)
KM.VariableUtils().ApplyFixity(KM.VELOCITY_Y, True,
self.model_part.Nodes)
if self.formulation == SW.Formulation.ConservativeVariables:
KM.VariableUtils().ApplyFixity(KM.MOMENTUM_X, True,
self.model_part.Nodes)
KM.VariableUtils().ApplyFixity(KM.MOMENTUM_Y, True,
self.model_part.Nodes)
def FinalizeSolutionStep(self):
super(ShallowWaterSolver, self).FinalizeSolutionStep()
epsilon = max(self.advection_epsilon,
self.main_model_part.ProcessInfo[SW.DRY_HEIGHT])
SW.ShallowWaterUtilities().ComputeHeightFromFreeSurface(
self.main_model_part)
SW.ComputeVelocityProcess(self.main_model_part, 1e-3).Execute()
SW.ShallowWaterUtilities().ComputeAccelerations(self.main_model_part)
def ExecuteInitialize(self):
self.process.ExecuteInitializeSolutionStep()
if self.variable == "HEIGHT":
SW.ShallowWaterUtilities().ComputeFreeSurfaceElevation(
self.model_part)
elif self.variable == "FREE_SURFACE_ELEVATION":
SW.ShallowWaterUtilities().ComputeHeightFromFreeSurface(
self.model_part)
def FinalizeSolutionStep(self):
super().FinalizeSolutionStep()
KM.VariableUtils().SetFlag(KM.ACTIVE, True, self.main_model_part.Nodes)
KM.VariableUtils().SetFlag(KM.ACTIVE, True, self.main_model_part.Elements)
dry_height = self.main_model_part.ProcessInfo.GetValue(SW.DRY_HEIGHT)
SW.ShallowWaterUtilities().ComputeFreeSurfaceElevation(self.main_model_part)
SW.ShallowWaterUtilities().ResetDryDomain(self.main_model_part, dry_height)
SW.ComputeVelocityProcess(self.main_model_part, dry_height).Execute()
self._CheckWaterLoss()
def FinalizeSolutionStep(self):
super().FinalizeSolutionStep()
epsilon = max(self.advection_epsilon,
self.GetComputingModelPart().ProcessInfo[SW.DRY_HEIGHT])
SW.ShallowWaterUtilities().ComputeHeightFromFreeSurface(
self.GetComputingModelPart())
SW.ComputeVelocityProcess(self.GetComputingModelPart(),
epsilon).Execute()
SW.ShallowWaterUtilities().ComputeAccelerations(
self.GetComputingModelPart())
def __execute_before_low_order_step(self):
self.main_model_part.ProcessInfo.SetValue(SW.LUMPED_MASS_FACTOR, 1.0)
self.main_model_part.ProcessInfo.SetValue(SW.IS_MONOTONIC_CALCULATION,
True)
dry_height = self.main_model_part.ProcessInfo.GetValue(SW.DRY_HEIGHT)
SW.ShallowWaterUtilities().ResetDryDomain(self.main_model_part,
dry_height)
SW.ShallowWaterUtilities().IdentifyWetDomain(self.main_model_part,
KM.ACTIVE, dry_height)
self.fct_utility.InitializeCorrection()
def InitializeSolutionStep(self):
self.bfecc.Convect(KM.MOMENTUM, KM.VELOCITY)
self.bfecc.CopyVariableToPreviousTimeStep(KM.MOMENTUM)
SW.ShallowWaterUtilities().IdentifyWetDomain(
self.GetComputingModelPart(), KM.FLUID, self.thickness)
SW.ShallowWaterUtilities().IdentifyWetDomain(
self.GetComputingModelPart(), KM.ACTIVE, self.thickness)
super(LagrangianShallowWaterSolver, self).InitializeSolutionStep()
def __init__(self, Model, settings):
KM.Process.__init__(self)
default_settings = KM.Parameters("""
{
"model_part_name" : "model_part_name",
"topographic_model_part_name" : "topographic_model_part",
"create_topographic_model_part": true,
"update_topography" : false,
"update_free_surface" : false,
"topography_variable" : "BATHYMETRY",
"free_surface_variable" : "FREE_SURFACE_ELEVATION",
"nodal_variables_to_transfer" : [],
"nonhistorical_variables_to_transfer" : []
}
""")
settings.ValidateAndAssignDefaults(default_settings)
self.computing_model_part = Model[
settings["model_part_name"].GetString()]
# Creating the utility for the topographic model part management
self.use_topographic_model_part = settings[
"create_topographic_model_part"].GetBool()
self.update_topography = False
self.update_free_surface = False
if self.use_topographic_model_part:
self.topographic_model_part = Model.CreateModelPart(
settings["topographic_model_part_name"].GetString())
self.topography_utility = SW.ReplicateModelPartUtility(
self.computing_model_part, self.topographic_model_part)
self.nodal_variables = self._GenerateVariableListFromInput(
settings["nodal_variables_to_transfer"])
self.nonhistorical_variables = self._GenerateVariableListFromInput(
settings["nonhistorical_variables_to_transfer"])
self.topography_variable = KM.KratosGlobals.GetVariable(
settings["topography_variable"].GetString())
self.free_surface_variable = KM.KratosGlobals.GetVariable(
settings["free_surface_variable"].GetString())
self.update_topography = settings["update_topography"].GetBool()
self.update_free_surface = settings["update_free_surface"].GetBool(
)
# The DefineAuxiliaryProperties method duplicates the current number of properties:
# For each property, it creates another one, which means dry state.
# It should be called only once, otherwise, the number of properties will increase without limits
self.properties_utility = SW.PostProcessUtilities(
self.computing_model_part)
self.properties_utility.DefineAuxiliaryProperties()
KM.VariableUtils().SetNonHistoricalVariableToZero(
SW.WATER_HEIGHT, self.computing_model_part.Nodes)
KM.VariableUtils().SetNonHistoricalVariableToZero(
SW.WATER_SURFACE, self.computing_model_part.Nodes)
def FinalizeSolutionStep(self):
super(LagrangianShallowWaterSolver, self).FinalizeSolutionStep()
KM.VariableUtils().SetFlag(KM.ACTIVE, True,
self.GetComputingModelPart().Elements)
SW.ShallowWaterUtilities().ResetDryDomain(self.GetComputingModelPart(),
self.thickness)
SW.ShallowWaterUtilities().ComputeFreeSurfaceElevation(
self.GetComputingModelPart())
SW.ComputeVelocityProcess(self.GetComputingModelPart(), 1e-1).Execute()
SW.ShallowWaterUtilities().ComputeAccelerations(
self.GetComputingModelPart())
def __init__(self, Model, settings):
KM.Process.__init__(self)
default_settings = KM.Parameters("""
{
"model_part_name" : "main_model_part",
"source_type" : "point or model_part",
"source_point_coordinates" : [0.0, 0.0, 0.0],
"source_model_part_name" : "main_model_part.sub_model_part",
"variable_name" : "FREE_SURFACE_ELEVATION",
"default_value" : 0.0,
"distance_of_influence" : 1.0,
"maximum_perturbation_value" : 1.0
}
""")
settings.ValidateAndAssignDefaults(default_settings)
self.variable_name = settings["variable_name"].GetString()
self.model_part = Model[settings["model_part_name"].GetString()]
variable = KM.KratosGlobals.GetVariable(self.variable_name)
# Creation of the parameters for the c++ process
cpp_parameters = KM.Parameters("""{}""")
cpp_parameters.AddValue("default_value", settings["default_value"])
cpp_parameters.AddValue("distance_of_influence",
settings["distance_of_influence"])
cpp_parameters.AddValue("maximum_perturbation_value",
settings["maximum_perturbation_value"])
if settings["source_type"].GetString() == "point":
# retrieving the position of the point
point_position = settings["source_point_coordinates"].GetVector()
if (point_position.Size() != 3):
raise Exception(
'The source_point_coordinates has to be provided with 3 coordinates! It has ',
point_position.Size())
node = KM.Node(1, point_position[0], point_position[1],
point_position[2])
# Construction of the process with one node
self.perturbation_process = SW.ApplyPerturbationFunctionToScalar(
self.model_part, node, variable, cpp_parameters)
elif settings["source_type"].GetString() == "model_part":
# Construction of the process with a sub model part
source_model_part = Model[
settings["source_model_part_name"].GetString()]
self.perturbation_process = SW.ApplyPerturbationFunctionToScalar(
self.model_part, source_model_part.Nodes, variable,
cpp_parameters)
else:
raise Exception("InitialPerturbationProcess: unknown source type")
def _EvaluateGlobalForces(self):
for node in self.model_part_wall.Nodes:
acceleration = node.GetSolutionStepValue(KM.MESH_ACCELERATION)
break
process_info = self.model_part_wall.ProcessInfo
sum_forces = SW.ShallowWaterUtilities().ComputeHydrostaticForces(
self.model_part_wall.Conditions, process_info)
sum_forces += SW.ShallowWaterUtilities().ComputeHydrostaticForces(
self.model_part_bottom.Elements, process_info)
return acceleration, sum_forces
def _CreateScheme(self):
if self.settings["add_flux_correction"].GetBool():
time_scheme = SW.FluxCorrectedShallowWaterScheme(
self.settings["time_integration_order"].GetInt())
if self.settings["shock_stabilization_factor"].GetDouble() > 0.0:
KM.Logger.PrintWarning(
self.__class__.__name__,
"Detected shock stabilization with flux correction, please, disable on of them."
)
else:
time_scheme = SW.ShallowWaterResidualBasedBDFScheme(
self.settings["time_integration_order"].GetInt())
return time_scheme
def _CreateWettingModel(self):
if self.settings["wetting_drying_model"].Has("model_name"):
if self.settings["wetting_drying_model"]["model_name"].GetString() == "rough_porous_layer":
return SW.RoughPorousLayerWettingModel(self.GetComputingModelPart(), self.settings["wetting_drying_model"])
if self.settings["wetting_drying_model"]["model_name"].GetString() == "negative_height":
return SW.NegativeHeightWettingModel(self.GetComputingModelPart(), self.settings["wetting_drying_model"])
else:
msg = "Requested wetting drying model: " + self.settings["wetting_drying_model"]["model_name"].GetString() +"\n"
msg += "Available options are:\n"
msg += "\t\"rough_porous_layer\"\n"
msg += "\t\"negative_height\"\n"
raise Exception(msg)
else:
return None
def __init__(self, model, settings ):
## Settings string in json format
default_parameters = KratosMultiphysics.Parameters("""
{
"model_part_name" : "model_part",
"error_variable" : "RESIDUAL_NORM",
"variable_threshold" : 1e-3,
"increase_threshold" : true,
"only_refine_wet_domain" : true
}
""")
# Overwrite the default settings with user-provided parameters
settings.ValidateAndAssignDefaults(default_parameters)
model_part = model[settings["model_part_name"].GetString()]
# Creation of the parameters for the c++ process
criteria_parameters = KratosMultiphysics.Parameters("""{}""")
criteria_parameters.AddValue("error_variable", settings["error_variable"])
criteria_parameters.AddValue("only_refine_wet_domain", settings["only_refine_wet_domain"])
criteria_parameters.AddValue("variable_threshold", settings["variable_threshold"])
if settings["increase_threshold"].GetBool():
variable_threshold = settings["variable_threshold"].GetDouble()
next_subscale_index = model_part.ProcessInfo[Meshing.SUBSCALE_INDEX] + 1
variable_threshold *= next_subscale_index
criteria_parameters["variable_threshold"].SetDouble(variable_threshold)
self.process = Shallow.ElementalRefiningCriteriaProcess(model_part, criteria_parameters)
def __init__(self, model, settings):
"""The constructor of the ApplyAbsorbingBoundaryProcess
Keyword arguments:
self -- It signifies an instance of a class.
model -- The model to be used
settings -- The ProjectParameters used
"""
KM.Process.__init__(self)
self.settings = settings
self.settings.ValidateAndAssignDefaults(self.GetDefaultParameters())
self.processes = []
self.model_part = model[
self.settings["computing_model_part_name"].GetString()]
boundaries_names = self.settings[
"absorbing_boundaries_list"].GetStringArray()
distance_calculator_settings = KM.Parameters()
distance_calculator_settings.AddValue(
"r_squared_threshold", self.settings["r_squared_threshold"])
for name in boundaries_names:
boundary_part = self.model_part.GetSubModelPart(name)
self.processes.append(
SW.CalculateDistanceToBoundaryProcess(
self.model_part, boundary_part,
distance_calculator_settings))
for process in self.processes:
process.Check()
def __init__(self, model, custom_settings): # Constructor of the class
settings = self._ValidateSettings(custom_settings)
super(ShallowWaterBaseSolver, self).__init__(model, settings)
# There is only a single rank in OpenMP, we always print
self._is_printing_rank = True
## Set the element and condition names for the replace settings
## These should be defined in derived classes
self.element_name = None
self.condition_name = None
self.min_buffer_size = 2
# Either retrieve the model part from the model or create a new one
model_part_name = self.settings["model_part_name"].GetString()
if model_part_name == "":
raise Exception('Please specify a model_part name!')
if self.model.HasModelPart(model_part_name):
self.main_model_part = self.model.GetModelPart(model_part_name)
else:
self.main_model_part = self.model.CreateModelPart(model_part_name)
domain_size = self.settings["domain_size"].GetInt()
self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, domain_size)
## Construct the linear solver
import linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
# Initialize shallow water variables utility
self.ShallowVariableUtils = Shallow.ShallowWaterVariablesUtility(self.main_model_part, self.settings["dry_height"].GetDouble())
def __execute_before_high_order_step(self):
self.main_model_part.ProcessInfo.SetValue(SW.LUMPED_MASS_FACTOR, 0.0)
self.main_model_part.ProcessInfo.SetValue(SW.IS_MONOTONIC_CALCULATION,
False)
dry_height = 10 * self.main_model_part.ProcessInfo.GetValue(
SW.DRY_HEIGHT)
SW.ShallowWaterUtilities().IdentifyWetDomain(self.main_model_part,
KM.ACTIVE, dry_height)
def Initialize(self):
# Creating the solution strategy for the particle stage
self.VariableUtils = KratosMultiphysics.VariableUtils()
#~ maximum_number_of_particles= 8*self.domain_size
self.moveparticles = KratosShallow.MoveShallowWaterParticleUtility(
self.model_part, self.settings["pfem2_settings"])
self.moveparticles.MountBin()
print("Pfem2 utility initialization finished")
def ExecuteInitialize(self):
time = self.model_part.ProcessInfo[KM.TIME]
for node in self.model_part.Nodes:
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))
SW.ShallowWaterUtilities().ComputeFreeSurfaceElevation(self.model_part)
def __init__(self, model_part,
custom_settings): # Constructor of the class
self.model_part = model_part
self.domain_size = self.model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE]
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type" : "shallow_water_base_solver",
"model_import_settings" : {
"input_type" : "mdpa",
"input_filename" : "unknown_name"
},
"echo_level" : 0,
"convergence_echo_level" : 1,
"solver_echo_level" : 0,
"buffer_size" : 2,
"dynamic_tau" : 0.005,
"dry_height" : 0.01,
"relative_tolerance" : 1e-6,
"absolute_tolerance" : 1e-9,
"maximum_iterations" : 20,
"compute_reactions" : false,
"reform_dofs_at_each_step" : false,
"calculate_norm_dx" : true,
"move_mesh_flag" : false,
"volume_model_part_name" : "volume_model_part",
"skin_parts" : [""],
"no_skin_parts" : [""],
"linear_solver_settings" : {
"solver_type" : "SkylineLUFactorizationSolver"
},
"time_stepping" : {
"automatic_time_step" : false,
"time_step" : 0.01
},
"pfem2_settings" : {
"convection_scalar_variable" : "HEIGHT",
"convection_vector_variable" : "VELOCITY",
"maximum_number_of_particles" : 16
}
}""")
default_settings["pfem2_settings"][
"maximum_number_of_particles"].SetInt(8 * self.domain_size)
## Overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
## Construct the linear solver
import linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
# Initialize shallow water variables utility
self.ShallowVariableUtils = KratosShallow.ShallowWaterVariablesUtility(
self.model_part, self.settings["dry_height"].GetDouble())
def ExecuteInitialize(self):
"""This method sets the topography and the initial conditions"""
time = self.model_part.ProcessInfo[KM.TIME]
for node in self.model_part.Nodes:
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))
SW.ShallowWaterUtilities().ComputeFreeSurfaceElevation(self.model_part)
def ExecuteAfterOutputStep(self):
# Restoring the mesh
if self.deform_mesh:
SW.ShallowWaterUtilities().SetMeshZCoordinateToZero(
self.computing_model_part)
# Restoring the properties
if self.use_properties_as_dry_wet_flag:
self.properties_utility.RestoreDryWetProperties()
def ExecuteBeforeSolutionLoop(self):
SW.ShallowWaterUtilities().IdentifyWetDomain(self.computing_model_part,
KM.FLUID, 0.0)
SW.ShallowWaterUtilities().ComputeVisualizationWaterSurface(
self.computing_model_part)
SW.ShallowWaterUtilities().ComputeVisualizationWaterHeight(
self.computing_model_part, KM.FLUID, 0.0)
if self.use_topographic_model_part:
for variable in self.nodal_variables:
self.topography_utility.TransferVariable(variable)
for variable in self.nonhistorical_variables:
self.topography_utility.TransferNonHistoricalVariable(variable)
self.topography_utility.SetDestinationMeshZCoordinate(
self.topography_variable)
if self.update_free_surface:
self.topography_utility.SetOriginMeshZCoordinate(
self.free_surface_variable)
else:
self.topography_utility.SetOriginMeshZCoordinate()
def ExecuteInitialize(self):
wave_amplitude = 0.5 * self.wave_height
depth = -self.model_part.Nodes.__iter__().__next__(
).GetSolutionStepValue(SW.TOPOGRAPHY)
gravity = self.model_part.ProcessInfo[KM.GRAVITY_Z]
wave_velocity = sqrt(depth * gravity)
velocity_amplitude = wave_amplitude * wave_velocity / depth
# Creation of the parameters for the c++ process
free_surface_parameters = KM.Parameters("""{}""")
free_surface_parameters.AddEmptyValue("amplitude").SetDouble(
wave_amplitude)
free_surface_parameters.AddEmptyValue("period").SetDouble(
self.wave_period)
free_surface_parameters.AddEmptyValue("phase_shift").SetDouble(0.0)
free_surface_parameters.AddEmptyValue("vertical_shift").SetDouble(0.0)
free_surface_parameters.AddEmptyValue("smooth_time").SetDouble(
self.smooth_time)
velocity_parameters = KM.Parameters("""{}""")
velocity_parameters.AddEmptyValue("amplitude").SetDouble(
velocity_amplitude)
velocity_parameters.AddEmptyValue("period").SetDouble(self.wave_period)
velocity_parameters.AddEmptyValue("phase_shift").SetDouble(
self.wave_period / 4)
velocity_parameters.AddEmptyValue("vertical_shift").SetDouble(0.0)
free_surface_parameters.AddEmptyValue("smooth_time").SetDouble(
self.smooth_time)
if self.variables == SW.Variables.VelocityVariable:
velocity_parameters.AddEmptyValue("phase_shift").SetDouble(0.0)
self.free_surface_process = SW.ApplySinusoidalFunctionToScalar(
self.model_part, SW.FREE_SURFACE_ELEVATION,
free_surface_parameters)
self.velocity_process = SW.ApplySinusoidalFunctionToVector(
self.model_part, KM.VELOCITY, velocity_parameters)
KM.NormalCalculationUtils().CalculateOnSimplex(
self.model_part, self.model_part.ProcessInfo[KM.DOMAIN_SIZE])
SW.ShallowWaterUtilities().NormalizeVector(self.model_part, KM.NORMAL)
