Action that creates the necessary objects, for the solid side, to couple a solid heat conduction region to a 1-D flow channel via convective heat transfer. More...

#include <CoupledHeatTransferAction.h>

Inheritance diagram for CoupledHeatTransferAction:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	CoupledHeatTransferAction (const InputParameters &params)

virtual void	act () override

void	timedAct ()

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

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	addBCs ()

virtual void	addUserObjects ()

virtual void	addTransfers ()

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::vector< BoundaryName >	_boundary
	Boundary where the BC is applied. More...

const VariableName	_T_solid_var_name
	Solid side temperature variable name. More...

const VariableName	_T_wall_var_name
	Variable on the flow channel side into which to transfer the solid temperature. More...

const std::vector< VariableName >	_T_fluid_var_names
	Variable(s) on the solid side into which to transfer the fluid temperature(s) More...

const std::vector< VariableName >	_htc_var_names
	Variable(s) on the solid side into which to transfer the heat transfer coefficient(s) More...

std::vector< VariableName >	_kappa_var_names
	Variables on the solid side into which to transfer the wall contact fractions. More...

const unsigned int	_n_phases
	Number of fluid phases. More...

const UserObjectName	_T_wall_user_object_name
	User object name with solid temperature. More...

std::vector< UserObjectName >	_T_fluid_user_object_names
	Spatial user object(s) holding the fluid temperature values. More...

std::vector< UserObjectName >	_htc_user_object_names
	Spatial user object(s) holding the heat transfer coefficient values. More...

std::vector< UserObjectName >	_kappa_user_object_names
	Spatial user objects holding the wall contact fraction values. More...

MultiAppName	_multi_app_name
	Name of the THM multi-app. More...

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

Detailed Description

Action that creates the necessary objects, for the solid side, to couple a solid heat conduction region to a 1-D flow channel via convective heat transfer.

Definition at line 20 of file CoupledHeatTransferAction.h.

Constructor & Destructor Documentation

◆ CoupledHeatTransferAction()

CoupledHeatTransferAction::CoupledHeatTransferAction ( const InputParameters & params )

Definition at line 97 of file CoupledHeatTransferAction.C.

   : Action(params),
 
     _boundary(getParam<std::vector<BoundaryName>>("boundary")),
 
     _T_solid_var_name(getParam<VariableName>("T")),
     _T_wall_var_name(getParam<VariableName>("T_wall")),
     _T_fluid_var_names(getParam<std::vector<VariableName>>("T_fluid")),
     _htc_var_names(getParam<std::vector<VariableName>>("htc")),
 
     _n_phases(_T_fluid_var_names.size()),
 
     _T_wall_user_object_name(name() + "_T_avg_uo"),
 
     _multi_app_name(getParam<std::string>("multi_app"))
 {
   if (isParamValid("T_fluid_user_objects"))
     _T_fluid_user_object_names = getParam<std::vector<UserObjectName>>("T_fluid_user_objects");
   else if (isParamValid("T_fluid_user_object"))
     _T_fluid_user_object_names = {getParam<UserObjectName>("T_fluid_user_object")};
   else
     mooseError("The parameter 'T_fluid_user_objects' must be specified.");
 
   if (isParamValid("htc_user_objects"))
     _htc_user_object_names = getParam<std::vector<UserObjectName>>("htc_user_objects");
   else if (isParamValid("htc_user_object"))
     _htc_user_object_names = {getParam<UserObjectName>("htc_user_object")};
   else
     mooseError("The parameter 'htc_user_objects' must be specified.");
 
   if (_htc_var_names.size() != _n_phases || _T_fluid_user_object_names.size() != _n_phases ||
       _htc_user_object_names.size() != _n_phases)
     mooseError("The parameters 'T_fluid', 'htc', 'T_fluid_user_objects', and 'htc_user_objects' "
                "must have the same numbers of elements.");
 
   if (_n_phases == 1)
   {
     if (isParamValid("kappa") || isParamValid("kappa_user_objects"))
       mooseError("If there is only one phase (e.g., only one element in 'T_fluid'), then the "
                  "parameters 'kappa' and 'kappa_user_objects' must not be provided.");
   }
   else
   {
     if (!isParamValid("kappa") || !isParamValid("kappa_user_objects"))
       mooseError("If there is more than one phase (e.g., more than one element in 'T_fluid'), then "
                  "the parameters 'kappa' and 'kappa_user_objects' must be provided.");
     else
     {
       _kappa_var_names = getParam<std::vector<VariableName>>("kappa");
       _kappa_user_object_names = getParam<std::vector<UserObjectName>>("kappa_user_objects");
       if (_kappa_var_names.size() != _n_phases || _kappa_user_object_names.size() != _n_phases)
         mooseError("The parameters 'kappa' and 'kappa_user_objects' must have the same number of "
                    "elements as 'T_fluid'.");
     }
   }
 
   if (isParamValid("orientation"))
   {
     const auto & orientation = getParam<RealVectorValue>("orientation");
     if (!DiscreteLineSegmentInterface::getAlignmentAxis(orientation).isValid())
       mooseError("The direction given by the parameter 'orientation' must be aligned with the x, "
                  "y, or z axis.");
   }
 }

