def AddDofs(model_part):
for node in model_part.Nodes:
# adding dofs
node.AddDof(VELOCITY_X)
node.AddDof(VELOCITY_Y)
node.AddDof(VELOCITY_Z)
node.AddDof(PRESSURE)
levelset_solver.AddDofs(model_part, distance_settings)
print("dofs for the monolithic solver added correctly")
def __init__(self, model_part, domain_size, fluid_linear_solver_settings,
redistance_settings, ConvectionType):
Timer.Start("DPG_Monolithic_constructor")
if (ConvectionType == "Classic"):
self.use_distance_convection_process = False
else:
self.use_distance_convection_process = True
# DISTANCE CONVECTION SELECTION
if (self.use_distance_convection_process == False):
import levelset_solver
levelset_solver.AddVariables(model_part, distance_settings)
levelset_solver.AddDofs(model_part, distance_settings)
else:
pass
#model_part.AddNodalSolutionStepVariable(DISTANCE)
#self.compute_flow_length_object=ComputeFlowLength1(model_part)
#def __init__(self, model_part, domain_size,linear_solver_iterations=300, linear_solver_tolerance=1e-5,dynamic_tau_levelset=0.01):
self.fluid_linear_solver_settings = fluid_linear_solver_settings
self.redistance_settings = redistance_settings
self.redistance_type = redistance_settings.redistance_type
self.model_part = model_part
self.domain_size = domain_size
self.alpha = -0.0
self.move_mesh_strategy = 0
# self.time_scheme = ResidualBasedPredictorCorrectorVelocityBossakSchemeDPGEnriched(
# self.alpha, self.move_mesh_strategy, self.domain_size)
self.time_scheme = ResidualBasedPredictorCorrectorBDFSchemeTurbulent(
self.domain_size)
self.time_scheme.Check(self.model_part)
# self.time_scheme = ResidualBasedPredictorCorrectorVelocityBossakScheme( self.alpha,self.move_mesh_strategy )
# definition of the solvers
# self.linear_solver = SkylineLUFactorizationSolver()
# self.linear_solver =SuperLUSolver()
# self.linear_solver = MKLPardisoSolver()
# pPrecond = DiagonalPreconditioner()
# pPrecond = ILU0Preconditioner()
# self.linear_solver = BICGSTABSolver(1e-6, 5000,pPrecond)
# gmres_size = 30
# ilu_level_of_fill = 2
# tol = 1e-5
# verbosity = 0
# self.linear_solver = PastixSolver(tol,gmres_size,ilu_level_of_fill,verbosity,False)
# self.linear_solver = PastixSolver(verbosity,False)
# new solvers
self.gmres_size = fluid_linear_solver_settings.gmres_size
self.iterations = fluid_linear_solver_settings.linear_solver_iterations #400 # Ojo, antes 200
self.tol = fluid_linear_solver_settings.linear_solver_tolerance #1e-5 #Before 1e-5
self.verbosity = fluid_linear_solver_settings.verbosity
if (fluid_linear_solver_settings.linear_solver_type == "BICGSTAB2"):
#self.linear_solver = ExternalSolver.ScalingSolver(AMGCLSolver(
self.linear_solver = ScalingSolver(
ExternalSolver.AMGCLSolver(
ExternalSolver.AMGCLSmoother.ILU0,
ExternalSolver.AMGCLIterativeSolverType.
BICGSTAB2, #AMGCLIterativeSolverType.GMRES, #BICGSTAB_WITH_GMRES_FALLBACK,
fluid_linear_solver_settings.linear_solver_tolerance,
fluid_linear_solver_settings.linear_solver_iterations,
fluid_linear_solver_settings.verbosity,
fluid_linear_solver_settings.gmres_size),
True)
else:
self.linear_solver = ScalingSolver(
ExternalSolver.AMGCLSolver(
ExternalSolver.AMGCLSmoother.ILU0,
ExternalSolver.AMGCLIterativeSolverType.
BICGSTAB_WITH_GMRES_FALLBACK, #AMGCLIterativeSolverType.GMRES, #BICGSTAB_WITH_GMRES_FALLBACK,
fluid_linear_solver_settings.linear_solver_tolerance,
fluid_linear_solver_settings.linear_solver_iterations,
fluid_linear_solver_settings.verbosity,
fluid_linear_solver_settings.gmres_size),
True)
# definition of the convergence criteria
self.rel_vel_tol = 1e-5
self.abs_vel_tol = 1e-7
self.rel_pres_tol = 1e-5
self.abs_pres_tol = 1e-7
self.dynamic_tau_levelset = fluid_linear_solver_settings.dynamic_tau_levelset
self.dynamic_tau_fluid = fluid_linear_solver_settings.dynamic_tau_fluid #0.01
self.oss_switch = 0
# non newtonian setting
self.regularization_coef = 1000
self.max_iter = 30
# default settings
self.echo_level = 0
self.CalculateReactionFlag = True
self.ReformDofSetAtEachStep = True
self.CalculateNormDxFlag = True
self.MoveMeshFlag = False
self.volume_correction = True
self.vol_cr_step = 5
# Data for constructing the mass loss
self.AcumulatedMassLossInWalls = 0.0
self.AcumulatedMassLossInWetWalls = 0.0
self.AcumulatedConvectedMass = 0.0
self.AcumulatedLossInRedistance = 0.0
# print "Construction monolithic solver finished"
# Creat Lavel_set solver
# construct the model part
if (self.use_distance_convection_process == False):
if (domain_size == 2):
raise "error, still not implemented in 2D"
conv_elem = "SUPGConv2D"
conv_cond = "Condition2D"
else:
conv_elem = "SUPGConv3D" #"SUPGConvLevelSet"#"SUPGConv3D"
conv_cond = "Condition3D"
self.level_set_model_part = ModelPart("level_set_model_part")
self.conv_generator = ConnectivityPreserveModeler()
(self.conv_generator).GenerateModelPart(self.model_part,
self.level_set_model_part,
conv_elem, conv_cond)
# constructing the convection solver for the distance
self.level_set_solver = levelset_solver.Solver(
self.level_set_model_part, domain_size, distance_settings)
self.level_set_solver.max_iter = 8
else: #### The Distance Convection will be used
max_cfl = 5.0
## For using linear solver GMRES #AMGCLIterativeSolverType.GMRES, #BICGSTAB_WITH_GMRES_FALLBACK,
#linear_solver = ScalingSolver(AMGCLSolver( AMGCLSmoother.ILU0, AMGCLIterativeSolverType.GMRES, 1e-9, 50, fluid_linear_solver_settings.verbosity, 50),True)
self.convection_tolerance = 1e-9
self.convection_max_number_iterations = 100
self.convection_gmres_size = 25
linear_solver = ScalingSolver(
ExternalSolver.AMGCLSolver(
ExternalSolver.AMGCLSmoother.ILU0, ExternalSolver.
AMGCLIterativeSolverType.BICGSTAB_WITH_GMRES_FALLBACK,
self.convection_tolerance,
self.convection_max_number_iterations,
fluid_linear_solver_settings.verbosity,
self.convection_gmres_size), True)
self.levelset_convection_process = LevelSetConvectionProcess3D(
DISTANCE, self.model_part, linear_solver, max_cfl)
#
# properties of the two fluids
self.rho1 = 2400.0 # applied on the negative part of the domain 1000.0
self.conductivity1 = 1.0
self.rho2 = 1.0 # applied to the positive part of the domain#1.0
self.conductivity2 = 1.0
self.mu = 3.0e-3
self.divergence_clearance_performed = False
##########################################
##### Compute Max Edge Size ########
##########################################
if (self.domain_size == 2):
self.max_edge_size = ParallelDistanceCalculator2D(
).FindMaximumEdgeSize(self.model_part)
else:
self.max_edge_size = ParallelDistanceCalculator3D(
).FindMaximumEdgeSize(self.model_part)
self.average_edge_size = BiphasicFillingUtilities().ComputePartAvgh(
self.model_part)
# self.max_distance = self.max_edge_size * self.redistance_settings.max_distance_factor #Ojo antes 5.0
##########################################
##### Initialize Counters ########
##########################################
self.internal_step_counter = 1
self.redistance_frequency = self.redistance_settings.redistance_frequency
##########################################
##### OLD REDISTANCE ########
##########################################
# Distance utilities
if (self.redistance_type == "Old"):
print("performing Old Redistance")
if (self.domain_size == 2):
self.distance_calculator = ParallelDistanceCalculator2D()
else:
self.distance_calculator = ParallelDistanceCalculator3D()
self.max_edge_size = self.distance_calculator.FindMaximumEdgeSize(
self.model_part)
self.max_distance = self.max_edge_size * self.redistance_settings.max_distance_factor #Ojo antes 5.0
self.max_levels = self.redistance_settings.max_levels #Ojo antes 25
self.max_ns_iterations = self.redistance_settings.max_ns_iterations #Ojo antes 8
else:
print("performing New Redistance")
for cond in self.model_part.Conditions:
for node in cond.GetNodes():
node.Set(BOUNDARY, True)
distance_calculator_aux = ParallelDistanceCalculator3D()
self.max_edge_size = distance_calculator_aux.FindMaximumEdgeSize(
self.model_part)
distance_linear_solver = linear_solver_factory.ConstructSolver(
self.redistance_settings)
self.distance_calculator = VariationalDistanceCalculationProcess3D(
self.model_part, distance_linear_solver,
self.redistance_settings.redistance_iterations)
self.max_distance = self.max_edge_size * self.redistance_settings.max_distance_factor
# Slip condition
self.use_slip_conditions = False
# volume correction
self.volume_correction_switch = True
self.negative_volume_correction = False
self.volume_corrector_type = "Old"
# element size
self.maxmin = []
ParticleLevelSetUtils3D().FindMaxMinEdgeSize(self.model_part,
self.maxmin)
# Variables needed for computing the Efficiency of the Injection
self.OldNetInletVolume = 0.0
self.OldWetVolume = 0.0
self.distance_utilities = DistanceUtilities()
self.volume_corrector = CorrectVolume(self.model_part,
self.average_edge_size,
self.max_edge_size)
Timer.Stop("DPG_Monolithic_constructor")