#include <RadiationTransferAction.h>

Inheritance diagram for RadiationTransferAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	RadiationTransferAction (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

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () 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 &name) const

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

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

void	paramWarning (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

std::string	messagePrefix (const bool hit_prefix=true) const

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

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

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

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

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

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

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

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

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

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

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) 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 ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
void	checkBoundaryParameterIsSubset (const std::string &param) const
	Checks that `param` boundaries are in the 'boundary' parameter. More...

void	addMeshGenerator ()

void	addRadiationObject () const

void	addViewFactorObject () const

void	addRadiationBCs () const

void	addRayStudyObject () const

void	addRayBCs () const

void	addHeatFluxAuxVariable () const

void	addHeatFluxAuxKernel () const

std::vector< std::vector< std::string > >	radiationPatchNames () const

std::vector< std::vector< std::string > >	bcRadiationPatchNames () const

std::vector< BoundaryName >	patchBoundaryNames (const std::vector< BoundaryName > &boundary_names) const

std::vector< BoundaryName >	radiationPatchBoundaryNames () const

std::vector< BoundaryName >	adiabaticPatchBoundaryNames () const

UserObjectName	viewFactorObjectName () const

UserObjectName	radiationObjectName () const

UserObjectName	rayStudyName () const

std::string	rayBCName () const

std::string	symmetryRayBCName () const

MeshGeneratorName	meshGeneratorName (unsigned int j) const

unsigned int	nPatch (unsigned int j) const
	provides the updated number of patches for this boundary More...

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

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

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

Protected Attributes
const std::vector< BoundaryName >	_boundary_names
	the boundary names participating in the radiative heat transfer More...

const MooseEnum	_view_factor_calculator
	the type of view factor calculation being performed More...

const bool	_add_heat_flux_aux
	Whether to add heat flux aux. More...

VariableName	_heat_flux_variable
	Heat flux aux name. More...

std::vector< SubdomainName >	_heat_flux_aux_block
	Blocks to use for heat flux aux. 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

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Detailed Description

Definition at line 16 of file RadiationTransferAction.h.

Constructor & Destructor Documentation

◆ RadiationTransferAction()

RadiationTransferAction::RadiationTransferAction ( const InputParameters & params )

Definition at line 121 of file RadiationTransferAction.C.

   : Action(params),
     _boundary_names(getParam<std::vector<BoundaryName>>("boundary")),
     _view_factor_calculator(getParam<MooseEnum>("view_factor_calculator")),
     _add_heat_flux_aux(getParam<bool>("add_heat_flux_aux"))
 {
   const auto & symmetry_names = getParam<std::vector<BoundaryName>>("symmetry_boundary");
 
   if (_view_factor_calculator != "ray_tracing")
   {
     for (const auto & param_name : {"polar_quad_order",
                                     "azimuthal_quad_order",
                                     "ray_tracing_face_type",
                                     "ray_tracing_face_order"})
       if (params.isParamSetByUser(param_name))
         paramWarning(param_name,
                      "Only used for view_factor_calculator = ray_tracing. It is ignored for this "
                      "calculation.");
 
     if (symmetry_names.size())
       paramError("symmetry_boundary",
                  "Symmetry boundaries are only supported with view_factor_calculator = "
                  "ray_tracing.");
   }
   else
   {
     // check that there is no overlap between sidesets and symmetry sidesets
     for (const auto & name : _boundary_names)
       if (std::find(symmetry_names.begin(), symmetry_names.end(), name) != symmetry_names.end())
         paramError("boundary",
                    "Boundary ",
                    name,
                    " is present in parameter boundary and symmetry_boundary.");
   }
 
   if (_add_heat_flux_aux)
   {
     if (isParamValid("heat_flux_variable"))
       _heat_flux_variable = getParam<VariableName>("heat_flux_variable");
     else
       paramError("heat_flux_variable",
                  "If 'add_heat_flux_aux' is true, then this parameter must be provided.");
 
     if (isParamValid("heat_flux_aux_block"))
       _heat_flux_aux_block = getParam<std::vector<SubdomainName>>("heat_flux_aux_block");
     else
       paramError("heat_flux_aux_block",
                  "If 'add_heat_flux_aux' is true, then this parameter must be provided.");
   }
 
   checkBoundaryParameterIsSubset("adiabatic_boundary");
   checkBoundaryParameterIsSubset("fixed_temperature_boundary");
 }

