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)