def ExecuteInitialize(self):
# check restart
self.restart = False
if (self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED]
== True):
self.restart = True
self.step_count = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP]
if self.meshing_control_is_time:
self.next_meshing = self.main_model_part.ProcessInfo[
KratosMultiphysics.TIME]
else:
self.next_meshing = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP]
# execute initialize base class
if (self.main_model_part.ProcessInfo[
KratosPfemBase.INITIALIZED_DOMAINS] == False):
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
domain_utils.InitializeDomains(self.main_model_part,
self.echo_level)
for domain in self.meshing_domains:
domain.Initialize()
def ExecuteInitialize(self):
self.main_model_part = self.Model[
self.settings["model_part_name"].GetString()]
self.dimension = self.main_model_part.ProcessInfo[
KratosMultiphysics.SPACE_DIMENSION]
# construct rigid body domains
self.rigid_bodies = []
bodies_list = self.settings["rigid_bodies"]
self.number_of_bodies = bodies_list.size()
for i in range(0, self.number_of_bodies):
item = bodies_list[i]
rigid_body_module = __import__(item["python_module"].GetString())
body = rigid_body_module.CreateRigidBody(self.main_model_part,
item)
self.rigid_bodies.append(body)
# initialize rigid body domains
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
domain_utils.InitializeDomains(self.main_model_part, self.echo_level)
for body in self.rigid_bodies:
body.Initialize()
print(self._class_prefix() + " Ready")
def ExecuteInitialize(self):
# check restart
self.restart = False
if( self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] == True ):
self.restart = True
self.step_count = self.main_model_part.ProcessInfo[KratosMultiphysics.STEP]
if self.meshing_control_is_time:
self.next_meshing = self.main_model_part.ProcessInfo[KratosMultiphysics.TIME] + self.meshing_frequency
else:
self.next_meshing = self.main_model_part.ProcessInfo[KratosMultiphysics.STEP] + self.meshing_frequency
else:
#if commented in the first step meshing is applied
self.next_meshing = self.meshing_frequency
# it must be initialized if restart is called//no
self.main_model_part.ProcessInfo.SetValue(KratosPfem.INITIALIZED_DOMAINS, False);
# initialize all meshing domains
if( self.remesh_domains_active ):
print("::[Meshing_Process]:: Initialize Domains")
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
domain_utils.InitializeDomains(self.main_model_part,self.echo_level)
for domain in self.meshing_domains:
domain.SetEchoLevel(self.echo_level)
domain.Initialize()
def ExecuteInitialize(self):
for i in range(0, self.number_of_walls):
self.parametric_walls[i].BuildParametricWall()
# check restart
self.restart = False
if (self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED]):
self.restart = True
self.step_count = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP]
if self.search_control_is_time:
self.next_search = self.main_model_part.ProcessInfo[
KratosMultiphysics.TIME]
else:
self.next_search = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP]
# initialize wall domains
print("::[Walls_Process]:: Initialize Domains ")
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
domain_utils.InitializeDomains(self.main_model_part, self.echo_level)
for wall in self.parametric_walls:
wall.Initialize()
def ExecuteInitialize(self):
self.main_model_part = self.Model[
self.settings["model_part_name"].GetString()]
self.dimension = self.main_model_part.ProcessInfo[
KratosMultiphysics.SPACE_DIMENSION]
#construct meshing domains
self.meshing_domains = []
domains_list = self.settings["meshing_domains"]
self.number_of_domains = domains_list.size()
for i in range(0, self.number_of_domains):
item = domains_list[i]
domain_module = __import__(item["python_module"].GetString())
domain = domain_module.CreateMeshingDomain(self.main_model_part,
item)
self.meshing_domains.append(domain)
# mesh modeler initial values
self.remesh_domains_active = False
for domain in self.meshing_domains:
if (domain.Active()):
self.remesh_domains_active = True
# check restart
self.restart = False
if (self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED]
== True):
self.restart = True
self.step_count = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP]
if self.meshing_control_is_time:
self.next_meshing = self.main_model_part.ProcessInfo[
KratosMultiphysics.TIME] + self.meshing_frequency
else:
self.next_meshing = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP] + self.meshing_frequency
else:
#if commented in the first step meshing is applied
self.next_meshing = self.meshing_frequency
# it must be initialized if restart is called//no
self.main_model_part.ProcessInfo.SetValue(
KratosPfem.INITIALIZED_DOMAINS, False)
# initialize all meshing domains
if (self.remesh_domains_active):
print("::[Meshing_Process]:: Initialize Domains")
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
domain_utils.InitializeDomains(self.main_model_part,
self.echo_level)
for domain in self.meshing_domains:
domain.SetEchoLevel(self.echo_level)
domain.Initialize()
def ExecuteInitialize(self):
# initialize rigid body domains
print("::[RigidBodies_Process]:: Initialize Domains ")
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
domain_utils.InitializeDomains(self.main_model_part, self.echo_level)
for body in self.rigid_bodies:
body.Initialize()
def ExecuteInitialize(self):
self.main_model_part = self.Model[
self.settings["model_part_name"].GetString()]
self.dimension = self.main_model_part.ProcessInfo[
KratosMultiphysics.SPACE_DIMENSION]
#construct parametric wall domains
self.parametric_walls = []
walls_list = self.settings["parametric_walls"]
self.number_of_walls = walls_list.size()
for i in range(0, self.number_of_walls):
item = walls_list[i]
parametric_wall_module = __import__(
item["python_module"].GetString())
wall = parametric_wall_module.CreateParametricWall(
self.main_model_part, item)
self.parametric_walls.append(wall)
# mesh mesher initial values
self.search_contact_active = False
if (self.number_of_walls):
self.search_contact_active = True
# build parametric walls
for i in range(0, self.number_of_walls):
self.parametric_walls[i].BuildParametricWall()
# check restart
self.restart = False
if (self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED]):
self.restart = True
self.step_count = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP]
if self.search_control_is_time:
self.next_search = self.main_model_part.ProcessInfo[
KratosMultiphysics.TIME]
else:
self.next_search = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP]
# initialize wall domains
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
domain_utils.InitializeDomains(self.main_model_part, self.echo_level)
for wall in self.parametric_walls:
wall.Initialize()
print(self._class_prefix() + " Ready")
def GetVariables(self):
import domain_utilities
nodal_variables = domain_utilities.DomainUtilities().GetVariables()
nodal_variables = nodal_variables + ['DETERMINANT_F'
] # variables smoothing
nodal_variables = nodal_variables + ['MEAN_ERROR'] # removing nodes
#nodal_variables = nodal_variables + ['CAUCHY_STRESS_VECTOR', 'DEFORMATION_GRADIENT'] # transfer variables
for domain in self.meshing_domains:
nodal_variables = nodal_variables + domain.GetVariables()
# print(self._class_prefix()+" Variables added")
return nodal_variables
def InitializeDomains(self):
# initialize the mesher
if (self.echo_level > 1):
print("::[Remesh_Fluid_Domains]:: Initialize Domains ")
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
# find node neighbours
domain_utils.SearchNodeNeighbours(self.main_model_part,
self.echo_level)
# find element neighbours
domain_utils.SearchElementNeighbours(self.main_model_part,
self.echo_level)
# set neighbour search performed
self.neighbour_search_performed = True
# set mesher utilities
self.mesher_utils = KratosDelaunay.MesherUtilities()
# set the domain labels to conditions
self.mesher_utils.SetModelPartNameToConditions(self.main_model_part)
# find skin and boundary normals
if (self.restart == False):
self.BuildMeshBoundaryForFluids()
#domain_utils.ConstructModelPartBoundary(self.main_model_part, self.echo_level)
# search nodal h
if (self.neighbour_search_performed):
domain_utils.SearchNodalH(self.main_model_part,
self.echo_level)
# set the domain labels to nodes
self.mesher_utils.SetModelPartNameToNodes(self.main_model_part)
self.main_model_part.ProcessInfo.SetValue(
KratosDelaunay.INITIALIZED_DOMAINS, True)
if (self.echo_level > 1):
print(self.main_model_part)
def ExecuteInitialize(self):
self.main_model_part = Model[
custom_settings["model_part_name"].GetString()]
self.dimension = self.main_model_part.ProcessInfo[
KratosMultiphysics.SPACE_DIMENSION]
#construct meshing domains
self.meshing_domains = []
domains_list = self.settings["meshing_domains"]
self.number_of_domains = domains_list.size()
for i in range(0, self.number_of_domains):
item = domains_list[i]
domain_module = __import__(item["python_module"].GetString())
domain = domain_module.CreateMeshingDomain(self.main_model_part,
item)
self.meshing_domains.append(domain)
# check restart
self.restart = False
if (self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED]
== True):
self.restart = True
self.step_count = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP]
if self.meshing_control_is_time:
self.next_meshing = self.main_model_part.ProcessInfo[
KratosMultiphysics.TIME]
else:
self.next_meshing = self.main_model_part.ProcessInfo[
KratosMultiphysics.STEP]
# execute initialize base class
if (self.main_model_part.ProcessInfo[KratosPfem.INITIALIZED_DOMAINS] ==
False):
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
domain_utils.InitializeDomains(self.main_model_part,
self.echo_level)
for domain in self.meshing_domains:
domain.Initialize()
def GetVariables(self):
import domain_utilities
nodal_variables = domain_utilities.DomainUtilities().GetVariables()
nodal_variables = nodal_variables + ['RIGID_WALL']
return nodal_variables
def InitializeDomains(self):
print(self._class_prefix() + " Initialize Domains")
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
domain_utils.InitializeDomains(self.main_model_part, self.echo_level)