Member Function Documentation

◆ act()

void RadiationTransferAction::act ( )

overridevirtual

Implements Action.

Definition at line 185 of file RadiationTransferAction.C.

 {
   if (_current_task == "append_mesh_generator")
     addMeshGenerator();
   else if (_current_task == "add_user_object")
   {
     addRadiationObject();
     addRayStudyObject();
     addViewFactorObject();
   }
   else if (_current_task == "add_bc")
     addRadiationBCs();
   else if (_current_task == "add_ray_boundary_condition")
     addRayBCs();
   else if (_current_task == "add_aux_variable" && _add_heat_flux_aux)
     addHeatFluxAuxVariable();
   else if (_current_task == "add_aux_kernel" && _add_heat_flux_aux)
     addHeatFluxAuxKernel();
 }

◆ addHeatFluxAuxKernel()

void RadiationTransferAction::addHeatFluxAuxKernel ( ) const

protected

Definition at line 593 of file RadiationTransferAction.C.

Referenced by act().

 {
   const std::string class_name = "GrayLambertRadiationHeatFluxAux";
   InputParameters params = _factory.getValidParams(class_name);
   params.set<AuxVariableName>("variable") = _heat_flux_variable;
   params.set<std::vector<BoundaryName>>("boundary") = radiationPatchBoundaryNames();
   params.set<UserObjectName>("surface_radiation_object") = radiationObjectName();
   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
   _problem->addAuxKernel(class_name, "radiation_heat_flux_aux_kernel", params);
 }

◆ addHeatFluxAuxVariable()

void RadiationTransferAction::addHeatFluxAuxVariable ( ) const

protected

Definition at line 582 of file RadiationTransferAction.C.

Referenced by act().

 {
   const std::string var_type = "MooseVariable";
   auto params = _factory.getValidParams(var_type);
   params.set<std::vector<SubdomainName>>("block") = _heat_flux_aux_block;
   params.set<MooseEnum>("order") = "CONSTANT";
   params.set<MooseEnum>("family") = "MONOMIAL";
   _problem->addAuxVariable(var_type, _heat_flux_variable, params);
 }

◆ addMeshGenerator()

void RadiationTransferAction::addMeshGenerator ( )

protected

Definition at line 517 of file RadiationTransferAction.C.

Referenced by act().

 {
   std::vector<unsigned int> n_patches = getParam<std::vector<unsigned int>>("n_patches");
   MultiMooseEnum partitioners = getParam<MultiMooseEnum>("partitioners");
   if (!_pars.isParamSetByUser("partitioners"))
   {
     partitioners.clearSetValues();
     for (unsigned int j = 0; j < _boundary_names.size(); ++j)
       partitioners.setAdditionalValue("metis");
   }
 
   MultiMooseEnum direction = getParam<MultiMooseEnum>("centroid_partitioner_directions");
 
   // check input parameters
   if (_boundary_names.size() != n_patches.size())
     mooseError("n_patches parameter must have same length as boundary parameter.");
 
   if (_boundary_names.size() != partitioners.size())
     mooseError("partitioners parameter must have same length as boundary parameter.");
 
   for (unsigned int j = 0; j < partitioners.size(); ++j)
     if (partitioners[j] == "centroid" && direction.size() != _boundary_names.size())
       mooseError(
           "centroid partitioner is selected for at least one sideset. "
           "centroid_partitioner_directions parameter must have same length as boundary parameter.");
 
   // check if mesh is a MeshGeneratorMesh
   std::shared_ptr<MeshGeneratorMesh> mg_mesh = std::dynamic_pointer_cast<MeshGeneratorMesh>(_mesh);
   if (!mg_mesh)
     mooseError("This action adds MeshGenerator objects and therefore only works with a "
                "MeshGeneratorMesh.");
 
   for (unsigned int j = 0; j < _boundary_names.size(); ++j)
   {
     InputParameters params = _factory.getValidParams("PatchSidesetGenerator");
     params.set<BoundaryName>("boundary") = _boundary_names[j];
     params.set<unsigned int>("n_patches") = n_patches[j];
     params.set<MooseEnum>("partitioner") = partitioners[j];
 
     if (partitioners[j] == "centroid")
       params.set<MooseEnum>("centroid_partitioner_direction") = direction[j];
 
     _app.appendMeshGenerator("PatchSidesetGenerator", meshGeneratorName(j), params);
   }
 }

