def __init__(self, Model, settings):
KratosMultiphysics.Process.__init__(self)
default_settings = KratosMultiphysics.Parameters("""
{
"mesh_id" : 0,
"model_part_name" : "please_specify_model_part_name",
"interval" : [0.0, 1e30],
"variable_name" : "HEIGHT",
"constrained" : false,
"value" : "1.0"
}
"""
)
settings.ValidateAndAssignDefaults(default_settings)
if settings["variable_name"].GetString() == "FREE_SURFACE_ELEVATION":
time_unit_converter = Model["main_model_part"].ProcessInfo.GetValue(KratosShallow.TIME_UNIT_CONVERTER)
free_surface = settings["value"].GetString()
settings["value"].SetString(free_surface + '-z*' + str(time_unit_converter))
settings["variable_name"].SetString("HEIGHT")
import assign_scalar_variable_process
self.process = assign_scalar_variable_process.AssignScalarVariableProcess(Model, settings)
def __init__(self, Model, settings ):
KratosMultiphysics.Process.__init__(self)
default_settings = KratosMultiphysics.Parameters("""
{
"help" : "This process assigns a given value (vector) to the nodes belonging a certain submodelpart",
"mesh_id" : 0,
"model_part_name" : "please_specify_model_part_name",
"variable_name" : "SPECIFY_VARIABLE_NAME",
"interval" : [0.0, 1e30],
"value" : [10.0, "3*t", "x+y"],
"constrained" : [true,true,true],
"local_axes" : {}
}
"""
)
#example of admissible values for "value" : [10.0, "3*t", "x+y"]
##trick to ensure that if someone sets constrained as a single bool, it is transformed to a vector
if(settings.Has("constrained")):
if(settings["constrained"].IsBool()):
is_fixed = settings["constrained"].GetBool()
#print("is_fixed = ",is_fixed)
settings["constrained"] = default_settings["constrained"]
for i in range(3):
settings["constrained"][i].SetBool(is_fixed)
settings.ValidateAndAssignDefaults(default_settings)
self.variable = KratosMultiphysics.KratosGlobals.GetVariable(settings["variable_name"].GetString())
if(type(self.variable) != KratosMultiphysics.Array1DVariable3 and type(self.variable) != KratosMultiphysics.VectorVariable):
msg = "Error in AssignVectorVariableProcess. Variable type of variable : " + settings["variable_name"].GetString() + " is incorrect . Must be a vector or array3"
raise Exception(msg)
self.model_part = Model[settings["model_part_name"].GetString()]
self.aux_processes = []
import assign_scalar_variable_process
# loop over components X, Y and Z
for indice,variable in enumerate(["_X", "_Y", "_Z"]):
if(not settings["value"][indice].IsNull()):
i_params = KratosMultiphysics.Parameters("{}")
i_params.AddValue("model_part_name",settings["model_part_name"])
i_params.AddValue("mesh_id",settings["mesh_id"])
i_params.AddEmptyValue("constrained").SetBool(settings["constrained"][indice].GetBool())
i_params.AddValue("interval",settings["interval"])
i_params.AddValue("value",settings["value"][indice])
i_params.AddEmptyValue("variable_name").SetString(settings["variable_name"].GetString() + variable)
i_params.AddValue("local_axes",settings["local_axes"])
self.aux_processes.append( assign_scalar_variable_process.AssignScalarVariableProcess(Model, i_params) )
def __init__(self, Model, settings):
KratosMultiphysics.Process.__init__(self)
default_settings = KratosMultiphysics.Parameters("""
{
"mesh_id" : 0,
"model_part_name" : "please_specify_model_part_name",
"interval" : [0.0, 1e30],
"variable_name" : "BATYMETRY",
"constrained" : false,
"value" : "z"
}
""")
settings.ValidateAndAssignDefaults(default_settings)
import assign_scalar_variable_process
self.process = assign_scalar_variable_process.AssignScalarVariableProcess(
Model, settings)
def __init__(self, Model, settings):
KratosMultiphysics.Process.__init__(self)
default_settings = KratosMultiphysics.Parameters("""
{
"mesh_id" : 0,
"model_part_name" : "please_specify_model_part_name",
"interval" : [0.0, 1e30],
"variable_name" : "HEIGHT",
"constrained" : false,
"value" : "1.0"
}
"""
)
settings.ValidateAndAssignDefaults(default_settings)
self.variable = settings["variable_name"].GetString()
self.model_part = Model[settings["model_part_name"].GetString()]
import assign_scalar_variable_process
self.process = assign_scalar_variable_process.AssignScalarVariableProcess(Model, settings)
self.variables_utility = KratosShallow.ShallowWaterVariablesUtility(self.model_part)
def __init__(self, Model, settings ):
KratosMultiphysics.Process.__init__(self)
default_settings = KratosMultiphysics.Parameters("""
{
"mesh_id" : 0,
"model_part_name" : "please_specify_model_part_name",
"variable_name" : "SPECIFY_VARIABLE_NAME",
"interval" : [0.0, 1e30],
"modulus" : 1.0,
"constrained" : true,
"direction" : [1.0, 0.0, 0.0],
"local_axes" : {}
}
""")
# Trick: allow "modulus" and "direction" to be a double or a string value (otherwise the ValidateAndAssignDefaults might fail)
if(settings.Has("modulus")):
if(settings["modulus"].IsString()):
default_settings["modulus"].SetString("0.0")
if(settings.Has("direction")):
if(settings["direction"].IsString()):
default_settings["direction"].SetString("Automatic")
# Detect "End" as a tag and replace it by a large number
if(settings.Has("interval")):
if(settings["interval"][1].IsString()):
if(settings["interval"][1].GetString() == "End"):
settings["interval"][1].SetDouble(1e30) # = default_settings["interval"][1]
else:
raise Exception("The second value of interval can be \"End\" or a number, interval currently:"+settings["interval"].PrettyPrintJsonString())
settings.ValidateAndAssignDefaults(default_settings)
self.model_part = Model[settings["model_part_name"].GetString()]
# Construct the component by component parameter objects
x_params = KratosMultiphysics.Parameters("{}")
y_params = KratosMultiphysics.Parameters("{}")
z_params = KratosMultiphysics.Parameters("{}")
# Component X
x_params.AddValue("model_part_name",settings["model_part_name"])
x_params.AddValue("mesh_id",settings["mesh_id"])
x_params.AddValue("constrained",settings["constrained"])
x_params.AddValue("interval",settings["interval"])
x_params.AddEmptyValue("variable_name").SetString(settings["variable_name"].GetString() + "_X")
x_params.AddValue("local_axes",settings["local_axes"])
# Component Y
y_params.AddValue("model_part_name",settings["model_part_name"])
y_params.AddValue("mesh_id",settings["mesh_id"])
y_params.AddValue("constrained",settings["constrained"])
y_params.AddValue("interval",settings["interval"])
y_params.AddEmptyValue("variable_name").SetString(settings["variable_name"].GetString() + "_Y")
y_params.AddValue("local_axes",settings["local_axes"])
# Component Z
z_params.AddValue("model_part_name",settings["model_part_name"])
z_params.AddValue("mesh_id",settings["mesh_id"])
z_params.AddValue("constrained",settings["constrained"])
z_params.AddValue("interval",settings["interval"])
z_params.AddEmptyValue("variable_name").SetString(settings["variable_name"].GetString() + "_Z")
z_params.AddValue("local_axes",settings["local_axes"])
# "Automatic" direction: get the inwards direction
if(settings["direction"].IsString()):
if ((settings["direction"].GetString() == "automatic_inwards_normal") or (settings["direction"].GetString() == "automatic_outwards_normal")):
# Compute the condition normals
KratosMultiphysics.NormalCalculationUtils().CalculateOnSimplex(self.model_part, self.model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE])
# Compute the average conditions normal in the submodelpart of interest
avg_normal = KratosMultiphysics.VariableUtils().SumConditionVectorVariable(KratosMultiphysics.NORMAL, self.model_part)
avg_normal_norm = math.sqrt(pow(avg_normal[0],2) + pow(avg_normal[1],2) + pow(avg_normal[2],2))
if(avg_normal_norm < 1e-6):
raise Exception("Direction norm is close to 0 in AssignVectorByDirectionProcess.")
unit_direction = KratosMultiphysics.Vector(3)
unit_direction = (1/avg_normal_norm)*avg_normal
# Note that the NormalCalculationUtils().CalculateOnSimplex gives the outwards normal vector
if (settings["direction"].GetString() == "automatic_inwards_normal"):
unit_direction = (-1)*unit_direction
# Direction is given as a vector
elif(settings["direction"].IsArray()):
# Normalize direction
direction_norm = math.sqrt(pow(settings["direction"][0].GetDouble(),2) +
pow(settings["direction"][1].GetDouble(),2) +
pow(settings["direction"][2].GetDouble(),2))
if(direction_norm < 1e-6):
raise Exception("Direction norm is close to 0 in AssignVectorByDirectionProcess.")
unit_direction = []
for i in range(0,3):
unit_direction.append(settings["direction"][i].GetDouble()/direction_norm)
# Set the remainding parameters
if(settings["modulus"].IsNumber()):
modulus = settings["modulus"].GetDouble()
x_params.AddEmptyValue("value").SetDouble(modulus*unit_direction[0])
y_params.AddEmptyValue("value").SetDouble(modulus*unit_direction[1])
z_params.AddEmptyValue("value").SetDouble(modulus*unit_direction[2])
elif(settings["modulus"].IsString()):
# The concatenated string is: "direction[i])*(f(x,y,z,t)"
modulus = settings["modulus"].GetString()
x_params.AddEmptyValue("value").SetString("("+str(unit_direction[0])+")*("+modulus+")")
y_params.AddEmptyValue("value").SetString("("+str(unit_direction[1])+")*("+modulus+")")
z_params.AddEmptyValue("value").SetString("("+str(unit_direction[2])+")*("+modulus+")")
# Construct a AssignScalarToNodesProcess for each component
import assign_scalar_variable_process
self.aux_processes = []
self.aux_processes.append( assign_scalar_variable_process.AssignScalarVariableProcess(Model, x_params) )
self.aux_processes.append( assign_scalar_variable_process.AssignScalarVariableProcess(Model, y_params) )
self.aux_processes.append( assign_scalar_variable_process.AssignScalarVariableProcess(Model, z_params) )
def __init__(self, Model, settings ):
KratosMultiphysics.Process.__init__(self)
default_settings = KratosMultiphysics.Parameters("""
{
"mesh_id" : 0,
"model_part_name" : "please_specify_model_part_name",
"variable_name" : "SPECIFY_VARIABLE_NAME",
"interval" : [0.0, 1e30],
"value" : [10.0, "3*t", "x+y"],
"constrained" : [true,true,true],
"local_axes" : {}
}
"""
)
#example of admissible values for "value" : [10.0, "3*t", "x+y"]
##trick to ensure that if someone sets constrained as a single bool, it is transformed to a vector
if(settings.Has("constrained")):
if(settings["constrained"].IsBool()):
is_fixed = settings["constrained"].GetBool()
#print("is_fixed = ",is_fixed)
settings["constrained"] = default_settings["constrained"]
for i in range(3):
settings["constrained"][i].SetBool(is_fixed)
#detect "End" as a tag and replace it by a large number
if(settings.Has("interval")):
if(settings["interval"][1].IsString() ):
if(settings["interval"][1].GetString() == "End"):
settings["interval"][1].SetDouble(1e30) # = default_settings["interval"][1]
else:
raise Exception("the second value of interval can be \"End\" or a number, interval currently:"+settings["interval"].PrettyPrintJsonString())
settings.ValidateAndAssignDefaults(default_settings)
self.variable = KratosMultiphysics.KratosGlobals.GetVariable(settings["variable_name"].GetString())
if(type(self.variable) != KratosMultiphysics.Array1DVariable3 and type(self.variable) != KratosMultiphysics.VectorVariable):
msg = "Error in AssignVectorVariableProcess. Variable type of variable : " + settings["variable_name"].GetString() + " is incorrect . Must be a vector or array3"
raise Exception(msg)
self.model_part = Model[settings["model_part_name"].GetString()]
self.aux_processes = []
import assign_scalar_variable_process
#component X
if(not settings["value"][0].IsNull()):
x_params = KratosMultiphysics.Parameters("{}")
x_params.AddValue("model_part_name",settings["model_part_name"])
x_params.AddValue("mesh_id",settings["mesh_id"])
(x_params.AddEmptyValue("constrained")).SetBool(settings["constrained"][0].GetBool())
x_params.AddValue("interval",settings["interval"])
x_params.AddValue("value",settings["value"][0])
x_params.AddEmptyValue("variable_name").SetString(settings["variable_name"].GetString() + "_X")
x_params.AddValue("local_axes",settings["local_axes"])
self.aux_processes.append( assign_scalar_variable_process.AssignScalarVariableProcess(Model, x_params) )
#component Y
if(not settings["value"][1].IsNull()):
y_params = KratosMultiphysics.Parameters("{}")
y_params.AddValue("model_part_name",settings["model_part_name"])
y_params.AddValue("mesh_id",settings["mesh_id"])
y_params.AddEmptyValue("constrained").SetBool(settings["constrained"][1].GetBool())
y_params.AddValue("interval",settings["interval"])
y_params.AddValue("value",settings["value"][1])
y_params.AddEmptyValue("variable_name").SetString(settings["variable_name"].GetString() + "_Y")
y_params.AddValue("local_axes",settings["local_axes"])
self.aux_processes.append( assign_scalar_variable_process.AssignScalarVariableProcess(Model, y_params) )
#component Z
if(not settings["value"][2].IsNull()):
z_params = KratosMultiphysics.Parameters("{}")
z_params.AddValue("model_part_name",settings["model_part_name"])
z_params.AddValue("mesh_id",settings["mesh_id"])
z_params.AddEmptyValue("constrained").SetBool(settings["constrained"][2].GetBool())
z_params.AddValue("interval",settings["interval"])
z_params.AddValue("value",settings["value"][2])
z_params.AddEmptyValue("variable_name").SetString(settings["variable_name"].GetString() + "_Z")
z_params.AddValue("local_axes",settings["local_axes"])
self.aux_processes.append( assign_scalar_variable_process.AssignScalarVariableProcess(Model, z_params) )
def __init__(self, Model, settings ):
KratosMultiphysics.Process.__init__(self)
default_settings = KratosMultiphysics.Parameters("""
{
"mesh_id" : 0,
"model_part_name" : "",
"variable_name" : "PRESSURE",
"constrained" : true,
"value" : 0.0,
"interval" : [0.0,"End"],
"hydrostatic_outlet" : false,
"h_top" : 0.0
}
""")
# Trick: allows "value" to be a double or a string value (otherwise the ValidateAndAssignDefaults might fail)
if(settings.Has("value")):
if(settings["value"].IsString()):
default_settings["value"].SetString("0.0")
settings.ValidateAndAssignDefaults(default_settings)
# Set a Kratos parameters suitable for the core processes to set the PRESSURE
pres_settings = settings.Clone()
pres_settings.RemoveValue("hydrostatic_outlet")
pres_settings.RemoveValue("h_top")
# Create a copy of the PRESSURE settings to set the EXTERNAL_PRESSURE
ext_pres_settings = pres_settings.Clone()
ext_pres_settings["constrained"].SetBool(False)
ext_pres_settings["variable_name"].SetString("EXTERNAL_PRESSURE")
# Check the core processes input data
if (pres_settings["model_part_name"].GetString() == ""):
raise Exception("Empty outlet pressure model part name. Set a valid model part name.")
elif (ext_pres_settings["model_part_name"].GetString() == ""):
raise Exception("Empty outlet external pressure model part name. Set a valid model part name.")
elif (pres_settings["variable_name"].GetString() != "PRESSURE"):
raise Exception("Outlet pressure settings variable_name is not PRESSURE.")
elif (ext_pres_settings["variable_name"].GetString() != "EXTERNAL_PRESSURE"):
raise Exception("Outlet external pressure settings variable_name is not EXTERNAL_PRESSURE.")
elif (pres_settings["value"].IsString()):
if (pres_settings["value"].GetString == ""):
raise Exception("Outlet pressure function sting is empty.")
elif (ext_pres_settings["value"].IsString()):
if (ext_pres_settings["value"].GetString == ""):
raise Exception("Outlet external pressure function sting is empty.")
self.hydrostatic_outlet = settings["hydrostatic_outlet"].GetBool()
self.h_top = settings["h_top"].GetDouble()
# Set the OUTLET flag in the outlet model part nodes and conditions
self.outlet_model_part = Model[pres_settings["model_part_name"].GetString()]
for node in self.outlet_model_part.Nodes:
node.Set(KratosMultiphysics.OUTLET, True)
for condition in self.outlet_model_part.Conditions:
condition.Set(KratosMultiphysics.OUTLET, True)
# Construct the base process AssignValueProcess
import assign_scalar_variable_process
self.aux_pressure_process = assign_scalar_variable_process.AssignScalarVariableProcess(Model, pres_settings)
self.aux_external_pressure_process = assign_scalar_variable_process.AssignScalarVariableProcess(Model, ext_pres_settings)