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())