#include <MortarGapHeatTransferAction.h>

Inheritance diagram for MortarGapHeatTransferAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	MortarGapHeatTransferAction (const InputParameters &params)

virtual void	act () override

virtual void	addRelationshipManagers (Moose::RelationshipManagerType input_rm_type) override

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)

void	timedAct ()

MooseObjectName	uniqueActionName () const

const std::string &	specificTaskName () const

const std::set< std::string > &	getAllTasks () const

void	appendTask (const std::string &task)

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &nm) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	mooseError (Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
virtual void	coreMortarMesh ()

virtual void	addConstraints ()

virtual void	addMortarMesh ()

virtual void	addMortarVariable ()

virtual void	addUserObjects ()

bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)

void	associateWithParameter (const std::string &param_name, InputParameters &params) const

void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::string	_registered_identifier

std::string	_specific_task_name

std::set< std::string >	_all_tasks

ActionWarehouse &	_awh

const std::string &	_current_task

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem

PerfID	_act_timer

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Private Member Functions
void	checkForExistingSubdomains ()

Private Attributes
bool	_user_provided_mortar_meshes

const bool	_user_provided_gap_flux_models

std::vector< MortarGapHeatTransfer::UserObjectToBuild >	_gap_flux_models

Detailed Description

Definition at line 26 of file MortarGapHeatTransferAction.h.

Constructor & Destructor Documentation

◆ MortarGapHeatTransferAction()

MortarGapHeatTransferAction::MortarGapHeatTransferAction ( const InputParameters & params )

Definition at line 72 of file MortarGapHeatTransferAction.C.

   : Action(params),
     _user_provided_mortar_meshes(false),
     _user_provided_gap_flux_models(
         getParam<std::vector<UserObjectName>>("user_created_gap_flux_models").size() > 0 ? true
                                                                                          : false)
 
 {
   if (getParam<MultiMooseEnum>("gap_flux_options").size() > 0 && _user_provided_gap_flux_models)
     paramError(
         "gap_flux_options",
         "Either create user objects for the action in the input file or provide the desire physics "
         "to the action via the gap_flux_options parameter. Mixed use is not supported");
 
   for (unsigned int i = 0; i < getParam<MultiMooseEnum>("gap_flux_options").size(); i++)
     _gap_flux_models.push_back(static_cast<MortarGapHeatTransfer::UserObjectToBuild>(
         getParam<MultiMooseEnum>("gap_flux_options").get(i)));
 
   // We do not currently support building more than one condution or more than one radiation user
   // object from this action.
   const unsigned int conduction_build_uos =
       cast_int<unsigned int>(std::count(_gap_flux_models.cbegin(),
                                         _gap_flux_models.cend(),
                                         MortarGapHeatTransfer::UserObjectToBuild::CONDUCTION));
   const unsigned int radiation_build_uos =
       cast_int<unsigned int>(std::count(_gap_flux_models.cbegin(),
                                         _gap_flux_models.cend(),
                                         MortarGapHeatTransfer::UserObjectToBuild::RADIATION));
 
   if (conduction_build_uos > 1 || radiation_build_uos > 1)
     paramError("gap_flux_options",
                "You cannot choose to have more than one conduction or more than one radiation user "
                "objects when they are built by the action. If you want to superimpose multiple "
                "physics, you can choose to create your own user objects and pass them to this "
                "action via 'user_created_gap_flux_models'");
 
   if (params.isParamSetByUser("primary_subdomain") &&
       params.isParamSetByUser("secondary_subdomain"))
   {
     mooseInfo("Mortar gap heat transfer action is using the lower-dimensional domains provided by "
               "the user");
     _user_provided_mortar_meshes = true;
   }
   else
     mooseInfo("Mortar gap heat transfer action is creating new lower-dimensional domains");
 
   if (_user_provided_gap_flux_models)
     mooseInfo(
         "User decided to create user objects to model physics for the mortar gap heat transfer "
         "action independently, i.e. not through the mortar gap heat transfer action.");
   else
     mooseInfo("The mortar gap heat transfer action will add gap heat transfer physics according to "
               "the gap_flux_options input parameter");
 
   const bool wrong_parameters_provided =
       _user_provided_gap_flux_models &&
       (params.isParamSetByUser("gap_conductivity") ||
        params.isParamSetByUser("primary_emissivity") ||
        params.isParamSetByUser("secondary_emissivity") ||
        params.isParamSetByUser("gap_conductivity_function") ||
        params.isParamSetByUser("gap_conductivity_function_variable") ||
        params.isParamSetByUser("min_gap"));
 
   if (wrong_parameters_provided)
     paramError(
         "user_created_gap_flux_models",
         "The mortar gap heat transfer action requires that the input file defines user objects "
         "with physics or adds physics parameters directly into the action. You have provided both "
         "user objects and physics parameters (e.g. emissivities, gap conductance, etc.).");
 }

