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