Member Function Documentation

◆ act()

void CoupledHeatTransferAction::act ( )

overridevirtual

Implements Action.

Definition at line 163 of file CoupledHeatTransferAction.C.

 {
   if (_current_task == "add_bc")
     addBCs();
   else if (_current_task == "add_user_object")
     addUserObjects();
   else if (_current_task == "add_transfer")
     addTransfers();
 }

◆ addBCs()

void CoupledHeatTransferAction::addBCs ( )

protectedvirtual

Definition at line 174 of file CoupledHeatTransferAction.C.

Referenced by act().

 {
   for (unsigned int k = 0; k < _n_phases; k++)
   {
     const std::string class_name = "CoupledConvectiveHeatFluxBC";
     InputParameters params = _factory.getValidParams(class_name);
     params.set<NonlinearVariableName>("variable") = _T_solid_var_name;
     params.set<std::vector<BoundaryName>>("boundary") = {_boundary};
     params.set<std::vector<VariableName>>("T_infinity") = {_T_fluid_var_names[k]};
     params.set<std::vector<VariableName>>("htc") = {_htc_var_names[k]};
     if (_n_phases > 1)
       params.set<std::vector<VariableName>>("scale_factor") = {_kappa_var_names[k]};
     _problem->addBoundaryCondition(class_name, name() + "_bc" + std::to_string(k), params);
   }
 }

◆ addTransfers()

void CoupledHeatTransferAction::addTransfers ( )

protectedvirtual

Definition at line 238 of file CoupledHeatTransferAction.C.