◆ addRadiationBCs()

void RadiationTransferAction::addRadiationBCs ( ) const

protected

Definition at line 206 of file RadiationTransferAction.C.

Referenced by act().

 {
   InputParameters params = _factory.getValidParams("GrayLambertNeumannBC");
 
   // set boundary
   std::vector<std::vector<std::string>> radiation_patch_names = bcRadiationPatchNames();
   std::vector<BoundaryName> boundary_names;
   for (auto & e1 : radiation_patch_names)
     for (auto & e2 : e1)
       boundary_names.push_back(e2);
 
   params.set<std::vector<BoundaryName>>("boundary") = boundary_names;
 
   // set temperature variable
   params.set<NonlinearVariableName>("variable") = getParam<VariableName>("temperature");
 
   // set radiationuserobject
   params.set<UserObjectName>("surface_radiation_object_name") = radiationObjectName();
 
   _problem->addBoundaryCondition("GrayLambertNeumannBC", "gray_lamber_neumann_bc_" + _name, params);
 }

◆ addRadiationObject()

void RadiationTransferAction::addRadiationObject ( ) const

protected

Definition at line 339 of file RadiationTransferAction.C.

Referenced by act().

 {
   std::vector<std::vector<std::string>> radiation_patch_names = radiationPatchNames();
 
   // input parameter check
   std::vector<FunctionName> emissivity = getParam<std::vector<FunctionName>>("emissivity");
   if (emissivity.size() != _boundary_names.size())
     mooseError("emissivity parameter needs to be the same size as the boundary parameter.");
 
   // the action only sets up ViewFactorObjectSurfaceRadiation, because after splitting
   // faces auotmatically, it makes no sense to require view factor input by hand.
   InputParameters params = _factory.getValidParams("ViewFactorObjectSurfaceRadiation");
   params.set<std::vector<VariableName>>("temperature") = {getParam<VariableName>("temperature")};
 
   std::vector<FunctionName> extended_emissivity;
   for (unsigned int j = 0; j < _boundary_names.size(); ++j)
     for (unsigned int i = 0; i < nPatch(j); ++i)
       extended_emissivity.push_back(emissivity[j]);
   params.set<std::vector<FunctionName>>("emissivity") = extended_emissivity;
 
   // add boundary parameter
   params.set<std::vector<BoundaryName>>("boundary") = radiationPatchBoundaryNames();
 
   // add adiabatic_boundary parameter if required
   if (isParamValid("adiabatic_boundary"))
     params.set<std::vector<BoundaryName>>("adiabatic_boundary") = adiabaticPatchBoundaryNames();
 
   // add isothermal sidesets if required
   if (isParamValid("fixed_temperature_boundary"))
   {
     if (!isParamValid("fixed_boundary_temperatures"))
       mooseError("fixed_temperature_boundary is provided so fixed_boundary_temperatures must be "
                  "provided too");
 
     std::vector<BoundaryName> fixed_T_boundary_names =
         getParam<std::vector<BoundaryName>>("fixed_temperature_boundary");
 
     std::vector<FunctionName> fixed_T_funcs =
         getParam<std::vector<FunctionName>>("fixed_boundary_temperatures");
 
     // check length of fixed_boundary_temperatures
     if (fixed_T_funcs.size() != fixed_T_boundary_names.size())
       mooseError("Size of parameter fixed_boundary_temperatures and fixed_temperature_boundary "
                  "must be equal.");
 
     std::vector<BoundaryName> fixed_T_patch_names;
     std::vector<FunctionName> fixed_T_function_names;
     for (unsigned int k = 0; k < fixed_T_boundary_names.size(); ++k)
     {
       BoundaryName bnd_name = fixed_T_boundary_names[k];
 
       // find the right entry in _boundary_names
       auto it = std::find(_boundary_names.begin(), _boundary_names.end(), bnd_name);
 
       // check if entry was found: it must be found or an error would occur later
       if (it == _boundary_names.end())
         mooseError("Fixed temperature sideset ", bnd_name, " not present in boundary.");
 
       // this is the position in the _boundary_names vector; this is what
       // we are really after
       auto index = std::distance(_boundary_names.begin(), it);
 
       // collect the correct boundary names
       for (auto & e : radiation_patch_names[index])
       {
         fixed_T_patch_names.push_back(e);
         fixed_T_function_names.push_back(fixed_T_funcs[k]);
       }
     }
     params.set<std::vector<BoundaryName>>("fixed_temperature_boundary") = fixed_T_patch_names;
     params.set<std::vector<FunctionName>>("fixed_boundary_temperatures") = fixed_T_function_names;
   }
 
   // the view factor userobject name
   params.set<UserObjectName>("view_factor_object_name") = viewFactorObjectName();
 
   // this userobject needs to be executed on linear and timestep end
   ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
   exec_enum = {EXEC_LINEAR, EXEC_TIMESTEP_END};
   params.set<ExecFlagEnum>("execute_on") = exec_enum;
 
   // add the object
   _problem->addUserObject("ViewFactorObjectSurfaceRadiation", radiationObjectName(), params);
 }

