def FluidSolve(self, time='None', solve_system=True):
Say('Solving Fluid... (', self.fluid_model_part.NumberOfElements(0), 'elements )\n')
if solve_system:
self.fluid_solution.fluid_solver.Solve()
else:
Say("Skipping solving system...\n")
def Rotate(self, model_part, time):
Say('Starting mesh movement...')
sin = math.sin(self.omega * time)
cos = math.cos(self.omega * time)
# Rotation matrix
R = cos * self.I + sin * self.Ux + (1.0 - cos) * self.UU
# Rotation matrix' (derivative of R with respect to time)
Rp = - self.omega * sin * self.I + self.omega * cos * self.Ux + self.omega * sin * self.UU
for node in model_part.Nodes:
P0 = np.array([node.X0, node.Y0, node.Z0])
P = self.a_init + R.dot(P0 - self.a_init)
Displacement = P - P0
Velocity = Rp.dot(P0 - self.a_init)
node.X, node.Y, node.Z = P[0], P[1], P[2]
node.SetSolutionStepValue(DISPLACEMENT, Vector(list(Displacement)))
node.SetSolutionStepValue(MESH_VELOCITY, Vector(list(Velocity)))
Say('Mesh movement finshed.')
def FinishAndSayEndMessage(self, message_start):
if self.n_simulations:
message_start += ' out of ' + str(self.n_simulations) + '...\n'
else:
message_start += '...\n'
message_start += '=' * self.print_line_length + '\n'
message_start += ('\n' + ' ' * int(self.print_line_length / 2) +
'*') * self.number_of_trailing_dots
Say(message_start)
def SetDragOutput(self):
# define the drag computation list
self.drag_list = define_output.DefineDragList()
self.drag_file_output_list = []
for it in self.drag_list:
f = open(it[1], 'w')
self.drag_file_output_list.append(f)
tmp = "#Drag for group " + it[1] + "\n"
f.write(tmp)
tmp = "time RX RY RZ"
f.write(tmp)
f.flush()
Say(self.drag_file_output_list)
def LoadFluid(self, fluid_time):
Say('\nLoading fluid from hdf5 file...')
# getting time indices and weights (identifying the two fluid time steps surrounding the current DEM step and assigning correspnding weights)
time_index_past, alpha_past, time_index_future, alpha_future = self.GetTimeIndicesAndWeights(fluid_time)
future_step_dataset_name = self.GetDatasetName(time_index_future)
must_load_from_database = self.time_index_past != time_index_past or self.time_index_future != time_index_future# old and future time steps must be updated
if must_load_from_database: # the current time is not between the two already loaded time steps
# the old future becomes the new past
self.data_array_past, self.data_array_future = self.data_array_future, self.data_array_past
index = Index()
self.UpdateFluidVariable(future_step_dataset_name + '/vx', Kratos.VELOCITY_X, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/vy', Kratos.VELOCITY_Y, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/vz', Kratos.VELOCITY_Z, next(index), must_load_from_database, alpha_past, alpha_future)
if self.store_pressure:
self.UpdateFluidVariable(future_step_dataset_name + '/p', Kratos.PRESSURE, next(index), must_load_from_database, alpha_past, alpha_future)
if self.load_derivatives:
self.UpdateFluidVariable(future_step_dataset_name + '/dvxx', Kratos.VELOCITY_X_GRADIENT_X, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvxy', Kratos.VELOCITY_X_GRADIENT_Y, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvxz', Kratos.VELOCITY_X_GRADIENT_Z, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvyx', Kratos.VELOCITY_Y_GRADIENT_X, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvyy', Kratos.VELOCITY_Y_GRADIENT_Y, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvyz', Kratos.VELOCITY_Y_GRADIENT_Z, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvzx', Kratos.VELOCITY_Z_GRADIENT_X, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvzy', Kratos.VELOCITY_Z_GRADIENT_Y, next(index), must_load_from_database, alpha_past, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvzz', Kratos.VELOCITY_Z_GRADIENT_Z, next(index), must_load_from_database, alpha_past, alpha_future)
if self.time_index_past == - 1: # it is the first upload
self.data_array_past[:] = self.data_array_future[:]
self.time_index_past = time_index_past
self.time_index_future = time_index_future
Say('Finished loading fluid from hdf5 file.\n')
def SayStartMessage(self):
message_start = '\n' + '=' * self.print_line_length
message_start += '\n\nRunning simulation number ' + str(
self.simulation_id)
if self.n_simulations:
message_start += ' out of ' + str(self.n_simulations) + '...\n'
else:
message_start += '...\n'
if self.identification_text:
message_start += self.identification_text
message_start += '_' * self.print_line_length + '\n'
Say(message_start)
def TellFinalSummary(self, time, step, DEM_step):
Say('*************************************************************')
Say('CALCULATIONS FINISHED. THE SIMULATION ENDED SUCCESSFULLY.')
simulation_elapsed_time = self.timer.time(
) - self.simulation_start_time
Say('Elapsed time: ' + '%.5f' % (simulation_elapsed_time) + ' s ')
Say('per fluid time step: ' + '%.5f' %
(simulation_elapsed_time / step) + ' s ')
Say('per DEM time step: ' + '%.5f' %
(simulation_elapsed_time / DEM_step) + ' s ')
Say('*************************************************************\n')
def TellFinalSummary(self, time, step, DEM_step):
simulation_elapsed_time = self.timer.time() - self.simulation_start_time
if simulation_elapsed_time and step and DEM_step:
elapsed_time_per_unit_fluid_step = simulation_elapsed_time / step
elapsed_time_per_unit_DEM_step = simulation_elapsed_time / DEM_step
else:
elapsed_time_per_unit_fluid_step = 0.0
elapsed_time_per_unit_DEM_step = 0.0
Say('*************************************************************')
Say('CALCULATIONS FINISHED. THE SIMULATION ENDED SUCCESSFULLY.')
Say('Elapsed time: ' + '%.5f'%(simulation_elapsed_time) + ' s ')
Say('per fluid time step: ' + '%.5f'%(elapsed_time_per_unit_fluid_step) + ' s ')
Say('per DEM time step: ' + '%.5f'%(elapsed_time_per_unit_DEM_step) + ' s ')
Say('*************************************************************\n')
def RunCase(self, parameters, simulation_id, identification_text=''):
self.simulation_id = simulation_id
self.identification_text = identification_text
self.SayStartMessage()
try:
with script.Solution(self.algorithm, parameters) as test:
test.Run()
error = None
message_start = 'Successfully finished running simulation number ' + str(
simulation_id)
self.FinishAndSayEndMessage(message_start)
except Exception:
error = sys.exc_info()
message_start = 'Finished running simulation number ' + str(
simulation_id)
self.FinishAndSayEndMessage(message_start)
Say('The simulation crashed.')
os.chdir(self.main_path)
return error
def LoadFluid(self, DEM_time):
Say('\nLoading fluid from hdf5 file...')
# getting time indices and weights (identifyint the two fluid time steps surrounding the current DEM step and assigning correspnding weights)
old_time_index, alpha_old, future_time_index, alpha_future = self.GetOldTimeIndicesAndWeights(
DEM_time, self.times, self.dt)
old_step_dataset_name = self.times_str[old_time_index]
future_step_dataset_name = self.times_str[future_time_index]
must_load_from_database = not self.old_time_index == old_time_index # old and future time steps must be updated
if must_load_from_database:
# new old becomes old future
self.old_data_array, self.future_data_array = self.future_data_array, self.old_data_array
indices = Index()
self.UpdateFluidVariable(future_step_dataset_name + '/vx', VELOCITY_X,
next(indices), must_load_from_database,
alpha_old, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/vy', VELOCITY_Y,
next(indices), must_load_from_database,
alpha_old, alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/vz', VELOCITY_Z,
next(indices), must_load_from_database,
alpha_old, alpha_future)
if self.store_pressure:
self.UpdateFluidVariable(future_step_dataset_name + '/p', PRESSURE,
next(indices), must_load_from_database,
alpha_old, alpha_future)
if self.load_derivatives:
self.UpdateFluidVariable(future_step_dataset_name + '/dvxx',
VELOCITY_X_GRADIENT_X, next(indices),
must_load_from_database, alpha_old,
alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvxy',
VELOCITY_X_GRADIENT_Y, next(indices),
must_load_from_database, alpha_old,
alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvxz',
VELOCITY_X_GRADIENT_Z, next(indices),
must_load_from_database, alpha_old,
alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvyx',
VELOCITY_Y_GRADIENT_X, next(indices),
must_load_from_database, alpha_old,
alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvyy',
VELOCITY_Y_GRADIENT_Y, next(indices),
must_load_from_database, alpha_old,
alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvyz',
VELOCITY_Y_GRADIENT_Z, next(indices),
must_load_from_database, alpha_old,
alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvzx',
VELOCITY_Z_GRADIENT_X, next(indices),
must_load_from_database, alpha_old,
alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvzy',
VELOCITY_Z_GRADIENT_Y, next(indices),
must_load_from_database, alpha_old,
alpha_future)
self.UpdateFluidVariable(future_step_dataset_name + '/dvzz',
VELOCITY_Z_GRADIENT_Z, next(indices),
must_load_from_database, alpha_old,
alpha_future)
Say('Finished loading fluid from hdf5 file.\n')
def TellTime(self, time):
Say('\nTIME = ', time)
Say('ELAPSED TIME = ',
self.timer.time() - self.simulation_start_time, '\n')
def AssessStationarity(self):
Say("Assessing Stationarity...\n")
self.stationarity = self.stationarity_tool.Assess(
self.fluid_model_part)
self.stationarity_counter.Deactivate(self.stationarity)
def RunMainTemporalLoop(self):
coupling_level_type = self.pp.CFD_DEM["coupling_level_type"].GetInt()
project_at_every_substep_option = self.pp.CFD_DEM[
"project_at_every_substep_option"].GetBool()
coupling_scheme_type = self.pp.CFD_DEM[
"coupling_scheme_type"].GetString()
integration_scheme = self.pp.CFD_DEM[
"TranslationalIntegrationScheme"].GetString()
dem_inlet_option = self.pp.CFD_DEM["dem_inlet_option"].GetBool()
interaction_start_time = self.pp.CFD_DEM[
"interaction_start_time"].GetDouble()
while self.TheSimulationMustGoOn():
self.time = self.time + self.Dt
self.step += 1
self.CloneTimeStep()
self.TellTime(self.time)
if coupling_scheme_type == "UpdatedDEM":
time_final_DEM_substepping = self.time + self.Dt
else:
time_final_DEM_substepping = self.time
#self.PerformEmbeddedOperations() TO-DO: it's crashing
self.UpdateALEMeshMovement(self.time)
# solving the fluid part
if self.step >= self.GetFirstStepForFluidComputation():
self.FluidSolve(self.time,
solve_system=self.fluid_solve_counter.Tick()
and not self.stationarity)
# assessing stationarity
if self.stationarity_counter.Tick():
self.AssessStationarity()
# printing if required
if self.particles_results_counter.Tick():
self.io_tools.PrintParticlesResults(
self.pp.variables_to_print_in_file, self.time,
self.spheres_model_part)
self.PrintDrag(self.drag_list, self.drag_file_output_list,
self.fluid_model_part, self.time)
if self.print_counter_updated_DEM.Tick():
if coupling_level_type:
self.projection_module.ComputePostProcessResults(
self.spheres_model_part.ProcessInfo)
self.post_utils.Writeresults(self.time_dem)
# solving the DEM part
self.derivative_recovery_counter.Activate(
self.time > interaction_start_time)
if self.derivative_recovery_counter.Tick():
self.RecoverDerivatives()
Say('Solving DEM... (',
self.spheres_model_part.NumberOfElements(0), 'elements )')
first_dem_iter = True
for self.time_dem in self.yield_DEM_time(
self.time_dem, time_final_DEM_substepping, self.Dt_DEM):
self.DEM_step += 1
self.spheres_model_part.ProcessInfo[TIME_STEPS] = self.DEM_step
self.rigid_face_model_part.ProcessInfo[
TIME_STEPS] = self.DEM_step
self.cluster_model_part.ProcessInfo[TIME_STEPS] = self.DEM_step
self.PerformInitialDEMStepOperations(self.time_dem)
it_is_time_to_forward_couple = (
self.time >= interaction_start_time and coupling_level_type
and (project_at_every_substep_option or first_dem_iter))
if it_is_time_to_forward_couple:
if coupling_scheme_type == "UpdatedDEM":
self.ApplyForwardCoupling()
else:
alpha = 1.0 - (time_final_DEM_substepping -
self.time_dem) / self.Dt
self.ApplyForwardCoupling(alpha)
if self.quadrature_counter.Tick():
self.AppendValuesForTheHistoryForce()
if integration_scheme in {
'Hybrid_Bashforth', 'TerminalVelocityScheme'
}:
# Advance in space only
self.DEMSolve(self.time_dem)
self.ApplyForwardCouplingOfVelocityToSlipVelocityOnly(
self.time_dem)
# performing the time integration of the DEM part
self.spheres_model_part.ProcessInfo[TIME] = self.time_dem
self.rigid_face_model_part.ProcessInfo[TIME] = self.time_dem
self.cluster_model_part.ProcessInfo[TIME] = self.time_dem
if self.do_solve_dem:
self.DEMSolve(self.time_dem)
self.disperse_phase_solution.DEMFEMProcedures.MoveAllMeshes(
self.all_model_parts, self.time_dem, self.Dt_DEM)
#### TIME CONTROL ##################################
# adding DEM elements by the inlet:
if dem_inlet_option:
# After solving, to make sure that neighbours are already set.
self.disperse_phase_solution.DEM_inlet.CreateElementsFromInletMesh(
self.spheres_model_part, self.cluster_model_part,
self.disperse_phase_solution.creator_destructor)
if self.print_counter_updated_fluid.Tick():
if coupling_level_type:
self.projection_module.ComputePostProcessResults(
self.spheres_model_part.ProcessInfo)
self.post_utils.Writeresults(self.time_dem)
first_dem_iter = False
# applying DEM-to-fluid coupling
if self.DEM_to_fluid_counter.Tick(
) and self.time >= interaction_start_time:
self.projection_module.ProjectFromParticles()
#### PRINTING GRAPHS ####
os.chdir(self.graphs_path)
# measuring mean velocities in a certain control volume (the 'velocity trap')
if self.pp.CFD_DEM["VelocityTrapOption"].GetBool():
self.post_utils_DEM.ComputeMeanVelocitiesinTrap(
"Average_Velocity.txt", self.time)
os.chdir(self.post_path)
# coupling checks (debugging)
if self.debug_info_counter.Tick():
self.dem_volume_tool.UpdateDataAndPrint(
self.pp.CFD_DEM["fluid_domain_volume"].GetDouble())
# printing if required
if self.particles_results_counter.Tick():
self.io_tools.PrintParticlesResults(
self.pp.variables_to_print_in_file, self.time,
self.spheres_model_part)
self.PrintDrag(self.drag_list, self.drag_file_output_list,
self.fluid_model_part, self.time)
def Initialize(self):
Say('\nInitializing Problem...\n')
self.run_code = self.GetRunCode()
# Moving to the recently created folder
os.chdir(self.main_path)
[self.post_path, data_and_results, self.graphs_path, MPI_results] = \
self.procedures.CreateDirectories(str(self.main_path),
str(self.pp.CFD_DEM["problem_name"].GetString()),
self.run_code)
SDP.CopyInputFilesIntoFolder(self.main_path, self.post_path)
self.MPI_results = MPI_results
#self.mixed_model_part = self.all_model_parts.Get('MixedPart')
vars_man.ConstructListsOfVariables(self.pp)
self.FluidInitialize()
self.DispersePhaseInitialize()
self.SetAllModelParts()
self.SetCutsOutput()
self.swimming_DEM_gid_io = \
swimming_DEM_gid_output.SwimmingDEMGiDOutput(
self.pp.problem_name,
self.pp.VolumeOutput,
self.pp.GiDPostMode,
self.pp.GiDMultiFileFlag,
self.pp.GiDWriteMeshFlag,
self.pp.GiDWriteConditionsFlag
)
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.SetDragOutput()
self.SetPointGraphPrinter()
self.TransferGravityFromDisperseToFluid()
# 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.pp.CFD_DEM["similarity_transformation_type"].GetInt(),
self.pp.CFD_DEM["model_over_real_diameter_factor"].GetDouble())
self.SetPostUtils()
# creating an IOTools object to perform other printing tasks
self.io_tools = SDP.IOTools(self.pp)
# creating a projection module for the fluid-DEM coupling
self.h_min = 0.01
n_balls = 1
fluid_volume = 10
# the variable n_particles_in_depth is only relevant in 2D problems
self.pp.CFD_DEM.n_particles_in_depth = int(
math.sqrt(n_balls / fluid_volume))
# creating a physical calculations module to analyse the DEM model_part
dem_physics_calculator = SphericElementGlobalPhysicsCalculator(
self.spheres_model_part)
if self.pp.CFD_DEM["coupling_level_type"].GetInt():
default_meso_scale_length_needed = (
self.pp.CFD_DEM["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, RADIUS))
self.pp.CFD_DEM.meso_scale_length = 20 * biggest_size
elif self.spheres_model_part.NumberOfElements(0) == 0:
self.pp.CFD_DEM.meso_scale_length = 1.0
self.projection_module = CFD_DEM_coupling.ProjectionModule(
self.fluid_model_part,
self.spheres_model_part,
self.rigid_face_model_part,
self.pp,
flow_field=self.GetFieldUtility())
self.projection_module.UpdateDatabase(self.h_min)
# creating a custom functions calculator for the implementation of
# additional custom functions
self.custom_functions_tool = SDP.FunctionsCalculator(self.pp)
# creating a stationarity assessment tool
self.stationarity_tool = SDP.StationarityAssessmentTool(
self.pp.CFD_DEM["max_pressure_variation_rate_tol"].GetDouble(),
self.custom_functions_tool)
# creating a debug tool
self.dem_volume_tool = self.GetVolumeDebugTool()
#self.SetEmbeddedTools()
Say('Initialization Complete\n')
self.report.Prepare(self.timer,
self.pp.CFD_DEM["ControlTime"].GetDouble())
#first_print = True; index_5 = 1; index_10 = 1; index_50 = 1; control = 0.0
if self.pp.CFD_DEM["ModelDataInfo"].GetBool():
os.chdir(data_and_results)
if self.pp.CFD_DEM.ContactMeshOption == "ON":
coordination_number = self.procedures.ModelData(
self.spheres_model_part, self.solver)
Say('Coordination Number: ' + str(coordination_number) + '\n')
os.chdir(self.main_path)
else:
Say('Activate Contact Mesh for ModelData information\n')
if self.pp.CFD_DEM["flow_in_porous_medium_option"].GetBool():
fluid_frac_util = SDP.FluidFractionFieldUtility(
self.fluid_model_part, self.pp.CFD_DEM.min_fluid_fraction)
for field in self.pp.fluid_fraction_fields:
fluid_frac_util.AppendLinearField(field)
fluid_frac_util.AddFluidFractionField()
if self.pp.CFD_DEM["flow_in_porous_DEM_medium_option"].GetBool():
SDP.FixModelPart(self.spheres_model_part)
# choosing the directory in which we want to work (print to)
os.chdir(self.post_path)
##################################################
# 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.pp.Start_time
self.Dt = self.pp.Dt
self.final_time = self.pp.CFD_DEM["FinalTime"].GetDouble()
self.DEM_step = 0
self.time_dem = 0.0
self.Dt_DEM = self.spheres_model_part.ProcessInfo.GetValue(DELTA_TIME)
self.rigid_face_model_part.ProcessInfo[DELTA_TIME] = self.Dt_DEM
self.cluster_model_part.ProcessInfo[DELTA_TIME] = self.Dt_DEM
self.stationarity = False
# setting up loop counters:
self.fluid_solve_counter = self.GetFluidSolveCounter()
self.DEM_to_fluid_counter = self.GetBackwardCouplingCounter()
self.derivative_recovery_counter = self.GetRecoveryCounter()
self.stationarity_counter = self.GetStationarityCounter()
self.print_counter_updated_DEM = self.GetPrintCounterUpdatedDEM()
self.print_counter_updated_fluid = self.GetPrintCounterUpdatedFluid()
self.debug_info_counter = self.GetDebugInfo()
self.particles_results_counter = self.GetParticlesResultsCounter()
self.quadrature_counter = self.GetHistoryForceQuadratureCounter()
self.mat_deriv_averager = SDP.Averager(1, 3)
self.laplacian_averager = SDP.Averager(1, 3)
self.report.total_steps_expected = int(self.final_time / self.Dt_DEM)
Say(self.report.BeginReport(self.timer))
# creating a Post Utils object that executes several post-related tasks
self.post_utils_DEM = DEM_procedures.PostUtils(self.pp.CFD_DEM,
self.spheres_model_part)
SDP.InitializeVariablesWithNonZeroValues(
self.fluid_model_part, self.spheres_model_part,
self.pp) # otherwise variables are set to 0 by default
self.SetUpResultsDatabase()
# ANALYTICS BEGIN
self.pp.CFD_DEM.perform_analytics_option = False
if self.pp.CFD_DEM.perform_analytics_option:
import analytics
variables_to_measure = [PRESSURE]
steps_between_measurements = 100
gauge = analytics.Gauge(self.fluid_model_part, self.Dt,
self.final_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
import derivative_recovery.derivative_recovery_strategy as derivative_recoverer
self.recovery = derivative_recoverer.DerivativeRecoveryStrategy(
self.pp, self.fluid_model_part, self.custom_functions_tool)
self.FillHistoryForcePrecalculatedVectors()
self.PerformZeroStepInitializations()
self.post_utils.Writeresults(self.time)
import define_output # MA: some GUI write this file, some others not!
except ImportError:
pass
# Import MPI modules if needed. This way to do this is only valid when using OpenMPI.
# For other implementations of MPI it will not work.
if "OMPI_COMM_WORLD_SIZE" in os.environ:
# Kratos MPI
from KratosMultiphysics.MetisApplication import *
from KratosMultiphysics.MPISearchApplication import *
from KratosMultiphysics.mpi import *
# DEM Application MPI
import DEM_procedures_mpi as DEM_procedures
import DEM_material_test_script_mpi as DEM_material_test_script
Say('Running under MPI...........\n')
else:
# DEM Application
import DEM_procedures
import DEM_material_test_script
Say('Running under OpenMP........\n')
sys.path.insert(0, '')
class Logger(object):
def __init__(self):
self.terminal = sys.stdout
self.console_output_file_name = 'console_output.txt'
self.path_to_console_out_file = os.getcwd()
self.path_to_console_out_file += '/' + self.console_output_file_name
simulation_id += 1
varying_parameters[
'material_acceleration_calculation_type'] = derivatives_type
varying_parameters[
'laplacian_calculation_type'] = derivatives_type
parameters = Parameters(json.dumps(varying_parameters))
identification_text = 'mesh size: ' + str(
size) + '\nrecovery type: ' + str(derivatives_type) + '\n'
error = runner.RunCase(parameters,
simulation_id,
identification_text=identification_text)
if error:
errors.append(error)
combinations_that_failed.append({
'size': size,
'type': derivatives_type
})
Say()
Say('****************************************')
if combinations_that_failed:
Say('The following combinations produced an error:')
Say('combinations_that_failed', combinations_that_failed)
for combination, error in zip(combinations_that_failed, errors):
Say(combination)
Say(error[1:2])
Say(traceback.print_tb(error[2]))
else:
Say('All combinations run without errors')
Say('****************************************')
def SetBetaParameters(
self
): # These are input parameters that have not yet been transferred to the interface
# import the configuration data as read from the GiD
##############################################################################
# #
# INITIALIZE #
# #
##############################################################################
#G
self.pp.CFD_DEM.AddEmptyValue("do_solve_dem").SetBool(True)
self.pp.CFD_DEM.AddEmptyValue("fluid_already_calculated").SetBool(
False)
self.pp.CFD_DEM.AddEmptyValue("recovery_echo_level").SetInt(1)
self.pp.CFD_DEM.AddEmptyValue("gradient_calculation_type").SetInt(1)
self.pp.CFD_DEM.AddEmptyValue("pressure_grad_recovery_type").SetInt(0)
self.pp.CFD_DEM.AddEmptyValue("fluid_fraction_grad_type").SetInt(0)
self.pp.CFD_DEM.AddEmptyValue("store_full_gradient_option").SetBool(
False)
self.pp.CFD_DEM.AddEmptyValue("store_fluid_pressure_option").SetBool(
False)
self.pp.CFD_DEM.AddEmptyValue("laplacian_calculation_type").SetInt(0)
self.pp.CFD_DEM.AddEmptyValue("do_search_neighbours").SetBool(True)
self.pp.CFD_DEM.AddEmptyValue("faxen_terms_type").SetInt(0)
self.pp.CFD_DEM.AddEmptyValue(
"material_acceleration_calculation_type").SetInt(1)
self.pp.CFD_DEM.AddEmptyValue("faxen_force_type").SetInt(0)
self.pp.CFD_DEM.AddEmptyValue("vorticity_calculation_type").SetInt(5)
self.pp.CFD_DEM.AddEmptyValue(
"print_FLUID_VEL_PROJECTED_RATE_option").SetBool(False)
self.pp.CFD_DEM.AddEmptyValue(
"print_MATERIAL_FLUID_ACCEL_PROJECTED_option").SetBool(True)
self.pp.CFD_DEM.AddEmptyValue("basset_force_type").SetInt(0)
self.pp.CFD_DEM.AddEmptyValue("print_BASSET_FORCE_option").SetBool(
True)
self.pp.CFD_DEM.AddEmptyValue("basset_force_integration_type").SetInt(
2)
self.pp.CFD_DEM.AddEmptyValue("n_init_basset_steps").SetInt(0)
self.pp.CFD_DEM.AddEmptyValue("time_steps_per_quadrature_step").SetInt(
1)
self.pp.CFD_DEM.AddEmptyValue("delta_time_quadrature").SetDouble(
self.pp.CFD_DEM["time_steps_per_quadrature_step"].GetInt() *
self.pp.CFD_DEM["MaxTimeStep"].GetDouble())
self.pp.CFD_DEM.AddEmptyValue("quadrature_order").SetInt(2)
self.pp.CFD_DEM.AddEmptyValue("time_window").SetDouble(0.8)
self.pp.CFD_DEM.AddEmptyValue("number_of_exponentials").SetInt(2)
self.pp.CFD_DEM.AddEmptyValue(
"number_of_quadrature_steps_in_window").SetInt(
int(self.pp.CFD_DEM["time_window"].GetDouble() /
self.pp.CFD_DEM["delta_time_quadrature"].GetDouble()))
self.pp.CFD_DEM.AddEmptyValue(
"do_impose_flow_from_field_option").SetBool(False)
self.pp.CFD_DEM.AddEmptyValue(
"print_MATERIAL_ACCELERATION_option").SetBool(True)
self.pp.CFD_DEM.AddEmptyValue(
"print_FLUID_ACCEL_FOLLOWING_PARTICLE_PROJECTED_option").SetBool(
False)
self.pp.CFD_DEM.AddEmptyValue("print_VORTICITY_option").SetBool(True)
self.pp.CFD_DEM.AddEmptyValue(
"print_MATERIAL_ACCELERATION_option").SetBool(True)
self.pp.CFD_DEM.AddEmptyValue(
"print_VELOCITY_GRADIENT_option").SetBool(True)
self.pp.CFD_DEM.AddEmptyValue(
"print_DISPERSE_FRACTION_option").SetBool(False)
self.pp.CFD_DEM.AddEmptyValue(
"print_FLUID_FRACTION_GRADIENT_option").SetBool(False)
self.pp.CFD_DEM.AddEmptyValue(
"print_FLUID_FRACTION_GRADIENT_PROJECTED_option").SetBool(False)
self.pp.CFD_DEM.AddEmptyValue("calculate_diffusivity_option").SetBool(
False)
self.pp.CFD_DEM.AddEmptyValue("print_CONDUCTIVITY_option").SetBool(
False)
self.pp.CFD_DEM.AddEmptyValue("filter_velocity_option").SetBool(False)
self.pp.CFD_DEM.AddEmptyValue("print_PARTICLE_VEL_option").SetBool(
False)
self.pp.CFD_DEM.AddEmptyValue(
"apply_time_filter_to_fluid_fraction_option").SetBool(False)
self.pp.CFD_DEM.AddEmptyValue(
"full_particle_history_watcher").SetString("Empty")
self.pp.CFD_DEM.AddEmptyValue("prerun_fluid_file_name").SetString("")
self.pp.CFD_DEM.AddEmptyValue("frame_of_reference_type").SetInt(0)
self.pp.CFD_DEM.AddEmptyValue("angular_velocity_of_frame_X").SetDouble(
0.0)
self.pp.CFD_DEM.AddEmptyValue("angular_velocity_of_frame_Y").SetDouble(
0.0)
self.pp.CFD_DEM.AddEmptyValue("angular_velocity_of_frame_Z").SetDouble(
0.0)
self.pp.CFD_DEM.AddEmptyValue(
"angular_velocity_of_frame_old_X").SetDouble(0.0)
self.pp.CFD_DEM.AddEmptyValue(
"angular_velocity_of_frame_old_Y").SetDouble(0.0)
self.pp.CFD_DEM.AddEmptyValue(
"angular_velocity_of_frame_old_Z").SetDouble(0.0)
self.pp.CFD_DEM.AddEmptyValue(
"acceleration_of_frame_origin_X").SetDouble(0.0)
self.pp.CFD_DEM.AddEmptyValue(
"acceleration_of_frame_origin_Y").SetDouble(0.0)
self.pp.CFD_DEM.AddEmptyValue(
"acceleration_of_frame_origin_Z").SetDouble(0.0)
self.pp.CFD_DEM.AddEmptyValue(
"angular_acceleration_of_frame_X").SetDouble(0.0)
self.pp.CFD_DEM.AddEmptyValue(
"angular_acceleration_of_frame_Y").SetDouble(0.0)
self.pp.CFD_DEM.AddEmptyValue(
"angular_acceleration_of_frame_Z").SetDouble(0.0)
self.pp.CFD_DEM.AddEmptyValue("ALE_option").SetBool(False)
self.pp.CFD_DEM.AddEmptyValue(
"frame_rotation_axis_initial_point").SetVector(Vector([0., 0.,
0.]))
self.pp.CFD_DEM.AddEmptyValue(
"frame_rotation_axis_final_point").SetVector(Vector([0., 0., 1.]))
self.pp.CFD_DEM.AddEmptyValue("angular_velocity_magnitude").SetDouble(
1.0)
self.pp.CFD_DEM.print_DISPERSE_FRACTION_option = False
self.pp.CFD_DEM.print_steps_per_plot_step = 1
self.pp.CFD_DEM.PostCationConcentration = False
# Making the fluid step an exact multiple of the DEM step
self.pp.Dt = int(self.pp.Dt / self.pp.CFD_DEM["MaxTimeStep"].GetDouble(
)) * self.pp.CFD_DEM["MaxTimeStep"].GetDouble()
self.output_time = int(self.pp.CFD_DEM["OutputTimeStep"].GetDouble() /
self.pp.CFD_DEM["MaxTimeStep"].GetDouble()
) * self.pp.CFD_DEM["MaxTimeStep"].GetDouble()
Say('Dt_DEM', self.pp.CFD_DEM["MaxTimeStep"].GetDouble())
Say('self.pp.Dt', self.pp.Dt)
Say('self.output_time', self.output_time)
self.pp.viscosity_modification_type = 0.0
self.domain_size = 3
self.pp.type_of_inlet = 'VelocityImposed' # 'VelocityImposed' or 'ForceImposed'
self.pp.force = Vector(3)
self.pp.force[0] = 0
self.pp.force[1] = 0
self.pp.force[2] = 1e-10
# defining and adding imposed porosity fields
self.pp.fluid_fraction_fields = []
field1 = SDP.FluidFractionFieldUtility.LinearField(
0.0, [0.0, 0.0, 0.0], [-1.0, -1.0, 0.15], [1.0, 1.0, 0.3])
from math import pi
self.pp.CFD_DEM.AddEmptyValue("fluid_domain_volume").SetDouble(
0.5**2 * 2 * pi) # write down the volume you know it has
self.pp.fluid_fraction_fields.append(field1)
def RunMainTemporalLoop(self):
while self.TheSimulationMustGoON():
self.time = self.time + self.Dt
self.step += 1
self.TransferTimeToFluidSolver()
self.CloneTimeStep()
self.TellTime(self.time)
if self.pp.CFD_DEM["coupling_scheme_type"].GetString(
) == "UpdatedDEM":
time_final_DEM_substepping = self.time + self.Dt
else:
time_final_DEM_substepping = self.time
#self.PerformEmbeddedOperations() #TODO: it's crashing
# solving the fluid part
if self.step >= self.GetFirstStepForFluidComputation():
self.FluidSolve(self.time,
solve_system=self.fluid_solve_counter.Tick()
and not self.stationarity)
# assessing stationarity
if self.stationarity_counter.Tick():
Say("Assessing Stationarity...\n")
self.stationarity = self.stationarity_tool.Assess(
self.fluid_model_part)
self.stationarity_counter.Deactivate(self.stationarity)
# printing if required
if self.particles_results_counter.Tick():
# eliminating remote balls
#if self.pp.dem.BoundingBoxOption == "ON":
# self.creator_destructor.DestroyParticlesOutsideBoundingBox(self.disperse_phase_algorithm.spheres_model_part)
self.io_tools.PrintParticlesResults(
self.pp.variables_to_print_in_file, self.time,
self.disperse_phase_algorithm.spheres_model_part)
#self.graph_printer.PrintGraphs(self.time) #MA: commented out because the constructor was already commented out
self.PrintDrag(self.drag_list, self.drag_file_output_list,
self.fluid_model_part, self.time)
if self.output_time <= self.out and self.pp.CFD_DEM[
"coupling_scheme_type"].GetString() == "UpdatedDEM":
if self.pp.CFD_DEM["coupling_level_type"].GetInt() > 0:
self.projection_module.ComputePostProcessResults(
self.disperse_phase_algorithm.spheres_model_part.
ProcessInfo)
self.post_utils.Writeresults(self.time)
self.out = 0
# solving the DEM part
self.derivative_recovery_counter.Activate(
self.time >
self.pp.CFD_DEM["interaction_start_time"].GetDouble())
if self.derivative_recovery_counter.Tick():
self.recovery.Recover()
Say(
'Solving DEM... (',
self.disperse_phase_algorithm.spheres_model_part.
NumberOfElements(0), 'elements )')
first_dem_iter = True
interaction_start_time = self.pp.CFD_DEM[
"interaction_start_time"].GetDouble()
coupling_level_type = self.pp.CFD_DEM[
"coupling_level_type"].GetInt()
project_at_every_substep_option = self.pp.CFD_DEM[
"project_at_every_substep_option"].GetBool()
coupling_scheme_type = self.pp.CFD_DEM[
"coupling_scheme_type"].GetString()
integration_scheme = self.pp.CFD_DEM[
"IntegrationScheme"].GetString()
basset_force_type = self.pp.CFD_DEM["basset_force_type"].GetInt()
dem_inlet_option = self.pp.CFD_DEM["dem_inlet_option"].GetBool()
for self.time_dem in self.yield_DEM_time(
self.time_dem, time_final_DEM_substepping, self.Dt_DEM):
self.DEM_step += 1 # this variable is necessary to get a good random insertion of particles
self.disperse_phase_algorithm.spheres_model_part.ProcessInfo[
TIME_STEPS] = self.DEM_step
self.disperse_phase_algorithm.rigid_face_model_part.ProcessInfo[
TIME_STEPS] = self.DEM_step
self.disperse_phase_algorithm.cluster_model_part.ProcessInfo[
TIME_STEPS] = self.DEM_step
self.PerformInitialDEMStepOperations(self.time_dem)
if self.time >= interaction_start_time and coupling_level_type and (
project_at_every_substep_option or first_dem_iter):
if coupling_scheme_type == "UpdatedDEM":
self.ApplyForwardCoupling()
else:
self.ApplyForwardCoupling(
(time_final_DEM_substepping - self.time_dem) /
self.Dt)
if integration_scheme in {
'Hybrid_Bashforth', 'TerminalVelocityScheme'
}:
self.DEMSolve(self.time_dem)
self.ApplyForwardCouplingOfVelocityOnly(
self.time_dem)
else:
if basset_force_type > 0:
node.SetSolutionStepValue(SLIP_VELOCITY_X, vx)
node.SetSolutionStepValue(SLIP_VELOCITY_Y, vy)
if self.quadrature_counter.Tick():
self.AppendValuesForTheHistoryForce()
# performing the time integration of the DEM part
self.disperse_phase_algorithm.spheres_model_part.ProcessInfo[
TIME] = self.time_dem
self.disperse_phase_algorithm.rigid_face_model_part.ProcessInfo[
TIME] = self.time_dem
self.disperse_phase_algorithm.cluster_model_part.ProcessInfo[
TIME] = self.time_dem
if self.pp.do_solve_dem:
self.DEMSolve(self.time_dem)
self.disperse_phase_algorithm.DEMFEMProcedures.MoveAllMeshes(
self.all_model_parts, self.time_dem, self.Dt_DEM)
#### TIME CONTROL ##################################
# adding DEM elements by the inlet:
if dem_inlet_option:
self.disperse_phase_algorithm.DEM_inlet.CreateElementsFromInletMesh(
self.disperse_phase_algorithm.spheres_model_part,
self.disperse_phase_algorithm.cluster_model_part,
self.disperse_phase_algorithm.creator_destructor
) # After solving, to make sure that neighbours are already set.
if self.output_time <= self.out and coupling_scheme_type == "UpdatedFluid":
if coupling_level_type:
self.projection_module.ComputePostProcessResults(
self.disperse_phase_algorithm.spheres_model_part.
ProcessInfo)
self.post_utils.Writeresults(self.time_dem)
self.out = 0
self.out = self.out + self.Dt_DEM
first_dem_iter = False
# applying DEM-to-fluid coupling
if self.DEM_to_fluid_counter.Tick(
) and self.time >= interaction_start_time:
self.projection_module.ProjectFromParticles()
#### PRINTING GRAPHS ####
os.chdir(self.graphs_path)
# measuring mean velocities in a certain control volume (the 'velocity trap')
if self.pp.CFD_DEM["VelocityTrapOption"].GetBool():
self.post_utils_DEM.ComputeMeanVelocitiesinTrap(
"Average_Velocity.txt", self.time)
os.chdir(self.post_path)
# coupling checks (debugging)
if self.debug_info_counter.Tick():
self.dem_volume_tool.UpdateDataAndPrint(
self.pp.CFD_DEM["fluid_domain_volume"].GetDouble())
# printing if required
if self.particles_results_counter.Tick():
self.io_tools.PrintParticlesResults(
self.pp.variables_to_print_in_file, self.time,
self.disperse_phase_algorithm.spheres_model_part)
#self.graph_printer.PrintGraphs(self.time) #MA: commented out because the constructor was already commented out
self.PrintDrag(self.drag_list, self.drag_file_output_list,
self.fluid_model_part, self.time)
