def SetRefiningParameters(self):
# Create RefiningParameters
self.RefiningParameters = KratosDelaunay.RefiningParameters()
self.RefiningParameters.Initialize()
# parameters
self.RefiningParameters.SetAlphaParameter(
self.settings["alpha_shape"].GetDouble())
# custom set of the mesh size from settings from initial mesh or other parts
self.SetMeshSizeValues()
# set mesh refinement in box
size = self.dimension
refining_box = self.settings["refining_parameters"]["refining_box"]
if (refining_box["refine_in_box_only"].GetBool()):
radius = refining_box["radius"].GetDouble()
center = Vector(size)
velocity = Vector(size)
for i in range(0, size):
center[i] = refining_box["center"][i].GetDouble()
velocity[i] = refining_box["velocity"][i].GetDouble()
refining_box = KratosDelaunay.SpatialBoundingBox(
center, radius, velocity)
self.RefiningParameters.SetRefiningBox(refining_box)
self.RefiningParameters.SetThresholdVariable(
KratosMultiphysics.KratosGlobals.GetVariable(
self.settings["refining_parameters"]
["threshold_variable"].GetString()))
self.RefiningParameters.SetReferenceThreshold(
self.settings["refining_parameters"]
["reference_threshold"].GetDouble())
self.RefiningParameters.SetErrorVariable(
KratosMultiphysics.KratosGlobals.GetVariable(
self.settings["refining_parameters"]
["error_variable"].GetString()))
self.RefiningParameters.SetReferenceError(
self.settings["refining_parameters"]
["reference_error"].GetDouble())
removing_options = KratosMultiphysics.Flags()
#remove nodes
remove_nodes = self.settings["refining_parameters"]["remove_nodes"]
removing_options.Set(KratosDelaunay.MesherUtilities.REMOVE_NODES,
remove_nodes["apply_removal"].GetBool())
removing_options.Set(
KratosDelaunay.MesherUtilities.REMOVE_NODES_ON_DISTANCE,
remove_nodes["on_distance"].GetBool())
removing_options.Set(
KratosDelaunay.MesherUtilities.REMOVE_NODES_ON_ERROR,
remove_nodes["on_error"].GetBool())
removing_options.Set(
KratosDelaunay.MesherUtilities.REMOVE_NODES_ON_THRESHOLD,
remove_nodes["on_threshold"].GetBool())
#remove boundary
remove_boundary = self.settings["refining_parameters"][
"remove_boundary"]
removing_options.Set(
KratosDelaunay.MesherUtilities.REMOVE_BOUNDARY_NODES,
remove_boundary["apply_removal"].GetBool())
removing_options.Set(
KratosDelaunay.MesherUtilities.REMOVE_BOUNDARY_NODES_ON_DISTANCE,
remove_boundary["on_distance"].GetBool())
removing_options.Set(
KratosDelaunay.MesherUtilities.REMOVE_BOUNDARY_NODES_ON_ERROR,
remove_boundary["on_error"].GetBool())
removing_options.Set(
KratosDelaunay.MesherUtilities.REMOVE_BOUNDARY_NODES_ON_THRESHOLD,
remove_boundary["on_threshold"].GetBool())
refining_options = KratosMultiphysics.Flags()
refining_options.Set(
KratosDelaunay.MesherUtilities.REFINE,
self.settings["meshing_strategy"]["refine"].GetBool())
refining_options.Set(
KratosDelaunay.MesherUtilities.REFINE_ADD_NODES,
self.settings["refining_parameters"]["add_nodes"].GetBool())
refining_options.Set(
KratosDelaunay.MesherUtilities.REFINE_INSERT_NODES,
self.settings["refining_parameters"]["insert_nodes"].GetBool())
#refine elements
refine_elements = self.settings["refining_parameters"][
"refine_elements"]
refining_options.Set(KratosDelaunay.MesherUtilities.REFINE_ELEMENTS,
refine_elements["apply_refinement"].GetBool())
refining_options.Set(
KratosDelaunay.MesherUtilities.REFINE_ELEMENTS_ON_DISTANCE,
refine_elements["on_distance"].GetBool())
refining_options.Set(
KratosDelaunay.MesherUtilities.REFINE_ELEMENTS_ON_ERROR,
refine_elements["on_error"].GetBool())
refining_options.Set(
KratosDelaunay.MesherUtilities.REFINE_ELEMENTS_ON_THRESHOLD,
refine_elements["on_threshold"].GetBool())
#refine boundary
refine_boundary = self.settings["refining_parameters"][
"refine_boundary"]
refining_options.Set(KratosDelaunay.MesherUtilities.REFINE_BOUNDARY,
refine_boundary["apply_refinement"].GetBool())
refining_options.Set(
KratosDelaunay.MesherUtilities.REFINE_BOUNDARY_ON_DISTANCE,
refine_boundary["on_distance"].GetBool())
refining_options.Set(
KratosDelaunay.MesherUtilities.REFINE_BOUNDARY_ON_ERROR,
refine_boundary["on_error"].GetBool())
refining_options.Set(
KratosDelaunay.MesherUtilities.REFINE_BOUNDARY_ON_THRESHOLD,
refine_boundary["on_threshold"].GetBool())
self.RefiningParameters.SetRefiningOptions(refining_options)
self.RefiningParameters.SetRemovingOptions(removing_options)
def SetInfoParameters(self):
# Create InfoParameters
self.InfoParameters = KratosDelaunay.MeshingInfoParameters()
self.InfoParameters.Initialize()
def Initialize(self, meshing_parameters, dimension):
#meshing parameters
self.MeshingParameters = meshing_parameters
meshing_options = KratosMultiphysics.Flags()
meshing_options.Set(KratosDelaunay.MesherUtilities.REMESH,
self.settings["remesh"].GetBool())
meshing_options.Set(KratosDelaunay.MesherUtilities.REFINE,
self.settings["refine"].GetBool())
meshing_options.Set(KratosDelaunay.MesherUtilities.RECONNECT,
self.settings["reconnect"].GetBool())
meshing_options.Set(KratosDelaunay.MesherUtilities.TRANSFER,
self.settings["transfer"].GetBool())
meshing_options.Set(KratosDelaunay.MesherUtilities.CONSTRAINED,
self.settings["constrained"].GetBool())
meshing_options.Set(KratosDelaunay.MesherUtilities.MESH_SMOOTHING,
self.settings["mesh_smoothing"].GetBool())
meshing_options.Set(KratosDelaunay.MesherUtilities.VARIABLES_SMOOTHING,
self.settings["variables_smoothing"].GetBool())
self.MeshingParameters.SetOptions(meshing_options)
self.MeshingParameters.SetReferenceElement(
self.settings["reference_element_type"].GetString())
self.MeshingParameters.SetReferenceCondition(
self.settings["reference_condition_type"].GetString())
#set variables to global transfer
self.MeshDataTransfer = KratosDelaunay.MeshDataTransferUtilities()
self.TransferParameters = KratosDelaunay.TransferParameters()
self.global_transfer = False
if (self.settings["variables_smoothing"].GetBool() == True):
self.global_transfer = True
transfer_variables = self.settings["elemental_variables_to_smooth"]
#for variable in transfer_variables:
# self.TransferParameters.SetVariable( KratosMultiphysics.KratosGlobals.GetVariable( variable.GetString() ) )
for i in range(0, transfer_variables.size()):
self.TransferParameters.SetVariable(
KratosMultiphysics.KratosGlobals.GetVariable(
transfer_variables[i].GetString()))
#mesh meshers for the current strategy
self.meshers = []
#configure meshers:
self.SetMeshers()
self.model_part = self.main_model_part
if (self.main_model_part.Name !=
self.MeshingParameters.GetSubModelPartName()):
self.model_part = self.main_model_part.GetSubModelPart(
self.MeshingParameters.GetSubModelPartName())
for mesher in self.meshers:
mesher.SetEchoLevel(self.echo_level)
mesher.Initialize(dimension)
self.number_of_nodes = 0
self.number_of_elements = 0
self.number_of_conditions = 0
print(self._class_prefix() + " Ready")
def GetModelManager(self):
meshing_options = KratosMultiphysics.Flags()
return KratosDelaunay.ModelStructure(self.main_model_part, meshing_options, self.echo_level)
def __init__(self, main_model_part, custom_settings):
self.main_model_part = main_model_part
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"python_module" : "rigid_body",
"model_part_name" : "RigidBodyDomain",
"rigid_body_settings":{
"rigid_body_element_type": "TranslatoryRigidElement3D1N",
"fixed_body": true,
"compute_body_parameters": false,
"rigid_body_model_part_name": "RigidBodyDomain",
"rigid_body_parameters":{
"center_of_gravity": [0.0 ,0.0, 0.0],
"mass":0.0,
"main_inertias": [0.0, 0.0, 0.0],
"main_axes": [ [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] ]
}
}
}
""")
## new node and rigid body element inside the same mesh : boundary conditions also applied
## this node and elements must be considered in the computing model part
## new contact conditions must be already assembled
## if exist a movement from a point different from CG a link condition must be used
##overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
# construct rigid body // it will contain the array of nodes, array of elements, and the array of conditions
self.rigid_body_model_part = self.main_model_part.GetSubModelPart(self.settings["model_part_name"].GetString())
self.rigid_body_model_part.Set(KratosMultiphysics.RIGID)
for node in self.rigid_body_model_part.Nodes:
node.Set(KratosMultiphysics.RIGID,True)
#for node in self.rigid_body_model_part.Elements:
# node.Set(KratosMultiphysics.ACTIVE,False)
#check for the bounding box of a compound wall
box_settings = KratosMultiphysics.Parameters("""
{
"parameters_list":[{
"upper_point": [0.0, 0.0, 0.0],
"lower_point": [0.0, 0.0, 0.0],
"convexity": 1
}],
"velocity" : [0.0, 0.0, 0.0]
}
""")
box_parameters = box_settings["parameters_list"][0]
upper_point = self.GetUpperPoint(self.rigid_body_model_part)
counter = 0
for i in upper_point:
box_parameters["upper_point"][counter].SetDouble(i)
counter+=1
lower_point = self.GetLowerPoint(self.rigid_body_model_part)
counter = 0
for i in lower_point:
box_parameters["lower_point"][counter].SetDouble(i)
counter+=1
self.bounding_box = KratosDelaunay.SpatialBoundingBox(box_settings)
# construct rigid element // must pass an array of nodes to the element, create a node (CG) and a rigid element set them in the model_part, set the node CG as the reference node of the wall_bounding_box, BLOCKED, set in the wall_model_part for imposed movements processes.
creation_utility = KratosContact.RigidBodyCreationUtility()
creation_utility.CreateRigidBodyElement(self.main_model_part, self.bounding_box, self.settings["rigid_body_settings"])
print(self._class_prefix()+" Ready")