def CreateBoundingBoxMesh(self, bounding_box, model_part):
# construct bounding box mesh of surface elements
# Note: new nodes must be inserted in boundary conditions subdomains
number_of_linear_partitions = 10
number_of_angular_partitions = 20
bounding_box.CreateBoundingBoxBoundaryMesh(
model_part, number_of_linear_partitions,
number_of_angular_partitions)
# set flag RIGID to the mesh elements and nodes
for node in model_part.Nodes:
node.Set(KratosMultiphysics.RIGID)
for element in model_part.Elements:
element.Set(KratosMultiphysics.RIGID)
#in order to write them
element.Set(KratosMultiphysics.ACTIVE)
# set mesh upper and lower points
upper_point = KratosMultiphysics.Array3()
upper = self.GetUpperPoint(model_part)
#print("upper",upper)
for i in range(0, len(upper)):
upper_point[i] = upper[i]
bounding_box.SetUpperPoint(upper_point)
lower_point = KratosMultiphysics.Array3()
lower = self.GetLowerPoint(model_part)
#print("lower",lower)
for i in range(0, len(lower)):
lower_point[i] = lower[i]
bounding_box.SetLowerPoint(lower_point)
print(self._class_prefix() + " Bounding Box Mesh Created")
def _DetectBoundingBox(self, mp):
min_corner = KratosMultiphysics.Array3()
min_corner[0] = 1e20
min_corner[1] = 1e20
min_corner[2] = 1e20
max_corner = KratosMultiphysics.Array3()
max_corner[0] = -1e20
max_corner[1] = -1e20
max_corner[2] = -1e20
for node in mp.Nodes:
x = node.X
min_corner[0] = min(min_corner[0], x)
max_corner[0] = max(max_corner[0], x)
y = node.Y
min_corner[1] = min(min_corner[1], y)
max_corner[1] = max(max_corner[1], y)
z = node.Z
min_corner[2] = min(min_corner[2], z)
max_corner[2] = max(max_corner[2], z)
KratosMultiphysics.Logger.PrintInfo(self._GetSimulationName(), "Boundng box detected")
KratosMultiphysics.Logger.PrintInfo(self._GetSimulationName(), "Min. corner = ", min_corner)
KratosMultiphysics.Logger.PrintInfo(self._GetSimulationName(), "Max. corner = ", max_corner)
return min_corner, max_corner
def SettingGeometricalSPValues(self):
self.center = KratosMultiphysics.Array3()
self.center[0] = 0
# self.sp_parameters["problem_data"]["center"][0].GetDouble()
self.center[1] = 0
# self.sp_parameters["problem_data"]["center"][1].GetDouble()
self.center[2] = 0
# self.sp_parameters["problem_data"]["center"][2].GetDouble()
self.axis = KratosMultiphysics.Array3()
self.axis[0] = 0
# self.sp_parameters["problem_data"]["axis"][0].GetDouble()
self.axis[1] = 0
# self.sp_parameters["problem_data"]["axis"][1].GetDouble()
self.axis[2] = 1
# self.sp_parameters["problem_data"]["axis"][2].GetDouble()
self.radius = 0
self.test_number = 1
if self.test_number == 1:
self.radius = 0.0036195
#0.01; #0.0036195; #95% of the real hole. CTW16 specimen
elif self.test_number == 2:
self.radius = 0.012065
#95% of the real hole. CTW10 specimen
elif self.test_number == 3:
self.radius = 0.036195
def CreateBoundingBoxMesh(self, bounding_box, model_part):
# construct bounding box mesh of surface elements
# Note: new nodes must be inserted in boundary conditions subdomains
number_of_linear_partitions = 10
number_of_angular_partitions = 20
bounding_box.CreateBoundingBoxBoundaryMesh(
model_part, number_of_linear_partitions,
number_of_angular_partitions)
# set mesh upper and lower points
upper_point = KratosMultiphysics.Array3()
upper = self.GetUpperPoint(model_part)
print("upper", upper)
for i in range(0, len(upper)):
upper_point[i] = upper[i]
bounding_box.SetUpperPoint(upper_point)
lower_point = KratosMultiphysics.Array3()
lower = self.GetLowerPoint(model_part)
print("lower", lower)
for i in range(0, len(lower)):
lower_point[i] = lower[i]
bounding_box.SetLowerPoint(lower_point)
def ReadModelParts(self, max_node_Id=0, max_elem_Id=0, max_cond_Id=0):
properties = KratosMultiphysics.Properties(0)
properties_walls = KratosMultiphysics.Properties(0)
SetHardcodedProperties(properties, properties_walls)
self.spheres_model_part.AddProperties(properties)
self.rigid_face_model_part.AddProperties(properties_walls)
translational_scheme = DEM.ForwardEulerScheme()
translational_scheme.SetTranslationalIntegrationSchemeInProperties(
properties, True)
rotational_scheme = DEM.ForwardEulerScheme()
rotational_scheme.SetRotationalIntegrationSchemeInProperties(
properties, True)
element_name = "SphericContinuumParticle3D"
DEM.PropertiesProxiesManager().CreatePropertiesProxies(
self.spheres_model_part)
coordinates = KratosMultiphysics.Array3()
coordinates[0] = -1
coordinates[1] = 0.0
coordinates[2] = 0.0
radius = 1
self.creator_destructor.CreateSphericParticle(self.spheres_model_part,
coordinates, properties,
radius, element_name)
coordinates = KratosMultiphysics.Array3()
coordinates[0] = 0.95
coordinates[1] = 0.0
coordinates[2] = 0.0
radius = 1
self.creator_destructor.CreateSphericParticle(self.spheres_model_part,
coordinates, properties,
radius, element_name)
for node in self.spheres_model_part.Nodes:
node.SetSolutionStepValue(DEM.COHESIVE_GROUP, 1)
for node in self.spheres_model_part.Nodes:
if node.Id == 2:
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY_X, 0.0)
if node.Id == 1:
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY_X, 0.1)
self.rigid_face_model_part.CreateNewNode(3, -5, 5, -1.008)
self.rigid_face_model_part.CreateNewNode(4, 5, 5, -1.008)
self.rigid_face_model_part.CreateNewNode(5, -5, -5, -1.008)
self.rigid_face_model_part.CreateNewNode(6, 5, -5, -1.008)
condition_name = "RigidFace3D3N"
self.rigid_face_model_part.CreateNewCondition(
condition_name, 7, [5, 6, 3],
self.rigid_face_model_part.GetProperties()[0])
self.rigid_face_model_part.CreateNewCondition(
condition_name, 8, [3, 6, 4],
self.rigid_face_model_part.GetProperties()[0])
def SPPostProcessResults(self, time):
DemFem.DemStructuresCouplingUtilities().MarkBrokenSpheres(
self.ring_submodelpart)
center = Kratos.Array3()
center[0] = self.sp_parameters["problem_data"]["center"][0].GetDouble()
center[1] = self.sp_parameters["problem_data"]["center"][1].GetDouble()
center[2] = self.sp_parameters["problem_data"]["center"][2].GetDouble()
axis = Kratos.Array3()
axis[0] = self.sp_parameters["problem_data"]["axis"][0].GetDouble()
axis[1] = self.sp_parameters["problem_data"]["axis"][1].GetDouble()
axis[2] = self.sp_parameters["problem_data"]["axis"][2].GetDouble()
radius = 0
if self.test_number == 1:
radius = 0.0036195
#95% of the real hole. CTW16 specimen
elif self.test_number == 2:
radius = 0.012065
#95% of the real hole. CTW10 specimen
elif self.test_number == 3:
radius = 0.036195
#95% of the real hole. Blind Test
self.dem_solution.creator_destructor.MarkParticlesForErasingGivenCylinder(
self.ring_submodelpart, center, axis, radius)
if self.test_number == 1 or self.test_number == 2:
if self.structural_solution._GetSolver(
).main_model_part.ProcessInfo[Kratos.DOMAIN_SIZE] == 2:
self.outer_walls_model_part = self.model[
"Structure.LinePressure2D_Outer_line"]
else:
self.outer_walls_model_part = self.model[
"Structure.SurfacePressure3D_lateral_pressure"]
DemFem.DemStructuresCouplingUtilities(
).ComputeSandProductionWithDepthFirstSearchNonRecursiveImplementation(
self.ring_submodelpart, self.outer_walls_model_part, time)
DemFem.DemStructuresCouplingUtilities().ComputeSandProduction(
self.ring_submodelpart, self.outer_walls_model_part, time)
elif self.test_number == 3:
if self.structural_solution._GetSolver(
).main_model_part.ProcessInfo[Kratos.DOMAIN_SIZE] == 2:
self.outer_walls_model_part_1 = self.model[
"Structure.LinePressure2D_Left_line"]
# self.outer_walls_model_part_2 = self.model["Structure.LinePressure2D_Bot_line"]
else:
self.outer_walls_model_part_1 = self.model[
"Structure.SurfacePressure3D_sigmaXpos"]
# self.outer_walls_model_part_2 = self.model["Structure.SurfacePressure3D_sigmaYpos"]
# NOTE: The stress printed in this case will also be the SigmaZ, but probably SigmaX is more appropriate
DemFem.DemStructuresCouplingUtilities(
).ComputeSandProductionWithDepthFirstSearchNonRecursiveImplementation(
self.ring_submodelpart, self.outer_walls_model_part_1, time)
DemFem.DemStructuresCouplingUtilities().ComputeSandProduction(
self.ring_submodelpart, self.outer_walls_model_part_1, time)
def _ApplyPeriodicity(self, strain, volume_mp, boundary_mp):
# clear
for constraint in volume_mp.GetRootModelPart().MasterSlaveConstraints:
constraint.Set(KratosMultiphysics.TO_ERASE)
volume_mp.GetRootModelPart().RemoveMasterSlaveConstraintsFromAllLevels(
KratosMultiphysics.TO_ERASE)
dx = self.max_corner[0] - self.min_corner[0]
dy = self.max_corner[1] - self.min_corner[1]
dz = self.max_corner[2] - self.min_corner[2]
periodicity_utility = KratosMultiphysics.StructuralMechanicsApplication.RVEPeriodicityUtility(self._GetSolver().GetComputingModelPart())
# assign periodicity to faces
periodicity_utility.AssignPeriodicity(self.min_x_face, self.max_x_face, strain, KratosMultiphysics.Vector([dx, 0.0, 0.0]))
periodicity_utility.AssignPeriodicity(self.min_y_face, self.max_y_face, strain, KratosMultiphysics.Vector([0.0, dy, 0.0]))
periodicity_utility.AssignPeriodicity(self.min_z_face, self.max_z_face, strain, KratosMultiphysics.Vector([0.0, 0.0, dz]))
periodicity_utility.Finalize(KratosMultiphysics.DISPLACEMENT)
# start from the exact solution in the case of a constant strain
x = KratosMultiphysics.Array3()
for node in volume_mp.Nodes:
x[0] = node.X0
x[1] = node.Y0
x[2] = node.Z0
d = strain*x
node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT, 0, d)
def ReadModelParts(self, max_node_Id=0, max_elem_Id=0, max_cond_Id=0):
properties = KratosMultiphysics.Properties(0)
properties_walls = KratosMultiphysics.Properties(0)
self.SetHardcodedProperties(properties, properties_walls)
self.spheres_model_part.AddProperties(properties)
self.rigid_face_model_part.AddProperties(properties_walls)
translational_scheme = DEM.ForwardEulerScheme()
translational_scheme.SetTranslationalIntegrationSchemeInProperties(properties, True)
rotational_scheme = DEM.ForwardEulerScheme()
rotational_scheme.SetRotationalIntegrationSchemeInProperties(properties, True)
element_name = "CylinderParticle2D"
DEM.PropertiesProxiesManager().CreatePropertiesProxies(self.spheres_model_part)
coordinates = KratosMultiphysics.Array3()
coordinates[0] = 0.0
coordinates[1] = 0.0025002
coordinates[2] = 0.0
radius = 0.0025
self.creator_destructor.CreateSphericParticle(self.spheres_model_part, coordinates, properties, radius, element_name)
for node in self.spheres_model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY_Y, -3.9)
self.rigid_face_model_part.CreateNewNode(3, -0.01, 0.0, 0.0)
self.rigid_face_model_part.CreateNewNode(4, 0.01, 0.0, 0.0)
condition_name = "RigidEdge2D2N"
self.rigid_face_model_part.CreateNewCondition(condition_name, 7, [3, 4], self.rigid_face_model_part.GetProperties()[0])
def setUpProblem(self):
velocity = KratosMultiphysics.Array3()
velocity[0] = self.config.ux
velocity[1] = 0.0
velocity[2] = 0.0
## Set initial and boundary conditions
for node in self.model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DENSITY,
self.config.rho)
node.SetSolutionStepValue(KratosMultiphysics.CONDUCTIVITY,
self.config.k)
node.SetSolutionStepValue(KratosMultiphysics.SPECIFIC_HEAT,
self.config.c)
node.SetSolutionStepValue(KratosMultiphysics.HEAT_FLUX,
self.config.source)
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY, velocity)
if node.X == self.config.xmin:
node.Fix(KratosMultiphysics.TEMPERATURE)
node.SetSolutionStepValue(KratosMultiphysics.TEMPERATURE,
self.config.T_xmin)
elif node.X == self.config.xmax:
node.Fix(KratosMultiphysics.TEMPERATURE)
node.SetSolutionStepValue(KratosMultiphysics.TEMPERATURE,
self.config.T_xmax)
def test_SetNodalArraySolutionStepValueFromPython_Array3(self):
model_part = self.CreateModelPart()
node = model_part.GetNode(1)
u = KM.Array3([1, 2, 3])
node.SetSolutionStepValue(KM.VORTICITY, u)
node.SetSolutionStepValue(KM.VORTICITY, 0, u)
def perturbedSolution(self, model, settings, objective_model_part_name, perturbed_node_ids):
model_part_name = settings["solver_settings"]["model_part_name"].GetString()
input_file_name = settings["solver_settings"]["model_import_settings"]["input_filename"].GetString()
base_temp = self.average_temperature_objective(model.GetModelPart(model_part_name+"."+objective_model_part_name))
results = []
for node_id in perturbed_node_ids:
coord = self._readNodalCoordinates(node_id,input_file_name)
# X perturbation
perturbed_coord = [coord[0]+self.perturbation_magnitude, coord[1], coord[2]]
self._writeNodalCoordinates(node_id,perturbed_coord,input_file_name,input_file_name+"_x")
model_x = kratos.Model()
settings["solver_settings"]["model_import_settings"]["input_filename"].SetString(input_file_name+"_x")
self.primalSolution(model_x,settings)
x_temp = self.average_temperature_objective(model_x.GetModelPart(model_part_name+"."+objective_model_part_name))
# Y perturbation
perturbed_coord = [coord[0], coord[1]+self.perturbation_magnitude, coord[2]]
self._writeNodalCoordinates(node_id,perturbed_coord,input_file_name,input_file_name+"_y")
model_y = kratos.Model()
settings["solver_settings"]["model_import_settings"]["input_filename"].SetString(input_file_name+"_y")
self.primalSolution(model_y,settings)
y_temp = self.average_temperature_objective(model_y.GetModelPart(model_part_name+"."+objective_model_part_name))
result = kratos.Array3()
result[0] = (x_temp-base_temp)/self.perturbation_magnitude
result[1] = (y_temp-base_temp)/self.perturbation_magnitude
results.append(result)
return results
def _ApplyMinimalConstraints(self, mp, strain, min_corner, max_corner):
aux = KratosMultiphysics.Array3()
# point coinciding with the min_corner
node = self._SelectClosestNode(mp, min_corner)
node.Fix(KratosMultiphysics.DISPLACEMENT_X)
node.Fix(KratosMultiphysics.DISPLACEMENT_Y)
node.Fix(KratosMultiphysics.DISPLACEMENT_Z)
coords_min_corner = KratosMultiphysics.Array3(node)
coords_min_corner[0] = node.X0
coords_min_corner[1] = node.Y0
coords_min_corner[2] = node.Z0
disp_min_corner = strain*coords_min_corner
node.SetSolutionStepValue(
KratosMultiphysics.DISPLACEMENT, 0, disp_min_corner)
def InitializeSolutionStep(self):
super(ElementSizeModifier, self).InitializeSolutionStep()
center = KratosMultiphysics.Array3()
center[0] = center[1] = center[2] = 0.0 #TODO: input
density = self.size_modifier_parameters["material_settings"][
"density_for_artificial_concentric_weight"].GetDouble()
self.PreUtilities.ApplyConcentricForceOnParticles(
self.spheres_model_part, center, density)
def test_point_constructor_with_kratos_array(self):
coords = [1.0, -2.5, 3.3]
arr = KM.Array3(coords)
point = KM.Point(arr)
self.assertAlmostEqual(point.X, coords[0])
self.assertAlmostEqual(point.Y, coords[1])
self.assertAlmostEqual(point.Z, coords[2])
def GetNodeCoordinates(self, Node):
X = Node.X
Y = Node.Y
Z = Node.Z
coord = KratosMultiphysics.Array3()
coord[0] = X
coord[1] = Y
coord[2] = Z
return coord
def __init__(self, model_part, custom_settings):
KratosMultiphysics.Process.__init__(self)
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"inner_separation_point": [0.03,0,0],
"outer_separation_point": [0.0375,0,0],
"bottom_point" : [0.03375, -0.00375, 0.0],
"piston_position": [100000.0, 100000.0, 100000.0],
"velocity": 0.0375
}
""")
#LMV: OBS: be careful with the tip and so on
settings = custom_settings
settings.ValidateAndAssignDefaults(default_settings)
self.model_part = model_part['Main_Domain']
self.velocity = settings["velocity"].GetDouble()
self.InnerSeparationPoint = KratosMultiphysics.Array3()
self.OuterSeparationPoint = KratosMultiphysics.Array3()
self.BottomPoint = KratosMultiphysics.Array3()
self.PistonPosition = KratosMultiphysics.Array3()
for ii in range(0,3):
self.InnerSeparationPoint[ii] = settings["inner_separation_point"][ii].GetDouble()
self.OuterSeparationPoint[ii] = settings["outer_separation_point"][ii].GetDouble()
self.BottomPoint[ii] = settings["bottom_point"][ii].GetDouble()
self.PistonPosition[ii] = settings["piston_position"][ii].GetDouble()
self.InnerForce = KratosMultiphysics.Array3()
self.OuterForce = KratosMultiphysics.Array3()
self.TipForce = KratosMultiphysics.Array3()
self.PistonForce = KratosMultiphysics.Array3()
self.InnerLength = 0.0
self.OuterLength = 0.0
self.Filling = 0.0
# initialize figure path
problem_path = os.getcwd()
self.figure_path = os.path.join(problem_path, "TubeSampler.csv")
def SettingGeometricalSPValues(self):
self.center = KratosMultiphysics.Array3()
self.center[0] = 0
# self.sp_parameters["problem_data"]["center"][0].GetDouble()
self.center[1] = 0
# self.sp_parameters["problem_data"]["center"][1].GetDouble()
self.center[2] = 0
# self.sp_parameters["problem_data"]["center"][2].GetDouble()
self.axis = KratosMultiphysics.Array3()
self.axis[0] = 0
# self.sp_parameters["problem_data"]["axis"][0].GetDouble()
self.axis[1] = 0
# self.sp_parameters["problem_data"]["axis"][1].GetDouble()
self.axis[2] = 1
# self.sp_parameters["problem_data"]["axis"][2].GetDouble()
self.outer_radius = 0.0508 # For the CTWs
if self.test_number == 1: # CTW16
self.inner_radius = 0.00381
self.zone_radius_to_measure_2d_sp = 0.015
self.radius_to_delete_sp = 0.0015
elif self.test_number == 2: # CTW10
self.inner_radius = 0.0127
self.zone_radius_to_measure_2d_sp = 0.02
self.radius_to_delete_sp = 0.005
elif self.test_number == 3: # CTW13
self.inner_radius = 0.00635
self.zone_radius_to_measure_2d_sp = 0.017
self.radius_to_delete_sp = 0.0025
elif self.test_number == 4: # CTW12
self.inner_radius = 0.008
self.zone_radius_to_measure_2d_sp = 0.018
self.radius_to_delete_sp = 0.003
else: # Blind
self.inner_radius = 0.0381
self.zone_radius_to_measure_2d_sp = 0.06
self.radius_to_delete_sp = 0.015
self.outer_radius = 0.1524
def variable_stiffness(self,model_part,variable,k,reference_z):
for i,node in enumerate(model_part.Nodes):
j = 3*i
position = node.GetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Z,0) + node.Z
if node.Z > reference_z:
delta = position - reference_z
else:
delta = reference_z - position
forces = KratosMultiphysics.Array3()
forces[0] = 0.0
forces[1] = 0.0
forces[2] = k * ( 1 + node.X*node.Y ) * delta
node.SetSolutionStepValue(variable,0,forces)
def test_copy_model_part_nodal_var_to_non_historical_var(self):
##set the origin model part
current_model = KratosMultiphysics.Model()
origin_model_part = current_model.CreateModelPart("OriginModelPart")
origin_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VISCOSITY)
origin_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT)
origin_model_part.SetBufferSize(2)
model_part_io = KratosMultiphysics.ModelPartIO(GetFilePath("auxiliar_files_for_python_unittest/mdpa_files/test_model_part_io_read"))
model_part_io.ReadModelPart(origin_model_part)
##set the destination model part
destination_model_part = current_model.CreateModelPart("DestinationModelPart")
destination_model_part.SetBufferSize(2)
destination_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VISCOSITY)
destination_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT)
model_part_io = KratosMultiphysics.ModelPartIO(GetFilePath("auxiliar_files_for_python_unittest/mdpa_files/test_model_part_io_read"))
model_part_io.ReadModelPart(destination_model_part)
##set the values in the origin model part
for node in origin_model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.VISCOSITY, 0, node.X + node.Y)
node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT, 1, [node.X, node.Y, node.Z])
## initialize the containers in destination model part (otherwise the operation is not threadsafe!)
for node in destination_model_part.Nodes:
node.SetValue(KratosMultiphysics.VISCOSITY, 0)
node.SetValue(KratosMultiphysics.DISPLACEMENT, KratosMultiphysics.Array3())
node.SetValue(KratosMultiphysics.VELOCITY, KratosMultiphysics.Array3())
##copy the values to the destination model part
KratosMultiphysics.VariableUtils().CopyModelPartNodalVarToNonHistoricalVar(KratosMultiphysics.VISCOSITY, origin_model_part, destination_model_part, 0)
KratosMultiphysics.VariableUtils().CopyModelPartNodalVarToNonHistoricalVar(KratosMultiphysics.DISPLACEMENT, origin_model_part, destination_model_part, 1)
KratosMultiphysics.VariableUtils().CopyModelPartNodalVarToNonHistoricalVar(KratosMultiphysics.DISPLACEMENT, KratosMultiphysics.VELOCITY, origin_model_part, destination_model_part, 1)
##check the copied values
for node in destination_model_part.Nodes:
self.assertEqual(node.GetValue(KratosMultiphysics.VISCOSITY), node.X + node.Y)
self.assertEqual(node.GetValue(KratosMultiphysics.VELOCITY_X), node.X)
self.assertEqual(node.GetValue(KratosMultiphysics.DISPLACEMENT_X), node.X)
def ApplyLateralStress(self, average_zstress_value, LAT, alpha_lat):
for node in LAT:
r = node.GetSolutionStepValue(Kratos.RADIUS)
x = node.X
y = node.Y
values = Kratos.Array3()
vect = Kratos.Array3()
cross_section = 2.0 * r
vect_moduli = math.sqrt(x * x + y * y)
if vect_moduli > 0.0:
vect[0] = x / vect_moduli
vect[1] = y / vect_moduli
values[0] = cross_section * average_zstress_value * vect[
0] * alpha_lat
values[1] = cross_section * average_zstress_value * vect[
1] * alpha_lat
node.SetSolutionStepValue(Kratos.EXTERNAL_APPLIED_FORCE, values)
def ReadModelParts(self, max_node_Id=0, max_elem_Id=0, max_cond_Id=0):
properties = KratosMultiphysics.Properties(0)
properties_walls = KratosMultiphysics.Properties(0)
self.spheres_model_part.AddProperties(properties)
self.rigid_face_model_part.AddProperties(properties_walls)
translational_scheme = DEM.ForwardEulerScheme()
translational_scheme.SetTranslationalIntegrationSchemeInProperties(
properties, True)
rotational_scheme = DEM.ForwardEulerScheme()
rotational_scheme.SetRotationalIntegrationSchemeInProperties(
properties, True)
element_name = "SphericParticle3D"
DEM.PropertiesProxiesManager().CreatePropertiesProxies(
self.spheres_model_part)
coordinates = KratosMultiphysics.Array3()
coordinates[0] = 0.0
coordinates[1] = 0.0
coordinates[2] = 0.0025002
radius = 0.0025
self.creator_destructor.CreateSphericParticle(self.spheres_model_part,
coordinates, properties,
radius, element_name)
# Second particle to check search flag against particles
coordinates[2] = -0.0026
self.creator_destructor.CreateSphericParticle(self.spheres_model_part,
coordinates, properties,
radius, element_name)
for node in self.spheres_model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY_Z, -3.9)
if node.Id == 2:
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY_Z, 1)
self.rigid_face_model_part.CreateNewNode(3, -0.01, 0.01, 0.0)
self.rigid_face_model_part.CreateNewNode(4, 0.01, 0.01, 0.0)
self.rigid_face_model_part.CreateNewNode(5, -0.01, -0.01, 0.0)
self.rigid_face_model_part.CreateNewNode(6, 0.01, -0.01, 0.0)
condition_name = "RigidFace3D3N"
self.rigid_face_model_part.CreateNewCondition(
condition_name, 7, [5, 6, 3],
self.rigid_face_model_part.GetProperties()[0])
self.rigid_face_model_part.CreateNewCondition(
condition_name, 8, [3, 6, 4],
self.rigid_face_model_part.GetProperties()[0])
def ExecuteInitializeSolutionStep(self):
KratosMultiphysics.BodyNormalCalculationUtils().CalculateBodyNormals(
self.active_contact_body, self.domain_size)
zero = KratosMultiphysics.Vector(3)
zero[0] = 0.0
zero[1] = 0.0
zero[2] = 0.0
N = KratosMultiphysics.Vector(self.domain_size + 1)
coords = KratosMultiphysics.Array3()
pelem = KratosMultiphysics.Element(
-1) #UGLY! here i create an empty pointer
grad = KratosMultiphysics.Vector(3)
for node in self.active_contact_surface.Nodes: #nodes on the skin of the rotor
#save the displacement
disp = node.GetSolutionStepValue(KratosMultiphysics.DISPLACEMENT)
node.SetValue(KratosMultiphysics.DISPLACEMENT, disp)
#now find if inside
coords[0] = node.X
coords[1] = node.Y
coords[2] = node.Z
found = self.locate_on_background.FindPointOnMesh(
coords, N, pelem, 1000, 1e-9)
if (found):
d = 0.0
grad[0] = 0.0
grad[1] = 0.0
grad[2] = 0.0
k = 0
for p in pelem.GetNodes():
d += N[k] * p.GetSolutionStepValue(
KratosMultiphysics.DISTANCE)
g = p.GetValue(KratosMultiphysics.DISTANCE_GRADIENT)
grad[0] += N[k] * g[0]
grad[1] += N[k] * g[1]
grad[2] += N[k] * g[2]
k += 1
node.SetValue(KratosMultiphysics.DISTANCE, d)
node.SetValue(KratosMultiphysics.DISTANCE_GRADIENT, grad)
else:
node.SetValue(KratosMultiphysics.DISTANCE, 0.0)
node.SetValue(KratosMultiphysics.DISTANCE_GRADIENT, zero)
def ReadModelParts(self, max_node_Id=0, max_elem_Id=0, max_cond_Id=0):
properties = KratosMultiphysics.Properties(0)
properties_walls = KratosMultiphysics.Properties(0)
self.SetHardcodedProperties(properties, properties_walls)
self.spheres_model_part.AddProperties(properties)
self.rigid_face_model_part.AddProperties(properties_walls)
DiscontinuumConstitutiveLaw = getattr(
DEM, properties[DEM.DEM_DISCONTINUUM_CONSTITUTIVE_LAW_NAME])()
DiscontinuumConstitutiveLaw.SetConstitutiveLawInProperties(
properties, False)
translational_scheme = DEM.ForwardEulerScheme()
translational_scheme.SetTranslationalIntegrationSchemeInProperties(
properties, True)
rotational_scheme = DEM.ForwardEulerScheme()
rotational_scheme.SetRotationalIntegrationSchemeInProperties(
properties, True)
element_name = "SphericParticle3D"
DEM.PropertiesProxiesManager().CreatePropertiesProxies(
self.spheres_model_part)
coordinates = KratosMultiphysics.Array3()
coordinates[0] = 0.0
coordinates[1] = 0.0
coordinates[2] = 0.00255
radius = 0.0025
self.creator_destructor.CreateSphericParticle(self.spheres_model_part,
coordinates, properties,
radius, element_name)
for node in self.spheres_model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY_Z, -3.9)
self.rigid_face_model_part.CreateNewNode(3, -0.01, 0.01, 0.0)
self.rigid_face_model_part.CreateNewNode(4, 0.01, 0.01, 0.0)
self.rigid_face_model_part.CreateNewNode(5, -0.01, -0.01, 0.0)
self.rigid_face_model_part.CreateNewNode(6, 0.01, -0.01, 0.0)
condition_name = "RigidFace3D3N"
self.rigid_face_model_part.CreateNewCondition(
condition_name, 7, [5, 6, 3],
self.rigid_face_model_part.GetProperties()[0])
self.rigid_face_model_part.CreateNewCondition(
condition_name, 8, [3, 6, 4],
self.rigid_face_model_part.GetProperties()[0])
def ExecuteBeforeOutputStep(self):
""" This method is executed right before the ouput process computation
Keyword arguments:
self -- It signifies an instance of a class.
"""
# We call to the base process
super(ALMContactProcess, self).ExecuteBeforeOutputStep()
if self.contact_settings["clear_inactive_for_post"].GetBool():
zero_vector = KM.Array3()
zero_vector[0] = 0.0
zero_vector[1] = 0.0
zero_vector[2] = 0.0
KM.VariableUtils().SetNonHistoricalVariable(CSMA.AUGMENTED_NORMAL_CONTACT_PRESSURE, 0.0, self.computing_model_part.Nodes, KM.ACTIVE, False)
KM.VariableUtils().SetNonHistoricalVariable(CSMA.AUGMENTED_TANGENT_CONTACT_PRESSURE, zero_vector, self.computing_model_part.Nodes, KM.ACTIVE, False)
def testFlowsMeasuring3D_1(self):
vel = Kratos.Array3()
vel[0] = 0.0
vel[1] = 0.0
vel[2] = 1.0
node = self.fluid_model_part.CreateNewNode(1, 0.0, 0.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
node = self.fluid_model_part.CreateNewNode(2, 1.0, 0.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
node = self.fluid_model_part.CreateNewNode(3, 0.0, 1.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
node = self.fluid_model_part.CreateNewNode(4, 1.0, 1.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
vel[0] = 1.0
vel[1] = 0.0
vel[2] = 0.0
node = self.fluid_model_part.CreateNewNode(5, 2.0, 0.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
node = self.fluid_model_part.CreateNewNode(6, 2.0, 0.0, 1.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
node = self.fluid_model_part.CreateNewNode(7, 2.0, 1.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
condition_name = "SurfaceCondition3D3N"
self.fluid_model_part.CreateNewCondition(
condition_name, 1, [1, 2, 3],
self.fluid_model_part.GetProperties()[0])
self.fluid_model_part.CreateNewCondition(
condition_name, 2, [3, 2, 4],
self.fluid_model_part.GetProperties()[0])
self.fluid_model_part.CreateNewCondition(
condition_name, 3, [5, 6, 7],
self.fluid_model_part.GetProperties()[0])
first_smp = self.fluid_model_part.CreateSubModelPart("first")
first_smp.AddConditions([1, 2])
second_smp = self.fluid_model_part.CreateSubModelPart("second")
second_smp.AddConditions([3])
flow_value_first = Fluid.FluidPostProcessUtilities().CalculateFlow(
first_smp)
flow_value_second = Fluid.FluidPostProcessUtilities().CalculateFlow(
second_smp)
self.assertAlmostEqual(flow_value_first, 1.0)
self.assertAlmostEqual(flow_value_second, -0.5)
def ExecuteFinalizeSolutionStep(self):
time = self._GetStepTime()
ContactForce = KratosMultiphysics.Array3()
for ii in range(0, 3):
ContactForce[ii] = 0
for node in self.model_part.GetNodes(0):
Force = node.GetSolutionStepValue(KratosMultiphysics.CONTACT_FORCE)
ContactForce = ContactForce + Force
line = str(time) + " , " + str(ContactForce[0]) + " , " + str(
ContactForce[1]) + " \n "
csv_file = open(self.csv_path, "a")
csv_file.write(line)
csv_file.close()
def testFlowsMeasuring2D_1(self):
vel = Kratos.Array3()
vel[0] = 0.0
vel[1] = 1.0
vel[2] = 0.0
node = self.fluid_model_part.CreateNewNode(1, 0.0, 0.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
node = self.fluid_model_part.CreateNewNode(2, 1.0, 1.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
node = self.fluid_model_part.CreateNewNode(3, 2.0, 2.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
node = self.fluid_model_part.CreateNewNode(4, 3.0, 3.0, 0.0)
node.SetSolutionStepValue(Kratos.VELOCITY, vel)
condition_name = "LineCondition2D2N"
self.fluid_model_part.CreateNewCondition(
condition_name, 1, [1, 2],
self.fluid_model_part.GetProperties()[0])
self.fluid_model_part.CreateNewCondition(
condition_name, 2, [2, 3],
self.fluid_model_part.GetProperties()[0])
self.fluid_model_part.CreateNewCondition(
condition_name, 3, [3, 4],
self.fluid_model_part.GetProperties()[0])
first_smp = self.fluid_model_part.CreateSubModelPart("first")
first_smp.AddConditions([1, 2])
second_smp = self.fluid_model_part.CreateSubModelPart("second")
second_smp.AddConditions([3])
flow_measurer = flow_process.FlowOutputProcess(self.current_model,
self.settings)
flow_measurer.ExecuteInitialize()
flow_measurer.ExecuteInitializeSolutionStep()
flow_measurer.ExecuteFinalizeSolutionStep()
flow_measurer.ExecuteFinalize()
with open(self.filename, "r") as f:
lines = f.readlines()
interesting_line = lines[2]
splitted_line = interesting_line.split()
self.assertAlmostEqual(float(splitted_line[1]), -2.0)
self.assertAlmostEqual(float(splitted_line[2]), -1.0)
def test_matrix_vector(self):
A = KM.Matrix(4, 3)
for i in range(A.Size1()):
for j in range(A.Size2()):
A[i, j] = i
#matrix vector
b = KM.Vector(3)
b.fill(1.0)
c = A * b
for i in range(len(c)):
self.assertEqual(c[i], i * A.Size2())
#matrix array_1d<double,3>
b = KM.Array3(1.0)
c = A * b
for i in range(len(c)):
self.assertEqual(c[i], i * A.Size2())
def _EraseElementsOutsideDomainAndMarkSkin(self):
if self.eraser_counter == 1:
self.eraser_counter = 0
mean_diameter_of_particles = self.size_modifier_parameters["mean_diameter_of_particles"].GetDouble()
if self.size_modifier_parameters["geometry_settings"]["geometry_type"].GetString() == "Radial":
max_radius = self.size_modifier_parameters["geometry_settings"]["outer_radius"].GetDouble()
tolerance = self.size_modifier_parameters["geometry_settings"]["tolerance"].GetDouble()
center = KratosMultiphysics.Array3()
center[0] = center[1] = center[2] = 0.0
self.PreUtilities.ResetSkinParticles(self.spheres_model_part)
self.PreUtilities.MarkToEraseParticlesOutsideRadius(self.spheres_model_part, max_radius, center, tolerance)
inner_radius = self.size_modifier_parameters["geometry_settings"]["inner_radius"].GetDouble()
radius_at_inner_boundary = mean_diameter_of_particles/2.0
self.PreUtilities.SetSkinParticlesInnerBoundary(self.spheres_model_part, inner_radius, 2.0 * radius_at_inner_boundary)
radius_at_outer_boundary = ComputeMeanRadiusOfThisParticle(max_radius, 0.0, 0.0, mean_diameter_of_particles/2.0)
portion_of_process = (self.time - self.size_modifier_parameters["initiation_time"].GetDouble()) / self.size_modifier_parameters["process_duration"].GetDouble()
radius_at_outer_boundary_at_current_time = mean_diameter_of_particles/2.0 + portion_of_process * (radius_at_outer_boundary - mean_diameter_of_particles/2.0)
self.PreUtilities.SetSkinParticlesOuterBoundary(self.spheres_model_part, max_radius, 1.4 * radius_at_outer_boundary_at_current_time)
else:
self.eraser_counter += 1
def setUpOuterBoundaryCondition(self, model_part, boundary_x,
boundary_value):
velocity = KratosMultiphysics.Array3()
velocity[0] = self.ux
velocity[1] = 0.0
velocity[2] = 0.0
## Set initial and boundary conditions
for node in model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DENSITY, self.rho)
node.SetSolutionStepValue(KratosMultiphysics.CONDUCTIVITY, self.k)
node.SetSolutionStepValue(KratosMultiphysics.SPECIFIC_HEAT, self.c)
node.SetSolutionStepValue(KratosMultiphysics.HEAT_FLUX,
self.source)
node.SetSolutionStepValue(KratosMultiphysics.VELOCITY, velocity)
node.SetSolutionStepValue(KratosMultiphysics.TEMPERATURE,
boundary_value)
if node.X == boundary_x:
node.Fix(KratosMultiphysics.TEMPERATURE)
