def GetFieldUtility(self):
self.flow_field = SDEM.PouliotFlowField2D()
space_time_set = SDEM.SpaceTimeSet()
self.field_utility = SDEM.FluidFieldUtility(space_time_set,
self.flow_field, 1000.0,
1e-6)
return self.field_utility
def GetFieldUtility(self):
period = self.project_parameters["field_period"].GetDouble()
self.flow_field = SDEM.ProductOfSines(period)
space_time_set = SDEM.SpaceTimeSet()
self.field_utility = SDEM.FluidFieldUtility(space_time_set,
self.flow_field, 1000.0,
1e-6)
return self.field_utility
def GetFieldUtility(self):
a = math.pi / 4
d = math.pi / 2
self.flow_field = SDEM.EthierFlowField(a, d)
space_time_set = SDEM.SpaceTimeSet()
self.field_utility = SDEM.FluidFieldUtility(space_time_set, self.flow_field, 1000.0, 1e-6)
return self.field_utility
def FunctionsCalculator(domain_size=3):
if domain_size == 2:
custom_functions_tool = SDEM.CustomFunctionsCalculator2D()
elif domain_size == 3:
custom_functions_tool = SDEM.CustomFunctionsCalculator3D()
return custom_functions_tool
def ProjectL2(self):
self.ComputeVelocityError()
self.ComputePressureError()
self.Solve()
self.velocity_error_projected = SDEM.L2ErrorProjection(
).GetL2VectorProjection(self.error_model_part)
self.pressure_error_projected = SDEM.L2ErrorProjection(
).GetL2ScalarProjection(self.error_model_part)
return self.velocity_error_projected, self.pressure_error_projected, self.error_model_part
def GetFieldUtility(self):
self.flow_field = SDEM.CellularFlowField(self.project_parameters.L,
self.project_parameters.U,
self.project_parameters.k,
self.project_parameters.omega)
space_time_set = SDEM.SpaceTimeSet()
self.field_utility = SDEM.FluidFieldUtility(space_time_set,
self.flow_field, 1000.0,
1e-6)
return self.field_utility
def SelectTranslationalScheme(self):
translational_scheme = BaseAnalysis.SelectTranslationalScheme(self)
translational_scheme_name = self.project_parameters[
"TranslationalIntegrationScheme"].GetString()
if translational_scheme is None:
if translational_scheme_name == 'Hybrid_Bashforth':
return SDEM.HybridBashforthScheme()
elif translational_scheme_name == "TerminalVelocityScheme":
return SDEM.TerminalVelocityScheme()
else:
return None
else:
return translational_scheme
def _CreateScheme(self):
domain_size = self.GetComputingModelPart().ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE]
# Cases in which the element manages the time integration
if self.element_integrates_in_time:
# "Fake" scheme for those cases in where the element manages the time integration
# It is required to perform the nodal update once the current time step is solved
scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip(
domain_size, domain_size + 1)
# In case the BDF2 scheme is used inside the element, the BDF time discretization utility is required to update the BDF coefficients
if (self.settings["time_scheme"].GetString() == "bdf2"):
time_order = 2
self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF(
time_order)
else:
err_msg = "Requested elemental time scheme \"" + self.settings[
"time_scheme"].GetString() + "\" is not available.\n"
err_msg += "Available options are: \"bdf2\""
raise Exception(err_msg)
# Cases in which a time scheme manages the time integration
else:
# Bossak time integration scheme
if self.settings["time_scheme"].GetString() == "bossak":
if self.settings["consider_periodic_conditions"].GetBool(
) == True:
scheme = KratosSDEM.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulentDEMCoupled(
self.settings["alpha"].GetDouble(), domain_size,
KratosSDEM.PATCH_INDEX)
else:
scheme = KratosSDEM.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulentDEMCoupled(
self.settings["alpha"].GetDouble(),
self.settings["move_mesh_strategy"].GetInt(),
domain_size)
# BDF2 time integration scheme
elif self.settings["time_scheme"].GetString() == "bdf2":
scheme = KratosSDEM.BDF2TurbulentSchemeDEMCoupled()
# Time scheme for steady state fluid solver
elif self.settings["time_scheme"].GetString() == "steady":
scheme = KratosCFD.ResidualBasedSimpleSteadyScheme(
self.settings["velocity_relaxation"].GetDouble(),
self.settings["pressure_relaxation"].GetDouble(),
domain_size)
else:
err_msg = "Requested time scheme " + self.settings[
"time_scheme"].GetString() + " is not available.\n"
err_msg += "Available options are: \"bossak\", \"bdf2\" and \"steady\""
raise Exception(err_msg)
return scheme
def __init__(self, model, settings):
"""The default constructor of the class.
Keyword arguments:
self -- It signifies an instance of a class.
model -- the container of the fluid model part.
settings -- Kratos parameters containing process settings.
"""
KratosMultiphysics.Process.__init__(self)
default_settings = KratosMultiphysics.Parameters("""
{
"model_part_name" : "please_specify_model_part_name",
"variable_name" : "BODY_FORCE",
"benchmark_name" : "custom_body_force.vortex",
"benchmark_parameters" : {},
"compute_nodal_error" : true,
"print_convergence_output" : false,
"output_parameters" : {}
}
""")
self.settings = settings
self.settings.ValidateAndAssignDefaults(default_settings)
self.model_part = model[self.settings["model_part_name"].GetString()]
self.variable = KratosMultiphysics.KratosGlobals.GetVariable(
self.settings["variable_name"].GetString())
self.ApplySpatialDependantPorositySolutionBodyForceProcess = KratosSDEM.SpatialDependantPorositySolutionBodyForceProcess(
self.model_part, settings)
def CreateCPlusPlusStrategy(self):
self.SetVariablesAndOptions()
if self.DEM_parameters["TranslationalIntegrationScheme"].GetString(
) == 'Verlet_Velocity':
self.cplusplus_strategy = DEM.IterativeSolverStrategy(
self.settings, self.max_delta_time, self.n_step_search,
self.safety_factor, self.delta_option, self.creator_destructor,
self.dem_fem_search, self.search_strategy,
self.solver_settings)
elif self.DEM_parameters["TranslationalIntegrationScheme"].GetString(
) in {'Hybrid_Bashforth', 'TerminalVelocityScheme'}:
self.cplusplus_strategy = SDEM.AdamsBashforthStrategy(
self.settings, self.max_delta_time, self.n_step_search,
self.safety_factor, self.delta_option, self.creator_destructor,
self.dem_fem_search, self.search_strategy,
self.solver_settings)
else:
self.cplusplus_strategy = DEM.ExplicitSolverStrategy(
self.settings, self.max_delta_time, self.n_step_search,
self.safety_factor, self.delta_option, self.creator_destructor,
self.dem_fem_search, self.search_strategy,
self.solver_settings)
def Writeresults(self, time):
Logger.PrintInfo(
"SwimmingDEM",
"******************* PRINTING RESULTS FOR GID ***************************"
)
Logger.Flush()
if self.pp.GiDMultiFileFlag == "Multiples":
renumbering_utility = SDEMApp.RenumberingNodesUtility(
self.fluid_model_part, self.rigid_faces_model_part,
self.balls_model_part)
renumbering_utility.Renumber()
self.mixed_model_part.Elements.clear()
self.mixed_model_part.Nodes.clear()
# here order is important!
self.post_utilities.AddModelPartToModelPart(
self.mixed_model_part, self.balls_model_part)
self.post_utilities.AddModelPartToModelPart(
self.mixed_model_part, self.rigid_faces_model_part)
self.post_utilities.AddModelPartToModelPart(
self.mixed_model_part, self.fluid_model_part)
self.gid_io.write_swimming_DEM_results(
time, self.fluid_model_part, self.balls_model_part,
self.clusters_model_part, self.rigid_faces_model_part,
self.mixed_model_part, self.pp.nodal_results,
self.pp.dem_nodal_results, self.pp.clusters_nodal_results,
self.pp.rigid_faces_nodal_results, self.pp.mixed_nodal_results,
self.pp.gauss_points_results)
if self.pp.GiDMultiFileFlag == "Multiples":
renumbering_utility.UndoRenumber()
def TransferWallsFromPfemToDem(self):
destination_model_part = self._GetDEMAnalysis().rigid_face_model_part
bodies_parts_list = self._GetFluidAnalysis().project_parameters["solver_settings"]["bodies_list"]
for i in range(bodies_parts_list.size()):
body_model_part_type = bodies_parts_list[i]["body_type"].GetString()
if body_model_part_type == "Rigid":
body_model_part_name = bodies_parts_list[i]["body_name"].GetString()
source_model_part = self._GetFluidAnalysis().main_model_part.GetSubModelPart(body_model_part_name)
SDEM.SwimmingDemInPfemUtils().TransferWalls(source_model_part, destination_model_part)
def __init__(self, varying_parameters=Parameters("{}")):
BaseAnalysis.__init__(self, varying_parameters)
final_time = self.project_parameters.AddEmptyValue(
"FinalTime").GetDouble()
L = 0.0048 # the channel width
center_x = 0.0044
self.bbox_watcher = SDEM.BoundingBoxRule(0.0, 2 * final_time,
center_x - L, center_x + L,
-0.007, -0.002, -0.005, 0.001)
def __init__(self, real_field_type, fixed_mesh_option):
self.real_field_type = real_field_type
self.fixed_mesh_option = fixed_mesh_option
if (self.real_field_type == 0):
self.force_formula = SDEM.TimeDependantForceField(2)
self.porosity_default_value = 1.0
self.force_default_vector = Array3()
self.force_default_vector[0] = 0.0
self.force_default_vector[1] = 0.0
self.force_default_vector[2] = 0.0
self.porosity_formula = self.force_formula.GetPorosityField()
self.b_box_rule = SDEM.BoundingBoxRule()
self.b_box_rule.SetTimeBoundingInterval(0, 3)
self.b_box_rule.SetYBoundingInterval(-1, 1)
self.domain = SDEM.SpaceTimeSet()
self.domain.AddAndRule(self.b_box_rule)
self.porosity_field_utility = SDEM.FieldUtility(self.domain)
self.force_field_utility = SDEM.FieldUtility(self.domain)
def SelectRotationalScheme(self):
rotational_scheme = BaseAnalysis.SelectRotationalScheme(self)
translational_scheme_name = self.project_parameters[
"TranslationalIntegrationScheme"].GetString()
rotational_scheme_name = self.project_parameters[
"RotationalIntegrationScheme"].GetString()
if rotational_scheme is None:
if rotational_scheme_name == 'Direct_Integration':
if translational_scheme_name == 'Hybrid_Bashforth':
return SDEM.HybridBashforthScheme()
elif translational_scheme_name == 'TerminalVelocityScheme':
return SDEM.TerminalVelocityScheme()
elif rotational_scheme_name == 'Runge_Kutta':
return SDEM.RungeKuttaScheme()
elif rotational_scheme_name == 'Quaternion_Integration':
return SDEM.QuaternionIntegrationScheme()
else:
return None
else:
return rotational_scheme
def __init__(self, project_parameters, model_part):
recoverer.DerivativesRecoverer.__init__(self, project_parameters, model_part)
self.dimension = project_parameters["fluid_parameters"]["solver_settings"]["domain_size"].GetInt()
self.model_part = model_part
self.use_lumped_mass_matrix = project_parameters["material_acceleration_calculation_type"].GetInt() == 3
self.recovery_model_part = ModelPart("PostGradientFluidPart")
self.custom_functions_tool = SDEM.CustomFunctionsCalculator3D()
self.calculate_vorticity = (project_parameters["vorticity_calculation_type"].GetInt() > 0
or PT.RecursiveFindParametersWithCondition(project_parameters["properties"],
'vorticity_induced_lift_parameters'))
self.GetFieldUtility()
self.CreateCPluPlusStrategies()
def InitializeVariablesWithNonZeroValues(fluid_model_part, balls_model_part,
pp):
checker = SDEMApp.VariableChecker()
if checker.ModelPartHasNodalVariableOrNot(fluid_model_part,
FLUID_FRACTION):
SetModelPartSolutionStepValue(fluid_model_part, FLUID_FRACTION, 1.0)
SetModelPartSolutionStepValue(fluid_model_part, FLUID_FRACTION_OLD,
1.0)
if checker.ModelPartHasNodalVariableOrNot(balls_model_part,
FLUID_FRACTION_PROJECTED):
SetModelPartSolutionStepValue(balls_model_part,
FLUID_FRACTION_PROJECTED, 1.0)
def __init__(self, Model, settings):
KratosMultiphysics.Process.__init__(self)
# Fluid walls model part
self.model_part = Model[settings["model_part_name"].GetString()]
self.params = KratosMultiphysics.Parameters("{}")
self.params.AddValue("model_part_name", settings["model_part_name"])
self.params.AddValue("angular_velocity", settings["angular_velocity"])
self.params.AddValue("rotation_axis_initial_point",
settings["rotation_axis_initial_point"])
self.params.AddValue("rotation_axis_final_point",
settings["rotation_axis_final_point"])
self.params.AddValue("initial_time", settings["initial_time"])
self.process = KratosSDEM.ApplyRigidRotationProcess(
self.model_part, self.params)
def __init__(self, project_parameters, model_part):
recoverer.DerivativesRecoverer.__init__(self, project_parameters,
model_part)
self.model_part = model_part
self.use_lumped_mass_matrix = project_parameters[
"material_acceleration_calculation_type"].GetInt() == 3
self.recovery_model_part = ModelPart("PostGradientFluidPart")
self.custom_functions_tool = SDEM.CustomFunctionsCalculator3D()
self.calculate_vorticity = (
project_parameters["vorticity_calculation_type"].GetInt() > 0
or PT.RecursiveFindParametersWithCondition(
project_parameters["properties"],
'vorticity_induced_lift_parameters'))
if self.use_lumped_mass_matrix:
self.model_part.ProcessInfo[Kratos.COMPUTE_LUMPED_MASS_MATRIX] = 1
else:
self.model_part.ProcessInfo[Kratos.COMPUTE_LUMPED_MASS_MATRIX] = 0
self.CreateCPluPlusStrategies()
def Writeresults(self, time):
Logger.PrintInfo(
"SwimmingDEM",
"******************* PRINTING RESULTS FOR GID ***************************"
)
Logger.Flush()
gid_output_options = self.project_parameters["sdem_output_processes"][
"gid_output"][0]["Parameters"]
result_file_configuration = gid_output_options[
"postprocess_parameters"]["result_file_configuration"]
multiple_files_option_key = result_file_configuration["gidpost_flags"][
"MultiFileFlag"].GetString()
if multiple_files_option_key == "MultipleFiles":
renumbering_utility = SDEM.RenumberingNodesUtility(
self.fluid_model_part, self.rigid_faces_model_part,
self.balls_model_part)
renumbering_utility.Renumber()
self.mixed_model_part.Elements.clear()
self.mixed_model_part.Nodes.clear()
# here order is important!
self.post_utilities.AddModelPartToModelPart(
self.mixed_model_part, self.balls_model_part)
self.post_utilities.AddModelPartToModelPart(
self.mixed_model_part, self.rigid_faces_model_part)
self.post_utilities.AddModelPartToModelPart(
self.mixed_model_part, self.fluid_model_part)
self.gid_io.write_swimming_DEM_results(
time, self.fluid_model_part, self.balls_model_part,
self.clusters_model_part, self.rigid_faces_model_part,
self.mixed_model_part, self.vars_man.nodal_results,
self.vars_man.dem_nodal_results,
self.vars_man.clusters_nodal_results,
self.vars_man.rigid_faces_nodal_results,
self.vars_man.mixed_nodal_results,
self.vars_man.gauss_points_results)
if multiple_files_option_key == "MultipleFiles":
renumbering_utility.UndoRenumber()
def RecordParticlesInBox(self, bounding_box = SDEM.BoundingBoxRule()):
self.bounding_box = bounding_box
time = self.model_part.ProcessInfo[Kratos.TIME]
def IsInside(node):
is_a_particle = node.IsNot(Kratos.BLOCKED)
is_inside = self.bounding_box.CheckIfRuleIsMet(time, node.X, node.Y, node.Z)
return is_a_particle and is_inside
nodes_inside = [node for node in self.model_part.Nodes if IsInside(node)]
Ids_inside = np.array([node.Id for node in nodes_inside])
X0s_inside = np.array([node.X0 for node in nodes_inside])
Y0s_inside = np.array([node.Y0 for node in nodes_inside])
Z0s_inside = np.array([node.Z0 for node in nodes_inside])
radii_inside = np.array([node.GetSolutionStepValue(Kratos.RADIUS) for node in nodes_inside])
if len(radii_inside):
mean_radius = sum(radii_inside) / len(radii_inside)
else:
mean_radius = 1.0
with h5py.File(self.main_path + '/particles_snapshots.hdf5') as f:
prerun_fluid_file_name = self.prerun_fluid_file_name.split('/')[- 1]
current_fluid = CreateGroup(f, prerun_fluid_file_name, overwrite_previous = False)
# snapshot_name = 't=' + str(round(time, 3)) + '_RADIUS=' + str(round(mean_radius, 4)) + '_in_box'
snapshot_name = str(len(current_fluid.items()) + 1)
self.run_code = prerun_fluid_file_name.strip('.hdf5') + '_' + snapshot_name
snapshot = CreateGroup(current_fluid, snapshot_name)
snapshot.attrs['time'] = time
snapshot.attrs['particles_nondimensional_radius'] = mean_radius
# storing the input parameters for this run, the one corresponding
# to the current pre-calculated fluid
for k, v in ((k, v) for k, v in json.loads(self.parameters.WriteJsonString()).items() if 'comment' not in k):
snapshot.attrs[k] = v
names = ['Id', 'X0', 'Y0', 'Z0', 'RADIUS']
data = [Ids_inside, X0s_inside, Y0s_inside, Z0s_inside, radii_inside]
for dset_name, datum in zip(names, data):
CreateDataset(snapshot, dset_name, datum)
def __init__(self,
fluid_model_part,
balls_model_part,
FEM_DEM_model_part,
project_parameters,
coupling_dem_vars,
coupling_fluid_vars,
time_filtered_vars,
flow_field=None,
domain_size=3):
self.fluid_model_part = fluid_model_part
self.particles_model_part = balls_model_part
self.FEM_DEM_model_part = FEM_DEM_model_part
self.project_parameters = project_parameters
self.dimension = domain_size
self.coupling_type = project_parameters["coupling"]["coupling_weighing_type"].GetInt()
self.backward_coupling_parameters = project_parameters["coupling"]["backward_coupling"]
self.meso_scale_length = self.backward_coupling_parameters["meso_scale_length"].GetDouble()
self.shape_factor = self.backward_coupling_parameters["shape_factor"].GetDouble()
self.do_impose_flow_from_field = project_parameters["custom_fluid"]["do_impose_flow_from_field_option"].GetBool()
self.flow_field = flow_field
# Create projector_parameters
self.projector_parameters = Parameters("{}")
self.projector_parameters.AddValue("backward_coupling", project_parameters["coupling"]["backward_coupling"])
self.projector_parameters.AddValue("coupling_type", project_parameters["coupling"]["coupling_weighing_type"])
self.projector_parameters.AddValue("forward_coupling", project_parameters["coupling"]["forward_coupling"])
self.projector_parameters.AddValue("viscosity_modification_type", project_parameters["coupling"]["backward_coupling"]["viscosity_modification_type"])
self.projector_parameters.AddValue("n_particles_per_depth_distance", project_parameters["n_particles_in_depth"])
self.projector_parameters.AddValue("body_force_per_unit_mass_variable_name", project_parameters["body_force_per_unit_mass_variable_name"])
if self.dimension == 3:
if project_parameters["ElementType"].GetString() == "SwimmingNanoParticle":
self.projector = SDEM.BinBasedNanoDEMFluidCoupledMapping3D(self.projector_parameters)
else:
self.projector = SDEM.BinBasedDEMFluidCoupledMapping3D(self.projector_parameters)
self.bin_of_objects_fluid = Kratos.BinBasedFastPointLocator3D(fluid_model_part)
else:
if project_parameters["ElementType"].GetString() == "SwimmingNanoParticle":
self.projector = SDEM.BinBasedNanoDEMFluidCoupledMapping2D(self.projector_parameters)
else:
self.projector = SDEM.BinBasedDEMFluidCoupledMapping2D(self.projector_parameters)
self.bin_of_objects_fluid = Kratos.BinBasedFastPointLocator2D(fluid_model_part)
# telling the projector which variables we are interested in modifying
for var in coupling_dem_vars:
self.projector.AddDEMCouplingVariable(var)
for var in coupling_fluid_vars:
self.projector.AddFluidCouplingVariable(var)
for var in coupling_dem_vars:
if var in {Kratos.FLUID_VEL_PROJECTED, Kratos.FLUID_ACCEL_PROJECTED, Kratos.FLUID_VEL_LAPL_PROJECTED, Kratos.FLUID_ACCEL_FOLLOWING_PARTICLE_PROJECTED}:
self.projector.AddDEMVariablesToImpose(var)
coupling_dem_vars.remove(var)
self.projector.AddDEMVariablesToImpose(Kratos.AUX_VEL)
for var in time_filtered_vars:
self.projector.AddFluidVariableToBeTimeFiltered(var, 0.004)
def __init__(self, project_parameters, model_part):
self.model_part = model_part
self.cplusplus_recovery_tool = SDEM.DerivativeRecoveryTool3D(
model_part, project_parameters)
def ScalarL2ErroNorm(self, error_model_part):
return SDEM.L2ErrorNormCalculator().GetL2ScalarErrorNorm(self.error_model_part)
def VectorL2ErrorNorm(self, error_model_part):
return SDEM.L2ErrorNormCalculator().GetL2VectorErrorNorm(self.error_model_part)
def ComputeDofsErrors(self, error_model_part):
SDEM.L2ErrorNormCalculator().ComputeDofsErrors(self.error_model_part)
def ConstructHistoryForceUtility(self):
self.quadrature_counter = self.GetHistoryForceQuadratureCounter()
if self.history_force_on:
self.basset_force_tool = SDEM.BassetForceTools(self.MAE_parameters)
def GetMeshingTool(self):
if self.dimension == 2:
return SDEM.DerivativeRecoveryMeshingTools2D()
else:
return SDEM.DerivativeRecoveryMeshingTools3D()
def SetRotator(self):
self.rotator = SDEM.MeshRotationUtility(self.project_parameters)
def ConstructStationarityTool(self):
self.stationarity = False
self.stationarity_counter = self.GetStationarityCounter()
self.stationarity_tool = SDEM.FlowStationarityCheck(
self.fluid_solver.main_model_part,
self.project_parameters["stationarity"]["tolerance"].GetDouble())