Member Function Documentation

◆ act()

void MortarGapHeatTransferAction::act ( )

overridevirtual

Implements Action.

Definition at line 144 of file MortarGapHeatTransferAction.C.

 {
   if (_current_task == "append_mesh_generator")
     addMortarMesh();
   else if (_current_task == "add_mortar_variable")
     addMortarVariable();
   if (_current_task == "add_constraint")
     addConstraints();
   else if (_current_task == "add_user_object")
     if (!_user_provided_gap_flux_models)
       addUserObjects();
 }

◆ addConstraints()

void MortarGapHeatTransferAction::addConstraints ( )

protectedvirtual

Definition at line 246 of file MortarGapHeatTransferAction.C.

Referenced by act().

 {
   checkForExistingSubdomains();
 
   InputParameters params = _factory.getValidParams("ModularGapConductanceConstraint");
   const std::string action_name = MooseUtils::shortName(name());
 
   params.applyParameters(parameters());
   params.set<bool>("use_displaced_mesh") = true;
 
   params.set<BoundaryName>("primary_boundary") = getParam<BoundaryName>("primary_boundary");
   params.set<BoundaryName>("secondary_boundary") = getParam<BoundaryName>("secondary_boundary");
 
   if (_user_provided_mortar_meshes)
   {
     params.set<SubdomainName>("primary_subdomain") = getParam<SubdomainName>("primary_subdomain");
     params.set<SubdomainName>("secondary_subdomain") =
         getParam<SubdomainName>("secondary_subdomain");
   }
   else
   {
     params.set<SubdomainName>("primary_subdomain") = action_name + "_primary_subdomain";
     params.set<SubdomainName>("secondary_subdomain") = action_name + "_secondary_subdomain";
   }
 
   params.set<NonlinearVariableName>("variable") = action_name + "_thermal_lm";
 
   params.set<VariableName>("secondary_variable") =
       getParam<std::vector<VariableName>>("temperature")[0];
 
   if (!_user_provided_gap_flux_models)
   {
     std::vector<UserObjectName> uoname_strings(0);
 
     for (const auto & uo_name : _gap_flux_models)
     {
       if (uo_name == MortarGapHeatTransfer::UserObjectToBuild::CONDUCTION)
         uoname_strings.push_back("gap_flux_model_conduction_object_" +
                                  MooseUtils::shortName(name()));
       else if (uo_name == MortarGapHeatTransfer::UserObjectToBuild::RADIATION)
         uoname_strings.push_back("gap_flux_model_radiation_object_" +
                                  MooseUtils::shortName(name()));
     }
 
     params.set<std::vector<UserObjectName>>("gap_flux_models") = uoname_strings;
   }
   else
     params.set<std::vector<UserObjectName>>("gap_flux_models") =
         getParam<std::vector<UserObjectName>>("user_created_gap_flux_models");
 
   _problem->addConstraint(
       "ModularGapConductanceConstraint", action_name + "_ModularGapConductanceConstraint", params);
 }

◆ addMortarMesh()

void MortarGapHeatTransferAction::addMortarMesh ( )

protectedvirtual

Definition at line 301 of file MortarGapHeatTransferAction.C.

Referenced by act().

 {
   // Evaluate whether we have sufficient information from the user to skip building the
   // lower-dimensional domains.
   checkForExistingSubdomains();
 
   // We may have available lower-dimensional domains (e.g. from a mechanical contact action), whose
   // subdomains can be reused for adding mortar variables and constraints.
   if (!_user_provided_mortar_meshes)
     coreMortarMesh();
 }

◆ addMortarVariable()

void MortarGapHeatTransferAction::addMortarVariable ( )

protectedvirtual

Definition at line 210 of file MortarGapHeatTransferAction.C.