Referenced by act().

 {
   // Transfers to the flow channel application
 
   const bool skip_coordinate_collapsing = getParam<bool>("skip_coordinate_collapsing");
 
   const bool use_bounding_boxes = isParamValid("fixed_bounding_box_size");
   std::vector<Real> fixed_bounding_box_size;
   if (use_bounding_boxes)
     fixed_bounding_box_size = getParam<std::vector<Real>>("fixed_bounding_box_size");
 
   {
     const std::string class_name = "MultiAppGeneralFieldUserObjectTransfer";
     InputParameters params = _factory.getValidParams(class_name);
     params.set<MultiAppName>("to_multi_app") = _multi_app_name;
     params.set<UserObjectName>("source_user_object") = {_T_wall_user_object_name};
     params.set<std::vector<AuxVariableName>>("variable") = {_T_wall_var_name};
     params.set<bool>("skip_coordinate_collapsing") = skip_coordinate_collapsing;
     params.set<bool>("error_on_miss") = true;
     if (use_bounding_boxes)
       params.set<std::vector<Real>>("fixed_bounding_box_size") = fixed_bounding_box_size;
     else
     {
       params.set<bool>("use_bounding_boxes") = false;
       params.set<bool>("greedy_search") = true;
     }
     _problem->addTransfer(class_name, name() + "_T_solid_transfer", params);
   }
 
   // Transfers from the flow channel application. Note that
   // Note that MultiAppGeneralFieldNearestLocationTransfer should be more optimal
   // choice in parallel calculations, while MultiAppGeneralFieldUserObjectTransfer should
   // be more optimal in serial calculations. If these transfers prove to be a significant time
   // burden, we may want to provide an option to switch these transfer classes.
   for (unsigned int k = 0; k < _n_phases; k++)
   {
     {
       const std::string class_name = "MultiAppGeneralFieldUserObjectTransfer";
       InputParameters params = _factory.getValidParams(class_name);
       params.set<MultiAppName>("from_multi_app") = _multi_app_name;
       params.set<UserObjectName>("source_user_object") = _T_fluid_user_object_names[k];
       params.set<std::vector<AuxVariableName>>("variable") = {_T_fluid_var_names[k]};
       params.set<bool>("skip_coordinate_collapsing") = skip_coordinate_collapsing;
       params.set<bool>("error_on_miss") = true;
       if (use_bounding_boxes)
         params.set<std::vector<Real>>("fixed_bounding_box_size") = fixed_bounding_box_size;
       else
       {
         params.set<bool>("use_bounding_boxes") = false;
         params.set<bool>("greedy_search") = true;
       }
       _problem->addTransfer(class_name, name() + "_T_fluid_transfer" + std::to_string(k), params);
     }
     {
       const std::string class_name = "MultiAppGeneralFieldUserObjectTransfer";
       InputParameters params = _factory.getValidParams(class_name);
       params.set<MultiAppName>("from_multi_app") = _multi_app_name;
       params.set<UserObjectName>("source_user_object") = _htc_user_object_names[k];
       params.set<std::vector<AuxVariableName>>("variable") = {_htc_var_names[k]};
       params.set<bool>("skip_coordinate_collapsing") = skip_coordinate_collapsing;
       params.set<bool>("error_on_miss") = true;
       if (use_bounding_boxes)
         params.set<std::vector<Real>>("fixed_bounding_box_size") = fixed_bounding_box_size;
       else
       {
         params.set<bool>("use_bounding_boxes") = false;
         params.set<bool>("greedy_search") = true;
       }
       _problem->addTransfer(class_name, name() + "_htc_transfer" + std::to_string(k), params);
     }
     if (_n_phases > 1)
     {
       const std::string class_name = "MultiAppGeneralFieldUserObjectTransfer";
       InputParameters params = _factory.getValidParams(class_name);
       params.set<MultiAppName>("from_multi_app") = _multi_app_name;
       params.set<UserObjectName>("source_user_object") = _kappa_user_object_names[k];
       params.set<std::vector<AuxVariableName>>("variable") = {_kappa_var_names[k]};
       params.set<bool>("skip_coordinate_collapsing") = skip_coordinate_collapsing;
       params.set<bool>("error_on_miss") = true;
       if (use_bounding_boxes)
         params.set<std::vector<Real>>("fixed_bounding_box_size") = fixed_bounding_box_size;
       else
       {
         params.set<bool>("use_bounding_boxes") = false;
         params.set<bool>("greedy_search") = true;
       }
       _problem->addTransfer(class_name, name() + "_kappa_transfer" + std::to_string(k), params);
     }
   }
 }

◆ addUserObjects()

void CoupledHeatTransferAction::addUserObjects ( )

protectedvirtual

Definition at line 191 of file CoupledHeatTransferAction.C.

Referenced by act().

 {
   // Solid temperature spatial user object
   {
     const std::string class_name = "NearestPointLayeredSideAverage";
     InputParameters params = _factory.getValidParams(class_name);
     params.set<std::vector<VariableName>>("variable") = {_T_solid_var_name};
     params.set<std::vector<BoundaryName>>("boundary") = {_boundary};
 
     // set sub-app positions
     if (isParamValid("positions"))
       params.set<std::vector<Point>>("points") = getParam<std::vector<Point>>("positions");
     else if (isParamValid("positions_file"))
       params.set<FileName>("points_file") = getParam<FileName>("positions_file");
     else
       params.set<std::vector<Point>>("points") = {Point(0, 0, 0)};
 
     // set layers
     if (isParamValid("direction") && isParamValid("num_layers"))
     {
       params.set<MooseEnum>("direction") = getParam<MooseEnum>("direction");
       params.set<unsigned int>("num_layers") = getParam<unsigned int>("num_layers");
     }
     else if (isParamValid("position") && isParamValid("orientation") && isParamValid("length") &&
              isParamValid("n_elems"))
     {
       const auto & position = getParam<Point>("position");
       const auto & orientation = getParam<RealVectorValue>("orientation");
       const auto & rotation = getParam<Real>("rotation");
       const auto & lengths = getParam<std::vector<Real>>("length");
       const auto & n_elems = getParam<std::vector<unsigned int>>("n_elems");
 
       params.set<MooseEnum>("direction") =
           DiscreteLineSegmentInterface::getAlignmentAxis(orientation);
       params.set<std::vector<Real>>("bounds") =
           DiscreteLineSegmentInterface::getElementBoundaryCoordinates(
               position, orientation, rotation, lengths, n_elems);
     }
     else
       mooseError(
           "The parameters 'position', 'orientation', 'length', and 'n_elems' must be provided.");
 
     _problem->addUserObject(class_name, _T_wall_user_object_name, params);
   }
 }

