#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

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
void	addMeshGenerator ()

void	addRadiationObject () const

void	addViewFactorObject () const

void	addRadiationBCs () const

void	addRayStudyObject () const

void	addRayBCs () const

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

std::vector< std::vector< std::string > >	bcRadiationPatchNames () 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

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...

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

Definition at line 16 of file RadiationTransferAction.h.

Constructor & Destructor Documentation

◆ RadiationTransferAction()

RadiationTransferAction::RadiationTransferAction ( const InputParameters & params )

Definition at line 113 of file RadiationTransferAction.C.

   : Action(params),
     _boundary_names(getParam<std::vector<BoundaryName>>("boundary")),
     _view_factor_calculator(getParam<MooseEnum>("view_factor_calculator"))
 {
   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.");
   }
 }

Member Function Documentation

◆ act()

void RadiationTransferAction::act ( )

overridevirtual

Implements Action.

Definition at line 149 of file RadiationTransferAction.C.

 {
   if (_current_task == "append_mesh_generator")
     addMeshGenerator();
   else if (_current_task == "setup_mesh_complete")
     radiationPatchNames();
   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();
 }

◆ addMeshGenerator()

void RadiationTransferAction::addMeshGenerator ( )

protected

Definition at line 485 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 168 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 319 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
   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;
 
   // add adiabatic_boundary parameter if required
   if (isParamValid("adiabatic_boundary"))
   {
     std::vector<BoundaryName> adiabatic_boundary_names =
         getParam<std::vector<BoundaryName>>("adiabatic_boundary");
     std::vector<BoundaryName> adiabatic_patch_names;
     for (unsigned int k = 0; k < adiabatic_boundary_names.size(); ++k)
     {
       BoundaryName bnd_name = adiabatic_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("Adiabatic boundary ", 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])
         adiabatic_patch_names.push_back(e);
     }
     params.set<std::vector<BoundaryName>>("adiabatic_boundary") = adiabatic_patch_names;
   }
 
   // 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 257 of file RadiationTransferAction.C.

Referenced by act().

 {
   if (_view_factor_calculator == "analytical")
     return;
 
   std::vector<std::vector<std::string>> radiation_patch_names = radiationPatchNames();
   std::vector<BoundaryName> boundary_names;
   for (auto & e1 : radiation_patch_names)
     for (auto & e2 : e1)
       boundary_names.push_back(e2);
 
   {
     InputParameters params = _factory.getValidParams("ViewFactorRayBC");
     params.set<std::vector<BoundaryName>>("boundary") = boundary_names;
     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 226 of file RadiationTransferAction.C.

Referenced by act().

 {
   if (_view_factor_calculator == "analytical")
     return;
 
   std::vector<std::vector<std::string>> radiation_patch_names = radiationPatchNames();
   std::vector<BoundaryName> boundary_names;
   for (auto & e1 : radiation_patch_names)
     for (auto & e2 : e1)
       boundary_names.push_back(e2);
 
   InputParameters params = _factory.getValidParams("ViewFactorRayStudy");
 
   params.set<std::vector<BoundaryName>>("boundary") = boundary_names;
 
   // 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 191 of file RadiationTransferAction.C.

Referenced by act().

 {
   std::vector<std::vector<std::string>> radiation_patch_names = radiationPatchNames();
   std::vector<BoundaryName> boundary_names;
   for (auto & e1 : radiation_patch_names)
     for (auto & e2 : e1)
       boundary_names.push_back(e2);
 
   // 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") = boundary_names;
     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") = boundary_names;
     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);
   }
 }

◆ bcRadiationPatchNames()

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

protected

Definition at line 454 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;
 }

◆ meshGeneratorName()

MeshGeneratorName RadiationTransferAction::meshGeneratorName ( unsigned int j ) const

protected

Definition at line 542 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 532 of file RadiationTransferAction.C.

Referenced by addRadiationObject(), bcRadiationPatchNames(), 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();
 }

◆ radiationObjectName()

UserObjectName RadiationTransferAction::radiationObjectName ( ) const

protected

Definition at line 313 of file RadiationTransferAction.C.

Referenced by addRadiationBCs(), and addRadiationObject().

 {
   return "view_factor_surface_radiation_" + _name;
 }

◆ radiationPatchNames()

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

protected

Definition at line 433 of file RadiationTransferAction.C.

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

 {
   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 295 of file RadiationTransferAction.C.

Referenced by addRayBCs().

 {
   return "ray_bc_" + _name;
 }

◆ rayStudyName()

UserObjectName RadiationTransferAction::rayStudyName ( ) const

protected

Definition at line 289 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 301 of file RadiationTransferAction.C.

Referenced by addRayBCs().

 {
   return "symmetry_ray_bc_" + _name;
 }

◆ validParams()

InputParameters RadiationTransferAction::validParams ( )

static

Definition at line 26 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.");
 
   return params;
 }

◆ viewFactorObjectName()

UserObjectName RadiationTransferAction::viewFactorObjectName ( ) const

protected

Definition at line 307 of file RadiationTransferAction.C.

Referenced by addRadiationObject(), and addViewFactorObject().

 {
   return "view_factor_uo_" + _name;
 }

Member Data Documentation

◆ _boundary_names

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

protected

the boundary names participating in the radiative heat transfer

Definition at line 46 of file RadiationTransferAction.h.

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

◆ _view_factor_calculator

const MooseEnum RadiationTransferAction::_view_factor_calculator

protected

the type of view factor calculation being performed

Definition at line 49 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()

◆ addMeshGenerator()

◆ addRadiationBCs()

◆ addRadiationObject()

◆ addRayBCs()

◆ addRayStudyObject()

◆ addViewFactorObject()

◆ bcRadiationPatchNames()

◆ meshGeneratorName()

◆ nPatch()

◆ radiationObjectName()

◆ radiationPatchNames()

◆ rayBCName()

◆ rayStudyName()

◆ symmetryRayBCName()

◆ validParams()

◆ viewFactorObjectName()

Member Data Documentation

◆ _boundary_names

◆ _view_factor_calculator