def Initialize(self):
# creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = False
import strategy_python
self.solver = strategy_python.SolvingStrategyPython(self.model_part, self.time_scheme, self.poisson_linear_solver, self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep, MoveMeshFlag)
def Initialize(self):
# definition of time scheme
self.time_scheme = ResidualBasedPredictorCorrectorBossakScheme(
self.damp_factor)
# definition of the convergence criteria
# self.conv_criteria = DisplacementCriteria(self.toll,self.absolute_tol)
# builder_and_solver = ResidualBasedEliminationBuilderAndSolver(self.structure_linear_solver)
# creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = True
MoveMeshFlag = True
import strategy_python
self.solver = strategy_python.SolvingStrategyPython(
self.model_part, self.time_scheme, self.structure_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
# flags necessary for save_structure
for node in (self.model_part).Nodes:
node.SetSolutionStepValue(IS_STRUCTURE, 0, 1.0)
node.SetSolutionStepValue(IS_FLUID, 0, 0.0)
(self.save_structure_model_part_process).SaveStructureModelPart(
self.model_part, self.shell_model_part, self.domain_size)
def Initialize(self):
#creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = False
pDiagPrecond = DiagonalPreconditioner()
maximum_number_of_particles= 8*self.domain_size
self.ExplicitStrategy=PFEM2_Explicit_Strategy(self.model_part,self.domain_size, MoveMeshFlag)
self.VariableUtils = VariableUtils()
if self.domain_size==2:
self.moveparticles = MoveParticleUtilityDiff2D(self.model_part,maximum_number_of_particles)
else:
self.moveparticles = MoveParticleUtilityDiff3D(self.model_part,maximum_number_of_particles)
print "self.domain_size = ", self.domain_size
if self.domain_size==2:
self.calculatewatervolume = CalculateWaterFraction2D(self.model_part)
else:
self.calculatewatervolume = CalculateWaterFraction3D(self.model_part)
self.moveparticles.MountBinDiff()
self.water_volume=0.0 #we initialize it at zero
self.water_initial_volume=0.0 #we initialize it at zero
self.water_initial_volume_flag=True #we initialize it at zero
self.mass_correction_factor=0.0
self.normal_tools.CalculateBodyNormals(self.model_part,self.domain_size);
condition_number=1
'''
if self.domain_size==2:
self.addBC = AddFixedVelocityCondition2D(self.model_part)
else:
self.addBC = AddFixedVelocityCondition3D(self.model_part)
(self.addBC).AddThem()
'''
import strategy_python #implicit solver
self.monolitic_solver = strategy_python.SolvingStrategyPython(self.model_part,self.time_scheme,self.monolitic_linear_solver,self.conv_criteria,CalculateReactionFlag,ReformDofSetAtEachStep,MoveMeshFlag)
#to test time
self.calculateinitialdrag=0.0
self.streamlineintegration=0.0
self.accelerateparticles=0.0
self.implicit_solving=0.0
self.lagrangiantoeulerian=0.0
self.reseed=0.0
self.prereseed=0.0
self.erasing=0.0
self.total=0.0
self.nodaltasks=0.0
self.thermal=0.0
self.implicitviscosity=0.0
def Initialize(self):
#creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = False
pDiagPrecond = DiagonalPreconditioner()
#build the edge data structure
#if self.domain_size==2:
# self.matrix_container = MatrixContainer2D()
#else:
# self.matrix_container = MatrixContainer3D()
#maximum_number_of_particles= 10*self.domain_size
maximum_number_of_particles= 12*self.domain_size
self.ExplicitStrategy=PFEM2_Explicit_Strategy(self.model_part,self.domain_size, MoveMeshFlag)
self.VariableUtils = VariableUtils()
if self.domain_size==2:
self.moveparticles = MoveParticleUtilityDiff2D(self.model_part,maximum_number_of_particles)
else:
self.moveparticles = MoveParticleUtilityDiff3D(self.model_part,maximum_number_of_particles)
print("self.domain_size = ", self.domain_size)
if self.domain_size==2:
self.calculatewatervolume = CalculateWaterFraction2D(self.model_part)
else:
self.calculatewatervolume = CalculateWaterFraction3D(self.model_part)
self.moveparticles.MountBinDiff()
self.water_volume=0.0 #we initialize it at zero
self.water_initial_volume=0.0 #we initialize it at zero
self.water_initial_volume_flag=True #we initialize it at zero
self.mass_correction_factor=0.0
self.normal_tools.CalculateBodyNormals(self.model_part,self.domain_size);
condition_number=1
'''
if self.domain_size==2:
self.addBC = AddMonolithicFixedVelocityCondition2D(self.model_part)
else:
self.addBC = AddMonolithicFixedVelocityCondition3D(self.model_part)
(self.addBC).AddThem()
'''
import strategy_python #implicit solver
self.monolitic_solver = strategy_python.SolvingStrategyPython(self.model_part,self.time_scheme,self.monolitic_linear_solver,self.conv_criteria,CalculateReactionFlag,ReformDofSetAtEachStep,MoveMeshFlag)
#to measure time spent in solving
self.total=0.0
self.implicit_tasks=0.0
def Initialize(self):
self.time_scheme = ResidualBasedPredictorCorrectorBossakScheme(
self.damp_factor)
# definition of the convergence criteria
self.conv_criteria = DisplacementCriteria(self.toll, self.absolute_tol)
# creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = True
import strategy_python
self.solver = strategy_python.SolvingStrategyPython(
self.model_part, self.time_scheme, self.structure_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
print("finished initialization of the dynamic strategy")
def Initialize(self):
self.time_scheme = ResidualBasedPredictorCorrectorBossakRotationScheme(
self.damp_factor)
self.time_scheme.Check(self.model_part)
# definition of the convergence criteria
self.conv_criteria = DisplacementCriteria(self.toll, self.absolute_tol)
self.conv_criteria.Check(self.model_part)
# builder_and_solver = ResidualBasedEliminationBuilderAndSolver(self.structure_linear_solver)
# creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = True
import strategy_python
self.solver = strategy_python.SolvingStrategyPython(
self.model_part, self.time_scheme, self.structure_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
self.solver.Check()
def Initialize(self):
#creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = False
#build the edge data structure
#if self.domain_size==2:
# self.matrix_container = MatrixContainer2D()
#else:
# self.matrix_container = MatrixContainer3D()
#maximum_number_of_particles= 10*self.domain_size
maximum_number_of_particles = 8 * self.domain_size
self.ExplicitStrategy = PFEM2_Explicit_Strategy(
self.model_part, self.domain_size, MoveMeshFlag)
self.VariableUtils = VariableUtils()
if self.domain_size == 2:
self.moveparticles = MoveParticleUtilityPFEM22D(
self.model_part, maximum_number_of_particles)
else:
self.moveparticles = MoveParticleUtilityPFEM23D(
self.model_part, maximum_number_of_particles)
#raw_input()
print("self.domain_size = ", self.domain_size)
if self.domain_size == 2:
self.calculatewatervolume = CalculateWaterFraction2D(
self.model_part)
else:
self.calculatewatervolume = CalculateWaterFraction3D(
self.model_part)
self.moveparticles.MountBin()
self.water_volume = 0.0 #we initialize it at zero
self.water_initial_volume = 0.0 #we initialize it at zero
self.mass_correction_factor = 0.0
self.normal_tools.CalculateBodyNormals(self.model_part,
self.domain_size)
condition_number = 1
if self.domain_size == 2:
self.addBC = AddFixedVelocityCondition2D(self.model_part)
else:
self.addBC = AddFixedVelocityCondition3D(self.model_part)
#(self.addBC).AddThem()
if self.domain_size == 2:
self.distance_utils = SignedDistanceCalculationUtils2D()
else:
self.distance_utils = SignedDistanceCalculationUtils3D()
self.redistance_step = 0
for condition in self.model_part.Conditions:
if condition.GetValue(IS_STRUCTURE) == 1.0:
condition.Set(SLIP, True)
for node in condition.GetNodes():
node.SetSolutionStepValue(IS_STRUCTURE, 0, 1.0)
node.SetValue(IS_STRUCTURE, 1.0)
node.Set(SLIP, True)
for condition in self.model_part.Conditions:
if condition.GetValue(IS_INLET) == 1.0:
for node in condition.GetNodes():
node.SetSolutionStepValue(IS_STRUCTURE, 0, 0.0)
node.SetValue(IS_STRUCTURE, 0.0)
node.Set(SLIP, False)
node.Fix(VELOCITY_X)
node.Fix(VELOCITY_Y)
node.Fix(VELOCITY_Z)
print("inlet node : ", node.Id)
if condition.GetValue(IS_AIR_EXIT) > 0.5:
for node in condition.GetNodes():
node.SetSolutionStepValue(IS_STRUCTURE, 0, 0.0)
node.SetValue(IS_STRUCTURE, 0.0)
node.Set(SLIP, False)
node.Fix(PRESSURE)
for node in self.model_part.Nodes:
if node.GetSolutionStepValue(
IS_STRUCTURE,
0) != 0.0 and node.IsFixed(PRESSURE) == False:
node.Fix(VELOCITY_X)
import strategy_python #implicit solver
self.monolithic_solver = strategy_python.SolvingStrategyPython(
self.model_part, self.time_scheme, self.monolithic_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
self.monolithic_solver.SetMaximumIterations(
self.maximum_nonlin_iterations)
self.streamlineintegration = 0.0
self.accelerateparticles = 0.0
self.implicitsystem = 0.0
self.lagrangiantoeulerian = 0.0
self.reseed = 0.0
self.prereseed = 0.0
self.erasing = 0.0
self.total = 0.0
self.model_part.ProcessInfo.SetValue(VOLUME_CORRECTION, 0.0)
self.print_times = False
self.model_part.ProcessInfo.SetValue(USE_PRESS_PROJ, 1) #true or false
def Initialize(self):
#creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = False
#build the edge data structure
#if self.domain_size==2:
# self.matrix_container = MatrixContainer2D()
#else:
# self.matrix_container = MatrixContainer3D()
#maximum_number_of_particles= 10*self.domain_size
maximum_number_of_particles = 8 * self.domain_size
self.ExplicitStrategy = PFEM2_Explicit_Strategy(
self.model_part, self.domain_size, MoveMeshFlag)
self.VariableUtils = VariableUtils()
if self.domain_size == 2:
self.moveparticles = MoveParticleUtilityPFEM22D(
self.model_part, maximum_number_of_particles)
else:
self.moveparticles = MoveParticleUtilityPFEM23D(
self.model_part, maximum_number_of_particles)
print("self.domain_size = ", self.domain_size)
if self.domain_size == 2:
self.calculatewatervolume = CalculateWaterFraction2D(
self.model_part)
else:
self.calculatewatervolume = CalculateWaterFraction3D(
self.model_part)
self.moveparticles.MountBin()
self.water_volume = 0.0 #we initialize it at zero
self.water_initial_volume = 0.0 #we initialize it at zero
self.mass_correction_factor = 0.0
self.normal_tools.CalculateBodyNormals(self.model_part,
self.domain_size)
condition_number = 1
if self.domain_size == 2:
self.addBC = AddFixedVelocityCondition2D(self.model_part)
else:
self.addBC = AddFixedVelocityCondition3D(self.model_part)
(self.addBC).AddThem()
if self.domain_size == 2:
self.distance_utils = SignedDistanceCalculationUtils2D()
else:
self.distance_utils = SignedDistanceCalculationUtils3D()
self.redistance_step = 0
import strategy_python #implicit solver
self.pressure_solver = strategy_python.SolvingStrategyPython(
self.model_part, self.time_scheme, self.pressure_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
self.streamlineintegration = 0.0
self.accelerateparticles = 0.0
self.implicitpressure = 0.0
self.lagrangiantoeulerian = 0.0
self.reseed = 0.0
self.prereseed = 0.0
self.erasing = 0.0
self.explicitviscous = 0.0
self.total = 0.0
def Initialize(self):
#creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = False
#build the edge data structure
#if self.domain_size==2:
# self.matrix_container = MatrixContainer2D()
#else:
# self.matrix_container = MatrixContainer3D()
#maximum_number_of_particles= 10*self.domain_size
maximum_number_of_particles = 8 * self.domain_size
self.ExplicitStrategy = PFEM2_Explicit_Strategy(
self.model_part, self.domain_size, MoveMeshFlag)
self.VariableUtils = VariableUtils()
if self.domain_size == 2:
self.moveparticles = MoveParticleUtilityPFEM22D(
self.model_part, maximum_number_of_particles)
else:
self.moveparticles = MoveParticleUtilityPFEM23D(
self.model_part, maximum_number_of_particles)
#raw_input()
print("self.domain_size = ", self.domain_size)
if self.domain_size == 2:
self.calculatewatervolume = CalculateWaterFraction2D(
self.model_part)
else:
self.calculatewatervolume = CalculateWaterFraction3D(
self.model_part)
self.moveparticles.MountBin()
self.water_volume = 0.0 #we initialize it at zero
self.water_initial_volume = 0.0 #we initialize it at zero
self.mass_correction_factor = 0.0
self.normal_tools.CalculateBodyNormals(self.model_part,
self.domain_size)
condition_number = 1
if self.domain_size == 2:
self.addBC = AddFixedPressureCondition2D(self.model_part)
else:
self.addBC = AddFixedPressureCondition3D(self.model_part)
(self.addBC).AddThem()
if self.domain_size == 2:
self.distance_utils = SignedDistanceCalculationUtils2D()
else:
self.distance_utils = SignedDistanceCalculationUtils3D()
self.redistance_step = 0
import strategy_python #implicit solver
self.monolithic_solver = strategy_python.SolvingStrategyPython(
self.model_part, self.time_scheme, self.monolithic_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
self.monolithic_solver.SetMaximumIterations(
self.maximum_nonlin_iterations)
self.streamlineintegration = 0.0
self.accelerateparticles = 0.0
self.implicitsystem = 0.0
self.lagrangiantoeulerian = 0.0
self.reseed = 0.0
self.prereseed = 0.0
self.erasing = 0.0
self.total = 0.0
self.model_part.ProcessInfo.SetValue(VOLUME_CORRECTION, 0.0)
self.print_times = False
visc_water = self.model_part.ProcessInfo.GetValue(VISCOSITY_WATER)
visc_air = self.model_part.ProcessInfo.GetValue(VISCOSITY_AIR)
dens_water = self.model_part.ProcessInfo.GetValue(DENSITY_WATER)
dens_air = self.model_part.ProcessInfo.GetValue(DENSITY_AIR)
for node in self.model_part.Nodes:
node.SetSolutionStepValue(VISCOSITY_WATER, visc_water)
node.SetSolutionStepValue(VISCOSITY_AIR, visc_air)
node.SetSolutionStepValue(DENSITY_WATER, dens_water)
node.SetSolutionStepValue(DENSITY_AIR, dens_air)
def Initialize(self, initial_offset):
#creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = False
maximum_number_of_particles = 10 * self.domain_size
self.ExplicitStrategy = PFEM2_Explicit_Strategy(
self.model_part, self.domain_size, MoveMeshFlag)
self.VariableUtils = VariableUtils()
if self.domain_size == 2:
self.moveparticles = MoveParticleUtilityDiff2D(
self.model_part, maximum_number_of_particles)
else:
self.moveparticles = MoveParticleUtilityDiff3D(
self.model_part, maximum_number_of_particles)
print("self.domain_size = ", self.domain_size)
if self.domain_size == 2:
self.calculatewatervolume = CalculateWaterFraction2D(
self.model_part)
else:
self.calculatewatervolume = CalculateWaterFraction3D(
self.model_part)
#to search particles.
self.moveparticles.MountBinDiff()
self.water_volume = 0.0 #we initialize it at zero
self.water_initial_volume = 0.0 #we initialize it at zero
self.water_initial_volume_flag = True #we initialize it at zero
self.mass_correction_factor = 0.0
#body normals, useful for boundary (inlet) conditions
self.normal_tools.CalculateBodyNormals(self.model_part,
self.domain_size)
condition_number = 1
#solvers:
import strategy_python_nonlinear #implicit solver
import strategy_python #implicit solver
self.monolitic_solver = strategy_python_nonlinear.SolvingStrategyPython(
self.model_part, self.time_scheme, self.monolitic_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
self.topographic_monolitic_solver = strategy_python.SolvingStrategyPython(
self.topographic_model_part, self.time_scheme,
self.topographic_monolitic_linear_solver, self.conv_criteria,
CalculateReactionFlag, ReformDofSetAtEachStep, MoveMeshFlag)
#(self.moveparticles).ReplaceParticlesVelocityAndDistance();
#to print the total time spent on the simulation
self.implicit_tasks = 0.0
self.total = 0.0
#finally we solve the topographic system only oonce:
nsteps = 1
for step in range(0, nsteps):
(self.topographic_monolitic_solver).Solve()
(self.moveparticles).CalculateElementalMeanStress(
self.topographic_model_part)
overwrite_particle_data = True
#this is the position where we place the calculation domain
(self.moveparticles).InitializeTransferTool(
self.topographic_model_part, initial_offset,
overwrite_particle_data)
def Initialize(self):
#creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = False
pDiagPrecond = DiagonalPreconditioner()
#build the edge data structure
#if self.domain_size==2:
# self.matrix_container = MatrixContainer2D()
#else:
# self.matrix_container = MatrixContainer3D()
#maximum_number_of_particles= 10*self.domain_size
maximum_number_of_particles = 8 * self.domain_size
self.ExplicitStrategy = PFEM2_Explicit_Strategy(
self.model_part, self.domain_size, MoveMeshFlag)
self.VariableUtils = VariableUtils()
if self.domain_size == 2:
self.moveparticles = MoveParticleUtilityDiffFluidOnly2D(
self.model_part, maximum_number_of_particles)
else:
self.moveparticles = MoveParticleUtilityDiffFluidOnly3D(
self.model_part, maximum_number_of_particles)
print "self.domain_size = ", self.domain_size
if self.domain_size == 2:
self.calculatewatervolume = CalculateWaterFraction2D(
self.model_part)
else:
self.calculatewatervolume = CalculateWaterFraction3D(
self.model_part)
print "hola0"
self.moveparticles.MountBinDiff()
#self.matrix_container.ConstructCSRVector(self.model_part)
#self.matrix_container.BuildCSRData(self.model_part)
self.water_volume = 0.0 #we initialize it at zero
self.water_initial_volume = 0.0 #we initialize it at zero
self.water_initial_volume_flag = True #we initialize it at zero
self.mass_correction_factor = 0.0
self.normal_tools.CalculateBodyNormals(self.model_part,
self.domain_size)
condition_number = 1
'''
if self.domain_size==2:
self.addBC = AddFixedVelocityCondition2D(self.model_part)
else:
self.addBC = AddFixedVelocityCondition3D(self.model_part)
(self.addBC).AddThem()
'''
#RICC TOOLS
self.convection_solver = PureConvectionUtilities2D()
self.convection_solver.ConstructSystem(self.model_part, DISTANCE,
VELOCITY, FORCE)
if self.domain_size == 2:
self.distance_utils = SignedDistanceCalculationUtils2D()
else:
self.distance_utils = SignedDistanceCalculationUtils3D()
self.redistance_step = 0
print "hola1"
import strategy_python #implicit solver
self.monolitic_solver = strategy_python.SolvingStrategyPython(
self.model_part, self.time_scheme, self.monolitic_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
self.temperature_solver = strategy_python.SolvingStrategyPython(
self.model_part, self.time_scheme, self.temperature_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
#pDiagPrecond = DiagonalPreconditioner()
self.linear_solver = BICGSTABSolver(1e-7, 5000, pDiagPrecond)
#(self.moveparticles).ReplaceParticlesVelocityAndDistance();
self.calculateinitialdrag = 0.0
self.streamlineintegration = 0.0
self.accelerateparticles = 0.0
self.navierstokes = 0.0
self.lagrangiantoeulerian = 0.0
self.reseed = 0.0
self.prereseed = 0.0
self.erasing = 0.0
self.total = 0.0
self.nodaltasks = 0.0
self.thermal = 0.0
self.implicitviscosity = 0.0
print "hola2"
overwrite_particle_data = False
intial_offset = Vector(3)
intial_offset[0] = 0.0
intial_offset[1] = 0.0
intial_offset[2] = 0.0
(self.moveparticles).IntializeTransferTool(self.model_part_topo,
intial_offset,
overwrite_particle_data)
def Initialize(self):
#creating the solution strategy
CalculateReactionFlag = False
ReformDofSetAtEachStep = False
MoveMeshFlag = False
pDiagPrecond = DiagonalPreconditioner()
maximum_number_of_particles = 8 * self.domain_size
self.ExplicitStrategy = PFEM2_Explicit_Strategy(
self.model_part, self.domain_size, MoveMeshFlag)
self.VariableUtils = VariableUtils()
if self.domain_size == 2:
self.moveparticles = MoveParticleUtilityDiffFluidOnly2D(
self.model_part, maximum_number_of_particles)
else:
self.moveparticles = MoveParticleUtilityDiffFluidOnly3D(
self.model_part, maximum_number_of_particles)
print("self.domain_size = ", self.domain_size)
if self.domain_size == 2:
self.calculatewatervolume = CalculateWaterFraction2D(
self.model_part)
else:
self.calculatewatervolume = CalculateWaterFraction3D(
self.model_part)
self.moveparticles.MountBinDiff()
self.water_volume = 0.0 #we initialize it at zero
self.water_initial_volume = 0.0 #we initialize it at zero
self.water_initial_volume_flag = True #we initialize it at zero
self.mass_correction_factor = 0.0
self.normal_tools.CalculateBodyNormals(self.model_part,
self.domain_size)
condition_number = 1
if self.domain_size == 2:
self.addBC = AddMonolithicFixedVelocityCondition2D(self.model_part)
else:
self.addBC = AddMonolithicFixedVelocityCondition3D(self.model_part)
(self.addBC).AddThem()
##RICC TOOLS
#if self.domain_size==2:
# self.convection_solver = PureConvectionUtilities2D();
#else:
# self.convection_solver = PureConvectionUtilities3D();
#self.convection_solver.ConstructSystem(self.model_part,DISTANCE,VELOCITY,FORCE);
#if self.domain_size==2:
# self.distance_utils = SignedDistanceCalculationUtils2D()
#else:
# self.distance_utils = SignedDistanceCalculationUtils3D()
#self.redistance_step = 0
########
import strategy_python #implicit solver
self.monolitic_solver = strategy_python.SolvingStrategyPython(
self.model_part, self.time_scheme, self.monolitic_linear_solver,
self.conv_criteria, CalculateReactionFlag, ReformDofSetAtEachStep,
MoveMeshFlag)
#to test time
self.calculateinitialdrag = 0.0
self.streamlineintegration = 0.0
self.accelerateparticles = 0.0
self.implicit_solving = 0.0
self.lagrangiantoeulerian = 0.0
self.reseed = 0.0
self.prereseed = 0.0
self.erasing = 0.0
self.total = 0.0
self.nodaltasks = 0.0
self.thermal = 0.0
self.implicitviscosity = 0.0