◆ validParams()

InputParameters CoupledHeatTransferAction::validParams ( )

static

Definition at line 19 of file CoupledHeatTransferAction.C.

 {
   InputParameters params = Action::validParams();
 
   params.addClassDescription(
       "Action that creates the necessary objects, for the solid side, to couple a "
       "solid heat conduction region to a 1-D flow channel via convective heat transfer");
 
   params.addRequiredParam<std::vector<BoundaryName>>("boundary",
                                                      "Boundary name(s) on the solid side");
   params.addRequiredParam<VariableName>("T", "Solid side temperature variable");
   params.addRequiredParam<VariableName>(
       "T_wall", "Variable on the flow channel side into which to transfer the solid temperature");
   params.addRequiredParam<std::vector<VariableName>>(
       "T_fluid", "Variable(s) on the solid side into which to transfer the fluid temperature(s)");
   params.addRequiredParam<std::vector<VariableName>>(
       "htc",
       "Variable(s) on the solid side into which to transfer the heat transfer coefficient(s)");
   params.addParam<std::vector<VariableName>>(
       "kappa", "Variables on the solid side into which to transfer the wall contact fractions");
   params.addParam<std::vector<UserObjectName>>(
       "T_fluid_user_objects", "Spatial user object(s) holding the fluid temperature values");
   params.addParam<std::vector<UserObjectName>>(
       "htc_user_objects", "Spatial user object(s) holding the heat transfer coefficient values");
   params.addDeprecatedParam<UserObjectName>(
       "T_fluid_user_object",
       "Spatial user object holding the fluid temperature values",
       "This parameter is deprecated in favor of 'T_fluid_user_objects' (just add an 's' to "
       "parameter name).");
   params.addDeprecatedParam<UserObjectName>(
       "htc_user_object",
       "Spatial user object holding the heat transfer coefficient values",
       "This parameter is deprecated in favor of 'htc_user_objects' (just add an 's' to parameter "
       "name).");
   params.addParam<std::vector<UserObjectName>>(
       "kappa_user_objects", "Spatial user object(s) holding the wall contact fraction values");
 
   MooseEnum directions("x y z");
   params.addDeprecatedParam<MooseEnum>(
       "direction",
       directions,
       "The direction of the layers.",
       "The usage of 'direction' and 'num_layers' is deprecated. Use 'position', 'orientation', "
       "'rotation', 'length', and 'n_elems' instead. The latter parameters correspond to the "
       "parameters of the same names in the coupled flow channel component.");
   params.addDeprecatedParam<unsigned int>(
       "num_layers",
       "The number of layers.",
       "The usage of 'direction' and 'num_layers' is deprecated. Use 'position', 'orientation', "
       "'rotation', 'length', and 'n_elems' instead. The latter parameters correspond to the "
       "parameters of the same names in the coupled flow channel component.");
 
   params.addParam<Point>("position", "Start position of axis in 3-D space [m]");
   params.addParam<RealVectorValue>(
       "orientation",
       "Direction of axis from start position to end position (no need to normalize)");
   params.addParam<Real>("rotation", 0.0, "Angle of rotation about the x-axis [degrees]");
   params.addParam<std::vector<Real>>("length", "Length of each axial section [m]");
   params.addParam<std::vector<unsigned int>>("n_elems", "Number of elements in each axial section");
 
   params.addRequiredParam<std::string>("multi_app", "The name of the multi-app.");
 
   params.addRangeCheckedParam<std::vector<Real>>(
       "fixed_bounding_box_size",
       "fixed_bounding_box_size >= 0",
       "The 'fixed_bounding_box_size' value to use for each MultiAppGeneralFieldUserObjectTransfer. "
       "If this parameter is not provided, a greedy search will be used instead of bounding boxes, "
       "which may be slower.");
 
   params.addParam<std::vector<Point>>(
       "positions", "Sub-app positions. Each set of 3 values represents a Point.");
   params.addParam<FileName>(
       "positions_file",
       "Name of file containing sub-app positions. Each set of 3 values represents a Point.");
   MultiAppTransfer::addSkipCoordCollapsingParam(params);
   return params;
 }