◆ addRayBCs()

void RadiationTransferAction::addRayBCs ( ) const

protected

Definition at line 283 of file RadiationTransferAction.C.

Referenced by act().

 {
   if (_view_factor_calculator == "analytical")
     return;
 
   {
     InputParameters params = _factory.getValidParams("ViewFactorRayBC");
     params.set<std::vector<BoundaryName>>("boundary") = radiationPatchBoundaryNames();
     params.set<RayTracingStudy *>("_ray_tracing_study") =
         &_problem->getUserObject<ViewFactorRayStudy>(rayStudyName());
     _problem->addObject<RayBoundaryConditionBase>("ViewFactorRayBC", rayBCName(), params);
   }
 
   // add symmetry BCs if applicable
   const auto & symmetry_names = getParam<std::vector<BoundaryName>>("symmetry_boundary");
   if (symmetry_names.size() > 0)
   {
     InputParameters params = _factory.getValidParams("ReflectRayBC");
     params.set<std::vector<BoundaryName>>("boundary") = symmetry_names;
     params.set<RayTracingStudy *>("_ray_tracing_study") =
         &_problem->getUserObject<ViewFactorRayStudy>(rayStudyName());
     _problem->addObject<RayBoundaryConditionBase>("ReflectRayBC", symmetryRayBCName(), params);
   }
 }

◆ addRayStudyObject()

void RadiationTransferAction::addRayStudyObject ( ) const

protected

Definition at line 258 of file RadiationTransferAction.C.

Referenced by act().

 {
   if (_view_factor_calculator == "analytical")
     return;
 
   InputParameters params = _factory.getValidParams("ViewFactorRayStudy");
 
   params.set<std::vector<BoundaryName>>("boundary") = radiationPatchBoundaryNames();
 
   // set this object to be execute on initial only
   ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
   exec_enum = {EXEC_INITIAL};
   params.set<ExecFlagEnum>("execute_on") = exec_enum;
 
   // set face order
   params.set<MooseEnum>("face_order") = getParam<MooseEnum>("ray_tracing_face_order");
   params.set<MooseEnum>("face_type") = getParam<MooseEnum>("ray_tracing_face_type");
 
   // set angular quadrature
   params.set<unsigned int>("polar_quad_order") = getParam<unsigned int>("polar_quad_order");
   params.set<unsigned int>("azimuthal_quad_order") = getParam<unsigned int>("azimuthal_quad_order");
   _problem->addUserObject("ViewFactorRayStudy", rayStudyName(), params);
 }

◆ addViewFactorObject()

void RadiationTransferAction::addViewFactorObject ( ) const

protected

