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
