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

void	addMeshGenerator ()

void	addRadiationObject () const

void	addViewFactorObject () const

void	addRadiationBCs () const

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

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

const MooseEnum	_view_factor_calculator
	the type of view factor calculation being performed

const bool	_add_heat_flux_aux
	Whether to add heat flux aux.

VariableName	_heat_flux_variable
	Heat flux aux name.

std::vector< SubdomainName >	_heat_flux_aux_block
	Blocks to use for heat flux aux.

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

Private Member Functions
bool	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)

virtual std::string	meshPropertyPrefix (const std::string &data_name) const

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

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

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

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.");
  }
 
  const auto & fixed_temperature_boundaries =
      getParam<std::vector<BoundaryName>>("fixed_temperature_boundary");
  const auto & fixed_boundary_temperatures =
      getParam<std::vector<FunctionName>>("fixed_boundary_temperatures");
 
  if (fixed_temperature_boundaries.size() != fixed_boundary_temperatures.size())
    paramError("fixed_boundary_temperatures",
               "The number of entries must match the number of entries in "
               "'fixed_temperature_boundary'.");
 
  checkBoundaryParameterIsSubset("adiabatic_boundary");
  checkBoundaryParameterIsSubset("fixed_temperature_boundary");
}

Member Function Documentation

◆ act()

void RadiationTransferAction::act ( )

overridevirtual

Implements Action.

Definition at line 195 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();
    addFixedTemperatureBCs();
  }
  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();
}

◆ addFixedTemperatureBCs()

void RadiationTransferAction::addFixedTemperatureBCs ( ) const

protected

Definition at line 242 of file RadiationTransferAction.C.

{
  const auto & fixed_temperature_boundaries =
      getParam<std::vector<BoundaryName>>("fixed_temperature_boundary");
  const auto & fixed_boundary_temperatures =
      getParam<std::vector<FunctionName>>("fixed_boundary_temperatures");
  const auto & temperature = getParam<VariableName>("temperature");
 
  for (unsigned int i = 0; i < fixed_temperature_boundaries.size(); ++i)
  {
    InputParameters params = _factory.getValidParams("FunctionDirichletBC");
    params.set<FunctionName>("function") = fixed_boundary_temperatures[i];
    params.set<NonlinearVariableName>("variable") = temperature;
    params.set<std::vector<BoundaryName>>("boundary") = {fixed_temperature_boundaries[i]};
 
    _problem->addBoundaryCondition("FunctionDirichletBC",
                                   "fixed_temperature_bc_" + _name + "_" +
                                       fixed_temperature_boundaries[i],
                                   params);
  }
}

Referenced by act().

◆ addHeatFluxAuxKernel()

void RadiationTransferAction::addHeatFluxAuxKernel ( ) const

protected

Definition at line 619 of file RadiationTransferAction.C.

{
  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);
}

Referenced by act().

◆ addHeatFluxAuxVariable()

void RadiationTransferAction::addHeatFluxAuxVariable ( ) const

protected

Definition at line 608 of file RadiationTransferAction.C.

{
  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);
}

Referenced by act().

◆ addMeshGenerator()

void RadiationTransferAction::addMeshGenerator ( )

protected

Definition at line 543 of file RadiationTransferAction.C.

{
  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);
  }
}

Referenced by act().

◆ addRadiationBCs()

void RadiationTransferAction::addRadiationBCs ( ) const

protected

Definition at line 219 of file RadiationTransferAction.C.

{
  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);
}

Referenced by act().

◆ addRadiationObject()

void RadiationTransferAction::addRadiationObject ( ) const

protected

Definition at line 375 of file RadiationTransferAction.C.

{
  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();
 
  const auto & fixed_T_boundary_names =
      getParam<std::vector<BoundaryName>>("fixed_temperature_boundary");
 
  // add isothermal sidesets if required
  if (!fixed_T_boundary_names.empty())
  {
    const auto & fixed_T_funcs = getParam<std::vector<FunctionName>>("fixed_boundary_temperatures");
 
    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);
}

Referenced by act().

◆ addRayBCs()

void RadiationTransferAction::addRayBCs ( ) const

protected

Definition at line 319 of file RadiationTransferAction.C.

{
  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);
  }
}

Referenced by act().

◆ addRayStudyObject()

void RadiationTransferAction::addRayStudyObject ( ) const

protected

Definition at line 294 of file RadiationTransferAction.C.

{
  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);
}

Referenced by act().

◆ addViewFactorObject()

void RadiationTransferAction::addViewFactorObject ( ) const

protected

Definition at line 265 of file RadiationTransferAction.C.

{
  // 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);
  }
}

Referenced by act().

◆ adiabaticPatchBoundaryNames()

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

protected

Definition at line 533 of file RadiationTransferAction.C.

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

Referenced by addRadiationObject().

◆ bcRadiationPatchNames()

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

protected

Definition at line 472 of file RadiationTransferAction.C.

{
  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;
}

Referenced by addRadiationBCs().

◆ checkBoundaryParameterIsSubset()

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

protected

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

Definition at line 186 of file RadiationTransferAction.C.

{
  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'.");
}

Referenced by RadiationTransferAction().

◆ meshGeneratorName()

MeshGeneratorName RadiationTransferAction::meshGeneratorName ( unsigned int j ) const

protected

Definition at line 600 of file RadiationTransferAction.C.

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

Referenced by addMeshGenerator(), and nPatch().

◆ nPatch()

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

protected

provides the updated number of patches for this boundary

Definition at line 590 of file RadiationTransferAction.C.

{
  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();
}

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

◆ patchBoundaryNames()

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

protected

Definition at line 503 of file RadiationTransferAction.C.

{
  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;
}

Referenced by adiabaticPatchBoundaryNames(), and radiationPatchBoundaryNames().

◆ radiationObjectName()

UserObjectName RadiationTransferAction::radiationObjectName ( ) const

protected

Definition at line 369 of file RadiationTransferAction.C.

{
  return "view_factor_surface_radiation_" + _name;
}

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

◆ radiationPatchBoundaryNames()

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

protected

Definition at line 527 of file RadiationTransferAction.C.

{
  return patchBoundaryNames(_boundary_names);
}

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

◆ radiationPatchNames()

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

protected

Definition at line 451 of file RadiationTransferAction.C.

{
  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;
}

Referenced by addRadiationObject().

◆ rayBCName()

std::string RadiationTransferAction::rayBCName ( ) const

protected

Definition at line 351 of file RadiationTransferAction.C.

{
  return "ray_bc_" + _name;
}

Referenced by addRayBCs().

◆ rayStudyName()

UserObjectName RadiationTransferAction::rayStudyName ( ) const

protected

Definition at line 345 of file RadiationTransferAction.C.

{
  return "ray_study_uo_" + _name;
}

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

◆ symmetryRayBCName()

std::string RadiationTransferAction::symmetryRayBCName ( ) const

protected

Definition at line 357 of file RadiationTransferAction.C.

{
  return "symmetry_ray_bc_" + _name;
}

Referenced by addRayBCs().

◆ 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 363 of file RadiationTransferAction.C.

{
  return "view_factor_uo_" + _name;
}

Referenced by addRadiationObject(), and addViewFactorObject().

Member Data Documentation

◆ _add_heat_flux_aux

const bool RadiationTransferAction::_add_heat_flux_aux

protected

Whether to add heat flux aux.

Definition at line 61 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 55 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 65 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 63 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 58 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

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RadiationTransferAction()

Member Function Documentation

◆ act()

◆ addFixedTemperatureBCs()

◆ 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