def _CreateCuttingUtility(self): if not CheckIfApplicationsAvailable("TrilinosApplication"): raise Exception( "Defining output cuts requires the TrilinosApplication, which appears to be unavailable." ) self.epetra_comm = KratosTrilinos.CreateCommunicator() return KratosTrilinos.TrilinosCuttingApplication(self.epetra_comm)
def CreateTurbulenceModel(model_part, settings): if not CheckIfApplicationsAvailable("RANSApplication"): msg = "Using a turbulence model requires the RANSApplication. " msg += "Please re-install/re-compile with RANSApplication." raise Exception(msg) from KratosMultiphysics.RANSApplication.turbulence_model_factory import Factory return Factory(model_part, settings)
def kratosFound(): try: from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable return CheckIfApplicationsAvailable( "ConvectionDiffusionApplication", "LinearSolversApplication", "MeshingApplication", "MultilevelMonteCarloApplication", ) except ImportError: return False
def __init__(self, Model, settings): KM.Process.__init__(self) """ model_part_name: The name of the MainModelPart for which the entities should be created sub_model_part_names: <optional> Names of the SubModelParts on which the entities should be created. This is needed to not create multiple entities on the same nodes, if model-part are overlapping/contain the same nodes. new_sub_model_part_name: The name of the SubModelPart that will be created as base of MainModelPart. The created entities will be in this ModelPart entity_name: The name of the entities to create entity_type: "condition" or "element" properties_id: Id of the properties to be used for the newly created entities kratos_application: <optional> Application in which the entities to create are implemented, needs to be imported before creating them """ default_settings = KM.Parameters("""{ "model_part_name" : "PLEASE_SPECIFY", "sub_model_part_names" : [], "new_sub_model_part_name" : "PLEASE_SPECIFY", "entity_name" : "PointLoadCondition3D1N", "entity_type" : "condition", "properties_id" : 0, "kratos_application" : "" }""") settings.ValidateAndAssignDefaults(default_settings) model_part_name = settings["model_part_name"].GetString() model_part = Model[model_part_name] if model_part.ProcessInfo[KM.IS_RESTARTED]: # Do nothing in case of restart return root_model_part = model_part.GetRootModelPart() entity_name = settings["entity_name"].GetString() entity_type = settings["entity_type"].GetString() properties_id = settings["properties_id"].GetInt() # importing the Application where the entites are registered (optional) kratos_application = settings["kratos_application"].GetString() if kratos_application != "": if not CheckIfApplicationsAvailable(kratos_application): raise Exception('Application "{}" is not available!'.format( kratos_application)) import_module("KratosMultiphysics." + kratos_application) # this registers the entities if settings["sub_model_part_names"].size() == 0: # if no sub-model-parts are specified then taking the main-model-part model_parts = [model_part] else: model_parts = [ Model[model_part_name + "." + sub_model_part_name] for sub_model_part_name in settings["sub_model_part_names"].GetStringArray() ] new_model_part = RecursiveCreateModelParts( model_part, settings["new_sub_model_part_name"].GetString()) node_ids = [ node.Id for mp in model_parts for node in mp.GetCommunicator().LocalMesh().Nodes ] node_ids = list( set(node_ids) ) # make sure the node-Ids are unique. This is needed to not create multiple entities for the same node new_model_part.AddNodes(node_ids) props = root_model_part.GetProperties( properties_id, 0) # 0 is mesh-id # maybe check and then create the props mp_comm = root_model_part.GetCommunicator() if entity_type == "element": max_id_entities = max( [elem.Id for elem in root_model_part.Elements] + [0]) # "+[0]" in case there are no local entities creation_fct_ptr = new_model_part.CreateNewElement elif entity_type == "condition": max_id_entities = max( [cond.Id for cond in root_model_part.Conditions] + [0]) # "+[0]" in case there are no local entities creation_fct_ptr = new_model_part.CreateNewCondition else: raise Exception( '"entity_type" "{}" is not valid, only "element" or "condition" are possible!' .format(entity_type)) # using ScanSum to compute the local Id-start. Otherwise the Ids would start with the same value on every rank data_comm = mp_comm.GetDataCommunicator() scan_sum_nodes = data_comm.ScanSum(len(node_ids)) max_id_entities_global = data_comm.MaxAll(max_id_entities) local_id_start = scan_sum_nodes + 1 + max_id_entities_global - len( node_ids) for i, node_id in enumerate(node_ids): creation_fct_ptr(entity_name, i + local_id_start, [node_id], props)
from __future__ import print_function, absolute_import, division # makes KratosMultiphysics backward compatible with python 2.6 and 2.7 # Importing the Kratos Library import KratosMultiphysics as KM from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable # Importing the base class from . import kratos_base_wrapper # Importing ParticleMechanics if not CheckIfApplicationsAvailable("ParticleMechanicsApplication"): raise ImportError("The ParticleMechanicsApplication is not available!") import KratosMultiphysics.ParticleMechanicsApplication as KPM from KratosMultiphysics.ParticleMechanicsApplication.particle_mechanics_analysis import ParticleMechanicsAnalysis # Other imports import math def Create(settings, solver_name): return ParticleMechanicsWrapper(settings, solver_name) class ParticleMechanicsWrapper(kratos_base_wrapper.KratosBaseWrapper): """This class is the interface to the ParticleMechanicsApplication of Kratos""" def _CreateAnalysisStage(self): return ParticleMechanicsAnalysis(self.model, self.project_parameters) def SolveSolutionStep(self): coupling_model_part = self.model.GetModelPart("MPM_Coupling_Interface") model_part_name = self.project_parameters["coupling_settings"][
def CheckIfApplicationsAvailable(*application_names): raise Exception("This function is untested!") if not CheckIfKratosAvailable(): return False from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable return CheckIfApplicationsAvailable(application_names)
def ComputeAdaptiveRefinement(self): """ Method computing the refinement of the model based on the solution on the coarse mesh, exploiting the hessian metric of the solution. Input: - self: an instance of the class Output: - current_model_refined : Kratos model class after refinement - current_parameters_refined : Kratos parameters class after refinement """ parameters_coarse = self.parameters_coarse model_coarse = self.model_coarse metric_param = self.metric_param remesh_param = self.remesh_param problem_type = self.problem_type current_level = self.current_level # check MeshingApplication is imported, # otherwise raise an error if not CheckIfApplicationsAvailable("MeshingApplication"): raise Exception( "[MultilevelMonteCarloApplication]: MeshingApplication cannot be imported, but it is necessary to perform adaptive refinement." ) if (self.metric is "hessian"): # initialize interpolation error original_interp_error = metric_param[ "hessian_strategy_parameters"][ "interpolation_error"].GetDouble() # set interpolation error for current level if current_level > 0: coefficient_interp_error = metric_param[ "hessian_strategy_parameters"][ "coefficient_interpolation_error"].GetDouble() metric_param["hessian_strategy_parameters"].RemoveValue( "coefficient_interpolation_error") interp_error = original_interp_error * ( coefficient_interp_error)**(-current_level) # interp_error = original_interp_error/(coefficient_interp_error*current_level) metric_param["hessian_strategy_parameters"][ "interpolation_error"].SetDouble(interp_error) # Setting metric tensor to 0 domain_size = self.wrapper.GetDomainSize() model_part_name = parameters_coarse["solver_settings"][ "model_part_name"].GetString() if domain_size == 2: KratosMultiphysics.VariableUtils( ).SetNonHistoricalVariableToZero( KratosMultiphysics.MeshingApplication.METRIC_TENSOR_2D, model_coarse.GetModelPart(model_part_name).Nodes) elif domain_size == 3: KratosMultiphysics.VariableUtils( ).SetNonHistoricalVariableToZero( KratosMultiphysics.MeshingApplication.METRIC_TENSOR_3D, model_coarse.GetModelPart(model_part_name).Nodes) else: err_msg = "Domain size is {}. Supported values are 2 and 3.\n".format( domain_size) # calculate NODAL_H find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess( model_coarse.GetModelPart(model_part_name)) find_nodal_h.Execute() # build the metric if metric_param["hessian_strategy_parameters"].Has( "metric_variable"): metric_variables = self.__generate_variable_list_from_input( metric_param["hessian_strategy_parameters"] ["metric_variable"]) # remove metric value from settings, since we pass it directly in the constructor metric_param["hessian_strategy_parameters"].RemoveValue( "metric_variable") else: raise Exception( "A list of variable is expected under the key [\"hessian_strategy_parameters\"][\"metric_variable\"] of the \"metric\" dictionary." ) for mv in metric_variables: local_gradient = KratosMultiphysics.MeshingApplication.ComputeHessianSolMetricProcess( model_coarse.GetModelPart(model_part_name), mv, metric_param) local_gradient.Execute() # create the remeshing process and execute it if KratosMultiphysics.IsDistributedRun(): # MPI KratosMultiphysics.mpi.ParallelFillCommunicator( model_coarse.GetModelPart(model_part_name)).Execute() if domain_size == 3: if (hasattr(KratosMultiphysics.MeshingApplication, "ParMmgProcess3D")): pmmg_process = KratosMultiphysics.MeshingApplication.ParMmgProcess3D( model_coarse.GetModelPart(model_part_name), remesh_param) else: raise Exception( "[MultilevelMonteCarloApplication]: ParMmgProcess3D atrribute not found within MeshingApplcation. It is required to perform remeshing." ) else: err_msg = "Domain size is {}. Supported value is 3.\n".format( domain_size) raise Exception(err_msg) pmmg_process.Execute() else: # serial if domain_size == 2: if (hasattr(KratosMultiphysics.MeshingApplication, "MmgProcess2D")): mmg_process = KratosMultiphysics.MeshingApplication.MmgProcess2D( model_coarse.GetModelPart(model_part_name), remesh_param) else: raise Exception( "[MultilevelMonteCarloApplication]: MmgProcess2D atrribute not found within MeshingApplcation. It is required to perform remeshing." ) elif domain_size == 3: if (hasattr(KratosMultiphysics.MeshingApplication, "MmgProcess3D")): mmg_process = KratosMultiphysics.MeshingApplication.MmgProcess3D( model_coarse.GetModelPart(model_part_name), remesh_param) else: raise Exception( "[MultilevelMonteCarloApplication]: MmgProcess3D atrribute not found within MeshingApplcation. It is required to perform remeshing." ) else: err_msg = "Domain size is {}. Supported values are 2 and 3.\n".format( domain_size) raise Exception(err_msg) mmg_process.Execute() # reset variables if needed model_coarse.GetModelPart(model_part_name).ProcessInfo.SetValue( KratosMultiphysics.TIME, 0.0) model_coarse.GetModelPart(model_part_name).ProcessInfo.SetValue( KratosMultiphysics.STEP, 0) model_coarse.GetModelPart(model_part_name).ProcessInfo.SetValue( KratosMultiphysics.IS_RESTARTED, False) if (problem_type in ["monolithic", "FractionalStep", "potential_flow"]): model_coarse.GetModelPart(model_part_name).RemoveSubModelPart( "fluid_computational_model_part") # the refinement process empties the coarse model part object and fill it with the refined model part # the solution on the refined grid is obtained from the interpolation of the coarse solution # there are not other operations, therefore to build the new model we just need to take the updated coarse model current_model_refined = model_coarse current_parameters_refined = parameters_coarse return current_model_refined, current_parameters_refined else: err_msg = "Metric passed to the AdaptiveRefinement class is {}, but the only supported metric is \"hessian\".\n".format( self.metric) raise Exception(err_msg)
# Import Python libraries from math import sqrt # Import Kratos import KratosMultiphysics from KratosMultiphysics.MultilevelMonteCarloApplication.tools import ParametersWrapper from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable if KratosMultiphysics.IsDistributedRun(): import KratosMultiphysics.mpi if CheckIfApplicationsAvailable("MeshingApplication"): import KratosMultiphysics.MeshingApplication class AdaptiveRefinement(object): """ Class managing the adaptive refinement process, called when executing Multilevel Monte Carlo algorithms. This class handles the call to the MeshingApplication, and to other applications, if needed along the process. Input: - model_coarse: Kratos model class before refinement - parameters_coarse: Kratos parameters class before refinement - minimal_size_value: minimal size after remeshing - maximal_size_value: maximal size after remeshing - metric_param: Kratos parameters class containing metric custom settings - remesh_param: Kratos parameters class containing remeshing custom settings - metric_name: string defining the metring which the class will use to build the metric """ def __init__(self, current_level, model_coarse, parameters_coarse,
from KratosMultiphysics import _ImportApplication from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable import KratosMultiphysics.mpi # importing the MPI-Core, since the TrilinosApp directly links to it if CheckIfApplicationsAvailable("MetisApplication"): import KratosMultiphysics.MetisApplication # importing to avoid problems with loading the metis library from KratosTrilinosApplication import * application = KratosTrilinosApplication() application_name = "KratosTrilinosApplication" _ImportApplication(application, application_name)
# Importing the Kratos Library import KratosMultiphysics as KM # Importing the Kratos Library from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable # Importing the base class from KratosMultiphysics.CoSimulationApplication.solver_wrappers.kratos import kratos_base_wrapper # Importing StructuralMechanics if not CheckIfApplicationsAvailable("DEMApplication"): raise ImportError("The DEMApplication is not available!") from KratosMultiphysics import DEMApplication from KratosMultiphysics.DEMApplication.DEM_analysis_stage import DEMAnalysisStage def Create(settings, model, solver_name): return DEMWrapper(settings, model, solver_name) class DEMWrapper(kratos_base_wrapper.KratosBaseWrapper): """This class is the interface to the DEMApplication of Kratos""" def _CreateAnalysisStage(self): dem_analysis_module = DEMAnalysisStage if self.settings["solver_wrapper_settings"].Has("working_directory"): working_dir = self.settings["solver_wrapper_settings"][ "working_directory"].GetString() class DEMAnalysisStageWithWorkingDir(DEMAnalysisStage):
# Importing the Kratos Library import KratosMultiphysics as KM # other imports import KratosMultiphysics.FluidDynamicsApplication.python_solvers_wrapper_fluid as fluid_solvers_wrapper from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable have_mesh_moving = CheckIfApplicationsAvailable("MeshMovingApplication") if have_mesh_moving: from KratosMultiphysics.MeshMovingApplication.ale_fluid_solver import AleFluidSolver else: raise Exception( "In importing the NavierStokesAleFluidSolver: The solver requires the MeshMovingApplication, but this application is not available." ) def CreateSolver(model, solver_settings, parallelism): return NavierStokesAleFluidSolver(model, solver_settings, parallelism) class NavierStokesAleFluidSolver(AleFluidSolver): def _CreateFluidSolver(self, solver_settings, parallelism): return fluid_solvers_wrapper.CreateSolverByParameters( self.model, solver_settings, parallelism) @classmethod def _ManipulateFluidSolverSettingsForReactionsComputation( cls, fluid_solver_settings): if fluid_solver_settings.Has("compute_reactions"): if not fluid_solver_settings["compute_reactions"].GetBool(): fluid_solver_settings["compute_reactions"].SetBool(True)
import os from KratosMultiphysics import * import KratosMultiphysics.KratosUnittest as KratosUnittest import KratosMultiphysics.FluidDynamicsApplication import KratosMultiphysics.kratos_utilities as kratos_utils from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable missing_applications_message = [ "Missing required application(s):", ] have_required_applications = CheckIfApplicationsAvailable("HDF5Application") if have_required_applications: import KratosMultiphysics.HDF5Application as kh5 else: missing_applications_message.append("HDF5Application") from KratosMultiphysics.FluidDynamicsApplication.fluid_dynamics_analysis import FluidDynamicsAnalysis from KratosMultiphysics.FluidDynamicsApplication.adjoint_fluid_analysis import AdjointFluidAnalysis class ControlledExecutionScope: def __init__(self, scope): self.currentPath = os.getcwd() self.scope = scope def __enter__(self): os.chdir(self.scope) def __exit__(self, type, value, traceback): os.chdir(self.currentPath)
# Importing the Kratos Library from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable if not CheckIfApplicationsAvailable("CompressiblePotentialFlowApplication"): raise ImportError( "The CompressiblePotentialFlowApplication is not available!") # Importing the base class from KratosMultiphysics.CoSimulationApplication.solver_wrappers.kratos import kratos_base_wrapper # Other imports from KratosMultiphysics.CompressiblePotentialFlowApplication.potential_flow_analysis import PotentialFlowAnalysis from KratosMultiphysics.CompressiblePotentialFlowApplication.compute_forces_on_nodes_process import ComputeForcesOnNodesProcess from KratosMultiphysics.CompressiblePotentialFlowApplication.define_wake_process_2d import DefineWakeProcess2D from KratosMultiphysics.CompressiblePotentialFlowApplication.compute_lift_process import ComputeLiftProcess def Create(settings, model, solver_name): return PotentialFlowWrapper(settings, model, solver_name) class PotentialFlowWrapper(kratos_base_wrapper.KratosBaseWrapper): def _CreateAnalysisStage(self): return PotentialFlowAnalysis(self.model, self.project_parameters) def Predict(self): pass def Initialize(self): super().Initialize()
# Application dependent names and paths from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable from KratosMultiphysics import IsDistributedRun if (IsDistributedRun() and CheckIfApplicationsAvailable("TrilinosApplication")): from KratosMultiphysics.TrilinosApplication import * elif (IsDistributedRun()): raise Exception("Distributed run requires TrilinosApplication") if (CheckIfApplicationsAvailable("FluidDynamicsApplication")): from KratosMultiphysics.FluidDynamicsApplication import * else: raise Exception("RANSApplication requires FluidDynamicsApplication.") from KratosRANSApplication import * from KratosMultiphysics import _ImportApplication application = KratosRANSApplication() application_name = "KratosRANSApplication" _ImportApplication(application, application_name)
# Imports # ============================================================================== # Making KratosMultiphysics backward compatible with python 2.6 and 2.7 from __future__ import print_function, absolute_import, division # Import Kratos core and apps from KratosMultiphysics import * # Import Kratos "wrapper" for unittests import KratosMultiphysics.KratosUnittest as KratosUnittest from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable # Check if external Apps are available if CheckIfApplicationsAvailable("EigenSolversApplication"): is_eigen_app_missing = False else: print( "WARNING: EigenSolversApplication is not available, skipping related tests!" ) is_eigen_app_missing = True if CheckIfApplicationsAvailable("MeshMovingApplication"): is_mesh_moving_app_missing = False else: print( "WARNING: MeshMovingApplication is not available, skipping related tests!" ) is_mesh_moving_app_missing = True
# Importing the Kratos Library from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable # Importing the base class from KratosMultiphysics.CoSimulationApplication.solver_wrappers.kratos import kratos_base_wrapper # Importing StructuralMechanics if not CheckIfApplicationsAvailable("StructuralMechanicsApplication"): raise ImportError("The StructuralMechanicsApplication is not available!") from KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_analysis import StructuralMechanicsAnalysis def Create(settings, model, solver_name): return StructuralMechanicsWrapper(settings, model, solver_name) class StructuralMechanicsWrapper(kratos_base_wrapper.KratosBaseWrapper): """This class is the interface to the StructuralMechanicsApplication of Kratos""" def _CreateAnalysisStage(self): return StructuralMechanicsAnalysis(self.model, self.project_parameters)
import KratosMultiphysics.KratosUnittest as KratosUnittest from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable from KratosMultiphysics.kratos_utilities import DeleteTimeFiles from KratosMultiphysics.FluidDynamicsApplication.finite_difference_sensitivity_utilities import ReadParameters from KratosMultiphysics.FluidDynamicsApplication.finite_difference_sensitivity_utilities import DeleteH5Files from KratosMultiphysics.FluidDynamicsApplication.finite_difference_sensitivity_utilities import SolvePrimalProblem from KratosMultiphysics.FluidDynamicsApplication.finite_difference_sensitivity_utilities import SolveAdjointProblem from KratosMultiphysics.FluidDynamicsApplication.finite_difference_sensitivity_utilities import ComputeAdjointSensitivity from KratosMultiphysics.FluidDynamicsApplication.finite_difference_sensitivity_utilities import FiniteDifferenceBodyFittedDragShapeSensitivityAnalysis @KratosUnittest.skipUnless(CheckIfApplicationsAvailable("HDF5Application"), "Missing HDF5Application") class AdjointVMSSensitivity2D(KratosUnittest.TestCase): @staticmethod def _ReadParameters(parameters_file_name): parameters = ReadParameters(parameters_file_name) parameters["problem_data"]["parallel_type"].SetString("OpenMP") return parameters def testOneElement(self): with KratosUnittest.WorkFolderScope('.', __file__): node_ids = [1] # calculate sensitivity by finite difference primal_parameters = AdjointVMSSensitivity2D._ReadParameters( './AdjointVMSSensitivity2DTest/one_element_test_parameters.json' ) step_size = 0.00000001 fd_sensitivities = FiniteDifferenceBodyFittedDragShapeSensitivityAnalysis.ComputeSensitivity(
import KratosMultiphysics import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication import KratosMultiphysics.KratosUnittest as KratosUnittest from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable if CheckIfApplicationsAvailable("ConstitutiveLawsApplication"): from KratosMultiphysics import ConstitutiveLawsApplication class BasePatchTestMembrane(KratosUnittest.TestCase): def _add_variables(self, mp, explicit_dynamics=False): mp.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT) mp.AddNodalSolutionStepVariable(KratosMultiphysics.REACTION) mp.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY) mp.AddNodalSolutionStepVariable(KratosMultiphysics.ACCELERATION) mp.AddNodalSolutionStepVariable(KratosMultiphysics.VOLUME_ACCELERATION) mp.AddNodalSolutionStepVariable( StructuralMechanicsApplication.POINT_LOAD) if explicit_dynamics: mp.AddNodalSolutionStepVariable( StructuralMechanicsApplication.MIDDLE_VELOCITY) mp.AddNodalSolutionStepVariable( StructuralMechanicsApplication.FRACTIONAL_ACCELERATION) mp.AddNodalSolutionStepVariable( StructuralMechanicsApplication.FRACTIONAL_ANGULAR_ACCELERATION) mp.AddNodalSolutionStepVariable(KratosMultiphysics.NODAL_MASS) mp.AddNodalSolutionStepVariable(KratosMultiphysics.FORCE_RESIDUAL) mp.AddNodalSolutionStepVariable(KratosMultiphysics.RESIDUAL_VECTOR) mp.AddNodalSolutionStepVariable( StructuralMechanicsApplication.MIDDLE_ANGULAR_VELOCITY)
# Importing the Kratos Library import KratosMultiphysics import KratosMultiphysics.FluidDynamicsApplication as KratosCFD from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable # other imports from KratosMultiphysics.time_based_ascii_file_writer_utility import TimeBasedAsciiFileWriterUtility if CheckIfApplicationsAvailable("StatisticsApplication"): from KratosMultiphysics.StatisticsApplication import SpatialMethods as spatial_methods else: msg = "CFLOutputProcess requires StatisticsApplication which is not found." msg += " Please install/compile it and try again." raise Exception(msg) from math import sqrt def Factory(settings, model): if (type(settings) != KratosMultiphysics.Parameters): raise Exception( "expected input shall be a Parameters object, encapsulating a json string" ) return CFLOutputProcess(model, settings["Parameters"]) class CFLOutputProcess(KratosMultiphysics.Process): """ A class responsible for the CFL output, which is an element value in Kratos. """
from __future__ import print_function, absolute_import, division #makes KratosMultiphysics backward compatible with python 2.6 and 2.7 from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable from KratosMultiphysics import IsDistributedRun from KratosMultiphysics.FluidDynamicsApplication.fluid_dynamics_analysis import FluidDynamicsAnalysis if (IsDistributedRun() and CheckIfApplicationsAvailable("TrilinosApplication")): from KratosMultiphysics.RANSApplication.trilinos_fluid_solver_no_replace import TrilinosFluidSolverNoReplace as fluid_solver_no_replace elif (not IsDistributedRun()): from KratosMultiphysics.RANSApplication.fluid_solver_no_replace import FluidSolverNoReplace as fluid_solver_no_replace else: raise Exception("Distributed run requires TrilinosApplication") class PeriodicFluidDynamicsAnalysis(FluidDynamicsAnalysis): def _CreateSolver(self): return fluid_solver_no_replace(self.model, self.project_parameters["solver_settings"])
from __future__ import print_function, absolute_import, division #makes KratosMultiphysics backward compatible with python 2.6 and 2.7 import KratosMultiphysics as KM from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable if CheckIfApplicationsAvailable("TrilinosApplication"): import KratosMultiphysics.TrilinosApplication as KratosTrilinos from KratosMultiphysics.gid_output_process import GiDOutputProcess import os def Factory(settings, Model): if not isinstance(settings, KM.Parameters): raise Exception( "Expected input shall be a Parameters object, encapsulating a json string" ) model_part = Model[settings["Parameters"]["model_part_name"].GetString()] output_name = settings["Parameters"]["output_name"].GetString() postprocess_parameters = settings["Parameters"]["postprocess_parameters"] return DistributedGiDOutputProcess(model_part, output_name, postprocess_parameters) class DistributedGiDOutputProcess(GiDOutputProcess): def __init__(self, model_part, file_name, param=None): super(DistributedGiDOutputProcess, self).__init__(model_part, file_name, param) self.serial_file_name = file_name self.base_file_name += "_" + str( KM.ParallelEnvironment.GetDefaultDataCommunicator().Rank(
from __future__ import print_function, absolute_import, division # makes KratosMultiphysics backward compatible with python 2.6 and 2.7 # Importing the Kratos Library from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable # Importing the base class from KratosMultiphysics.CoSimulationApplication.solver_wrappers.kratos import kratos_base_wrapper # Importing FluidDynamics if not CheckIfApplicationsAvailable("FluidDynamicsApplication"): raise ImportError("The FluidDynamicsApplication is not available!") from KratosMultiphysics.FluidDynamicsApplication.fluid_dynamics_analysis import FluidDynamicsAnalysis def Create(settings, solver_name): return FluidDynamicsWrapper(settings, solver_name) class FluidDynamicsWrapper(kratos_base_wrapper.KratosBaseWrapper): """This class is the interface to the FluidDynamicsApplication of Kratos""" def _CreateAnalysisStage(self): return FluidDynamicsAnalysis(self.model, self.project_parameters)
os.chdir(self.currentPath) if self.add_to_path: sys.path.remove(self.scope) try: from KratosMultiphysics.kratos_utilities import ( CheckIfApplicationsAvailable, IsMPIAvailable, ) is_Kratos = (CheckIfApplicationsAvailable( "FluidDynamicsApplication", "LinearSolversApplication", "MappingApplication", "MeshingApplication", "MetisApplication", "MultilevelMonteCarloApplication", "StatisticsApplication", "TrilinosApplication", ) and IsMPIAvailable()) except ImportError: is_Kratos = False try: import KratosMultiphysics import KratosMultiphysics.MeshingApplication is_ParMmg = hasattr(KratosMultiphysics.MeshingApplication, "ParMmgProcess3D") except ImportError: is_ParMmg = False