Definition at line 229 of file RadiationTransferAction.C.

Referenced by act().

 {
   // this userobject is only executed on initial
   ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
   exec_enum = {EXEC_INITIAL};
 
   if (_view_factor_calculator == "analytical")
   {
     // this branch adds the UnobstructedPlanarViewFactor
     InputParameters params = _factory.getValidParams("UnobstructedPlanarViewFactor");
     params.set<std::vector<BoundaryName>>("boundary") = radiationPatchBoundaryNames();
     params.set<ExecFlagEnum>("execute_on") = exec_enum;
 
     _problem->addUserObject("UnobstructedPlanarViewFactor", viewFactorObjectName(), params);
   }
   else if (_view_factor_calculator == "ray_tracing")
   {
     // this branch adds the ray tracing UO
     InputParameters params = _factory.getValidParams("RayTracingViewFactor");
     params.set<std::vector<BoundaryName>>("boundary") = radiationPatchBoundaryNames();
     params.set<ExecFlagEnum>("execute_on") = exec_enum;
     params.set<UserObjectName>("ray_study_name") = rayStudyName();
     params.set<bool>("print_view_factor_info") = getParam<bool>("print_view_factor_info");
     params.set<bool>("normalize_view_factor") = getParam<bool>("normalize_view_factor");
     _problem->addUserObject("RayTracingViewFactor", viewFactorObjectName(), params);
   }
 }

◆ adiabaticPatchBoundaryNames()

std::vector< BoundaryName > RadiationTransferAction::adiabaticPatchBoundaryNames ( ) const

protected

Definition at line 507 of file RadiationTransferAction.C.

Referenced by addRadiationObject().

 {
   std::vector<BoundaryName> patch_boundary_names;
   if (isParamValid("adiabatic_boundary"))
     patch_boundary_names =
         patchBoundaryNames(getParam<std::vector<BoundaryName>>("adiabatic_boundary"));
   return patch_boundary_names;
 }

◆ bcRadiationPatchNames()

std::vector< std::vector< std::string > > RadiationTransferAction::bcRadiationPatchNames ( ) const

protected

Definition at line 446 of file RadiationTransferAction.C.

Referenced by addRadiationBCs().

 {
   auto ad_bnd_names = getParam<std::vector<BoundaryName>>("adiabatic_boundary");
   auto ft_bnd_names = getParam<std::vector<BoundaryName>>("fixed_temperature_boundary");
   std::vector<std::vector<std::string>> radiation_patch_names;
   std::vector<BoundaryID> boundary_ids = _mesh->getBoundaryIDs(_boundary_names);
   for (unsigned int j = 0; j < boundary_ids.size(); ++j)
   {
     boundary_id_type bid = boundary_ids[j];
     BoundaryName bnd_name = _boundary_names[j];
 
     // check if this sideset is adiabatic or isothermal
     auto it_a = std::find(ad_bnd_names.begin(), ad_bnd_names.end(), bnd_name);
     auto it_t = std::find(ft_bnd_names.begin(), ft_bnd_names.end(), bnd_name);
     if (it_a != ad_bnd_names.end() || it_t != ft_bnd_names.end())
       continue;
 
     std::string base_name = _mesh->getBoundaryName(bid);
     std::vector<std::string> bnames;
     for (unsigned int i = 0; i < nPatch(j); ++i)
     {
       std::stringstream ss;
       ss << base_name << "_" << i;
       bnames.push_back(ss.str());
     }
     radiation_patch_names.push_back(bnames);
   }
   return radiation_patch_names;
 }

◆ checkBoundaryParameterIsSubset()

void RadiationTransferAction::checkBoundaryParameterIsSubset ( const std::string & param ) const

protected

Checks that param boundaries are in the 'boundary' parameter.

Definition at line 176 of file RadiationTransferAction.C.

Referenced by RadiationTransferAction().

 {
   const auto boundary_names = getParam<std::vector<BoundaryName>>(param);
   for (const auto & bname : boundary_names)
     if (std::find(_boundary_names.begin(), _boundary_names.end(), bname) == _boundary_names.end())
       paramError(param, "The boundaries in '" + param + "' must be a subset of 'boundary'.");
 }