Referenced by act().

 {
   checkForExistingSubdomains();
 
   InputParameters params = _factory.getValidParams("MooseVariableBase");
 
   const std::string & temperature = getParam<std::vector<VariableName>>("temperature")[0];
   std::string action_name = MooseUtils::shortName(name());
 
   if (!_problem->hasVariable(temperature))
     mooseError("Temperature variable is missing");
 
   const auto primal_type =
       _problem->getVariable(0, temperature, Moose::VarKindType::VAR_SOLVER).feType();
   const int lm_order = primal_type.order.get_order();
 
   if (primal_type.family != LAGRANGE)
     mooseError("The mortar thermal action can only be used with LAGRANGE finite elements");
 
   params.set<MooseEnum>("family") = Utility::enum_to_string<FEFamily>(primal_type.family);
   params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(libMesh::OrderWrapper{lm_order});
 
   if (_user_provided_mortar_meshes)
     params.set<std::vector<SubdomainName>>("block") = {
         getParam<SubdomainName>("secondary_subdomain")};
   else
     params.set<std::vector<SubdomainName>>("block") = {action_name + "_secondary_subdomain"};
 
   params.set<std::vector<Real>>("scaling") = {getParam<Real>("thermal_lm_scaling")};
   auto fe_type = AddVariableAction::feType(params);
   auto var_type = AddVariableAction::variableType(fe_type);
 
   _problem->addVariable(var_type, action_name + "_thermal_lm", params);
 }

◆ addRelationshipManagers() [1/3]

virtual void Action::addRelationshipManagers

◆ addRelationshipManagers() [2/3]

bool Action::addRelationshipManagers

◆ addRelationshipManagers() [3/3]

void MortarGapHeatTransferAction::addRelationshipManagers ( Moose::RelationshipManagerType input_rm_type )

overridevirtual

Reimplemented from Action.

Definition at line 184 of file MortarGapHeatTransferAction.C.

 {
   checkForExistingSubdomains();
   std::string action_name = MooseUtils::shortName(name());
 
   auto params = MortarConstraintBase::validParams();
   params.set<bool>("use_displaced_mesh") = getParam<bool>("use_displaced_mesh");
   params.set<BoundaryName>("primary_boundary") = getParam<BoundaryName>("primary_boundary");
   params.set<BoundaryName>("secondary_boundary") = getParam<BoundaryName>("secondary_boundary");
 
   if (_user_provided_mortar_meshes)
   {
     params.set<SubdomainName>("primary_subdomain") = getParam<SubdomainName>("primary_subdomain");
     params.set<SubdomainName>("secondary_subdomain") =
         getParam<SubdomainName>("secondary_subdomain");
   }
   else
   {
     params.set<SubdomainName>("primary_subdomain") = action_name + "_primary_subdomain";
     params.set<SubdomainName>("secondary_subdomain") = action_name + "_secondary_subdomain";
   }
 
   addRelationshipManagers(input_rm_type, params);
 }

◆ addUserObjects()

void MortarGapHeatTransferAction::addUserObjects ( )

protectedvirtual

Definition at line 314 of file MortarGapHeatTransferAction.C.

Referenced by act().

 {
   // It is risky to apply this optimization to contact problems
   // since the problem configuration may be changed during Jacobian
   // evaluation. We therefore turn it off for all contact problems so that
   // PETSc-3.8.4 or higher will have the same behavior as PETSc-3.8.3 or older.
   mooseAssert(_problem, "Problem pointer is null");
 
   if (!_problem->isSNESMFReuseBaseSetbyUser())
     _problem->setSNESMFReuseBase(false, false);
 
   for (const auto & uo_name : _gap_flux_models)
   {
     if (uo_name == MortarGapHeatTransfer::UserObjectToBuild::CONDUCTION)
     {
       auto var_params = _factory.getValidParams("GapFluxModelConduction");
 
       var_params.set<std::vector<VariableName>>("temperature") =
           getParam<std::vector<VariableName>>("temperature");
       var_params.set<Real>("gap_conductivity") = getParam<Real>("gap_conductivity");
 
       if (isParamValid("gap_conductivity_function"))
         var_params.set<FunctionName>("gap_conductivity_function") =
             getParam<FunctionName>("gap_conductivity_function");
 
       if (isParamValid("gap_conductivity_function_variable"))
         var_params.set<std::vector<VariableName>>("gap_conductivity_function_variable") =
             getParam<std::vector<VariableName>>("gap_conductivity_function_variable");
 
       var_params.set<Real>("min_gap") = getParam<Real>("min_gap");
       var_params.set<unsigned int>("min_gap_order") = getParam<unsigned int>("min_gap_order");
 
       var_params.set<std::vector<BoundaryName>>("boundary") =
           getParam<std::vector<BoundaryName>>("boundary");
 
       var_params.set<bool>("use_displaced_mesh") = true;
 
       _problem->addUserObject("GapFluxModelConduction",
                               "gap_flux_model_conduction_object_" + MooseUtils::shortName(name()),
                               var_params);
     }
     else if (uo_name == MortarGapHeatTransfer::UserObjectToBuild::RADIATION)
 
     {
       auto var_params = _factory.getValidParams("GapFluxModelRadiation");
 
       var_params.set<Real>("stefan_boltzmann") = getParam<Real>("stefan_boltzmann");
       var_params.set<Real>("primary_emissivity") = getParam<Real>("primary_emissivity");
       var_params.set<Real>("secondary_emissivity") = getParam<Real>("secondary_emissivity");
 
       var_params.set<std::vector<BoundaryName>>("boundary") =
           getParam<std::vector<BoundaryName>>("boundary");
 
       var_params.set<std::vector<VariableName>>("temperature") =
           getParam<std::vector<VariableName>>("temperature");
 
       var_params.set<bool>("use_displaced_mesh") = true;
 
       _problem->addUserObject("GapFluxModelRadiation",
                               "gap_flux_model_radiation_object_" + MooseUtils::shortName(name()),
                               var_params);
     }
   }
 }

