def CreateFastestAvailableDirectLinearSolver():
# Using a default linear solver (selecting the fastest one available)
if kratos_utils.CheckIfApplicationsAvailable("LinearSolversApplication"):
from KratosMultiphysics import LinearSolversApplication
elif kratos_utils.CheckIfApplicationsAvailable(
"ExternalSolversApplication"):
from KratosMultiphysics import ExternalSolversApplication
linear_solvers_by_speed = [
"pardiso_lu", # LinearSolversApplication (if compiled with Intel-support)
"sparse_lu", # LinearSolversApplication
"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 KM.LinearSolverFactory().Has(solver_name):
linear_solver_configuration = KM.Parameters(
"""{ "solver_type" : "%s"}""" % solver_name)
KM.Logger.PrintInfo(
'Linear-Solver-Factory',
'Creating "{}" as fastest available direct solver'.format(
solver_name))
return KM.LinearSolverFactory().Create(linear_solver_configuration)
raise Exception("Linear-Solver could not be constructed!")
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 ConstructSolver(settings):
if not isinstance(settings, KM.Parameters):
raise Exception("Input is expected to be provided as a Kratos Parameters object")
solver_type = settings["solver_type"].GetString()
if solver_type == "eigen_eigensystem":
if kratos_utils.CheckIfApplicationsAvailable("EigenSolversApplication"):
import KratosMultiphysics.EigenSolversApplication as EiSA
eigen_solver = EiSA.EigensystemSolver(settings)
return eigen_solver
else:
raise Exception("EigenSolversApplication not available")
elif solver_type == "feast":
if kratos_utils.CheckIfApplicationsAvailable("EigenSolversApplication"):
import KratosMultiphysics.EigenSolversApplication as EiSA
if EiSA.HasFEAST():
is_symmetric = settings["symmetric"].GetBool() if settings.Has("symmetric") else True
eigen_solver = EiSA.FEASTSymmetricEigensystemSolver(settings) if is_symmetric else EiSA.FEASTGeneralEigensystemSolver(settings)
return eigen_solver
else:
raise Exception("FEAST not available in EigenSolversApplication")
else:
raise Exception("EigenSolversApplication not available")
elif solver_type == "feast_complex":
if kratos_utils.CheckIfApplicationsAvailable("EigenSolversApplication"):
import KratosMultiphysics.EigenSolversApplication as EiSA
if EiSA.HasFEAST():
is_symmetric = settings["symmetric"].GetBool() if settings.Has("symmetric") else True
eigen_solver = EiSA.ComplexFEASTSymmetricEigensystemSolver(settings) if is_symmetric else EiSA.ComplexFEASTGeneralEigensystemSolver(settings)
return eigen_solver
else:
raise Exception("FEAST not available in EigenSolversApplication")
else:
raise Exception("EigenSolversApplication not available")
linear_solver_configuration = settings["linear_solver_settings"]
if linear_solver_configuration.Has("solver_type"): # user specified a linear solver
linear_solver = linear_solver_factory.ConstructSolver(linear_solver_configuration)
else:
linear_solver = linear_solver_factory.CreateFastestAvailableDirectLinearSolver()
if solver_type == "power_iteration_eigenvalue_solver":
eigen_solver = KM.PowerIterationEigenvalueSolver( settings, linear_solver)
elif solver_type == "power_iteration_highest_eigenvalue_solver":
eigen_solver = KM.PowerIterationHighestEigenvalueSolver( settings, linear_solver)
elif solver_type == "rayleigh_quotient_iteration_eigenvalue_solver":
eigen_solver = KM.RayleighQuotientIterationEigenvalueSolver( settings, linear_solver)
else:
raise Exception("Solver type not found. Asking for :" + solver_type)
return eigen_solver
def test_harmonic_mdpa_input(self):
if not kratos_utils.CheckIfApplicationsAvailable("HDF5Application"):
self.skipTest(
"HDF5Application not found: Skipping harmonic analysis mdpa test"
)
with ControlledExecutionScope(
os.path.dirname(os.path.realpath(__file__))):
#run simulation and write to hdf5 file
model = KratosMultiphysics.Model()
project_parameter_file_name = "harmonic_analysis_test/harmonic_analysis_test_eigenproblem_parameters.json"
with open(project_parameter_file_name, 'r') as parameter_file:
project_parameters = KratosMultiphysics.Parameters(
parameter_file.read())
test = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model, project_parameters)
test.Run()
#start new simulation and read from hdf5 file
model = KratosMultiphysics.Model()
project_parameter_file_name = "harmonic_analysis_test/harmonic_analysis_test_parameters.json"
with open(project_parameter_file_name, 'r') as parameter_file:
project_parameters = KratosMultiphysics.Parameters(
parameter_file.read())
test = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model, project_parameters)
test.Run()
# remove hdf5 file
kratos_utils.DeleteFileIfExisting(
"harmonic_analysis_test/eigen_results.h5")
kratos_utils.DeleteFileIfExisting(
"harmonic_analysis_test/harmonic_analysis_test.time")
def SelectAndVerifyLinearSolver(settings, skiptest):
# The mechanical solver selects automatically the fastest linear-solver available
# this might not be appropriate for a test, therefore in case nothing is specified,
# the previous default linear-solver is set
if not settings["solver_settings"].Has("linear_solver_settings"):
# check if running in MPI because there we use a different default linear solver
if IsDistributedRun():
default_lin_solver_settings = KratosMultiphysics.Parameters("""{
"solver_type" : "amesos",
"amesos_solver_type" : "Amesos_Klu"
}""")
else:
default_lin_solver_settings = KratosMultiphysics.Parameters("""{
"solver_type": "EigenSolversApplication.sparse_lu"
}""")
settings["solver_settings"].AddValue("linear_solver_settings",
default_lin_solver_settings)
solver_type = settings["solver_settings"]["linear_solver_settings"][
"solver_type"].GetString()
solver_type_splitted = solver_type.split(".")
if len(solver_type_splitted) == 2:
# this means that we use a solver from an application
# hence we have to check if it exists, otherwise skip the test
app_name = solver_type_splitted[0]
solver_name = solver_type_splitted[1]
if not kratos_utils.CheckIfApplicationsAvailable(app_name):
skiptest(
'Application "{}" is needed for the specified solver "{}" but is not available'
.format(app_name, solver_name))
def setUp(self):
# Within this location context:
with KratosUnittest.WorkFolderScope(".", __file__):
# Reading the ProjectParameters
with open(self.file_name + "_parameters.json",
'r') as parameter_file:
ProjectParameters = KratosMultiphysics.Parameters(
parameter_file.read())
# The mechanical solver selects automatically the fastest linear-solver available
# this might not be appropriate for a test, therefore in case nothing is specified,
# the previous default linear-solver is set
if not ProjectParameters["solver_settings"].Has(
"linear_solver_settings"):
# check if running in MPI because there we use a different default linear solver
if IsDistributedRun():
default_lin_solver_settings = KratosMultiphysics.Parameters(
"""{
"solver_type" : "amesos",
"amesos_solver_type" : "Amesos_Klu"
}""")
else:
default_lin_solver_settings = KratosMultiphysics.Parameters(
"""{
"solver_type": "EigenSolversApplication.sparse_lu"
}""")
ProjectParameters["solver_settings"].AddValue(
"linear_solver_settings", default_lin_solver_settings)
solver_type = ProjectParameters["solver_settings"][
"linear_solver_settings"]["solver_type"].GetString()
solver_type_splitted = solver_type.split(".")
if len(solver_type_splitted) == 2:
# this means that we use a solver from an application
# hence we have to check if it exists, otherwise skip the test
app_name = solver_type_splitted[0]
solver_name = solver_type_splitted[1]
if not kratos_utils.CheckIfApplicationsAvailable(app_name):
self.skipTest(
'Application "{}" is needed for the specified solver "{}" but is not available'
.format(app_name, solver_name))
self.modify_parameters(ProjectParameters)
# To avoid many prints
if ProjectParameters["problem_data"]["echo_level"].GetInt() == 0:
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(
KratosMultiphysics.Logger.Severity.WARNING)
else:
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(
KratosMultiphysics.Logger.Severity.INFO)
# Creating the test
model = KratosMultiphysics.Model()
self.test = StructuralMechanicsAnalysis(model, ProjectParameters)
self.test.Initialize()
def __DeprecatedApplicationImport(solver_type):
# dict specifying in which applications the linear-solvers are defined
# it is necessary to import the applications in which the linear-solvers
# are defined, because otherwise they are not registered in the kernel
# and hence cannot be created by the C-linear-solver-factory
# NOTE: this is only for backwards-compatibility!!!
# the correct way is to specify the application in which the linear solver
# is defined, e.g. "solver_type" : "ExternalSolversApplication.super_lu"
linear_solver_apps = {
"ExternalSolversApplication" : [
"gmres",
"super_lu",
"super_lu_iterative",
"pastix",
"pastix_complex",
"feast"
],
"EigenSolversApplication" : [
"sparse_lu",
"sparse_lu_complex",
"sparse_qr",
"sparse_qr_complex",
"pardiso_llt",
"pardiso_ldlt",
"pardiso_lu",
"pardiso_lu_complex"
]
}
for app_name, linear_solver_names in linear_solver_apps.items():
if solver_type in linear_solver_names:
depr_msg = 'DEPRECATION-WARNING:\nThe linear-solver "' + solver_type + '" is defined in the "' + app_name + '"\n'
depr_msg += 'Please specify the "solver_type" including the name of the application:\n'
depr_msg += '"' + app_name + '.' + solver_type + '"'
depr_msg += '\nPlease update your settings accordingly, the current settings are deprecated!'
KM.Logger.PrintWarning('Linear-Solver-Factory', depr_msg)
from KratosMultiphysics import kratos_utilities as kratos_utils
if not kratos_utils.CheckIfApplicationsAvailable(app_name):
err_msg = 'Trying to use the linear-solver "' + solver_type
err_msg += '"\nThis solver is defined in the "' + app_name
err_msg += '" which is not compiled'
raise Exception(err_msg)
# import the Application in which the linear solver is defined
__import__("KratosMultiphysics." + app_name)
break
import KratosMultiphysics as KM
import KratosMultiphysics.KratosUnittest as KratosUnittest
import KratosMultiphysics.kratos_utilities as kratos_utils
import co_simulation_test_case
import os
try:
import numpy
numpy_available = True
except ImportError:
numpy_available = False
have_fsi_dependencies = kratos_utils.CheckIfApplicationsAvailable(
"FluidDynamicsApplication", "StructuralMechanicsApplication",
"MappingApplication", "MeshMovingApplication", "LinearSolversApplication")
def GetFilePath(fileName):
return os.path.join(os.path.dirname(os.path.realpath(__file__)), fileName)
class TestMokFSI(co_simulation_test_case.CoSimulationTestCase):
cfd_tes_file_name = "fsi_mok/ProjectParametersCFD_for_test.json"
def setUp(self):
if not numpy_available:
self.skipTest("Numpy not available")
if not have_fsi_dependencies:
self.skipTest("FSI dependencies are not available!")
# import Kratos
import KratosMultiphysics
import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
import run_cpp_unit_tests
import KratosMultiphysics.kratos_utilities as kratos_utilities
# Import Kratos "wrapper" for unittests
import KratosMultiphysics.KratosUnittest as KratosUnittest
import os, subprocess
if kratos_utilities.CheckIfApplicationsAvailable("ExternalSolversApplication"):
has_external_solvers_application = True
else:
has_external_solvers_application = False
# Import the tests or test_classes to create the suits
##### SELF-CONTAINED TESTS #####
# CL tests
from test_constitutive_law import TestConstitutiveLaw as TTestConstitutiveLaw
from test_perfect_plasticity_implementation_verification import TestPerfectPlasticityImplementationVerification as TTestPerfectPlasticityImplementationVerification
# Processes test
from test_mass_calculation import TestMassCalculation as TTestMassCalculation
from test_compute_center_of_gravity import TestComputeCenterOfGravity as TTestComputeCenterOfGravity
from test_compute_mass_moment_of_inertia import TestComputeMassMomentOfInertia as TTestComputeMassMomentOfInertia
# Simple patch tests
from test_patch_test_small_strain import TestPatchTestSmallStrain as TTestPatchTestSmallStrain
from test_patch_test_small_strain_bbar import TestPatchTestSmallStrainBbar as TTestPatchTestSmallStrainBbar
from test_patch_test_large_strain import TestPatchTestLargeStrain as TTestPatchTestLargeStrain
from test_quadratic_elements import TestQuadraticElements as TTestQuadraticElements
# Importing the Kratos Library
import KratosMultiphysics as KM
# Import applications
import KratosMultiphysics.StructuralMechanicsApplication as SMA
import KratosMultiphysics.ContactStructuralMechanicsApplication as CSMA
import KratosMultiphysics.kratos_utilities as kratos_utilities
if kratos_utilities.CheckIfApplicationsAvailable("MeshingApplication"):
has_meshing_application = True
else:
has_meshing_application = False
# Import adaptive remeshing utilities
import KratosMultiphysics.ContactStructuralMechanicsApplication.adaptative_remeshing_contact_structural_mechanics_utilities as adaptative_remeshing_contact_structural_mechanics_utilities
# Import base class file
import KratosMultiphysics.ContactStructuralMechanicsApplication.contact_structural_mechanics_static_solver as contact_structural_mechanics_static_solver
def CreateSolver(model, custom_settings):
return AdaptativeRemeshingContactStaticMechanicalSolver(
model, custom_settings)
class AdaptativeRemeshingContactStaticMechanicalSolver(
contact_structural_mechanics_static_solver.
ContactStaticMechanicalSolver):
"""The structural mechanics static solver. (Fot adaptative remeshing)
See contact_structural_mechanics_static_solver.py for more information.
"""
# Importing the Kratos Library
import KratosMultiphysics
import KratosMultiphysics.CompressiblePotentialFlowApplication as CPFApp
# Import KratosUnittest
import KratosMultiphysics.KratosUnittest as UnitTest
# Other imports
from KratosMultiphysics.CompressiblePotentialFlowApplication.potential_flow_analysis import PotentialFlowAnalysis
import KratosMultiphysics.kratos_utilities as kratos_utilities
from KratosMultiphysics.KratosUnittest import isclose as t_isclose
import os
# Check other applications dependency
hdf5_is_available = kratos_utilities.CheckIfApplicationsAvailable("HDF5Application")
meshing_is_available = kratos_utilities.CheckIfApplicationsAvailable("MeshingApplication")
try:
import stl
numpy_stl_is_available = True
except:
numpy_stl_is_available = False
class WorkFolderScope:
def __init__(self, work_folder):
self.currentPath = os.getcwd()
self.scope = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)),work_folder))
def __enter__(self):
os.chdir(self.scope)
# Making KratosMultiphysics backward compatible with python 2.6 and 2.7
from __future__ import print_function, absolute_import, division
import os
# Import Kratos core and apps
import KratosMultiphysics as KM
import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
import KratosMultiphysics.KratosUnittest as KratosUnittest
from KratosMultiphysics.StructuralMechanicsApplication import structural_response_function_factory
import KratosMultiphysics.kratos_utilities as kratos_utils
has_eigensolvers_application = kratos_utils.CheckIfApplicationsAvailable(
"EigenSolversApplication")
def _get_test_working_dir():
this_file_dir = os.path.dirname(os.path.realpath(__file__))
return os.path.join(this_file_dir, "response_function_tests")
class StructuralResponseFunctionTestFactory(KratosUnittest.TestCase):
def setUp(self):
with KratosUnittest.WorkFolderScope(_get_test_working_dir(), __file__):
with open(self.file_name + "_parameters.json",
'r') as parameter_file:
parameters = KM.Parameters(parameter_file.read())
# To avoid many prints
if (parameters["problem_data"]["echo_level"].GetInt() == 0):
KM.Logger.GetDefaultOutput().SetSeverity(
KM.Logger.Severity.WARNING)
# import Kratos
import KratosMultiphysics
import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
import run_cpp_unit_tests
import KratosMultiphysics.kratos_utilities as kratos_utilities
# Import Kratos "wrapper" for unittests
import KratosMultiphysics.KratosUnittest as KratosUnittest
import os, subprocess
has_linear_solvers_application = kratos_utilities.CheckIfApplicationsAvailable(
"LinearSolversApplication")
# Import the tests or test_classes to create the suits
##### SELF-CONTAINED TESTS #####
# CL tests
from test_constitutive_law import TestConstitutiveLaw as TTestConstitutiveLaw
from test_perfect_plasticity_implementation_verification import TestPerfectPlasticityImplementationVerification as TTestPerfectPlasticityImplementationVerification
# Processes test
from test_mass_calculation import TestMassCalculation as TTestMassCalculation
from test_compute_center_of_gravity import TestComputeCenterOfGravity as TTestComputeCenterOfGravity
from test_compute_mass_moment_of_inertia import TestComputeMassMomentOfInertia as TTestComputeMassMomentOfInertia
from test_axis_projection import TestAxisProjection as TTestAxisProjection
from test_distribute_load_on_surface_process import TestDistributeLoadOnSurfaceProcess as TTestDistributeLoadOnSurfaceProcess
from test_perturb_geometry_utility import TestPerturbGeometryUtility as TTestPerturbGeometryUtility
# Simple patch tests
from test_patch_test_small_strain import TestPatchTestSmallStrain as TTestPatchTestSmallStrain
from test_patch_test_small_strain_bbar import TestPatchTestSmallStrainBbar as TTestPatchTestSmallStrainBbar
from test_patch_test_small_displacement_mixed_volumetric_strain import TestPatchTestSmallDisplacementMixedVolumetricStrain as TTestPatchTestSmallDisplacementMixedVolumetricStrain
import KratosMultiphysics as KM
import KratosMultiphysics.CoSimulationApplication as KMC
import KratosMultiphysics.KratosUnittest as KratosUnittest
import KratosMultiphysics.kratos_utilities as kratos_utils
from KratosMultiphysics.CoSimulationApplication.factories import data_transfer_operator_factory
from KratosMultiphysics.CoSimulationApplication.coupling_interface_data import CouplingInterfaceData
mapping_app_available = kratos_utils.CheckIfApplicationsAvailable(
"MappingApplication")
class TestDataTransferOperators(KratosUnittest.TestCase):
def setUp(self):
self.model = KM.Model()
mp_o = self.model.CreateModelPart("mp_origin", 2)
mp_d_m = self.model.CreateModelPart("mp_destination_matching", 2)
mp_d_nm = self.model.CreateModelPart("mp_destination_non_matching", 2)
mp_one_n = self.model.CreateModelPart("mp_single_node", 2)
mp_o.AddNodalSolutionStepVariable(KM.PRESSURE)
mp_o.AddNodalSolutionStepVariable(KM.DISPLACEMENT)
mp_d_m.AddNodalSolutionStepVariable(KM.TEMPERATURE)
mp_d_m.AddNodalSolutionStepVariable(KM.FORCE)
mp_d_nm.AddNodalSolutionStepVariable(KM.TEMPERATURE)
mp_d_nm.AddNodalSolutionStepVariable(KM.FORCE)
mp_one_n.AddNodalSolutionStepVariable(KMC.SCALAR_DISPLACEMENT)
mp_one_n.AddNodalSolutionStepVariable(KMC.SCALAR_FORCE)
mp_o.ProcessInfo[KM.DOMAIN_SIZE] = 2
mp_d_m.ProcessInfo[KM.DOMAIN_SIZE] = 2
from __future__ import print_function, absolute_import, division
import KratosMultiphysics
import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
import KratosMultiphysics.KratosUnittest as KratosUnittest
from KratosMultiphysics import eigen_solver_factory
from math import sqrt, sin, cos, pi, exp, atan
from KratosMultiphysics import kratos_utilities as kratos_utils
eigen_solvers_application_available = kratos_utils.CheckIfApplicationsAvailable(
"EigenSolversApplication")
if eigen_solvers_application_available:
import KratosMultiphysics.EigenSolversApplication as EiSA
feast_available = EiSA.HasFEAST()
else:
feast_available = False
class SpringDamperElementTests(KratosUnittest.TestCase):
def setUp(self):
pass
def _add_variables(self, mp):
mp.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT)
mp.AddNodalSolutionStepVariable(KratosMultiphysics.ROTATION)
mp.AddNodalSolutionStepVariable(KratosMultiphysics.REACTION)
mp.AddNodalSolutionStepVariable(KratosMultiphysics.REACTION_MOMENT)
mp.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY)
mp.AddNodalSolutionStepVariable(KratosMultiphysics.ANGULAR_VELOCITY)
from __future__ import print_function, absolute_import, division # makes KratosMultiphysics backward compatible with python 2.6 and 2.7
import KratosMultiphysics as KM
# Import KratosUnittest
import KratosMultiphysics.KratosUnittest as kratos_unittest
import KratosMultiphysics.kratos_utilities as kratos_utilities
# Other imports
import os
# Check if external Apps are available
has_eigen_app = kratos_utilities.CheckIfApplicationsAvailable(
"EigenSolversApplication")
has_csm_app = kratos_utilities.CheckIfApplicationsAvailable(
"StructuralMechanicsApplication")
has_mesh_moving_app = kratos_utilities.CheckIfApplicationsAvailable(
"MeshMovingApplication")
has_mapping_app = kratos_utilities.CheckIfApplicationsAvailable(
"MappingApplication")
# ==============================================================================
class ShapeOptimizationTestFactory(kratos_unittest.TestCase):
# --------------------------------------------------------------------------
def setUp(self):
KM.Logger.GetDefaultOutput().SetSeverity(KM.Logger.Severity.WARNING)
# --------------------------------------------------------------------------
def test_execution(self):
with kratos_unittest.WorkFolderScope(self.execution_directory,
# import Kratos
import KratosMultiphysics
import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
import run_cpp_unit_tests
import KratosMultiphysics.kratos_utilities as kratos_utilities
# Import Kratos "wrapper" for unittests
import KratosMultiphysics.KratosUnittest as KratosUnittest
import os, subprocess
has_eigen_solvers_application = kratos_utilities.CheckIfApplicationsAvailable("EigenSolversApplication")
# Import the tests or test_classes to create the suits
##### SELF-CONTAINED TESTS #####
# CL tests
from test_constitutive_law import TestConstitutiveLaw as TTestConstitutiveLaw
from test_perfect_plasticity_implementation_verification import TestPerfectPlasticityImplementationVerification as TTestPerfectPlasticityImplementationVerification
# Processes test
from test_mass_calculation import TestMassCalculation as TTestMassCalculation
from test_compute_center_of_gravity import TestComputeCenterOfGravity as TTestComputeCenterOfGravity
from test_compute_mass_moment_of_inertia import TestComputeMassMomentOfInertia as TTestComputeMassMomentOfInertia
from test_axis_projection import TestAxisProjection as TTestAxisProjection
from test_distribute_load_on_surface_process import TestDistributeLoadOnSurfaceProcess as TTestDistributeLoadOnSurfaceProcess
# Simple patch tests
from test_patch_test_small_strain import TestPatchTestSmallStrain as TTestPatchTestSmallStrain
from test_patch_test_small_strain_bbar import TestPatchTestSmallStrainBbar as TTestPatchTestSmallStrainBbar
from test_patch_test_small_displacement_mixed_volumetric_strain import TestPatchTestSmallDisplacementMixedVolumetricStrain as TTestPatchTestSmallDisplacementMixedVolumetricStrain
from test_patch_test_large_strain import TestPatchTestLargeStrain as TTestPatchTestLargeStrain
from test_quadratic_elements import TestQuadraticElements as TTestQuadraticElements
return suites
if __name__ == '__main__':
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(
KratosMultiphysics.Logger.Severity.WARNING)
KratosMultiphysics.Logger.PrintInfo("Unittests",
"\nRunning cpp unit tests ...")
KratosMultiphysics.Tester.SetVerbosity(
KratosMultiphysics.Tester.Verbosity.PROGRESS) # TESTS_OUTPUTS
KratosMultiphysics.Tester.RunTestSuite("FluidDynamicsApplicationFastSuite")
KratosMultiphysics.Logger.PrintInfo("Unittests",
"Finished running cpp unit tests!")
if kratos_utilities.IsMPIAvailable(
) and kratos_utilities.CheckIfApplicationsAvailable(
"MetisApplication", "TrilinosApplication"):
KratosMultiphysics.Logger.PrintInfo("Unittests",
"\nRunning mpi python tests ...")
p = subprocess.Popen([
"mpiexec", "-np", "2", "python3",
"test_FluidDynamicsApplication_mpi.py"
],
stdout=subprocess.PIPE,
cwd=os.path.dirname(os.path.abspath(__file__)))
p.wait()
KratosMultiphysics.Logger.PrintInfo("Unittests",
"Finished mpi python tests!")
else:
KratosMultiphysics.Logger.PrintInfo(
"Unittests",
"\nSkipping mpi python tests due to missing dependencies")
from KratosMultiphysics import *
from KratosMultiphysics.FSIApplication import *
import KratosMultiphysics.StructuralMechanicsApplication as KratosStructural
import KratosMultiphysics.KratosUnittest as UnitTest
import KratosMultiphysics.kratos_utilities as KratosUtils
if KratosUtils.CheckIfApplicationsAvailable("StructuralMechanicsApplication"):
from KratosMultiphysics.StructuralMechanicsApplication import python_solvers_wrapper_structural
from os import remove
class WorkFolderScope:
# TODO use KratosUnittest.WorkFolderScope
def __init__(self, work_folder):
self.currentPath = os.getcwd()
self.scope = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)),work_folder))
def __enter__(self):
os.chdir(self.scope)
def __exit__(self, type, value, traceback):
os.chdir(self.currentPath)
@UnitTest.skipIfApplicationsNotAvailable("StructuralMechanicsApplication", "LinearSolversApplication")
class FSIProblemEmulatorTest(UnitTest.TestCase):
def setUp(self):
self.work_folder = "FSIProblemEmulatorTest"
self.input_file = "test_FSI_emulator_Structural"
import math
import KratosMultiphysics
import KratosMultiphysics.KratosUnittest as UnitTest
import KratosMultiphysics.kratos_utilities as KratosUtilities
have_mesh_moving = KratosUtilities.CheckIfApplicationsAvailable(
"MeshMovingApplication")
from KratosMultiphysics.FluidDynamicsApplication.fluid_dynamics_analysis import FluidDynamicsAnalysis
class CustomFluidDynamicsAnalysis(FluidDynamicsAnalysis):
def __init__(self,
model,
project_parameters,
A=1.5,
w=2.0 * math.pi,
print_output=False):
self.A = A # Piston amplitude
self.w = w # Piston angular frequency
self.print_output = print_output # Print output flag
super(CustomFluidDynamicsAnalysis,
self).__init__(model, project_parameters)
def ModifyInitialGeometry(self):
# Call the parent ModifyInitialGeometry()
super(CustomFluidDynamicsAnalysis, self).ModifyInitialGeometry()
# Create and read the structure model part
structure_model_part = self.model.CreateModelPart("Structure")
structure_model_part.SetBufferSize(2)
# Importing the Kratos Library
import KratosMultiphysics
import KratosMultiphysics.CompressiblePotentialFlowApplication as CPFApp
# Import KratosUnittest
import KratosMultiphysics.KratosUnittest as UnitTest
# Other imports
from KratosMultiphysics.CompressiblePotentialFlowApplication.potential_flow_analysis import PotentialFlowAnalysis
import KratosMultiphysics.kratos_utilities as kratos_utilities
from KratosMultiphysics.KratosUnittest import isclose as t_isclose
import os
# Check other applications dependency
hdf5_is_available = kratos_utilities.CheckIfApplicationsAvailable(
"HDF5Application")
eignsolver_is_available = kratos_utilities.CheckIfApplicationsAvailable(
"EigenSolversApplication")
meshing_is_available = kratos_utilities.CheckIfApplicationsAvailable(
"MeshingApplication")
try:
import stl
numpy_stl_is_available = True
except:
numpy_stl_is_available = False
class WorkFolderScope:
def __init__(self, work_folder):
self.currentPath = os.getcwd()
self.scope = os.path.abspath(
import os
import sys
# Importing the Kratos Library
import KratosMultiphysics
import KratosMultiphysics.KratosUnittest as KratosUnittest
import KratosMultiphysics.kratos_utilities as KratosUtils
from KratosMultiphysics import read_materials_process
dependencies_are_available = KratosUtils.CheckIfApplicationsAvailable("StructuralMechanicsApplication", "FluidDynamicsApplication")
if dependencies_are_available:
import KratosMultiphysics.FluidDynamicsApplication as KratosFluid
import KratosMultiphysics.StructuralMechanicsApplication
def GetFilePath(fileName):
return os.path.join(os.path.dirname(os.path.realpath(__file__)), fileName)
class TestMaterialsInput(KratosUnittest.TestCase):
def _prepare_test(self, input_file = "materials.json"):
# Define a Model
self.current_model = KratosMultiphysics.Model()
self.model_part = self.current_model.CreateModelPart("Main")
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT)
self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VISCOSITY)
self.model_part_io = KratosMultiphysics.ModelPartIO(GetFilePath("auxiliar_files_for_python_unittest/mdpa_files/test_model_part_io_read")) #reusing the file that is already in the directory
self.model_part_io.ReadModelPart(self.model_part)
self.test_settings = KratosMultiphysics.Parameters("""
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
import KratosMultiphysics.kratos_utilities as KratosUtilities
# Import applications
import KratosMultiphysics.FluidDynamicsApplication as KratosCFD
have_conv_diff = KratosUtilities.CheckIfApplicationsAvailable(
"ConvectionDiffusionApplication")
if have_conv_diff:
import KratosMultiphysics.ConvectionDiffusionApplication as KratosConvDiff
# Import base class file
from KratosMultiphysics.FluidDynamicsApplication.fluid_solver import FluidSolver
from KratosMultiphysics.FluidDynamicsApplication.read_distance_from_file import DistanceImportUtility
import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory
def CreateSolver(model, custom_settings):
return NavierStokesTwoFluidsSolver(model, custom_settings)
class NavierStokesTwoFluidsSolver(FluidSolver):
@classmethod
def GetDefaultSettings(cls):
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "two_fluids_solver_from_defaults",
from __future__ import print_function, absolute_import, division #makes KratosMultiphysics backward compatible with python 2.6 and 2.7
#import kratos core and applications
from KratosMultiphysics import *
from KratosMultiphysics.StructuralMechanicsApplication import *
import KratosMultiphysics.KratosUnittest as KratosUnittest
import structural_mechanics_analysis
import KratosMultiphysics.kratos_utilities as kratos_utilities
if kratos_utilities.CheckIfApplicationsAvailable("HDF5Application"):
has_hdf5_application = True
else:
has_hdf5_application = False
# This utility will control the execution scope in case we need to access files or we depend
# on specific relative locations of the files.
# TODO: Should we move this to KratosUnittest?
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)
def solve_primal_problem():
import KratosMultiphysics
import KratosMultiphysics.process_factory as process_factory
import KratosMultiphysics.KratosUnittest as UnitTest
import KratosMultiphysics.kratos_utilities as KratosUtilities
from KratosMultiphysics.FluidDynamicsApplication import python_solvers_wrapper_fluid
import KratosMultiphysics.FluidDynamicsApplication as KratosFluid
have_external_solvers = KratosUtilities.CheckIfApplicationsAvailable(
"ExternalSolversApplication")
@UnitTest.skipUnless(have_external_solvers,
"Missing required application: ExternalSolversApplication"
)
class EmbeddedCouetteTest(UnitTest.TestCase):
# Embedded element tests
def testEmbeddedCouette2D(self):
self.distance = 0.25
self.slip_flag = False
self.work_folder = "EmbeddedCouette2DTest"
self.reference_file = "reference_couette_embedded_2D"
self.settings = "EmbeddedCouette2DTestParameters.json"
self.ExecuteEmbeddedCouetteTest()
def testEmbeddedCouette3D(self):
self.distance = 0.25
self.slip_flag = False
self.work_folder = "EmbeddedCouette3DTest"
self.reference_file = "reference_couette_embedded_3D"
# import Kratos
import KratosMultiphysics
import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
import run_cpp_unit_tests
import KratosMultiphysics.kratos_utilities as kratos_utilities
# Import Kratos "wrapper" for unittests
import KratosMultiphysics.KratosUnittest as KratosUnittest
import subprocess
if kratos_utilities.CheckIfApplicationsAvailable("ExternalSolversApplication"):
has_external_solvers_application = True
else:
has_external_solvers_application = False
# Import the tests or test_classes to create the suits
##### SELF-CONTAINED TESTS #####
# CL tests
from test_constitutive_law import TestConstitutiveLaw as TTestConstitutiveLaw
from test_perfect_plasticity_implementation_verification import TestPerfectPlasticityImplementationVerification as TTestPerfectPlasticityImplementationVerification
# Processes test
from test_mass_calculation import TestMassCalculation as TTestMassCalculation
from test_compute_center_of_gravity import TestComputeCenterOfGravity as TTestComputeCenterOfGravity
from test_compute_mass_moment_of_inertia import TestComputeMassMomentOfInertia as TTestComputeMassMomentOfInertia
# Simple patch tests
from test_patch_test_small_strain import TestPatchTestSmallStrain as TTestPatchTestSmallStrain
from test_patch_test_small_strain_bbar import TestPatchTestSmallStrainBbar as TTestPatchTestSmallStrainBbar
from test_patch_test_large_strain import TestPatchTestLargeStrain as TTestPatchTestLargeStrain
from test_quadratic_elements import TestQuadraticElements as TTestQuadraticElements
import KratosMultiphysics.KratosUnittest as KratosUnittest
import KratosMultiphysics.kratos_utilities as kratos_utils
import co_simulation_test_case
import os
try:
import numpy
numpy_available = True
except ImportError:
numpy_available = False
have_fsi_dependencies = kratos_utils.CheckIfApplicationsAvailable("FluidDynamicsApplication", "StructuralMechanicsApplication", "MappingApplication", "MeshMovingApplication", "LinearSolversApplication")
have_potential_fsi_dependencies = kratos_utils.CheckIfApplicationsAvailable("CompressiblePotentialFlowApplication", "StructuralMechanicsApplication", "MappingApplication", "MeshMovingApplication", "LinearSolversApplication")
have_mpm_fem_dependencies = kratos_utils.CheckIfApplicationsAvailable("ParticleMechanicsApplication", "StructuralMechanicsApplication", "MappingApplication", "LinearSolversApplication")
have_dem_fem_dependencies = kratos_utils.CheckIfApplicationsAvailable("DEMApplication", "StructuralMechanicsApplication", "MappingApplication", "LinearSolversApplication")
have_fem_fem_dependencies = kratos_utils.CheckIfApplicationsAvailable("StructuralMechanicsApplication", "MappingApplication")
def GetFilePath(fileName):
return os.path.join(os.path.dirname(os.path.realpath(__file__)), fileName)
class TestTinyFetiCoSimulationCases(co_simulation_test_case.CoSimulationTestCase):
'''This class contains "tiny" FETI CoSimulation-Cases, small enough to run in the CI
'''
def test_FEM_FEM_small_2d_plate_feti_explict_explicit(self):
if not numpy_available:
self.skipTest("Numpy not available")
if not have_fem_fem_dependencies:
self.skipTest("FEM-FEM dependencies are not available!")
self.name = "test_FEM_FEM_small_2d_plate_feti_explict_explicit"
import os
#import kratos core and applications
import KratosMultiphysics
import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
import KratosMultiphysics.KratosUnittest as KratosUnittest
from KratosMultiphysics.StructuralMechanicsApplication import structural_mechanics_analysis
import KratosMultiphysics.kratos_utilities as kratos_utilities
from KratosMultiphysics import IsDistributedRun
from structural_mechanics_test_factory import SelectAndVerifyLinearSolver
has_hdf5_application = kratos_utilities.CheckIfApplicationsAvailable(
"HDF5Application")
class AdjointSensitivityAnalysisTestFactory(KratosUnittest.TestCase):
def setUp(self):
# Within this location context:
with KratosUnittest.WorkFolderScope(".", __file__):
# Reading the ProjectParameters
with open(self.primal_file_name, 'r') as parameter_file:
primal_parameters = KratosMultiphysics.Parameters(
parameter_file.read())
with open(self.adjoint_file_name, 'r') as parameter_file:
self.adjoint_parameters = KratosMultiphysics.Parameters(
parameter_file.read())
self.problem_name = primal_parameters["problem_data"][
"problem_name"].GetString()
self.model_part_name = primal_parameters["solver_settings"][
"model_part_name"].GetString()
from __future__ import print_function, absolute_import, division
import os
import sys
# Importing the Kratos Library
import KratosMultiphysics
import KratosMultiphysics.KratosUnittest as KratosUnittest
import KratosMultiphysics.kratos_utilities as KratosUtils
structural_mechanics_is_available = KratosUtils.CheckIfApplicationsAvailable("StructuralMechanicsApplication")
if structural_mechanics_is_available:
import KratosMultiphysics.StructuralMechanicsApplication
def GetFilePath(fileName):
return os.path.join(os.path.dirname(os.path.realpath(__file__)), fileName)
class TestModelPartIO(KratosUnittest.TestCase):
def tearDown(self):
# Clean up temporary files
KratosUtils.DeleteFileIfExisting(GetFilePath("test_model_part_io_write.out.mdpa"))
KratosUtils.DeleteFileIfExisting(GetFilePath("test_model_part_io_write.out.time"))
KratosUtils.DeleteFileIfExisting(GetFilePath("test_model_part_io_write.time"))
def test_model_part_io_read_model_part(self):
current_model = KratosMultiphysics.Model()
model_part = current_model.CreateModelPart("Main")
model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT)
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
# Import KratosUnittest
import KratosMultiphysics.KratosUnittest as KratosUnittest
from KratosMultiphysics.ConvectionDiffusionApplication.convection_diffusion_analysis import ConvectionDiffusionAnalysis
import KratosMultiphysics.kratos_utilities as kratos_utilities
have_eigen_solvers_dependencies = kratos_utilities.CheckIfApplicationsAvailable(
"EigenSolversApplication")
# Other imports
import os
# This utility will control the execution scope in case we need to access files or we depend
# on specific relative locations of the files.
# TODO: Should we move this to KratosUnittest?
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)