◆ meshGeneratorName()

MeshGeneratorName RadiationTransferAction::meshGeneratorName ( unsigned int j ) const

protected

Definition at line 574 of file RadiationTransferAction.C.

Referenced by addMeshGenerator(), and nPatch().

 {
   std::stringstream ss;
   ss << "patch_side_set_generator_" << _boundary_names[j];
   return ss.str();
 }

◆ nPatch()

unsigned int RadiationTransferAction::nPatch ( unsigned int j ) const

protected

provides the updated number of patches for this boundary

Definition at line 564 of file RadiationTransferAction.C.

Referenced by addRadiationObject(), bcRadiationPatchNames(), patchBoundaryNames(), and radiationPatchNames().

 {
   const MeshGenerator * mg = &_app.getMeshGenerator(meshGeneratorName(j));
   const PatchSidesetGenerator * psg = dynamic_cast<const PatchSidesetGenerator *>(mg);
   if (!psg)
     mooseError("Failed to convert mesh generator ", mg->name(), " to PatchSidesetGenerator.");
   return psg->nPatches();
 }

◆ patchBoundaryNames()

std::vector< BoundaryName > RadiationTransferAction::patchBoundaryNames ( const std::vector< BoundaryName > & boundary_names ) const

protected

Definition at line 477 of file RadiationTransferAction.C.

Referenced by adiabaticPatchBoundaryNames(), and radiationPatchBoundaryNames().

 {
   std::vector<BoundaryName> patch_boundary_names;
   std::vector<BoundaryID> ids = _mesh->getBoundaryIDs(boundary_names_or_ids);
   for (const auto i : index_range(boundary_names_or_ids))
   {
     const auto boundary_name_or_id = boundary_names_or_ids[i];
     const auto it = std::find(_boundary_names.begin(), _boundary_names.end(), boundary_name_or_id);
     mooseAssert(it != _boundary_names.end(), boundary_name_or_id + " not found in 'boundary'.");
     const auto boundary_index = std::distance(_boundary_names.begin(), it);
     const auto n_patches = nPatch(boundary_index);
     const auto boundary_name = _mesh->getBoundaryName(ids[i]);
     for (const auto j : make_range(n_patches))
     {
       std::stringstream ss;
       ss << boundary_name << "_" << j;
       patch_boundary_names.push_back(ss.str());
     }
   }
   return patch_boundary_names;
 }

◆ radiationObjectName()

UserObjectName RadiationTransferAction::radiationObjectName ( ) const

protected

Definition at line 333 of file RadiationTransferAction.C.

Referenced by addHeatFluxAuxKernel(), addRadiationBCs(), and addRadiationObject().

 {
   return "view_factor_surface_radiation_" + _name;
 }

◆ radiationPatchBoundaryNames()

std::vector< BoundaryName > RadiationTransferAction::radiationPatchBoundaryNames ( ) const

protected

Definition at line 501 of file RadiationTransferAction.C.

Referenced by addHeatFluxAuxKernel(), addRadiationObject(), addRayBCs(), addRayStudyObject(), and addViewFactorObject().

 {
   return patchBoundaryNames(_boundary_names);
 }

◆ radiationPatchNames()

std::vector< std::vector< std::string > > RadiationTransferAction::radiationPatchNames ( ) const

protected

Definition at line 425 of file RadiationTransferAction.C.

Referenced by addRadiationObject().

 {
   std::vector<std::vector<std::string>> radiation_patch_names(_boundary_names.size());
   std::vector<BoundaryID> boundary_ids = _mesh->getBoundaryIDs(_boundary_names);
   for (unsigned int j = 0; j < boundary_ids.size(); ++j)
   {
     boundary_id_type bid = boundary_ids[j];
     std::string base_name = _mesh->getBoundaryName(bid);
     std::vector<std::string> bnames;
     for (unsigned int i = 0; i < nPatch(j); ++i)
     {
       std::stringstream ss;
       ss << base_name << "_" << i;
       bnames.push_back(ss.str());
     }
     radiation_patch_names[j] = bnames;
   }
   return radiation_patch_names;
 }

