def __init__(self, model, parameters):
self._validate_settings_in_baseclass = True # To be removed eventually
super(PfemFluidSolver, self).__init__(model, parameters)
#construct the linear solver
from KratosMultiphysics import python_linear_solver_factory
self.pressure_linear_solver = python_linear_solver_factory.ConstructSolver(
self.settings["pressure_linear_solver_settings"])
self.velocity_linear_solver = python_linear_solver_factory.ConstructSolver(
self.settings["velocity_linear_solver_settings"])
self.compute_reactions = self.settings["compute_reactions"].GetBool()
super(PfemFluidSolver, self).__init__(model, parameters)
model_part_name = self.settings["model_part_name"].GetString()
if model_part_name == "":
raise Exception('Please specify a model_part name!')
if self.model.HasModelPart(model_part_name):
self.main_model_part = self.model.GetModelPart(model_part_name)
else:
self.main_model_part = self.model.CreateModelPart(model_part_name)
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass = True # To be removed eventually
super(NavierStokesSolverFractionalStep,
self).__init__(model, custom_settings)
if custom_settings["formulation"]["element_type"].GetString(
) != "FractionalStep":
raise Exception(
"NavierStokesFractionalStepSolver only accepts FractionalStep as the \"element_type\" in \"formulation\""
)
self.element_name = custom_settings["formulation"][
"element_type"].GetString()
self.condition_name = custom_settings["formulation"][
"condition_type"].GetString()
self.min_buffer_size = 3
self.element_has_nodal_properties = True
## Construct the linear solvers
self.pressure_linear_solver = linear_solver_factory.ConstructSolver(
self.settings["pressure_linear_solver_settings"])
self.velocity_linear_solver = linear_solver_factory.ConstructSolver(
self.settings["velocity_linear_solver_settings"])
self.compute_reactions = self.settings["compute_reactions"].GetBool()
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesSolverFractionalStep",
"Construction of NavierStokesSolverFractionalStep solver finished."
)
def CreateSolver(model_part, config, periodic=False):
fluid_solver = IncompressibleFluidSolver(model_part, config.domain_size,
periodic)
# default settings
fluid_solver.vel_toll = config.vel_toll
if (hasattr(config, "vel_toll")):
fluid_solver.vel_toll = config.vel_toll
if (hasattr(config, "press_toll")):
fluid_solver.press_toll = config.press_toll
if (hasattr(config, "max_vel_its")):
fluid_solver.max_vel_its = config.max_vel_its
if (hasattr(config, "max_press_its")):
fluid_solver.max_press_its = config.max_press_its
if (hasattr(config, "time_order")):
fluid_solver.time_order = config.time_order
if (hasattr(config, "compute_reactions")):
fluid_solver.compute_reactions = config.compute_reactions
if (hasattr(config, "ReformDofAtEachIteration")):
fluid_solver.ReformDofAtEachIteration = config.ReformDofAtEachIteration
if (hasattr(config, "predictor_corrector")):
fluid_solver.predictor_corrector = config.predictor_corrector
if (hasattr(config, "echo_level")):
fluid_solver.echo_level = config.echo_level
if (hasattr(config, "dynamic_tau")):
fluid_solver.dynamic_tau = config.dynamic_tau
# linear solver settings
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
if (hasattr(config, "pressure_linear_solver_config")):
fluid_solver.pressure_linear_solver = linear_solver_factory.ConstructSolver(
config.pressure_linear_solver_config)
if (hasattr(config, "velocity_linear_solver_config")):
fluid_solver.velocity_linear_solver = linear_solver_factory.ConstructSolver(
config.velocity_linear_solver_config)
if (hasattr(config, "divergence_cleareance_step")):
fluid_solver.divergence_clearance_steps = config.divergence_cleareance_step
# RANS or DES settings
if hasattr(config, "TurbulenceModel"):
if config.TurbulenceModel == "Spalart-Allmaras":
fluid_solver.use_spalart_allmaras = True
elif config.TurbulenceModel == "Smagorinsky-Lilly":
if hasattr(config, "SmagorinskyConstant"):
fluid_solver.activate_smagorinsky(config.SmagorinskyConstant)
else:
msg = """Fluid solver error: Smagorinsky model requested, but
the value for the Smagorinsky constant is
undefined."""
raise Exception(msg)
return fluid_solver
def _CreateLinearSolver(self):
# Create the pressure linear solver
pressure_linear_solver_configuration = self.settings[
"pressure_linear_solver_settings"]
pressure_linear_solver = linear_solver_factory.ConstructSolver(
pressure_linear_solver_configuration)
# Create the velocity linear solver
velocity_linear_solver_configuration = self.settings[
"velocity_linear_solver_settings"]
velocity_linear_solver = linear_solver_factory.ConstructSolver(
velocity_linear_solver_configuration)
# Return a tuple containing both linear solvers
return (pressure_linear_solver, velocity_linear_solver)
def _create_linear_solver(self):
linear_solver_configuration = self.settings["linear_solver_settings"]
if linear_solver_configuration.Has("solver_type"): # user specified a linear solver
return linear_solver_factory.ConstructSolver(linear_solver_configuration)
else:
KratosMultiphysics.Logger.PrintInfo('::[MechanicalSolver]:: No linear solver was specified, using fastest available solver')
return linear_solver_factory.CreateFastestAvailableDirectLinearSolver()
def __init__(self, model, custom_settings):
super(NavierStokesEmbeddedMonolithicSolver,
self).__init__(model, custom_settings)
# There is only a single rank in OpenMP, we always print
self._is_printing_rank = True
self.min_buffer_size = 3
self.embedded_formulation = EmbeddedFormulation(
self.settings["formulation"])
self.element_name = self.embedded_formulation.element_name
self.condition_name = self.embedded_formulation.condition_name
## Construct the linear solver
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
## Set the distance reading filename
# TODO: remove the manual "distance_file_name" set as soon as the problem type one has been tested.
if (self.settings["distance_reading_settings"]
["import_mode"].GetString() == "from_GiD_file"):
self.settings["distance_reading_settings"][
"distance_file_name"].SetString(
self.settings["model_import_settings"]
["input_filename"].GetString() + ".post.res")
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesEmbeddedMonolithicSolver",
"Construction of NavierStokesEmbeddedMonolithicSolver finished.")
def CreateSolver(model_part, config, periodic=False):
fluid_solver = MonolithicSolver(model_part, config.domain_size, periodic)
if(hasattr(config, "alpha")):
fluid_solver.alpha = config.alpha
# definition of the convergence criteria
if(hasattr(config, "velocity_relative_tolerance")):
fluid_solver.rel_vel_tol = config.velocity_relative_tolerance
if(hasattr(config, "velocity_absolute_tolerance")):
fluid_solver.abs_vel_tol = config.velocity_absolute_tolerance
if(hasattr(config, "pressure_relative_tolerance")):
fluid_solver.rel_pres_tol = config.pressure_relative_tolerance
if(hasattr(config, "pressure_absolute_tolerance")):
fluid_solver.abs_pres_tol = config.pressure_absolute_tolerance
if(hasattr(config, "dynamic_tau")):
fluid_solver.dynamic_tau = config.dynamic_tau
if(hasattr(config, "max_iteration")):
fluid_solver.max_iter = config.max_iteration
if(hasattr(config, "echo_level")):
fluid_solver.echo_level = config.echo_level
if(hasattr(config, "compute_reactions")):
fluid_solver.compute_reactions = config.compute_reactions
if(hasattr(config, "ReformDofSetAtEachStep")):
fluid_solver.ReformDofSetAtEachStep = config.ReformDofSetAtEachStep
if(hasattr(config, "divergence_cleareance_step")):
fluid_solver.divergence_clearance_steps = config.divergence_cleareance_step
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
if(hasattr(config, "linear_solver_config")):
fluid_solver.linear_solver = linear_solver_factory.ConstructSolver(
config.linear_solver_config)
return fluid_solver
def setUpSolver(self):
oss_switch = 0
import vms_monolithic_solver
vms_monolithic_solver.AddVariables(self.fluid_model_part)
self.fluid_model_part.AddNodalSolutionStepVariable(DISTANCE)
self.fluid_model_part.AddNodalSolutionStepVariable(FLAG_VARIABLE)
model_part_io = ModelPartIO(self.input_file)
model_part_io.ReadModelPart(self.fluid_model_part)
self.fluid_model_part.SetBufferSize(3)
vms_monolithic_solver.AddDofs(self.fluid_model_part)
# Building custom fluid solver
self.fluid_solver = vms_monolithic_solver.MonolithicSolver(
self.fluid_model_part, self.domain_size)
rel_vel_tol = 1e-5
abs_vel_tol = 1e-7
rel_pres_tol = 1e-5
abs_pres_tol = 1e-7
self.fluid_solver.conv_criteria = VelPrCriteria(
rel_vel_tol, abs_vel_tol, rel_pres_tol, abs_pres_tol)
self.fluid_solver.conv_criteria.SetEchoLevel(0)
self.fluid_solver.time_scheme = ResidualBasedPredictorCorrectorBDFSchemeTurbulentNoReaction(
self.domain_size)
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.fluid_solver.linear_solver = linear_solver_factory.ConstructSolver(
Parameters(r'''{
"solver_type" : "amgcl"
}'''))
builder_and_solver = ResidualBasedBlockBuilderAndSolver(
self.fluid_solver.linear_solver)
self.fluid_solver.max_iter = 50
self.fluid_solver.compute_reactions = False
self.fluid_solver.ReformDofSetAtEachStep = False
self.fluid_solver.MoveMeshFlag = False
self.fluid_solver.solver = ResidualBasedNewtonRaphsonStrategy(\
self.fluid_model_part,
self.fluid_solver.time_scheme,
self.fluid_solver.linear_solver,
self.fluid_solver.conv_criteria,
builder_and_solver,
self.fluid_solver.max_iter,
self.fluid_solver.compute_reactions,
self.fluid_solver.ReformDofSetAtEachStep,
self.fluid_solver.MoveMeshFlag)
self.fluid_solver.solver.SetEchoLevel(0)
self.fluid_solver.solver.Check()
self.fluid_model_part.ProcessInfo.SetValue(OSS_SWITCH, oss_switch)
self.fluid_model_part.ProcessInfo.SetValue(DYNAMIC_TAU,
self.dynamic_tau)
self.fluid_solver.divergence_clearance_steps = 0
self.fluid_solver.use_slip_conditions = 0
def _create_linear_solver(self):
"""Create the eigensolver.
This overrides the base class method and replaces the usual linear solver
with an eigenvalue problem solver.
"""
if self.eigensolver_settings["solver_type"].GetString() == "FEAST":
feast_system_solver_settings = self.eigensolver_settings[
"linear_solver_settings"]
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
linear_solver = linear_solver_factory.ConstructSolver(
feast_system_solver_settings)
if feast_system_solver_settings["solver_type"].GetString(
) == "skyline_lu_complex":
# default built-in feast system solver
linear_solver = ExternalSolversApplication.FEASTSolver(
self.eigensolver_settings, linear_solver)
elif feast_system_solver_settings["solver_type"].GetString(
) == "pastix":
feast_system_solver = ExternalSolversApplication.PastixComplexSolver(
feast_system_solver_settings)
linear_solver = ExternalSolversApplication.FEASTSolver(
self.eigensolver_settings, feast_system_solver)
else:
raise Exception(
"Unsupported FEAST system solver_type: " +
feast_system_solver_settings["solver_type"].GetString())
else:
raise Exception(
"Unsupported eigensolver solver_type: " +
self.eigensolver_settings["solver_type"].GetString())
return linear_solver
def Initialize(self):
"""This function initializes the PfemFluidExplicitSolver
Usage: It is designed to be called ONCE, BEFORE the execution of the solution-loop
"""
self.KratosPrintInfo("::[Pfem Fluid Explicit Solver]:: -START-")
# Get the computing model part
self.computing_model_part = self.GetComputingModelPart()
mechanical_scheme = KratosPfemFluid.FirstOrderForwardEulerScheme(
1.0e-4, 1.0, 0, 0)
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
linear_solver = linear_solver_factory.ConstructSolver(
self.settings["velocity_linear_solver_settings"])
self.fluid_solver = KratosPfemFluid.ExplicitStrategy(
self.computing_model_part, mechanical_scheme, linear_solver, False,
True, True)
# Set echo_level
self.fluid_solver.SetEchoLevel(self.settings["echo_level"].GetInt())
# Set initialize flag
if self.main_model_part.ProcessInfo[
KratosMultiphysics.IS_RESTARTED] == True:
self.mechanical_solver.SetInitializePerformedFlag(True)
# Check if everything is assigned correctly
self.fluid_solver.Check()
self.KratosPrintInfo("::[Pfem Fluid Explicit Solver]:: -END- ")
def test_variational_redistance_maintain_plane_3d(self):
current_model = KratosMultiphysics.Model()
free_surface_level = 0.25
model_part = current_model.CreateModelPart("Main")
model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISTANCE)
model_part.AddNodalSolutionStepVariable(KratosMultiphysics.FLAG_VARIABLE)
model_part.CreateNewNode(1, 0.0 , 0.0 , 0.0)
model_part.CreateNewNode(2, 1.0 , 2.0 , 0.0)
model_part.CreateNewNode(3, -1.0 , 1.0 , 0.0)
model_part.CreateNewNode(4, 2.0 , 1.0 , 0.0)
model_part.CreateNewNode(5, 2.0 , 2.0 , 1.0)
model_part.AddProperties(KratosMultiphysics.Properties(1))
model_part.CreateNewElement("Element3D4N", 1, [1,2,3,5], model_part.GetProperties()[1])
model_part.CreateNewElement("Element3D4N", 2, [1,4,2,5], model_part.GetProperties()[1])
for node in model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, node.Y - free_surface_level)
linear_solver = linear_solver_factory.ConstructSolver( KratosMultiphysics.Parameters( """ { "solver_type" : "skyline_lu_factorization" } """ ) )
model_part.CloneTimeStep(1.0)
max_iterations = 2
KratosMultiphysics.VariationalDistanceCalculationProcess3D(
model_part,
linear_solver,
max_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess3D.CALCULATE_EXACT_DISTANCES_TO_PLANE).Execute()
for node in model_part.Nodes:
self.assertAlmostEqual(node.GetSolutionStepValue(KratosMultiphysics.DISTANCE), node.Y - free_surface_level, 10 )
def test_model_part_sub_model_parts(self):
current_model = KratosMultiphysics.Model()
model_part = current_model.CreateModelPart("Main")
model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISTANCE)
model_part.AddNodalSolutionStepVariable(KratosMultiphysics.FLAG_VARIABLE)
KratosMultiphysics.ModelPartIO(GetFilePath("auxiliar_files_for_python_unittest/mdpa_files/coarse_sphere")).ReadModelPart(model_part)
model_part.SetBufferSize(2)
for node in model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE,0, self._ExpectedDistance(node.X,node.Y,node.Z) )
linear_solver = linear_solver_factory.ConstructSolver( KratosMultiphysics.Parameters( """ { "solver_type" : "skyline_lu_factorization" } """ ) )
model_part.CloneTimeStep(1.0)
max_iterations = 2
KratosMultiphysics.VariationalDistanceCalculationProcess3D(model_part, linear_solver, max_iterations).Execute()
max_distance = -1.0
min_distance = +1.0
for node in model_part.Nodes:
d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE)
max_distance = max(max_distance, d)
min_distance = min(min_distance, d)
self.assertAlmostEqual(max_distance, 0.44556526310761013)
self.assertAlmostEqual(min_distance,-0.504972246827639)
def CreateSolver(model_part, config):
conv_diffr_solver = ConvectionDiffusionrSolver(model_part,
config.domain_size, config)
print(conv_diffr_solver)
#sssssssss
# default settings
if (hasattr(config, "time_order")):
conv_diffr_solver.time_order = config.time_order
if (hasattr(config, "domain_size")):
conv_diffr_solver.domain_size = config.domain_size
if (hasattr(config, "prediction_order")):
conv_diffr_solver.prediction_order = config.prediction_order
if (hasattr(config, "ReformDofAtEachIteration")):
conv_diffr_solver.ReformDofAtEachIteration = config.ReformDofAtEachIteration
if (hasattr(config, "echo_level")):
conv_diffr_solver.echo_level = config.echo_level
if (hasattr(config, "max_ite")):
conv_diffr_solver.max_iter = config.max_iter
if (hasattr(config, "toll")):
conv_diffr_solver.toll = config.toll
# linear solver settings
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
if (hasattr(config, "linear_solver_config")):
conv_diffr_solver.linear_solver = linear_solver_factory.ConstructSolver(
config.linear_solver_config)
return conv_diffr_solver
def _create_linear_solver(self):
linear_solver_configuration = self.settings["linear_solver_settings"]
if linear_solver_configuration.Has("solver_type"): # user specified a linear solver
from KratosMultiphysics import python_linear_solver_factory as linear_solver_factory
return linear_solver_factory.ConstructSolver(linear_solver_configuration)
else:
# using a default linear solver (selecting the fastest one available)
import KratosMultiphysics.kratos_utilities as kratos_utils
if kratos_utils.CheckIfApplicationsAvailable("EigenSolversApplication"):
from KratosMultiphysics import EigenSolversApplication
elif kratos_utils.CheckIfApplicationsAvailable("ExternalSolversApplication"):
from KratosMultiphysics import ExternalSolversApplication
linear_solvers_by_speed = [
"pardiso_lu", # EigenSolversApplication (if compiled with Intel-support)
"sparse_lu", # EigenSolversApplication
"pastix", # ExternalSolversApplication (if Pastix is included in compilation)
"super_lu", # ExternalSolversApplication
"skyline_lu_factorization" # in Core, always available, but slow
]
for solver_name in linear_solvers_by_speed:
if KratosMultiphysics.LinearSolverFactory().Has(solver_name):
linear_solver_configuration.AddEmptyValue("solver_type").SetString(solver_name)
KratosMultiphysics.Logger.PrintInfo('::[MechanicalSolver]:: ',\
'Using "' + solver_name + '" as default linear solver')
return KratosMultiphysics.LinearSolverFactory().Create(linear_solver_configuration)
raise Exception("Linear-Solver could not be constructed!")
def __init__(self, main_model_part, custom_settings):
#TODO: shall obtain the compute_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "lagrangian_mpm_solver",
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name"
},
"maximum_iterations": 10,
"echo_level": 1,
"compute_reactions": false,
"reform_dofs_at_each_step": true,
"relative_tolerance": 1e-5,
"absolute_tolerance": 1e-7,
"linear_solver_settings" : {
"solver_type" : "Super LU",
"scaling": true
},
"processes_sub_model_part_list" : [""]
}""")
##overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
#construct the linear solver
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
print("Construction of NavierStokesSolver_VMSMonolithic finished")
def __init__(self, model, custom_settings):
super(NavierStokesSolverMonolithic,self).__init__(model,custom_settings)
self.formulation = StabilizedFormulation(self.settings["formulation"])
self.element_name = self.formulation.element_name
self.condition_name = self.formulation.condition_name
self.element_integrates_in_time = self.formulation.element_integrates_in_time
scheme_type = self.settings["time_scheme"].GetString()
if scheme_type == "bossak":
self.min_buffer_size = 2
elif scheme_type == "bdf2":
self.min_buffer_size = 3
elif scheme_type == "steady":
self.min_buffer_size = 1
self._SetUpSteadySimulation()
else:
msg = "Unknown time_scheme option found in project parameters:\n"
msg += "\"" + scheme_type + "\"\n"
msg += "Accepted values are \"bossak\", \"bdf2\" or \"steady\".\n"
raise Exception(msg)
## Construct the linear solver
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
KratosMultiphysics.Logger.PrintInfo("NavierStokesSolverMonolithic", "Construction of NavierStokesSolverMonolithic finished.")
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass=True # To be removed eventually
custom_settings = self._BackwardsCompatibilityHelper(custom_settings)
super(NavierStokesSolverMonolithic,self).__init__(model,custom_settings)
self.formulation = StabilizedFormulation(self.settings["formulation"])
self.element_name = self.formulation.element_name
self.condition_name = self.formulation.condition_name
self.element_integrates_in_time = self.formulation.element_integrates_in_time
self.element_has_nodal_properties = self.formulation.element_has_nodal_properties
scheme_type = self.settings["time_scheme"].GetString()
if scheme_type == "bossak":
self.min_buffer_size = 2
elif scheme_type == "bdf2":
self.min_buffer_size = 3
elif scheme_type == "steady":
self.min_buffer_size = 1
self._SetUpSteadySimulation()
else:
msg = "Unknown time_scheme option found in project parameters:\n"
msg += "\"" + scheme_type + "\"\n"
msg += "Accepted values are \"bossak\", \"bdf2\" or \"steady\".\n"
raise Exception(msg)
## Construct the linear solver
self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
## Construct the turbulence model solver
if not self.settings["turbulence_model_solver_settings"].IsEquivalentTo(KratosMultiphysics.Parameters("{}")):
self._turbulence_model_solver = CreateTurbulenceModel(model, self.settings["turbulence_model_solver_settings"])
self.condition_name = self._turbulence_model_solver.GetFluidVelocityPressureConditionName()
KratosMultiphysics.Logger.PrintInfo("NavierStokesSolverMonolithic", "Using " + self.condition_name + " as wall condition")
KratosMultiphysics.Logger.PrintInfo("NavierStokesSolverMonolithic", "Construction of NavierStokesSolverMonolithic finished.")
def __init__(self, model, settings): # Constructor of the class
self._validate_settings_in_baseclass = True
super(ShallowWaterBaseSolver, self).__init__(model, settings)
## Set the element and condition names for the replace settings
## These should be defined in derived classes
self.element_name = None
self.condition_name = None
self.min_buffer_size = 2
# Either retrieve the model part from the model or create a new one
model_part_name = self.settings["model_part_name"].GetString()
if model_part_name == "":
raise Exception('Please specify a model_part name!')
if self.model.HasModelPart(model_part_name):
self.main_model_part = self.model.GetModelPart(model_part_name)
else:
self.main_model_part = self.model.CreateModelPart(model_part_name)
domain_size = self.settings["domain_size"].GetInt()
self.main_model_part.ProcessInfo.SetValue(KM.DOMAIN_SIZE, domain_size)
## Construct the linear solver
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
def __init__(self, model, settings):
settings = self._ValidateSettings(settings)
self.model = model # TODO: inherit from PythonSolver and use super
self.settings = settings
self.echo_level = self.settings["echo_level"].GetInt()
# There is only a single rank in OpenMP, we always print
self._is_printing_rank = True
## Set the element and condition names for the replace settings
## These should be defined in derived classes
self.element_name = "EulerPrimVarElement"
self.condition_name = "Condition"
self.min_buffer_size = 2
# Initialize the multigrid process. It creates the model part
self.multigrid = MultiscaleRefiningProcess(model, settings["multigrid_settings"])
self.main_model_part = self.multigrid.GetRefinedModelPart()
domain_size = self.settings["domain_size"].GetInt()
self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, domain_size)
## Construct the linear solver
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
def set_variational_distance_process(self):
# Construct the variational distance calculation process
maximum_iterations = 5
### for serial and OpenMP
serial_settings = KratosMultiphysics.Parameters("""
{
"linear_solver_settings" : {
"solver_type" : "amgcl"
}
}
""")
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(
serial_settings["linear_solver_settings"])
if self.complete_model.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2:
variational_distance_process = KratosMultiphysics.VariationalDistanceCalculationProcess2D(
self.complete_model, self.linear_solver, maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess2D.
CALCULATE_EXACT_DISTANCES_TO_PLANE, "distance_from_inlet_2D")
else:
variational_distance_process = KratosMultiphysics.VariationalDistanceCalculationProcess3D(
self.complete_model, self.linear_solver, maximum_iterations,
KratosMultiphysics.VariationalDistanceCalculationProcess3D.
CALCULATE_EXACT_DISTANCES_TO_PLANE, "distance_from_inlet_3D")
return variational_distance_process
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass = True # To be removed eventually
super(PotentialFlowSolver, self).__init__(model, custom_settings)
# There is only a single rank in OpenMP, we always print
self._is_printing_rank = True
# Set the element and condition names for the replace settings
self.formulation = PotentialFlowFormulation(
self.settings["formulation"])
self.element_name = self.formulation.element_name
self.condition_name = self.formulation.condition_name
self.formulation.SetProcessInfo(self.main_model_part)
self.min_buffer_size = 1
self.domain_size = custom_settings["domain_size"].GetInt()
self.reference_chord = custom_settings["reference_chord"].GetDouble()
self.main_model_part.ProcessInfo.SetValue(KCPFApp.REFERENCE_CHORD,
self.reference_chord)
self.element_has_nodal_properties = False
#construct the linear solvers
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass=True # To be removed eventually
super(NavierStokesEmbeddedMonolithicSolver,self).__init__(model,custom_settings)
self.min_buffer_size = 3
self.embedded_formulation = EmbeddedFormulation(self.settings["formulation"])
self.element_name = self.embedded_formulation.element_name
self.condition_name = self.embedded_formulation.condition_name
## Set the formulation level set type
self.level_set_type = self.embedded_formulation.level_set_type
## Set the nodal properties flag
self.element_has_nodal_properties = self.embedded_formulation.element_has_nodal_properties
## Construct the linear solver
self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
## Set the distance reading filename
# TODO: remove the manual "distance_file_name" set as soon as the problem type one has been tested.
if (self.settings["distance_reading_settings"]["import_mode"].GetString() == "from_GiD_file"):
self.settings["distance_reading_settings"]["distance_file_name"].SetString(self.settings["model_import_settings"]["input_filename"].GetString()+".post.res")
# If the FM-ALE is required, do a first call to the _get_fm_ale_virtual_model_part
# Note that this will create the virtual model part in the model
self.__fm_ale_is_active = self.settings["fm_ale_settings"]["fm_ale_step_frequency"].GetInt() > 0
if self.__fm_ale_is_active:
self._get_fm_ale_virtual_model_part()
KratosMultiphysics.Logger.PrintInfo("NavierStokesEmbeddedMonolithicSolver", "Construction of NavierStokesEmbeddedMonolithicSolver finished.")
def _ExtendDistance(self):
''' This function extends the distance field to all the nodes of the main_model_part in order to
remesh the background mesh.'''
ini_time = time.time()
# Construct the variational distance calculation process
maximum_iterations = 2 #TODO: Make this user-definable
###Defining linear solver to be used by the variational distance process###
from KratosMultiphysics import python_linear_solver_factory #Linear solver for variational distance process
linear_solver_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "amgcl",
"max_iteration": 200,
"gmres_krylov_space_dimension": 100,
"smoother_type":"ilu0",
"coarsening_type":"ruge_stuben",
"coarse_enough" : 5000,
"krylov_type": "lgmres",
"tolerance": 1e-3,
"verbosity": 0,
"scaling": false
}""")
linear_solver = python_linear_solver_factory.ConstructSolver(
linear_solver_settings)
variational_distance_process = KratosMultiphysics.VariationalDistanceCalculationProcess2D(
self.main_model_part, linear_solver, maximum_iterations)
variational_distance_process.Execute()
KratosMultiphysics.Logger.PrintInfo(
'LevelSetRemeshing', 'Variational distance process time: ',
time.time() - ini_time)
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass = True # To be removed eventually
super(AdjointVMSMonolithicSolver,
self).__init__(model, custom_settings)
self.element_has_nodal_properties = True
# construct the linear solver
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
if not self.settings[
"adjoint_turbulence_model_solver_settings"].IsEquivalentTo(
KratosMultiphysics.Parameters("{}")):
# if not empty
self._adjoint_turbulence_model_solver = CreateAdjointTurbulenceModel(
model,
self.settings["adjoint_turbulence_model_solver_settings"])
self.element_name = self._adjoint_turbulence_model_solver.GetAdjointElementName(
)
self.condition_name = self._adjoint_turbulence_model_solver.GetAdjointConditionName(
)
else:
self.element_name = "VMSAdjointElement"
if self.settings["domain_size"].GetInt() == 2:
self.condition_name = "LineCondition"
elif self.settings["domain_size"].GetInt() == 3:
self.condition_name = "SurfaceCondition"
KratosMultiphysics.Logger.PrintInfo(
self.__class__.__name__,
"Construction of AdjointVMSMonolithicSolver finished.")
def Initialize(self):
self.computing_model_part = self.GetComputingModelPart()
## Construct the linear solver
self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
KratosMultiphysics.NormalCalculationUtils().CalculateOnSimplex(self.computing_model_part, self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE])
self.neighbour_search = KratosMultiphysics.FindNodalNeighboursProcess(self.computing_model_part, 10, 10)
(self.neighbour_search).Execute()
self.accelerationLimitationUtility = KratosCFD.AccelerationLimitationUtilities( self.computing_model_part, 5.0 )
# If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility()
# Set the time discretization utility to compute the BDF coefficients
time_order = self.settings["time_order"].GetInt()
if time_order == 2:
self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF(time_order)
else:
raise Exception("Only \"time_order\" equal to 2 is supported. Provided \"time_order\": " + str(time_order))
# Creating the solution strategy
self.conv_criteria = KratosCFD.VelPrCriteria(self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
self.level_set_convection_process = self._set_level_set_convection_process()
self.variational_distance_process = self._set_variational_distance_process()
time_scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE], # Domain size (2,3)
self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]+1) # DOFs (3,4)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(self.computing_model_part,
time_scheme,
self.linear_solver,
self.conv_criteria,
builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
(self.solver).Initialize() # Initialize the solver. Otherwise the constitutive law is not initializated.
(self.solver).Check()
self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DYNAMIC_TAU, self.settings["formulation"]["dynamic_tau"].GetDouble())
KratosMultiphysics.Logger.PrintInfo("NavierStokesTwoFluidsSolver", "Solver initialization finished.")
def _auxiliary_test_function(self, settings, matrix_name="A.mm"):
space = KratosMultiphysics.UblasSparseSpace()
#read the matrices
A = KratosMultiphysics.CompressedMatrix()
KratosMultiphysics.ReadMatrixMarketMatrix(GetFilePath(matrix_name), A)
Aoriginal = KratosMultiphysics.CompressedMatrix(A) #create a copy of A
n = A.Size1()
b = KratosMultiphysics.Vector(n)
space.SetToZeroVector(b)
for i in range(len(b)):
b[i] = i / len(b)
x = KratosMultiphysics.Vector(n)
#KratosMultiphysics.ReadMatrixMarketVector("b.mm",b)
boriginal = KratosMultiphysics.Vector(b) #create a copy of b
space.SetToZeroVector(x)
#space.SetToZeroVector(boriginal)
#space.UnaliasedAdd(boriginal, 1.0, b) #boriginal=1*bs
#construct the solver
from KratosMultiphysics import python_linear_solver_factory as linear_solver_factory
linear_solver = linear_solver_factory.ConstructSolver(settings)
#solve
linear_solver.Solve(A, x, b)
#test the results
tmp = KratosMultiphysics.Vector(n)
tmp *= 0.0
space.Mult(Aoriginal, x, tmp)
check = KratosMultiphysics.Vector(n)
check = boriginal - tmp
achieved_norm = space.TwoNorm(check)
tolerance = 1e-9
if (settings.Has("tolerance")):
tolerance = settings["tolerance"].GetDouble()
target_norm = tolerance * space.TwoNorm(boriginal)
if (not (achieved_norm <= target_norm)):
KratosMultiphysics.Logger.PrintInfo(
"Test linear solvers: ",
"Echo of settings for failing test:\n",
settings.PrettyPrintJsonString())
KratosMultiphysics.Logger.PrintInfo("Test linear solvers: ",
"Achieved_norm", achieved_norm,
"\n", "Target_norm",
target_norm)
self.assertTrue(achieved_norm <= target_norm)
def CreateSolver(model_part, config):
solver = LaplacianSolver(model_part, config.domain_size)
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
if (hasattr(config, "linear_solver_config")):
solver.linear_solver = linear_solver_factory.ConstructSolver(
config.linear_solver_config)
return solver
def __init__(self, model, custom_settings):
super(NavierStokesSolverFractionalStep,self).__init__(model,custom_settings)
self.element_name = "FractionalStep"
self.condition_name = "WallCondition"
self.min_buffer_size = 3
# There is only a single rank in OpenMP, we always print
self._is_printing_rank = True
## Construct the linear solvers
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
self.pressure_linear_solver = linear_solver_factory.ConstructSolver(self.settings["pressure_linear_solver_settings"])
self.velocity_linear_solver = linear_solver_factory.ConstructSolver(self.settings["velocity_linear_solver_settings"])
self.compute_reactions = self.settings["compute_reactions"].GetBool()
KratosMultiphysics.Logger.PrintInfo("NavierStokesSolverFractionalStep", "Construction of NavierStokesSolverFractionalStep solver finished.")
def ConstructSolver(configuration):
import KratosMultiphysics
depr_msg = '"kratos/python_scripts/new_linear_solver_factory.py" is deprecated and will be removed\n'
depr_msg += 'Please use "kratos/python_scripts/python_linear_solver_factory.py" instead!'
KratosMultiphysics.Logger.PrintWarning('DEPRECATION-WARNING', depr_msg)
from KratosMultiphysics import python_linear_solver_factory
return python_linear_solver_factory.ConstructSolver(configuration)
def CreateSolver(model_part, config):
convection_solver = EulerianConvectionDiffusionSolver(
model_part, config.domain_size)
# linear solver settings
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
if (hasattr(config, "convection_linear_solver_config")):
self.linear_solver = linear_solver_factory.ConstructSolver(
config.convection_linear_solver_config)
return convection_solver
