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)