def InitializeSolutionStep(self):
csprint(
0,
bold("time={0:.12g}".format(self.time) + " | step=" +
str(self.step)))
self._GetSolver().InitializeSolutionStep()
def __GetMapper(self, from_client, to_client, data_settings):
data_name = data_settings["data_name"]
data_definition_from = from_client.GetDataDefinition(data_name)
data_definition_to = to_client.GetDataDefinition(data_name)
geometry_name_from = data_definition_from["geometry_name"]
geometry_name_to = data_definition_to["geometry_name"]
mapper = None
is_inverse_mapper = False
if geometry_name_from in self.mappers: # a "Map"-Mapper exists
if geometry_name_to in self.mappers[geometry_name_from]:
mapper = self.mappers[geometry_name_from][geometry_name_to]
if mapper == None and geometry_name_to in self.mappers: # an "InverseMap"-Mapper exists
if geometry_name_from in self.mappers[geometry_name_to]:
mapper = self.mappers[geometry_name_to][geometry_name_from]
is_inverse_mapper = True
if mapper == None: # no mapper for this geometry-pair exists, initializing a "Map"-Mapper
if not geometry_name_from in self.mappers:
self.mappers[geometry_name_from] = {}
client_mesh_from = from_client.model[geometry_name_from]
client_mesh_to = to_client.model[geometry_name_to]
mapper_settings = KratosMultiphysics.Parameters("""{
"mapper_type" : ""
}""")
mapper_settings["mapper_type"].SetString(
data_settings["io_settings"]["mapper_type"])
if from_client.IsDistributed() or to_client.IsDistributed():
mapper = KratosMapping.MapperFactory.CreateMPIMapper(
client_mesh_from, client_mesh_to, mapper_settings)
else:
mapper = KratosMapping.MapperFactory.CreateMapper(
client_mesh_from, client_mesh_to, mapper_settings)
self.mappers[geometry_name_from][geometry_name_to] = mapper
# Printing information related to mapping
if self.echo_level > 2:
info_msg = bold(
"Mapper created"
) + ' for solver "' + self.solver_name + '": from "'
info_msg += from_client._Name(
) + ':' + geometry_name_from + '" to "'
info_msg += to_client._Name() + ':' + geometry_name_to + '"'
csprint(self.lvl, info_msg)
return mapper, is_inverse_mapper
def Initialize(self):
csprint(self.lvl, yellow(self.__class__.__name__ + ":") + " Starting to initialize Empire")
import empire_wrapper
csprint(self.lvl, yellow(self.__class__.__name__ + ":") + " Wrapper-Import Successful")
self.empire = empire_wrapper.EmpireWrapper()
csprint(self.lvl, yellow(self.__class__.__name__ + ":") + " Wrapper Created")
self.empire.Connect(self.xml_file_name)
self.empire.ReceiveMesh("client_mesh", self.client_model_part)
def __Map(self, from_client, to_client, data_settings):
mapper, is_inverse_mapper = self.__GetMapper(from_client, to_client,
data_settings)
data_name = data_settings["data_name"]
data_definition_from = from_client.GetDataDefinition(data_name)
data_definition_to = to_client.GetDataDefinition(data_name)
if is_inverse_mapper:
var_origin = self.__GetKratosVariable(
data_definition_to["data_identifier"])
var_dest = self.__GetKratosVariable(
data_definition_from["data_identifier"])
else:
var_origin = self.__GetKratosVariable(
data_definition_from["data_identifier"])
var_dest = self.__GetKratosVariable(
data_definition_to["data_identifier"])
var_origin_for_mapping = var_origin
var_dest_for_mapping = var_dest
mapper_flags = KratosMultiphysics.Flags()
if "mapper_args" in data_settings["io_settings"]:
for flag_name in data_settings["io_settings"]["mapper_args"]:
mapper_flags |= self.mapper_flags[flag_name]
if "type_of_quantity" in data_definition_from:
if data_definition_from["type_of_quantity"] == "nodal_point":
redistribution_tolerance = 1e-8
redistribution_max_iters = 50
geometry_name = data_definition_from["geometry_name"]
# Convert the nodal point quantities to distributed quantities before mapping
errr #Talk to Philipp befoe using this => VAUX_EQ_TRACTION has to be added to the ModelPart!
KratosMultiphysics.VariableRedistributionUtility.DistributePointValues(
from_client.model[geometry_name], var_origin,
KratosMultiphysics.VAUX_EQ_TRACTION,
redistribution_tolerance, redistribution_max_iters)
var_origin_for_mapping = KratosMultiphysics.VAUX_EQ_TRACTION
if self.echo_level > -1:
info_msg = bold("Distributing Point Values of ")
info_msg += bold("Variable: ") + var_origin.Name()
info_msg += bold(" On: ") + geometry_name
csprint(self.lvl, info_msg)
distribute_on_dest = False
if "type_of_quantity" in data_definition_to:
if data_definition_to["type_of_quantity"] == "nodal_point":
var_dest_for_mapping = KratosMultiphysics.VAUX_EQ_TRACTION
distribute_on_dest = True
if is_inverse_mapper:
mapper.InverseMap(var_origin_for_mapping, var_dest_for_mapping,
mapper_flags)
else:
mapper.Map(var_origin_for_mapping, var_dest_for_mapping,
mapper_flags)
if distribute_on_dest:
geometry_name = data_definition_to["geometry_name"]
# Convert the transferred traction loads to point loads
KratosMultiphysics.VariableRedistributionUtility.ConvertDistributedValuesToPoint(
to_client.model[geometry_name],
KratosMultiphysics.VAUX_EQ_TRACTION, var_dest)
if self.echo_level > -1:
info_msg = bold(
"Converting Distributed-Values to Point-Values ")
info_msg += bold("Variable: ") + var_dest.Name()
info_msg += bold(" On: ") + geometry_name
csprint(self.lvl, info_msg)
if self.echo_level > 3:
pre_string = ""
if is_inverse_mapper:
pre_string = "Inverse-"
info_msg = bold(pre_string + "Mapping with: ")
info_msg += bold("Origin_Variable: ") + var_origin.Name() + " | "
info_msg += bold("Destination_Variable: ") + var_dest.Name()
if "mapper_args" in data_settings["io_settings"]:
info_msg += " | " + bold("Mapper-Flags: ") + ", ".join(
data_settings["io_settings"]["mapper_args"])
csprint(self.lvl, info_msg)