def testNutYPlusWallFunctionUpdateProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "NutYPlusWallFunctionUpdateProcess",
"Parameters" : {
"model_part_name" : "FluidModelPart"
}
}
]''')
KratosRANS.RansTestUtilities.RandomFillConditionVariable(
self.model.GetModelPart("FluidModelPart"), KratosRANS.RANS_Y_PLUS,
10.0, 100.0)
test_variables = ["TURBULENT_VISCOSITY", "VISCOSITY"]
test_model_part_name = "FluidModelPart.AutomaticInlet2D_inlet"
test_file_name = "nut_y_plus_wall_function_test_output"
CustomProcessTest.__AddJsonCheckProcess(settings, test_variables,
test_model_part_name,
test_file_name)
# CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name)
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
def testOmegaTurbulentMixingLengthInletProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "OmegaTurbulentMixingLengthInletProcess",
"Parameters" : {
"model_part_name" : "FluidModelPart"
}
}
]''')
Kratos.VariableUtils().AddDof(
KratosRANS.TURBULENT_SPECIFIC_ENERGY_DISSIPATION_RATE,
self.model_part)
test_variables = ["TURBULENT_SPECIFIC_ENERGY_DISSIPATION_RATE"]
test_model_part_name = "FluidModelPart.AutomaticInlet2D_inlet"
test_file_name = "omega_turbulent_mixing_length_inlet_test_output"
CustomProcessTest.__AddJsonCheckProcess(settings, test_variables,
test_model_part_name,
test_file_name)
# CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name)
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
for node in self.model.GetModelPart(test_model_part_name).Nodes:
self.assertEqual(
node.IsFixed(
KratosRANS.TURBULENT_SPECIFIC_ENERGY_DISSIPATION_RATE),
True)
def testWallDistanceCalculationProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "WallDistanceCalculationProcess",
"Parameters" : {
"main_model_part_name" : "FluidModelPart",
"wall_model_part_name" : "FluidModelPart.Slip2D.Slip2D_walls",
"echo_level" : 0,
"max_distance" : 1e+30,
"max_levels" : 14,
"re_calculate_at_each_time_step" : false
}
}
]''')
test_variables = ["DISTANCE"]
test_model_part_name = "FluidModelPart"
test_file_name = "wall_distance_calculation_test_output"
CustomProcessTest.__AddJsonCheckProcess(settings, test_variables,
test_model_part_name,
test_file_name)
# CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name)
CalculateNormalsOnConditions(self.model_part)
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
def testKTurbulentIntensityInletProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "KTurbulentIntensityInletProcess",
"Parameters" : {
"model_part_name" : "FluidModelPart.AutomaticInlet2D_inlet",
"turbulent_intensity" : 0.01
}
}
]''')
Kratos.VariableUtils().AddDof(KratosRANS.TURBULENT_KINETIC_ENERGY,
self.model_part)
test_variables = ["TURBULENT_KINETIC_ENERGY"]
test_model_part_name = "FluidModelPart.AutomaticInlet2D_inlet"
test_file_name = "k_turbulent_intensity_inlet_test_output"
CustomProcessTest.__AddJsonCheckProcess(settings, test_variables,
test_model_part_name,
test_file_name)
# CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name)
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
for node in self.model.GetModelPart(test_model_part_name).Nodes:
self.assertEqual(node.IsFixed(KratosRANS.TURBULENT_KINETIC_ENERGY),
True)
def testClipScalarVariableProcess(self):
self.__CreateModel()
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ClipScalarVariableProcess",
"Parameters" : {
"model_part_name" : "test",
"variable_name" : "DENSITY",
"min_value" : 0.5,
"max_value" : 0.6
}
}
]''')
model_part = self.model["test"]
for node in model_part.Nodes:
density = node.GetSolutionStepValue(Kratos.DENSITY)
node.SetSolutionStepValue(Kratos.DENSITY, 0,
math.pow(-1, node.Id) * density)
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
for node in model_part.Nodes:
density = node.GetSolutionStepValue(Kratos.DENSITY)
self.assertEqual(density >= 0.5, True)
self.assertEqual(density <= 0.6, True)
def _CreateProcesses(self, parameter_name, initialization_order):
"""Create a list of Processes
This method is TEMPORARY to not break existing code
It will be removed in the future
"""
list_of_processes = super(FluidTransportAnalysis, self)._CreateProcesses(parameter_name, initialization_order)
if parameter_name == "processes":
processes_block_names = ["constraints_process_list", "loads_process_list","auxiliar_process_list"]
if len(list_of_processes) == 0: # Processes are given in the old format
KratosMultiphysics.Logger.PrintInfo(self._GetSimulationName(), "Using the old way to create the processes, this will be removed!")
from KratosMultiphysics.process_factory import KratosProcessFactory
factory = KratosProcessFactory(self.model)
for process_name in processes_block_names:
if (self.project_parameters.Has(process_name) is True):
list_of_processes += factory.ConstructListOfProcesses(self.project_parameters[process_name])
else: # Processes are given in the new format
for process_name in processes_block_names:
if (self.project_parameters.Has(process_name) is True):
raise Exception("Mixing of process initialization is not alowed!")
elif parameter_name == "output_processes":
if self.project_parameters.Has("output_configuration"):
gid_output= self._SetUpGiDOutput()
list_of_processes += [gid_output,]
else:
raise NameError("wrong parameter name")
return list_of_processes
def testComputeReactionsProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ComputeReactionsProcess",
"Parameters" : {
"model_part_name" : "FluidModelPart"
}
}
]''')
KratosRANS.RansTestUtilities.RandomFillConditionVariable(
self.model.GetModelPart("FluidModelPart"),
KratosRANS.FRICTION_VELOCITY, 10.0, 100.0)
test_variables = ["REACTION"]
test_model_part_name = "FluidModelPart.Slip2D.Slip2D_walls"
test_file_name = "compute_reactions_test_output"
CustomProcessTest.__AddJsonCheckProcess(settings, test_variables,
test_model_part_name,
test_file_name)
# CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name)
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
def testNutKEpsilonHighReCalculationProcess(self):
self.__CreateModel()
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "NutKEpsilonHighReCalculationProcess",
"Parameters" : {
"model_part_name" : "test",
"echo_level" : 0,
"c_mu" : 0.09
}
}
]''')
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
c_mu = 0.09
for node in self.model_part.Nodes:
k = node.GetSolutionStepValue(KratosRANS.TURBULENT_KINETIC_ENERGY)
epsilon = node.GetSolutionStepValue(
KratosRANS.TURBULENT_ENERGY_DISSIPATION_RATE)
node_value = node.GetSolutionStepValue(Kratos.TURBULENT_VISCOSITY)
self.assertAlmostEqual(node_value, c_mu * k * k / epsilon, 9)
def Initialize(self):
factory = KratosProcessFactory(self.GetBaseModelPart().GetModel())
self.auxiliar_process_list = factory.ConstructListOfProcesses(
self.GetParameters()["auxiliar_process_list"])
for process in self.auxiliar_process_list:
self.AddProcess(process)
super().Initialize()
def testVectorAlignProcessNormal(self):
self.__CreateModel()
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "VectorAlignProcess",
"Parameters" : {
"model_part_name" : "test.submodelpart_1",
"input_variable_name" : "VELOCITY",
"output_variable_name" : "VELOCITY",
"alignment_variable_name" : "NORMAL",
"is_tangential_alignment" : false,
"echo_level" : 0
}
}
]''')
node_ids = [1, 2, 3]
check_values = []
for node in self.model_part.Nodes:
if (node.Id in node_ids):
normal = node.GetSolutionStepValue(Kratos.NORMAL)
normal_magnitude = float(
math.pow(
normal[0] * normal[0] + normal[1] * normal[1] +
normal[2] * normal[2], 0.5))
unit_normal = [
normal[0] / normal_magnitude, normal[1] / normal_magnitude,
normal[2] / normal_magnitude
]
vector = node.GetSolutionStepValue(Kratos.VELOCITY)
vector_normal_magnitude = float(vector[0] * unit_normal[0] +
vector[1] * unit_normal[1] +
vector[2] * unit_normal[2])
check_values.append([
vector_normal_magnitude * unit_normal[0],
vector_normal_magnitude * unit_normal[1],
vector_normal_magnitude * unit_normal[2]
])
else:
vector = node.GetSolutionStepValue(Kratos.VELOCITY)
check_values.append(
[float(vector[0]),
float(vector[1]),
float(vector[2])])
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
for node, value in zip(self.model_part.Nodes, check_values):
node_value = node.GetSolutionStepValue(Kratos.VELOCITY)
for i in range(3):
self.assertAlmostEqual(node_value[i], value[i], 9)
def _CreateProcesses(self, parameter_name, initialization_order):
"""Create a list of Processes
This method is TEMPORARY to not break existing code
It will be removed in the future
"""
list_of_processes = super(StructuralMechanicsAnalysis,
self)._CreateProcesses(
parameter_name, initialization_order)
if parameter_name == "processes":
processes_block_names = [
"constraints_process_list", "loads_process_list",
"list_other_processes", "json_output_process",
"json_check_process", "check_analytic_results_process",
"contact_process_list"
]
if len(
list_of_processes
) == 0: # Processes are given in the old format (or no processes are specified)
deprecation_warning_issued = False
from KratosMultiphysics.process_factory import KratosProcessFactory
factory = KratosProcessFactory(self.model)
for process_name in processes_block_names:
if self.project_parameters.Has(process_name):
if not deprecation_warning_issued:
info_msg = "Using the old way to create the processes, this will be removed!\n"
info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-"
info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" "
info_msg += "for a description of the new format"
KratosMultiphysics.Logger.PrintWarning(
"StructuralMechanicsAnalysis", info_msg)
deprecation_warning_issued = True
list_of_processes += factory.ConstructListOfProcesses(
self.project_parameters[process_name])
else: # Processes are given in the new format
for process_name in processes_block_names:
if self.project_parameters.Has(process_name):
raise Exception(
"Mixing of process initialization is not allowed!")
elif parameter_name == "output_processes":
if self.project_parameters.Has("output_configuration"):
info_msg = "Using the old way to create the gid-output, this will be removed!\n"
info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-"
info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" "
info_msg += "for a description of the new format"
KratosMultiphysics.Logger.PrintWarning(
"StructuralMechanicsAnalysis", info_msg)
gid_output = self._SetUpGiDOutput()
list_of_processes += [
gid_output,
]
else:
raise NameError("wrong parameter name")
return list_of_processes
def testVectorCellCenterAveragingProcess(self):
self.__CreateModel()
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "FindNodalNeighboursProcess",
"Parameters" : {
"model_part_name" : "test"
}
},
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "FindConditionParentProcess",
"Parameters" : {
"model_part_name" : "test.submodelpart_1"
}
},
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "VectorCellCenteredAveragingProcess",
"Parameters" : {
"echo_level" : 0,
"model_part_name" : "test.submodelpart_1",
"input_variable_name" : "VELOCITY",
"output_variable_name" : "VELOCITY"
}
}
]''')
check_values = []
for node in self.model_part.Nodes:
velocity = node.GetSolutionStepValue(Kratos.VELOCITY)
check_values.append(
[float(velocity[0]),
float(velocity[1]),
float(velocity[2])])
for i in range(3):
check_values[0][i] = check_values[5][i] / 3.0
check_values[1][
i] = check_values[5][i] / 6.0 + check_values[4][i] / 6.0
check_values[2][i] = check_values[4][i] / 3.0
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
for node, value in zip(self.model_part.Nodes, check_values):
node_value = node.GetSolutionStepValue(Kratos.VELOCITY)
for i in range(3):
self.assertAlmostEqual(node_value[i], value[i], 9)
def _CreateProcesses(self, parameter_name, initialization_order):
"""Create a list of Processes"""
list_of_processes = super(ParticleMechanicsAnalysis,
self)._CreateProcesses(
parameter_name, initialization_order)
if parameter_name == "processes":
processes_block_names = [
"constraints_process_list", "loads_process_list",
"list_other_processes", "gravity"
]
if len(list_of_processes
) == 0: # Processes are given in the old format
info_msg = "Using the old way to create the processes, this will be removed!\n"
info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-"
info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" "
info_msg += "for a description of the new format"
KratosMultiphysics.Logger.PrintWarning(
"ParticleMechanicsAnalysis", info_msg)
from KratosMultiphysics.process_factory import KratosProcessFactory
factory = KratosProcessFactory(self.model)
for process_name in processes_block_names:
if (self.project_parameters.Has(process_name) is True):
list_of_processes += factory.ConstructListOfProcesses(
self.project_parameters[process_name])
else: # Processes are given in the new format
for process_name in processes_block_names:
if (self.project_parameters.Has(process_name) is True):
raise Exception(
"Mixing of process initialization is not allowed!")
elif parameter_name == "output_processes":
if self.project_parameters.Has("grid_output_configuration"
) or self.project_parameters.Has(
"body_output_configuration"):
info_msg = "Using the old way to create the gid-output for grid, this will be removed!\n"
info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-"
info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" "
info_msg += "for a description of the new format"
KratosMultiphysics.Logger.PrintInfo(
"ParticleMechanicsAnalysis", info_msg)
if self.project_parameters.Has("grid_output_configuration"):
grid_gid_output = self._SetUpGiDOutput("grid_output")
list_of_processes += [
grid_gid_output,
]
if self.project_parameters.Has("body_output_configuration"):
mp_gid_output = self._SetUpGiDOutput("body_output")
list_of_processes += [
mp_gid_output,
]
else:
raise NameError("wrong parameter name")
return list_of_processes
def __TestMethod(self, settings):
factory = KratosProcessFactory(self.current_model)
self.process_list = factory.ConstructListOfProcesses(settings)
InitializeProcesses(self)
for step in range(0, 12, 2):
self.model_part.CloneTimeStep(step)
self.model_part.ProcessInfo[Kratos.STEP] = step
InitializeModelPartVariables(self.model_part, False)
ExecuteProcessFinalizeSolutionStep(self)
for process in self.process_list:
process.ExecuteFinalize()
def testApplyFlagProcess(self):
self.__CreateModel()
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ApplyFlagProcess",
"Parameters" : {
"model_part_name" : "test.submodelpart_1",
"echo_level" : 0,
"flag_variable_name" : "STRUCTURE",
"flag_variable_value" : true,
"apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"]
}
},
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ApplyFlagProcess",
"Parameters" : {
"model_part_name" : "test.submodelpart_2",
"echo_level" : 0,
"flag_variable_name" : "INLET",
"flag_variable_value" : true,
"apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"]
}
}
]''')
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
check_values = [True, True, True, False, False, False]
for node, value in zip(self.model_part.Nodes, check_values):
self.assertEqual(node.Is(Kratos.STRUCTURE), value)
check_values = [False, False, True, True, True, False]
for node, value in zip(self.model_part.Nodes, check_values):
self.assertEqual(node.Is(Kratos.INLET), value)
check_values = [True, True, False, False, False, False]
for condition, value in zip(self.model_part.Conditions, check_values):
self.assertEqual(condition.Is(Kratos.STRUCTURE), value)
check_values = [False, False, True, True, False, False]
for condition, value in zip(self.model_part.Conditions, check_values):
self.assertEqual(condition.Is(Kratos.INLET), value)
def testLogarithmicYPlusCalculationProcess(self):
self.__CreateModel()
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "LogarithmicYPlusCalculationProcess",
"Parameters" : {
"model_part_name" : "test",
"echo_level" : 0,
"step" : 0,
"max_iterations" : 10,
"tolerance" : 1e-6,
"constants": {
"von_karman" : 0.41,
"beta" : 5.2
}
}
}
]''')
# for node, distance in zip(self.model_part.Nodes, distance_value):
# node.SetSolutionStepValue(Kratos.DISTANCE, 0, distance)
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
beta = 5.2
von_karman = 0.41
for node in self.model_part.Nodes:
y_plus = node.GetSolutionStepValue(KratosRANS.RANS_Y_PLUS)
nu = node.GetSolutionStepValue(Kratos.KINEMATIC_VISCOSITY)
y = node.GetSolutionStepValue(Kratos.DISTANCE)
u = node.GetSolutionStepValue(Kratos.VELOCITY)
if (y > 0.0):
u_tau = y_plus * nu / y
u_plus = math.sqrt(u[0] * u[0] + u[1] * u[1] +
u[2] * u[2]) / u_tau
if (y_plus > 11.06):
self.assertAlmostEqual(
u_plus, 1 / von_karman * math.log(y_plus) + beta, 9)
print("Checked logarithmic region...")
else:
self.assertAlmostEqual(u_plus, y_plus, 9)
print("Checked linear region...")
else:
self.assertAlmostEqual(y_plus, 0.0, 9)
def testApplyFlagProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ApplyFlagProcess",
"Parameters" : {
"model_part_name" : "FluidModelPart.Slip2D.Slip2D_walls",
"echo_level" : 0,
"flag_variable_name" : "STRUCTURE",
"flag_variable_value" : true,
"apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"]
}
},
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ApplyFlagProcess",
"Parameters" : {
"model_part_name" : "FluidModelPart.AutomaticInlet2D_inlet",
"echo_level" : 0,
"flag_variable_name" : "INLET",
"flag_variable_value" : true,
"apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"]
}
}
]''')
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
for node in self.model.GetModelPart(
"FluidModelPart.AutomaticInlet2D_inlet").Nodes:
self.assertEqual(node.Is(Kratos.INLET), True)
for condition in self.model.GetModelPart(
"FluidModelPart.AutomaticInlet2D_inlet").Conditions:
self.assertEqual(condition.Is(Kratos.INLET), True)
self.assertEqual(condition.Is(Kratos.STRUCTURE), False)
for node in self.model.GetModelPart(
"FluidModelPart.Slip2D.Slip2D_walls").Nodes:
self.assertEqual(node.Is(Kratos.STRUCTURE), True)
for condition in self.model.GetModelPart(
"FluidModelPart.Slip2D.Slip2D_walls").Conditions:
self.assertEqual(condition.Is(Kratos.STRUCTURE), True)
self.assertEqual(condition.Is(Kratos.INLET), False)
def testScalarCellCenterAveragingProcess(self):
self.__CreateModel()
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "FindNodalNeighboursProcess",
"Parameters" : {
"model_part_name" : "test"
}
},
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "FindConditionParentProcess",
"Parameters" : {
"model_part_name" : "test.submodelpart_1"
}
},
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ScalarCellCenteredAveragingProcess",
"Parameters" : {
"echo_level" : 0,
"model_part_name" : "test.submodelpart_1",
"input_variable_name" : "DENSITY",
"output_variable_name" : "DENSITY"
}
}
]''')
check_values = []
for node in self.model_part.Nodes:
check_values.append(node.GetSolutionStepValue(Kratos.DENSITY))
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
check_values[0] = check_values[5] / 3.0
check_values[1] = check_values[5] / 6.0 + check_values[4] / 6.0
check_values[2] = check_values[4] / 3.0
for node, value in zip(self.model_part.Nodes, check_values):
self.assertAlmostEqual(node.GetSolutionStepValue(Kratos.DENSITY),
value, 9)
def _CreateProcesses(self, parameter_name, initialization_order):
"""Create a list of Processes
This method is TEMPORARY to not break existing code
It will be removed in the future
"""
list_of_processes = super(FluidDynamicsAnalysis,
self)._CreateProcesses(
parameter_name, initialization_order)
# The list of processes will contain a list with each individual process already constructed (boundary conditions, initial conditions and gravity)
# Note 1: gravity is constructed first. Outlet process might need its information.
# Note 2: initial conditions are constructed before BCs. Otherwise, they may overwrite the BCs information.
if parameter_name == "processes":
processes_block_names = [
"gravity", "initial_conditions_process_list",
"boundary_conditions_process_list", "auxiliar_process_list"
]
if len(list_of_processes
) == 0: # Processes are given in the old format
info_msg = "Using the old way to create the processes, this will be removed!\n"
info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-"
info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" "
info_msg += "for a description of the new format"
Kratos.Logger.PrintWarning("FluidDynamicsAnalysis", info_msg)
factory = KratosProcessFactory(self.model)
for process_name in processes_block_names:
if (self.project_parameters.Has(process_name) is True):
list_of_processes += factory.ConstructListOfProcesses(
self.project_parameters[process_name])
else: # Processes are given in the new format
for process_name in processes_block_names:
if (self.project_parameters.Has(process_name) is True):
raise Exception(
"Mixing of process initialization is not alowed!")
elif parameter_name == "output_processes":
if self.project_parameters.Has("output_configuration"):
info_msg = "Using the old way to create the gid-output, this will be removed!\n"
info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-"
info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" "
info_msg += "for a description of the new format"
Kratos.Logger.PrintWarning("FluidDynamicsAnalysis", info_msg)
gid_output = self._SetUpGiDOutput()
list_of_processes += [
gid_output,
]
else:
raise NameError("wrong parameter name")
return list_of_processes
def _CreateProcesses(self, parameter_name, initialization_order):
"""Create a list of Processes
This method is TEMPORARY to not break existing code
It will be removed in the future
"""
list_of_processes = super(AdjointFluidAnalysis, self)._CreateProcesses(
parameter_name, initialization_order)
# The list of processes will contain a list with each individual process already constructed (boundary conditions, initial conditions and gravity)
# Note 1: gravity is constructed first. Outlet process might need its information.
# Note 2: initial conditions are constructed before BCs. Otherwise, they may overwrite the BCs information.
if parameter_name == "processes":
processes_block_names = [
"gravity", "initial_conditions_process_list",
"boundary_conditions_process_list", "auxiliar_process_list"
]
if len(list_of_processes
) == 0: # Processes are given in the old format
Kratos.Logger.PrintWarning(
self.__class__.__name__,
"Using the old way to create the processes, this will be removed!"
)
factory = KratosProcessFactory(self.model)
for process_name in processes_block_names:
if (self.project_parameters.Has(process_name) is True):
list_of_processes += factory.ConstructListOfProcesses(
self.project_parameters[process_name])
else: # Processes are given in the new format
for process_name in processes_block_names:
if (self.project_parameters.Has(process_name) is True):
raise Exception(
"Mixing of process initialization is not alowed!")
elif parameter_name == "output_processes":
if self.project_parameters.Has("output_configuration"):
Kratos.Logger.PrintWarning(
self.__class__.__name__,
"Using the old way to create the gid-output, this will be removed!"
)
gid_output = self._SetUpGiDOutput()
list_of_processes += [
gid_output,
]
else:
raise NameError("wrong parameter name")
return list_of_processes
def Initialize(self):
self.PrepareSolvingStrategy()
factory = KratosProcessFactory(self.model)
self.auxiliar_process_list = factory.ConstructListOfProcesses(
self.settings["auxiliar_process_list"])
for process in self.auxiliar_process_list:
self.GetTurbulenceSolvingProcess().AddAuxiliaryProcess(process)
process.ExecuteInitialize()
self.GetTurbulenceSolvingProcess().ExecuteInitialize()
for strategy in self.strategies_list:
strategy.Initialize()
Kratos.Logger.PrintInfo(self.__class__.__name__,
"Initialization successfull.")
def testCheckScalarBoundsProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "CheckScalarBoundsProcess",
"Parameters" : {
"model_part_name" : "FluidModelPart",
"variable_name" : "DENSITY"
}
}
]''')
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
def testWallDistanceCalculationProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ApplyFlagProcess",
"Parameters" : {
"model_part_name" : "test.Slip2D.Slip2D_walls",
"echo_level" : 0,
"flag_variable_name" : "STRUCTURE",
"flag_variable_value" : true,
"apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"]
}
},
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "WallDistanceCalculationProcess",
"Parameters" : {
"model_part_name" : "test",
"max_iterations" : 10,
"echo_level" : 0,
"wall_flag_variable_name" : "STRUCTURE",
"wall_flag_variable_value" : true,
"re_calculate_at_each_time_step" : false,
"correct_distances_using_neighbors": true,
"linear_solver_settings" : {
"solver_type" : "amgcl"
}
}
}
]''')
test_variables = ["DISTANCE"]
test_model_part_name = "test"
test_file_name = "wall_distance_calculation_test_output"
CustomProcessTest.__AddJsonCheckProcess(settings, test_variables,
test_model_part_name,
test_file_name)
# CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name)
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
def testWallDistanceCalculationProcess(self):
self.__CreateModel(
variable_list=[Kratos.DISTANCE, Kratos.FLAG_VARIABLE])
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ApplyFlagProcess",
"Parameters" : {
"model_part_name" : "test.submodelpart_1",
"echo_level" : 0,
"flag_variable_name" : "STRUCTURE",
"flag_variable_value" : true,
"apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"]
}
},
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "WallDistanceCalculationProcess",
"Parameters" : {
"model_part_name" : "test",
"max_iterations" : 1000,
"echo_level" : 0,
"wall_flag_variable_name" : "STRUCTURE",
"wall_flag_variable_value" : true,
"linear_solver_settings" : {
"solver_type" : "amgcl"
}
}
}
]''')
check_values = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
for node, value in zip(self.model_part.Nodes, check_values):
node_value = node.GetSolutionStepValue(Kratos.DISTANCE)
self.assertAlmostEqual(node_value, value, 9)
def _CreateProcesses(self, parameter_name, initialization_order):
"""Create a list of processes
Format:
"processes" : {
initial_processes : [
{ proces_specific_params },
{ proces_specific_params }
],
boundary_processes : [
{ proces_specific_params },
{ proces_specific_params }
]
}
The order of intialization can be specified by setting it in "initialization_order"
if e.g. the "boundary_processes" should be constructed before the "initial_processes", then
initialization_order should be a list containing ["boundary_processes", "initial_processes"]
see the functions _GetOrderOfProcessesInitialization and _GetOrderOfOutputProcessesInitialization
"""
list_of_processes = []
factory = KratosProcessFactory(self.model)
if self.project_parameters.Has(parameter_name):
processes_params = self.project_parameters[parameter_name]
# first initialize the processes that depend on the order
for processes_names in initialization_order:
if processes_params.Has(processes_names):
list_of_processes += factory.ConstructListOfProcesses(
processes_params[processes_names])
# then initialize the processes that don't depend on the order
for name, value in processes_params.items():
if not name in initialization_order:
list_of_processes += factory.ConstructListOfProcesses(
value
) # Does this work? or should it be processes[name]
return list_of_processes
def testLogarithmicYPlusVelocitySensitivitiesProcessFlow(self):
self.__CreateModel()
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "LogarithmicYPlusCalculationProcess",
"Parameters" : {
"model_part_name" : "test",
"echo_level" : 0,
"max_iterations" : 10,
"tolerance" : 1e-6,
"constants": {
"von_karman" : 0.41,
"beta" : 5.2
}
}
},
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "LogarithmicYPlusVelocitySensitivitiesProcess",
"Parameters" : {
"model_part_name" : "test",
"echo_level" : 0,
"constants": {
"von_karman" : 0.41,
"beta" : 5.2
}
}
}
]''')
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
def testClipScalarVariableProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "ClipScalarVariableProcess",
"Parameters" : {
"model_part_name" : "FluidModelPart",
"variable_name" : "DENSITY",
"min_value" : 20.0,
"max_value" : 60.0
}
}
]''')
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
for node in self.model_part.Nodes:
density = node.GetSolutionStepValue(Kratos.DENSITY)
self.assertEqual(density >= 20.0, True)
self.assertEqual(density <= 60.0, True)
def testNutKOmegaSSTUpdateProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "NutKOmegaSSTUpdateProcess",
"Parameters" : {
"model_part_name" : "FluidModelPart"
}
}
]''')
test_variables = ["TURBULENT_VISCOSITY", "VISCOSITY"]
test_model_part_name = "FluidModelPart.AutomaticInlet2D_inlet"
test_file_name = "nut_k_omega_sst_test_output"
CustomProcessTest.__AddJsonCheckProcess(settings, test_variables,
test_model_part_name,
test_file_name)
# CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name)
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self.__ExecuteProcesses()
def _RunProcessTest(self, settings):
with UnitTest.WorkFolderScope(".", __file__):
factory = KratosProcessFactory(self.model)
self.process_list = factory.ConstructListOfProcesses(settings)
self._ExecuteProcesses()
def RunTemporalStatisticsTest(self, norm_type, container_name):
settings = TemporalMaxMethodHelperClass.__GetDefaultParameters(
norm_type, container_name)
input_method = TemporalMaxMethodHelperClass.GetInputMethod(
container_name)
output_method = TemporalMaxMethodHelperClass.GetOutputMethod(
container_name)
container = self.GetContainer(container_name)
factory = KratosProcessFactory(self.GetModel())
self.process_list = factory.ConstructListOfProcesses(settings)
InitializeProcesses(self)
scalar_list, vec_3d_list, vec_list, mat_list = InitializeContainerArrays(
container)
step_list = []
for step in range(0, 12, 2):
self.model_part.CloneTimeStep(step)
InitializeModelPartVariables(self.GetModelPart())
ExecuteProcessFinalizeSolutionStep(self)
step_list.append(step)
for index, item in enumerate(container):
current_scalar = input_method(item, Kratos.PRESSURE)
current_vector_3d = input_method(item, Kratos.VELOCITY)
current_vector = input_method(item, Kratos.LOAD_MESHES)
current_matrix = input_method(
item, Kratos.GREEN_LAGRANGE_STRAIN_TENSOR)
if (step >= 0):
scalar_list[index].append(current_scalar)
vec_3d_list[index].append(current_vector_3d)
vec_list[index].append(current_vector)
mat_list[index].append(current_matrix)
analytical_method_scalar = TemporalMaxMethodHelperClass.__AnalyticalMethod(
norm_type, Kratos.PRESSURE, scalar_list[index], step_list)
analytical_method_vec_3d = TemporalMaxMethodHelperClass.__AnalyticalMethod(
norm_type, Kratos.VELOCITY, vec_3d_list[index], step_list)
analytical_method_vec = TemporalMaxMethodHelperClass.__AnalyticalMethod(
norm_type, Kratos.LOAD_MESHES, vec_list[index], step_list)
analytical_method_mat = TemporalMaxMethodHelperClass.__AnalyticalMethod(
norm_type, Kratos.GREEN_LAGRANGE_STRAIN_TENSOR,
mat_list[index], step_list)
mean_method_scalar = output_method(item,
KratosStats.SCALAR_NORM)
mean_method_vec_3d = output_method(item,
KratosStats.VECTOR_3D_NORM)
mean_method_vec = output_method(item, Kratos.DENSITY)
mean_method_mat = output_method(item, Kratos.VISCOSITY)
variance_method_scalar = output_method(item,
Kratos.YIELD_STRESS)
variance_method_vec_3d = output_method(item,
Kratos.CUTTED_AREA)
variance_method_vec = output_method(item,
Kratos.NET_INPUT_MATERIAL)
variance_method_mat = output_method(item, Kratos.WET_VOLUME)
CheckValues(self, analytical_method_scalar[0],
mean_method_scalar, 8)
CheckValues(self, analytical_method_vec_3d[0],
mean_method_vec_3d, 8)
CheckValues(self, analytical_method_vec[0], mean_method_vec, 8)
CheckValues(self, analytical_method_mat[0], mean_method_mat, 8)
CheckValues(self, analytical_method_scalar[1],
variance_method_scalar, 8)
CheckValues(self, analytical_method_vec_3d[1],
variance_method_vec_3d, 8)
CheckValues(self, analytical_method_vec[1],
variance_method_vec, 8)
CheckValues(self, analytical_method_mat[1],
variance_method_mat, 8)