◆ rayBCName()

std::string RadiationTransferAction::rayBCName ( ) const

protected

Definition at line 315 of file RadiationTransferAction.C.

Referenced by addRayBCs().

 {
   return "ray_bc_" + _name;
 }

◆ rayStudyName()

UserObjectName RadiationTransferAction::rayStudyName ( ) const

protected

Definition at line 309 of file RadiationTransferAction.C.

Referenced by addRayBCs(), addRayStudyObject(), and addViewFactorObject().

 {
   return "ray_study_uo_" + _name;
 }

◆ symmetryRayBCName()

std::string RadiationTransferAction::symmetryRayBCName ( ) const

protected

Definition at line 321 of file RadiationTransferAction.C.

Referenced by addRayBCs().

 {
   return "symmetry_ray_bc_" + _name;
 }

◆ validParams()

InputParameters RadiationTransferAction::validParams ( )

static

Definition at line 27 of file RadiationTransferAction.C.

 {
   InputParameters params = Action::validParams();
   params.addClassDescription(
       "This action sets up the net radiation calculation between specified sidesets.");
 
   params.addRequiredParam<std::vector<BoundaryName>>(
       "boundary", "The boundaries that participate in the radiative exchange.");
 
   params.addParam<std::vector<BoundaryName>>(
       "adiabatic_boundary",
       {},
       "The adiabatic boundaries that participate in the radiative exchange.");
 
   params.addParam<std::vector<BoundaryName>>(
       "fixed_temperature_boundary",
       {},
       "The fixed temperature boundaries that participate in the radiative exchange.");
 
   params.addParam<std::vector<FunctionName>>(
       "fixed_boundary_temperatures", {}, "The temperatures of the fixed boundary.");
 
   params.addRequiredParam<std::vector<unsigned int>>("n_patches",
                                                      "Number of radiation patches per sideset.");
   MultiMooseEnum partitioning(
       "default=-3 metis=-2 parmetis=-1 linear=0 centroid hilbert_sfc morton_sfc", "default");
   partitioning.addValidName("grid");
   params.addParam<MultiMooseEnum>(
       "partitioners",
       partitioning,
       "Specifies a mesh partitioner to use when preparing the radiation patches.");
 
   MultiMooseEnum direction("x y z radial");
   params.addParam<MultiMooseEnum>("centroid_partitioner_directions",
                                   direction,
                                   "Specifies the sort direction if using the centroid partitioner. "
                                   "Available options: x, y, z, radial");
 
   params.addRequiredParam<VariableName>("temperature", "The coupled temperature variable.");
   params.addRequiredParam<std::vector<FunctionName>>("emissivity",
                                                      "Emissivities for each boundary.");
 
   MooseEnum view_factor_calculator("analytical ray_tracing", "ray_tracing");
   params.addParam<MooseEnum>(
       "view_factor_calculator", view_factor_calculator, "The view factor calculator being used.");
 
   params.addParam<bool>(
       "print_view_factor_info", false, "Flag to print information about computed view factors.");
   params.addParam<bool>("normalize_view_factor",
                         true,
                         "Determines if view factors are normalized to sum to one (consistent with "
                         "their definition).");
 
   std::vector<BoundaryName> empty = {};
   params.addParam<std::vector<BoundaryName>>(
       "symmetry_boundary",
       empty,
       "The sidesets that represent symmetry lines/planes for the problem. These sidesets do not "
       "participate in the radiative exchange"
       "so they should not be listed in the sidesets parameter.");
 
   MooseEnum qtypes("GAUSS GRID", "GRID");
   params.addParam<MooseEnum>(
       "ray_tracing_face_type", qtypes, "The face quadrature rule type used for ray tracing.");
 
   MooseEnum qorders("CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH TENTH "
                     "ELEVENTH TWELFTH THIRTEENTH FOURTEENTH FIFTEENTH SIXTEENTH SEVENTEENTH "
                     "EIGHTTEENTH NINTEENTH TWENTIETH",
                     "CONSTANT");
   params.addParam<MooseEnum>(
       "ray_tracing_face_order", qorders, "The face quadrature rule order used for ray tracing.");
 
   params.addParam<unsigned int>(
       "polar_quad_order",
       16,
       "Order of the polar quadrature [polar angle is between ray and normal]. Must be even. Only "
       "used if view_factor_calculator = ray_tracing.");
   params.addParam<unsigned int>(
       "azimuthal_quad_order",
       8,
       "Order of the azimuthal quadrature per quadrant [azimuthal angle is measured in "
       "a plane perpendicular to the normal]. Only used if view_factor_calculator = "
       "ray_tracing.");
 
   params.addParam<bool>("add_heat_flux_aux", false, "If true, add a heat flux aux variable");
   params.addParam<VariableName>(
       "heat_flux_variable",
       "Heat flux aux variable name; this must be provided if 'add_heat_flux_aux' is true");
   params.addParam<std::vector<SubdomainName>>(
       "heat_flux_aux_block", "Subdomains to use for heat flux aux if 'add_heat_flux_aux' is true");
 
   return params;
 }

