def _GetAdjointParameters(self):
with open(self.response_settings["adjoint_settings"].GetString(),
'r') as parameter_file:
adjoint_parameters = Parameters(parameter_file.read())
if self.response_settings["transfer_response_parameters"].GetBool():
# sensitivity settings
if adjoint_parameters["solver_settings"].Has(
"sensitivity_settings"):
Logger.PrintWarning(
self._GetLabel(),
"Adjoint settings already have 'sensitivity_settings' - Will be overwritten!"
)
adjoint_parameters["solver_settings"].RemoveValue(
"sensitivity_settings")
adjoint_parameters["solver_settings"].AddValue(
"sensitivity_settings",
self.response_settings["sensitivity_settings"])
# response settings
if adjoint_parameters["solver_settings"].Has(
"response_function_settings"):
Logger.PrintWarning(
self._GetLabel(),
"Adjoint settings already have 'response_function_settings' - Will be overwritten!"
)
adjoint_parameters["solver_settings"].RemoveValue(
"response_function_settings")
adjoint_parameters["solver_settings"].AddValue(
"response_function_settings", self.response_settings)
return adjoint_parameters
def RenumberNodesIdsToAvoidRepeating(fluid_model_part, dem_model_part,
rigid_faces_model_part):
max_fluid_id = FindMaxNodeId(fluid_model_part)
must_renumber = True in (node.Id < max_fluid_id
for node in list(dem_model_part.Nodes) +
list(rigid_faces_model_part.Nodes))
if must_renumber:
Logger.PrintWarning(
"SwimmingDEM",
"WARNING!, the DEM model part and the fluid model part have some ID values in common. Renumbering..."
)
for node in dem_model_part.Nodes:
node.Id += max_fluid_id
for node in rigid_faces_model_part.Nodes:
node.Id += max_fluid_id
Logger.PrintWarning(
"SwimmingDEM",
"The DEM model part and the fem-DEM model parts Ids have been renumbered"
)
def ImportApplication(application,
application_name,
application_folder,
caller,
mod_path=None):
KratosGlobals = KratosMultiphysics.KratosGlobals
Kernel = KratosGlobals.Kernel
applications_root = KratosGlobals.ApplicationsRoot
Logger.PrintInfo("", "Importing " + application_name)
# Add python scrips folder to path
application_path = os.path.join(applications_root, application_folder)
python_path = os.path.join(application_path, 'python_scripts')
sys.path.append(python_path)
# Add constitutive laws python scrips folder to path
constitutive_laws_path = os.path.join(python_path, 'constitutive_laws')
sys.path.append(constitutive_laws_path)
warn_msg = '\nThe python-import-mechanism used for application "' + application_name
warn_msg += '" is DEPRECATED!\n'
warn_msg += 'Please check the following website for instuctions on how to update it:\n'
warn_msg += 'https://github.com/KratosMultiphysics/Kratos/wiki/Applications-as-python-modules\n'
warn_msg += 'The old mechanism will be removed on 01.10.2019!\n'
Logger.PrintWarning('\n\x1b[1;31mDEPRECATION-WARNING\x1b[0m', warn_msg)
# adding the scripts in "APP_NAME/python_scripts" such that they are treated as a regular python-module
if mod_path is not None: # optional for backwards compatibility
mod_path.append(python_path)
# Add application to kernel
Kernel.ImportApplication(application)
def _CheckParameters(self, parameters):
if not parameters["solver_settings"].Has(
"reform_dofs_at_each_step") or not parameters[
"solver_settings"]["reform_dofs_at_each_step"].GetBool():
if not parameters["solver_settings"].Has(
"reform_dofs_at_each_step"):
parameters["solver_settings"].AddEmptyValue(
"reform_dofs_at_each_step")
parameters["solver_settings"]["reform_dofs_at_each_step"].SetBool(
True)
wrn_msg = 'This solver requires the setting reform the dofs at each step in optimization.'
wrn_msg += 'The solver setting has been set to True'
Logger.PrintWarning(self._GetLabel(), wrn_msg)
for subproc_keys, subproc_values in parameters["processes"].items():
for process in subproc_values:
if "wake" in process["python_module"].GetString():
if not process["Parameters"].Has(
"compute_wake_at_each_step"
) or not process["Parameters"][
"compute_wake_at_each_step"].GetBool():
if not process["Parameters"].Has(
"compute_wake_at_each_step"):
process["Parameters"].AddEmptyValue(
"compute_wake_at_each_step")
process["Parameters"]["compute_wake_at_each_step"].SetBool(
True)
return parameters
def Initialize(self):
if self.response_settings["model_import_settings"][
"input_type"].GetString() == "mdpa":
file_name = self.response_settings["model_import_settings"][
"input_filename"].GetString()
model_part_io = KM.ModelPartIO(file_name)
model_part_io.ReadModelPart(self.model_part)
else:
self.model_part = self.model.GetModelPart(self._model_part_name)
only = self.response_settings["only"].GetString()
if only != "":
only_part = self.model.GetModelPart(only)
if only_part.NumberOfConditions() == 0:
_AddConditionsFromParent(self.model_part, only_part)
Logger.PrintWarning(
"FaceAngleResponse",
"Automatically added {} conditions to model_part '{}'.".
format(only_part.NumberOfConditions(), only_part.Name))
else:
only_part = self.model_part
if only_part.NumberOfConditions() == 0:
raise RuntimeError(
"The model_part '{}' does not have any surface conditions!".
format(only_part.Name))
self.response_function_utility = KSO.FaceAngleResponseFunctionUtility(
only_part, self.response_settings)
self.response_function_utility.Initialize()
def ApplySimilarityTransformations(fluid_model_part, transformation_type,
mod_over_real):
if transformation_type == 0:
return
elif transformation_type == 1:
Logger.PrintWarning(
"SwimmingDEM",
'***\n\nWARNING!, applying similarity transformations to the problem fluid variables'
)
Logger.PrintWarning("SwimmingDEM",
'The particles diameters quotient is\n')
Logger.PrintWarning("SwimmingDEM", 'D_model / D_real =', mod_over_real)
Logger.PrintWarning("SwimmingDEM", )
if transformation_type == 1: # Tsuji 2013, (Preserves Archimedes and Reynolds numbers)
Logger.PrintWarning(
'The fluid variables to be modified are\n\nDENSITY\nVISCOSITY\n\n***'
)
fluid_density_factor = mod_over_real
fluid_viscosity_factor = mod_over_real * mod_over_real
MultiplyNodalVariableByFactor(fluid_model_part, Kratos.DENSITY,
fluid_density_factor)
MultiplyNodalVariableByFactor(fluid_model_part, Kratos.VISCOSITY,
fluid_viscosity_factor)
else:
Logger.PrintWarning(
"SwimmingDEM",
('The entered value similarity_transformation_type = ',
transformation_type, 'is not currently supported'))
def __init__(self, identifier, response_settings, model):
self.identifier = identifier
with open(response_settings["primal_settings"].GetString()) as parameters_file:
ProjectParametersPrimal = Parameters(parameters_file.read())
eigen_solver_settings = ProjectParametersPrimal["solver_settings"]["eigensolver_settings"]
max_required_eigenfrequency = int(max(response_settings["traced_eigenfrequencies"].GetVector()))
if max_required_eigenfrequency is not eigen_solver_settings["number_of_eigenvalues"].GetInt():
Logger.PrintWarning("EigenFrequencyResponse", "Specified number of eigenvalues in the primal analysis and the max required eigenvalue according the response settings do not match!!!")
Logger.PrintWarning("EigenFrequencyResponse", "Primal parameters were adjusted accordingly!\n")
eigen_solver_settings["number_of_eigenvalues"].SetInt(max_required_eigenfrequency)
if not eigen_solver_settings.Has("normalize_eigenvectors"):
eigen_solver_settings.AddEmptyValue("normalize_eigenvectors")
eigen_solver_settings["normalize_eigenvectors"].SetBool(True)
Logger.PrintWarning("EigenFrequencyResponse", "Eigenfrequency response function requires mass normalization of eigenvectors!")
Logger.PrintWarning("EigenFrequencyResponse", "Primal parameters were adjusted accordingly!\n")
if not eigen_solver_settings["normalize_eigenvectors"].GetBool():
eigen_solver_settings["normalize_eigenvectors"].SetBool(True)
Logger.PrintWarning("EigenFrequencyResponse", "Eigenfrequency response function requires mass normalization of eigenvectors!")
Logger.PrintWarning("EigenFrequencyResponse", "Primal parameters were adjusted accordingly!\n")
self.primal_model_part = _GetModelPart(model, ProjectParametersPrimal["solver_settings"])
self.primal_analysis = StructuralMechanicsAnalysis(model, ProjectParametersPrimal)
self.primal_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.SHAPE_SENSITIVITY)
self.response_function_utility = StructuralMechanicsApplication.EigenfrequencyResponseFunctionUtility(self.primal_model_part, response_settings)
def _GetAdjointParameters(self):
adjoint_settings = self.response_settings[
"adjoint_settings"].GetString()
if adjoint_settings == "auto":
Logger.PrintInfo(
self._GetLabel(),
"Automatic set up adjoint parameters for response:",
self.identifier)
if not self.primal_data_transfer_with_python:
raise Exception(
"Auto setup of adjoint parameters does only support primal data transfer with python."
)
with open(self.response_settings["primal_settings"].GetString(),
'r') as parameter_file:
primal_parameters = Parameters(parameter_file.read())
# check that HDF5 process is not there
if primal_parameters["processes"].Has("list_other_processes"):
for i in range(
0, primal_parameters["processes"]
["list_other_processes"].size()):
process = primal_parameters["processes"][
"list_other_processes"][i]
raise Exception(
"Auto setup of adjoint parameters does not support {} in list_other_processes"
.format(process["python_module"].GetString()))
# clone primal settings as base for adjoint
adjoint_parameters = primal_parameters.Clone()
# analysis settings
solver_settings = adjoint_parameters["solver_settings"]
primal_solver_type = solver_settings["solver_type"].GetString()
if primal_solver_type != "static":
raise Exception(
"Auto setup of adjoint parameters does not support {} solver_type. Only available for 'static'"
.format(primal_solver_type))
solver_settings["solver_type"].SetString("adjoint_" +
primal_solver_type)
if not solver_settings.Has("compute_reactions"):
solver_settings.AddEmptyValue("compute_reactions")
solver_settings["compute_reactions"].SetBool(False)
if not solver_settings.Has("move_mesh_flag"):
solver_settings.AddEmptyValue("move_mesh_flag")
solver_settings["move_mesh_flag"].SetBool(False)
if solver_settings.Has("scheme_settings"):
depr_msg = '\nDEPRECATION-WARNING: "scheme_settings" is deprecated, please remove it from your json parameters.\n'
Logger.PrintWarning(__name__, depr_msg)
solver_settings.RemoveValue("scheme_settings")
if solver_settings["model_import_settings"][
"input_type"].GetString() == "use_input_model_part":
solver_settings["model_import_settings"][
"input_type"].SetString("mdpa")
if solver_settings["model_import_settings"].Has(
"input_filename"):
file_name = solver_settings["model_import_settings"][
"input_filename"].GetString()
else:
Logger.PrintWarning(
self._GetLabel(),
"Automatic adjoint settings creator assumes the model_part_name as input_filename."
)
solver_settings["model_import_settings"].AddEmptyValue(
"input_filename")
file_name = solver_settings["model_part_name"].GetString()
solver_settings["model_import_settings"][
"input_filename"].SetString(file_name)
# Dirichlet conditions: change variables
for i in range(
0, primal_parameters["processes"]
["constraints_process_list"].size()):
process = adjoint_parameters["processes"][
"constraints_process_list"][i]
variable_name = process["Parameters"][
"variable_name"].GetString()
process["Parameters"]["variable_name"].SetString("ADJOINT_" +
variable_name)
# Neumann conditions - do not modify to read the same load values as in primal:
# Output process:
# TODO how to add the output process? How find out about the variables?
if adjoint_parameters.Has("output_processes"):
Logger.PrintInfo(
self._GetLabel(),
"Output process is removed for adjoint analysis. To enable it define adjoint_parameters yourself."
)
adjoint_parameters.RemoveValue("output_processes")
# sensitivity settings
adjoint_parameters["solver_settings"].AddValue(
"sensitivity_settings",
self.response_settings["sensitivity_settings"])
# response settings
adjoint_parameters["solver_settings"].AddValue(
"response_function_settings", self.response_settings)
else: # adjoint parameters file is explicitely given - do not change it.
with open(self.response_settings["adjoint_settings"].GetString(),
'r') as parameter_file:
adjoint_parameters = Parameters(parameter_file.read())
return adjoint_parameters
# Import KratosUnittest
import KratosMultiphysics.KratosUnittest as UnitTest
import BackwardCouplingTestFactory as BackwardCouplingTF
# Importing test factories if possible
try:
import InterpolationTestFactory as InterpolationTF
interpolation_imports_available = True
except ImportError:
interpolation_imports_available = False
try:
import CandelierTestFactory as CandelierTF
candelier_imports_available = True
except ImportError:
candelier_imports_available = False
Logger.PrintWarning("SwimmingDEMTests", "Failed to import some of the modules necessary for the Candelier tests.")
try:
import FluidDEMTestFactory as FDEMTF
fluid_DEM_coupling_imports_available = True
except ImportError:
fluid_DEM_coupling_imports_available = False
try:
import AnalyticTestFactory as AnalyticTF
analytic_imports_available = True
except ImportError:
analytic_imports_available = False
class interpolation_test_linear(InterpolationTF.TestFactory):
file_name = "interpolation_tests/cube"
file_parameters = "interpolation_tests/ProjectParametersCubeLinear.json"
def IssueDeprecationWarning(label, *message):
from KratosMultiphysics import Logger
Logger.PrintWarning('DEPRECATION-Warning; ' + label,
' '.join(map(str, message)))