◆ checkForExistingSubdomains()

void MortarGapHeatTransferAction::checkForExistingSubdomains ( )

private

Definition at line 380 of file MortarGapHeatTransferAction.C.

Referenced by addConstraints(), addMortarMesh(), addMortarVariable(), and addRelationshipManagers().

 {
   if (parameters().isParamSetByUser("primary_subdomain") &&
       parameters().isParamSetByUser("secondary_subdomain"))
   {
     _user_provided_mortar_meshes = true;
   }
   else
     _user_provided_mortar_meshes = false;
 }

◆ coreMortarMesh()

void MortarGapHeatTransferAction::coreMortarMesh ( )

protectedvirtual

Definition at line 158 of file MortarGapHeatTransferAction.C.

Referenced by addMortarMesh().

 {
   if (!(_app.isRecovering() && _app.isUltimateMaster()) && !_app.masterMesh())
   {
     std::string action_name = MooseUtils::shortName(name());
 
     const MeshGeneratorName primary_name = action_name + "_primary_subdomain" + "_generator";
     const MeshGeneratorName secondary_name = action_name + "_secondary_subdomain" + "_generator";
 
     auto primary_params = _factory.getValidParams("LowerDBlockFromSidesetGenerator");
     auto secondary_params = _factory.getValidParams("LowerDBlockFromSidesetGenerator");
 
     primary_params.set<SubdomainName>("new_block_name") = action_name + "_primary_subdomain";
     secondary_params.set<SubdomainName>("new_block_name") = action_name + "_secondary_subdomain";
 
     primary_params.set<std::vector<BoundaryName>>("sidesets") = {
         getParam<BoundaryName>("primary_boundary")};
     secondary_params.set<std::vector<BoundaryName>>("sidesets") = {
         getParam<BoundaryName>("secondary_boundary")};
 
     _app.appendMeshGenerator("LowerDBlockFromSidesetGenerator", primary_name, primary_params);
     _app.appendMeshGenerator("LowerDBlockFromSidesetGenerator", secondary_name, secondary_params);
   }
 }

◆ validParams()

InputParameters MortarGapHeatTransferAction::validParams ( )

static

Definition at line 29 of file MortarGapHeatTransferAction.C.

 {
   InputParameters params = Action::validParams();
   params.addClassDescription(
       "Action that controls the creation of all of the necessary objects for "
       "calculation of heat transfer through an open/closed gap using a mortar formulation and a "
       "modular design approach");
 
   params.addParam<Real>("thermal_lm_scaling",
                         1.,
                         "Scaling factor to apply to the thermal Lagrange multiplier variable");
 
   params += ModularGapConductanceConstraint::validParams();
   params += GapFluxModelRadiation::validParams();
   params += GapFluxModelConduction::validParams();
 
   params.addParam<bool>(
       "correct_edge_dropping",
       true,
       "Whether to enable correct edge dropping treatment for mortar constraints. When disabled "
       "any Lagrange Multiplier degree of freedom on a secondary element without full primary "
       "contributions will be set (strongly) to 0.");
 
   params.makeParamNotRequired<SubdomainName>("primary_subdomain");
   params.makeParamNotRequired<SubdomainName>("secondary_subdomain");
   params.makeParamNotRequired<Real>("gap_conductivity");
 
   params.addParam<MultiMooseEnum>(
       "gap_flux_options", MortarGapHeatTransfer::gapFluxPhysics, "The gap flux models to build");
 
   params.addParam<std::vector<UserObjectName>>(
       "user_created_gap_flux_models",
       {},
       "The name of the user objects created by the user to represent gap heat transfer physics");
 
   params.addParamNamesToGroup("primary_subdomain secondary_subdomain", "Gap surface definition");
   params.addParamNamesToGroup("gap_flux_options user_created_gap_flux_models", "Gap flux models");
   params.addParamNamesToGroup("thermal_lm_scaling correct_edge_dropping",
                               "Thermal Lagrange multiplier");
 
   return params;
 }