◆ viewFactorObjectName()

UserObjectName RadiationTransferAction::viewFactorObjectName ( ) const

protected

Definition at line 327 of file RadiationTransferAction.C.

Referenced by addRadiationObject(), and addViewFactorObject().

 {
   return "view_factor_uo_" + _name;
 }

Member Data Documentation

◆ _add_heat_flux_aux

const bool RadiationTransferAction::_add_heat_flux_aux

protected

Whether to add heat flux aux.

Definition at line 60 of file RadiationTransferAction.h.

Referenced by act(), and RadiationTransferAction().

◆ _boundary_names

const std::vector<BoundaryName> RadiationTransferAction::_boundary_names

protected

the boundary names participating in the radiative heat transfer

Definition at line 54 of file RadiationTransferAction.h.

Referenced by addMeshGenerator(), addRadiationObject(), bcRadiationPatchNames(), checkBoundaryParameterIsSubset(), meshGeneratorName(), patchBoundaryNames(), radiationPatchBoundaryNames(), radiationPatchNames(), and RadiationTransferAction().

◆ _heat_flux_aux_block

std::vector<SubdomainName> RadiationTransferAction::_heat_flux_aux_block

protected

Blocks to use for heat flux aux.

Definition at line 64 of file RadiationTransferAction.h.

Referenced by addHeatFluxAuxVariable(), and RadiationTransferAction().

◆ _heat_flux_variable

VariableName RadiationTransferAction::_heat_flux_variable

protected

Heat flux aux name.

Definition at line 62 of file RadiationTransferAction.h.

Referenced by addHeatFluxAuxKernel(), addHeatFluxAuxVariable(), and RadiationTransferAction().

◆ _view_factor_calculator

const MooseEnum RadiationTransferAction::_view_factor_calculator

protected

the type of view factor calculation being performed

Definition at line 57 of file RadiationTransferAction.h.

Referenced by addRayBCs(), addRayStudyObject(), addViewFactorObject(), and RadiationTransferAction().

The documentation for this class was generated from the following files:

heat_transfer/include/actions/RadiationTransferAction.h
heat_transfer/src/actions/RadiationTransferAction.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RadiationTransferAction()

Member Function Documentation

◆ act()

◆ addHeatFluxAuxKernel()

◆ addHeatFluxAuxVariable()

◆ addMeshGenerator()

◆ addRadiationBCs()

◆ addRadiationObject()

◆ addRayBCs()

◆ addRayStudyObject()

◆ addViewFactorObject()

◆ adiabaticPatchBoundaryNames()

◆ bcRadiationPatchNames()

◆ checkBoundaryParameterIsSubset()

◆ meshGeneratorName()

◆ nPatch()

◆ patchBoundaryNames()

◆ radiationObjectName()

◆ radiationPatchBoundaryNames()

◆ radiationPatchNames()

◆ rayBCName()

◆ rayStudyName()

◆ symmetryRayBCName()

◆ validParams()

◆ viewFactorObjectName()

Member Data Documentation

◆ _add_heat_flux_aux

◆ _boundary_names

◆ _heat_flux_aux_block

◆ _heat_flux_variable

◆ _view_factor_calculator