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 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 setUp(self): self.current_model = Kratos.Model() self.spheres_model_part = self.current_model.CreateModelPart( "SpheresPart") self.spheres_model_part.AddNodalSolutionStepVariable(Kratos.VELOCITY) self.spheres_model_part.AddNodalSolutionStepVariable( Kratos.ANGULAR_VELOCITY) self.spheres_model_part.AddNodalSolutionStepVariable(Kratos.RADIUS) self.spheres_model_part.AddNodalSolutionStepVariable( Kratos.PARTICLE_MATERIAL) self.spheres_model_part.AddNodalSolutionStepVariable(Kratos.NODAL_MASS) properties = Kratos.Properties(0) properties[Kratos.YOUNG_MODULUS] = 3.331 properties[ DEM. DEM_DISCONTINUUM_CONSTITUTIVE_LAW_NAME] = "DEM_D_Hertz_viscous_Coulomb" properties[DEM.FRICTION] = 0.0 properties[Kratos.POISSON_RATIO] = 0.0 properties[DEM.DAMPING_GAMMA] = 0.0 properties[DEM.COEFFICIENT_OF_RESTITUTION] = 0.0 self.ModifyProperties(properties) self.spheres_model_part.AddProperties(properties) DEM.PropertiesProxiesManager().CreatePropertiesProxies( self.spheres_model_part) self.creator_destructor = DEM.ParticleCreatorDestructor()
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 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 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 SolveSolutionStep(self): # move the rigid wall object in the dem mp w.r.t. the current displacement and velocities for model_part_nodes in self.list_of_nodes_in_move_mesh_model_parts: DEMApplication.MoveMeshUtility().MoveDemMesh( model_part_nodes, True) # solve DEM super().SolveSolutionStep()
def __init__(self, Model, settings): KratosMultiphysics.Process.__init__(self) # Control module process acting on the imposed direction: 0 (X), 1 (Y), 2 (Z) or 3 (radial) # The radial direction is valid only for the vertical walls of a right cylinder with the base # on the 'X-Y' plane centered on (0,0). Negative target_stress means compression. 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("imposed_direction", settings["imposed_direction"]) self.params.AddValue("target_stress_table_id", settings["target_stress_table_id"]) self.params.AddValue("initial_velocity", settings["initial_velocity"]) self.params.AddValue("limit_velocity", settings["limit_velocity"]) self.params.AddValue("velocity_factor", settings["velocity_factor"]) self.params.AddValue("compression_length", settings["compression_length"]) self.params.AddValue("young_modulus", settings["young_modulus"]) self.params.AddValue("stress_increment_tolerance", settings["stress_increment_tolerance"]) self.params.AddValue("update_stiffness", settings["update_stiffness"]) self.params.AddValue("start_time", settings["start_time"]) self.control_module_process = Dem.ControlModule2DProcess( self.model_part, self.params)
def Factory(settings, Model): if (type(settings) != KratosMultiphysics.Parameters): raise Exception( "expected input shall be a Parameters object, encapsulating a json string" ) process_settings = settings["Parameters"] folder_settings = KratosMultiphysics.Parameters("""{ "help" : "This process applies constraints to the rigid walls in a certain submodelpart, for a certain time interval", "mesh_id" : 0, "model_part_name" : "please_specify_model_part_name", "force_settings" : { "value" : [10.0, "3*t", "x+y"] }, "moment_settings" : { "value" : [10.0, "3*t", "x+y"] }, "interval" : [0.0, 1e30] }""") process_settings.AddMissingParameters(folder_settings) if process_settings.Has("model_part_name"): computing_model_part = Model[ process_settings["model_part_name"].GetString()] else: # using default name computing_model_part = Model["DEM_FEM_boundary"] process_settings.RemoveValue("help") return DEM.ApplyForcesAndMomentsToWallsProcess(computing_model_part, process_settings)
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 different model parts. settings -- Kratos parameters containing solver settings. """ KratosMultiphysics.Process.__init__(self) default_settings = KratosMultiphysics.Parameters(""" { "help" : "This process applies constraints to the particles in a certain submodelpart, for a certain time interval", "mesh_id" : 0, "model_part_name" : "please_specify_model_part_name", "velocity_constraints_settings" : { "constrained" : [true,true,true], "value" : [10.0, "3*t", "x+y"] }, "angular_velocity_constraints_settings" : { "constrained" : [true,true,true], "value" : [10.0, "3*t", "x+y"] }, "interval" : [0.0, 1e30] } """) #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["velocity_constraints_settings"].Has("constrained"): if settings["velocity_constraints_settings"]["constrained"].IsBool( ): is_fixed = settings["velocity_constraints_settings"][ "constrained"].GetBool() settings["velocity_constraints_settings"][ "constrained"] = default_settings[ "velocity_constraints_settings"]["constrained"] for i in range(3): settings["velocity_constraints_settings"]["constrained"][ i].SetBool(is_fixed) if settings["angular_velocity_constraints_settings"].Has( "constrained"): if settings["angular_velocity_constraints_settings"][ "constrained"].IsBool(): is_fixed = settings["angular_velocity_constraints_settings"][ "constrained"].GetBool() settings["angular_velocity_constraints_settings"][ "constrained"] = default_settings[ "angular_velocity_constraints_settings"]["constrained"] for i in range(3): settings["angular_velocity_constraints_settings"][ "constrained"][i].SetBool(is_fixed) settings.ValidateAndAssignDefaults(default_settings) self.model_part = Model[settings["model_part_name"].GetString()] self.cplusplus_version_of_this_process = DEM.ApplyKinematicConstraintsProcess( self.model_part, settings)
def GetParticleHistoryWatcher(self): watcher_type = self.sdem_parameters[ "full_particle_history_watcher"].GetString() if watcher_type == 'Empty': return None elif watcher_type == 'ParticlesHistoryWatcher': return DEM.ParticlesHistoryWatcher()
def __init__(self, Model, settings): KratosMultiphysics.Process.__init__(self) # Control module process acting on the imposed direction: 0 (X), 1 (Y), 2 (Z) or 3 (radial) # The radial direction is valid only for the vertical walls of a right cylinder with the base # on the 'X-Y' plane centered on (0,0). Negative target_stress means compression. self.model_part = Model[settings["model_part_name"].GetString()] self.control_module_process = Dem.ControlModule2DProcess( self.model_part, settings)
def Writeresults(self, time): # We reorder the Id of the model parts femdem_util = FEMDEM.FEMDEMCouplingUtilities() reorder_util_elem = FEMDEM.RenumberingNodesUtility( self.solid_model_part, self.fluid_model_part) reorder_util_elem.RenumberElements() Logger.PrintInfo("", "") Logger.PrintInfo( "", "***************** PRINTING RESULTS FOR GID *************************" ) Logger.PrintInfo("", "") Logger.Flush() number_pfem_nodes = femdem_util.GetNumberOfNodes(self.fluid_model_part) for node in self.balls_model_part.Nodes: node.Id = node.Id + number_pfem_nodes if self.GiDMultiFileFlag == "Multiples": self.mixed_solid_fluid_model_part.Elements.clear() self.mixed_solid_fluid_model_part.Nodes.clear() self.mixed_solid_balls_model_part.Elements.clear() self.mixed_solid_balls_model_part.Nodes.clear() self.mixed_solid_balls_fluid_model_part.Elements.clear() self.mixed_solid_balls_fluid_model_part.Nodes.clear() # Now we fill the mixed MDPA in order to print post_utils = DEMApplication.PostUtilities() post_utils.AddModelPartToModelPart( self.mixed_solid_fluid_model_part, self.fluid_model_part) post_utils.AddModelPartToModelPart( self.mixed_solid_balls_model_part, self.balls_model_part) post_utils.AddModelPartToModelPart( self.mixed_solid_balls_model_part, self.rigid_faces_model_part) post_utils.AddModelPartToModelPart( self.mixed_solid_balls_fluid_model_part, self.balls_model_part) post_utils.AddModelPartToModelPart( self.mixed_solid_balls_fluid_model_part, self.rigid_faces_model_part) post_utils.AddModelPartToModelPart( self.mixed_solid_balls_fluid_model_part, self.solid_model_part) post_utils.AddModelPartToModelPart( self.mixed_solid_balls_fluid_model_part, self.fluid_model_part) FEMDEM.FEMDEMCouplingUtilities().RemoveDuplicates( self.mixed_solid_fluid_model_part) self.write_dem_fem_results(time) reorder_util_elem.UndoRenumberElements()
def ModifyProperties(self, properties, param=0): if not param: DiscontinuumConstitutiveLaw = getattr( DEM, properties[DEM.DEM_DISCONTINUUM_CONSTITUTIVE_LAW_NAME])() DiscontinuumConstitutiveLaw.SetConstitutiveLawInProperties( properties, False) scheme = DEM.SymplecticEulerScheme() scheme.SetTranslationalIntegrationSchemeInProperties(properties, False) scheme.SetRotationalIntegrationSchemeInProperties(properties, False)
def SetFluidSolverParameters(self): self.time = self.pp.Start_time self.Dt = self.pp.Dt self.out = self.Dt if "REACTION" in self.pp.nodal_results: self.fluid_model_part.AddNodalSolutionStepVariable(Kratos.REACTION) if "DISTANCE" in self.pp.nodal_results: self.fluid_model_part.AddNodalSolutionStepVariable(Kratos.DISTANCE) self.vars_man.AddNodalVariables(self.fluid_model_part, self.vars_man.fluid_vars) if self.pp.type_of_inlet == 'ForceImposed': self.DEM_inlet = DEM.DEM_Force_Based_Inlet(self.dem_inlet_model_part, self.pp.force)
def __init__(self, gid_io, project_parameters, fluid_model_part, balls_model_part, clusters_model_part, rigid_faces_model_part, mixed_model_part): self.gid_io = weakref.proxy(gid_io) self.fluid_model_part = fluid_model_part self.balls_model_part = balls_model_part self.clusters_model_part = clusters_model_part self.rigid_faces_model_part = rigid_faces_model_part self.mixed_model_part = mixed_model_part self.pp = project_parameters self.post_utilities = DEMApp.PostUtilities()
def Writeresults(self, time): Logger.PrintInfo("DEM-Struct", "") Logger.PrintInfo( "DEM-Struct", "******************* PRINTING RESULTS FOR GID ***************************" ) Logger.Flush() if self.GiDMultiFileFlag == "Multiples": self.mixed_model_part.Elements.clear() self.mixed_model_part.Nodes.clear() # here order is important! DEMApplication.PostUtilities().AddModelPartToModelPart( self.mixed_model_part, self.balls_model_part) DEMApplication.PostUtilities().AddModelPartToModelPart( self.mixed_model_part, self.rigid_faces_model_part) DEMApplication.PostUtilities().AddModelPartToModelPart( self.mixed_model_part, self.contact_model_part) DEMApplication.PostUtilities().AddModelPartToModelPart( self.mixed_model_part, self.structures_model_part) self.write_dem_fem_results(time)
def setUp(self): self.current_model = Kratos.Model() self.spheres_model_part = self.current_model.CreateModelPart( "SpheresPart") self.spheres_model_part.AddNodalSolutionStepVariable(Kratos.VELOCITY) self.spheres_model_part.AddNodalSolutionStepVariable( Kratos.ANGULAR_VELOCITY) self.spheres_model_part.AddNodalSolutionStepVariable(Kratos.RADIUS) self.spheres_model_part.AddNodalSolutionStepVariable( Kratos.PARTICLE_MATERIAL) self.spheres_model_part.AddNodalSolutionStepVariable(Kratos.NODAL_MASS) properties = Kratos.Properties(0) properties[Kratos.YOUNG_MODULUS] = 3.331 properties[Kratos.POISSON_RATIO] = 0.0 self.ModifyProperties(properties) self.spheres_model_part.AddProperties(properties) DEM.PropertiesProxiesManager().CreatePropertiesProxies( self.spheres_model_part) self.creator_destructor = DEM.ParticleCreatorDestructor()
def __init__(self, Model, settings): #NOTE: Negative target_stress means compression self.spheres_model_part = Model["SpheresPart"] self.fem_model_part = Model["RigidFacePart"] #rigid_walls_model_part self.parameters = settings[ "multiaxial_control_module_generalized_2d_utility"] self.cm_step = 0 self.output_interval = self.parameters["Parameters"][ "output_interval"].GetInt() self.cm_utility = Dem.MultiaxialControlModuleGeneralized2DUtilities( self.spheres_model_part, self.fem_model_part, self.parameters)
def Factory(settings, Model): if (type(settings) != KratosMultiphysics.Parameters): raise Exception( "expected input shall be a Parameters object, encapsulating a json string" ) process_settings = settings["Parameters"] folder_settings = KratosMultiphysics.Parameters(""" { "help" : "This process applies constraints to the particles in a certain submodelpart, for a certain time interval", "mesh_id" : 0, "model_part_name" : "please_specify_model_part_name", "velocity_constraints_settings" : { "constrained" : [true,true,true], "value" : [10.0, "3*t", "x+y"], "table" : [0, 0, 0] }, "angular_velocity_constraints_settings" : { "constrained" : [true,true,true], "value" : [10.0, "3*t", "x+y"], "table" : [0, 0, 0] }, "interval" : [0.0, 1e30] } """) process_settings.AddMissingParameters(folder_settings) if process_settings.Has("model_part_name"): computing_model_part = Model[ process_settings["model_part_name"].GetString()] else: # using default name computing_model_part = Model["DEM"] process_settings.RemoveValue("help") return DEM.ApplyKinematicConstraintsToWallsProcess(computing_model_part, process_settings)
def RunCoupledSystem(): ## create structural analysis model = KratosMultiphysics.Model() with open("ProjectParameters.json", 'r') as parameter_file: parameters = KratosMultiphysics.Parameters(parameter_file.read()) structural_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis( model, parameters) structural_analysis.Initialize() print("-----> Initialized fem part") ## create dem analysis model_dem = KratosMultiphysics.Model() dem_analysis = main_script.Solution(model_dem) dem_analysis.Initialize() dem_analysis.InitializeTime() print("-----> Initialized dem part") ## create model parts mp_struct = model["Structure.computing_domain"] mp_dem = dem_analysis.rigid_face_model_part.GetSubModelPart('1') mp_dem_particle = dem_analysis.spheres_model_part ####################################################################### WALL ## create point load condition on all fem nodes cond_counter = 0 node_id_list = [] for node_i in mp_struct.Nodes: node_id = node_i.Id node_id_list.append(node_id) cond_counter += 1 mp_struct.CreateNewCondition("PointLoadCondition3D1N", cond_counter, [node_id], mp_struct.GetProperties()[0]) print("-----> Created fem PointLoadConditions") ## create structural submodal part used for mapping struct_smp = mp_struct.CreateSubModelPart("struct_sub") struct_smp.AddNodes(node_id_list) ## set up mapper print("-----> Added node list for mapping part") mapper_settings = KratosMultiphysics.Parameters("""{"mapper_settings": {"mapper_type": "nearest_neighbor", "interface_submodel_part_destination": "struct_sub", "echo_level":1}}""") print("-----> Wrote mapper settings") mapper = KratosMapping.MapperFactory.CreateMapper( mp_dem, mp_struct, mapper_settings["mapper_settings"]) print("-----> Initialized mapper") dem_mesh_moving_utility = DEMApplication.MoveMeshUtility() print("-----> Starting time loop:") ## run solving loop while dem_analysis.time < dem_analysis.final_time: print('current t: ', dem_analysis.time) ## call dem functions dem_analysis.UpdateTimeParameters() dem_analysis.BeforeSolveOperations(dem_analysis.time) dem_analysis.SolverSolve() dem_analysis.AfterSolveOperations() dem_analysis.FinalizeSingleTimeStep() ## map loads mapper.Map(DEMApplication.CONTACT_FORCES, StructuralMechanicsApplication.POINT_LOAD) ## call fem functions structural_analysis.time = structural_analysis._GetSolver( ).AdvanceInTime(structural_analysis.time) structural_analysis.InitializeSolutionStep() structural_analysis._GetSolver().Predict() structural_analysis._GetSolver().SolveSolutionStep() structural_analysis.FinalizeSolutionStep() structural_analysis.OutputSolutionStep() ## map-1 vel,disp mapper.InverseMap(KratosMultiphysics.VELOCITY, KratosMultiphysics.VELOCITY) mapper.InverseMap(KratosMultiphysics.DISPLACEMENT, KratosMultiphysics.DISPLACEMENT) ## move dem wall mesh dem_mesh_moving_utility.MoveDemMesh(mp_dem.Nodes, True) dem_analysis.OutputSingleTimeLoop( ) ## do this at the end of the loop to see deformed net ## finalize dem dem_analysis.Finalize() dem_analysis.CleanUpOperations() ## finalize fem structural_analysis.Finalize()
def Initialize(self): Say('Initializing simulation...\n') self.run_code = self.GetRunCode() # Moving to the recently created folder os.chdir(self.main_path) if self.do_print_results: [self.post_path, data_and_results, self.graphs_path, MPI_results] = \ self.procedures.CreateDirectories(str(self.main_path), str(self.project_parameters["problem_data"]["problem_name"].GetString()), self.run_code) SDP.CopyInputFilesIntoFolder(self.main_path, self.post_path) self.MPI_results = MPI_results self.FluidInitialize() self.DispersePhaseInitialize() self.SetAllModelParts() if self.project_parameters.Has( 'sdem_output_processes') and self.do_print_results: gid_output_options = self.project_parameters[ "sdem_output_processes"]["gid_output"][0]["Parameters"] result_file_configuration = gid_output_options[ "postprocess_parameters"]["result_file_configuration"] write_conditions_option = result_file_configuration[ "gidpost_flags"]["WriteConditionsFlag"].GetString( ) == "WriteConditions" deformed_mesh_option = result_file_configuration["gidpost_flags"][ "WriteDeformedMeshFlag"].GetString() == "WriteDeformed" old_gid_output_post_options_dict = { 'GiD_PostAscii': 'Ascii', 'GiD_PostBinary': 'Binary', 'GiD_PostAsciiZipped': 'AsciiZipped' } old_gid_output_multiple_file_option_dict = { 'SingleFile': 'Single', 'MultipleFiles': 'Multiples' } post_mode_key = result_file_configuration["gidpost_flags"][ "GiDPostMode"].GetString() multiple_files_option_key = result_file_configuration[ "gidpost_flags"]["MultiFileFlag"].GetString() self.swimming_DEM_gid_io = \ swimming_DEM_gid_output.SwimmingDEMGiDOutput( file_name = self.project_parameters["problem_data"]["problem_name"].GetString(), vol_output = result_file_configuration["body_output"].GetBool(), post_mode = old_gid_output_post_options_dict[post_mode_key], multifile = old_gid_output_multiple_file_option_dict[multiple_files_option_key], deformed_mesh = deformed_mesh_option, write_conditions = write_conditions_option) self.swimming_DEM_gid_io.initialize_swimming_DEM_results( self.spheres_model_part, self.cluster_model_part, self.rigid_face_model_part, self.mixed_model_part) self.SetPointGraphPrinter() self.AssignKinematicViscosityFromDynamicViscosity() super(SwimmingDEMAnalysis, self).Initialize() # coarse-graining: applying changes to the physical properties of the model to adjust for # the similarity transformation if required (fluid effects only). SDP.ApplySimilarityTransformations( self.fluid_model_part, self.project_parameters["similarity"] ["similarity_transformation_type"].GetInt(), self.project_parameters["similarity"] ["model_over_real_diameter_factor"].GetDouble()) if self.do_print_results: self.SetPostUtils() # creating an IOTools object to perform other printing tasks self.io_tools = SDP.IOTools(self.project_parameters) dem_physics_calculator = DEM.SphericElementGlobalPhysicsCalculator( self.spheres_model_part) if self.project_parameters["coupling"]["coupling_level_type"].GetInt(): default_meso_scale_length_needed = ( self.project_parameters["coupling"]["backward_coupling"] ["meso_scale_length"].GetDouble() <= 0.0 and self.spheres_model_part.NumberOfElements(0) > 0) if default_meso_scale_length_needed: biggest_size = ( 2 * dem_physics_calculator.CalculateMaxNodalVariable( self.spheres_model_part, Kratos.RADIUS)) self.project_parameters["coupling"]["backward_coupling"][ "meso_scale_length"].SetDouble(20 * biggest_size) elif self.spheres_model_part.NumberOfElements(0) == 0: self.project_parameters["coupling"]["backward_coupling"][ "meso_scale_length"].SetDouble(1.0) # creating a custom functions calculator for the implementation of # additional custom functions fluid_domain_dimension = self.project_parameters["fluid_parameters"][ "solver_settings"]["domain_size"].GetInt() self.custom_functions_tool = SDP.FunctionsCalculator( fluid_domain_dimension) # creating a debug tool self.dem_volume_tool = self.GetVolumeDebugTool() #self.SetEmbeddedTools() Say('Initialization Complete\n') if self.project_parameters["custom_fluid"][ "flow_in_porous_DEM_medium_option"].GetBool(): SDP.FixModelPart(self.spheres_model_part) ################################################## # I N I T I A L I Z I N G T I M E L O O P ################################################## self.step = 0 self.time = self.fluid_parameters["problem_data"][ "start_time"].GetDouble() self.fluid_time_step = self._GetFluidAnalysis()._GetSolver( )._ComputeDeltaTime() self.time_step = self.spheres_model_part.ProcessInfo.GetValue( Kratos.DELTA_TIME) self.rigid_face_model_part.ProcessInfo[ Kratos.DELTA_TIME] = self.time_step self.cluster_model_part.ProcessInfo[Kratos.DELTA_TIME] = self.time_step self.stationarity = False # setting up loop counters: self.DEM_to_fluid_counter = self.GetBackwardCouplingCounter() self.stationarity_counter = self.GetStationarityCounter() self.print_counter = self.GetPrintCounter() self.debug_info_counter = self.GetDebugInfo() self.particles_results_counter = self.GetParticlesResultsCounter() self.quadrature_counter = self.GetHistoryForceQuadratureCounter() # Phantom self._GetDEMAnalysis( ).analytic_data_counter = self.ProcessAnalyticDataCounter() self.mat_deriv_averager = SDP.Averager(1, 3) self.laplacian_averager = SDP.Averager(1, 3) self.report.total_steps_expected = int(self.end_time / self.time_step) Say(self.report.BeginReport(self.timer)) # creating a Post Utils object that executes several post-related tasks self.post_utils_DEM = DP.PostUtils( self.project_parameters['dem_parameters'], self.spheres_model_part) # otherwise variables are set to 0 by default: SDP.InitializeVariablesWithNonZeroValues(self.project_parameters, self.fluid_model_part, self.spheres_model_part) if self.do_print_results: self.SetUpResultsDatabase() # ANALYTICS BEGIN self.project_parameters.AddEmptyValue( "perform_analytics_option").SetBool(False) if self.project_parameters["perform_analytics_option"].GetBool(): import KratosMultiphysics.SwimmingDEMApplication.analytics as analytics variables_to_measure = [Kratos.PRESSURE] steps_between_measurements = 100 gauge = analytics.Gauge(self.fluid_model_part, self.fluid_time_step, self.end_time, variables_to_measure, steps_between_measurements) point_coors = [0.0, 0.0, 0.01] target_node = SDP.FindClosestNode(self.fluid_model_part, point_coors) target_id = target_node.Id Say(target_node.X, target_node.Y, target_node.Z) Say(target_id) def condition(node): return node.Id == target_id gauge.ConstructArrayOfNodes(condition) Say(gauge.variables) # ANALYTICS END self.FillHistoryForcePrecalculatedVectors() self.PerformZeroStepInitializations() if self.do_print_results: self._Print()
def SetAnalyticParticleWatcher(self): from analytic_tools import analytic_data_procedures self.particle_watcher = DEM.AnalyticParticleWatcher() self.particle_watcher_analyser = analytic_data_procedures.ParticleWatcherAnalyzer( analytic_particle_watcher=self.particle_watcher, path=self.main_path)
def __init__(self, Model, settings ): KratosMultiphysics.Process.__init__(self) self.model_part = Model[settings["model_part_name"].GetString()] self.automatic_dt_process = Dem.AutomaticDTProcess(self.model_part, settings)
def test_random_variable(self): settings = KratosMultiphysics.Parameters(""" { "pdf_breakpoints" : [0, 1, 2, 3, 3.5, 4, 4.5, 5, 5.5, 6], "pdf_values" : [1, 2, 3, 4, 3.5, 3, 2.5, 2, 1.5, 1], "do_use_seed" : true, "seed" : 1, "relative_closeness_tolerance" : 1e-6 } """) seed = settings["seed"].GetInt() n_bins = 25 # for the histogram tolerance = 0.005 n_max_experiments = int( 1e6) # should be enough with the tolerance=0.005 if settings["do_use_seed"].GetBool(): random_variable = DEM.PiecewiseLinearRandomVariable(settings, seed) else: random_variable = DEM.PiecewiseLinearRandomVariable(settings) mean_expected = TestRandomVariable.GetMean( settings["pdf_breakpoints"].GetVector(), settings["pdf_values"].GetVector()) mean = random_variable.GetMean() self.assertAlmostEqual( mean_expected, mean, None, 'The calculated PDF mean differs from the expected one.') TestRandomVariable.Say('Mean:', mean) n_experiments = 2 * n_bins error = tolerance + 1 i_iteration = 1 # Increase number of experiments until the 'L2-norm' of the # error of the recovered pdf is smaller than the tolerance while error > tolerance: sample = np.zeros(n_experiments) for i in range(n_experiments): sample[i] = random_variable.Sample() empirical_pdf, interval_boundaries = np.histogram(sample, n_bins, density=True) centers = 0.5 * (interval_boundaries[1:] + interval_boundaries[:-1]) interval_widths = interval_boundaries[1:] - interval_boundaries[:-1] pdf_expected = np.array( [random_variable.ProbabilityDensity(x) for x in centers]) error = TestRandomVariable.Error(empirical_pdf, pdf_expected, interval_widths) if i_iteration > 1: n_experiments *= int(max(2, (error / tolerance)**2)) else: n_experiments *= 2 if n_experiments > n_max_experiments: raise ValueError( '\nThe requested tolerance (' + '{:.4f}'.format(tolerance) + ')' + ' requires a greater number of experiments than the maximum allowed (' + '{:d}'.format(n_max_experiments) + ')! Please, increase it (reduce desired precision).') TestRandomVariable.Say('Sample size', n_experiments) TestRandomVariable.Say( 'Error = ' + '{:.4f}'.format(error), '( tolerance = ' + '{:.4f}'.format(tolerance), ')') i_iteration += 1 if TestRandomVariable.debug_mode: import matplotlib.pyplot as plt plt.plot(centers, empirical_pdf) plt.hist(sample, bins=n_bins, density=True, label='obtained (' + str(n_experiments) + ' samples)') plt.plot(centers, pdf_expected, label='desired') plt.legend() plt.savefig('piecewise_pdf.pdf')
def ModifyProperties(self, properties, param=0): scheme = DEM.SymplecticEulerScheme() scheme.SetTranslationalIntegrationSchemeInProperties(properties, False) scheme.SetRotationalIntegrationSchemeInProperties(properties, False)
def __init__(self, use_internal_interface=True, **kwargs): super(DEMWrapper, self).__init__(use_internal_interface, **kwargs) self.time = 0 self.step = 0 self.substeps = 0 self.particle_type = "SphericParticle3D" self.condition_type = "RigidFace3D3N" # The dictionary defines the relation between CUBA and # kratos variables self.variables_dictionary = { "RADIUS": [CUBA.RADIUS, KRTS.RADIUS], "DENSITY": [CUBA.DENSITY, KRTSDEM.PARTICLE_DENSITY], "NODAL_MASS": [None, KRTS.NODAL_MASS], "VELOCITY": [ CUBA.VELOCITY, KRTS.VELOCITY, KRTS.VELOCITY_X, KRTS.VELOCITY_Y, KRTS.VELOCITY_Z ], "DISPLACEMENT": [ CUBA.DELTA_DISPLACEMENT, KRTS.DISPLACEMENT, KRTS.DISPLACEMENT_X, KRTS.DISPLACEMENT_Y, KRTS.DISPLACEMENT_Z ], "EXTERNAL_APPLIED_FORCE": [ CUBA.EXTERNAL_APPLIED_FORCE, KRTSDEM.EXTERNAL_APPLIED_FORCE, KRTSDEM.EXTERNAL_APPLIED_FORCE_X, KRTSDEM.EXTERNAL_APPLIED_FORCE_Y, KRTSDEM.EXTERNAL_APPLIED_FORCE_Z ], "COHESIVE_GROUP": [None, KRTSDEM.COHESIVE_GROUP] } self.properties_dictionary = { "PARTICLE_DENSITY": [CUBA.DENSITY, KRTSDEM.PARTICLE_DENSITY], "YOUNG_MODULUS": [CUBA.YOUNG_MODULUS, KRTS.YOUNG_MODULUS], "POISSON_RATIO": [CUBA.POISSON_RATIO, KRTS.POISSON_RATIO], "PARTICLE_FRICTION": [CUBA.FRICTION_COEFFICIENT, KRTSDEM.PARTICLE_FRICTION], "PARTICLE_COHESION": [None, KRTSDEM.PARTICLE_COHESION], "ROLLING_FRICTION": [CUBA.ROLLING_FRICTION, KRTSDEM.ROLLING_FRICTION], "DEM_CONTINUUM_CONSTITUTIVE_LAW_NAME": [None, KRTSDEM.PARTICLE_COHESION], "DEM_DISCONTINUUM_CONSTITUTIVE_LAW_NAME": [None, KRTSDEM.PARTICLE_COHESION] } # Set DEM parameters self.solver_strategy = SolverStrategy self.creator_destructor = KRTSDEM.ParticleCreatorDestructor() self.dem_fem_search = KRTSDEM.DEM_FEM_Search() self.procedures = DEM_procedures.Procedures(DEM_parameters) # Define some paths as they are nedded by some modules of them. # These paths will NOT be used in this wrapper. self.graphs_path = '.' # This should not be nedded for Simphony self.parallelutils = DEM_procedures.ParallelUtils() self.scheme = self.procedures.SetScheme() self.initialize()
# To use this script just type in the terminal: python (or python3) cartesian_specimen_mdpa_creator.py name_of_your_case # It creates a file called name_of_your_caseDEM.mdpa. # Remember to overwrite the Properties and the boundary conditions if necessary!! from __future__ import print_function, absolute_import, division #makes KratosMultiphysics backward compatible with python 2.6 and 2.7 from KratosMultiphysics import * import KratosMultiphysics.DEMApplication as DEMapp import sys if len(sys.argv) < 2: print( "You must specify the name of the file to be printed. The string 'DEM.mdpa' will be appended to the provided string. " ) sys.exit() DEMapp.PreUtilities().CreateCartesianSpecimenMdpa(sys.argv[1])