RadiationTransferAction Class Reference

#include <RadiationTransferAction.h>

Inheritance diagram for RadiationTransferAction:

Public Member Functions
	RadiationTransferAction (const InputParameters &params)
virtual void	act () override

Protected Member Functions
void	addMeshGenerator () const
void	addRadiationObject () const
void	addViewFactorObject () const
void	addRadiationBCs () const
std::vector< std::vector< std::string > >	radiationPatchNames () const
UserObjectName	viewFactorObjectName () const
UserObjectName	radiationObjectName () const

Protected Attributes
std::vector< boundary_id_type >	_boundary_ids
	the boundary ids participating in the radiative heat transfer More...
std::vector< unsigned int >	_n_patches
	the number of radiation patches per boundary More...

Detailed Description

Definition at line 16 of file RadiationTransferAction.h.

Constructor & Destructor Documentation

RadiationTransferAction()

RadiationTransferAction::RadiationTransferAction

(

const InputParameters &

params

)

Definition at line 65 of file RadiationTransferAction.C.

  : Action(params),
    _boundary_ids(getParam<std::vector<boundary_id_type>>("sidesets")),
    _n_patches(getParam<std::vector<unsigned int>>("n_patches"))
{
}

Member Function Documentation

act()

void RadiationTransferAction::act ( )

overridevirtual

Definition at line 73 of file RadiationTransferAction.C.

{
  if (_current_task == "add_mesh_generator")
    addMeshGenerator();
  else if (_current_task == "setup_mesh_complete")
    radiationPatchNames();
  else if (_current_task == "add_user_object")
  {
    addRadiationObject();
    addViewFactorObject();
  }
  else if (_current_task == "add_bc")
    addRadiationBCs();
}

addMeshGenerator()

void RadiationTransferAction::addMeshGenerator ( ) const

protected

Definition at line 279 of file RadiationTransferAction.C.

{
  MultiMooseEnum partitioners = getParam<MultiMooseEnum>("partitioners");
  if (!_pars.isParamSetByUser("partitioners"))
  {
    partitioners.clear();
    for (unsigned int j = 0; j < _boundary_ids.size(); ++j)
      partitioners.push_back("metis");
  }
 
  MultiMooseEnum direction = getParam<MultiMooseEnum>("centroid_partitioner_directions");
 
  // check input parameters
  if (_boundary_ids.size() != _n_patches.size())
    mooseError("n_patches parameter must have same length as sidesets parameter.");
 
  if (_boundary_ids.size() != partitioners.size())
    mooseError("partitioners parameter must have same length as sidesets parameter.");
 
  for (unsigned int j = 0; j < partitioners.size(); ++j)
    if (partitioners[j] == "centroid" && direction.size() != _boundary_ids.size())
      mooseError(
          "centroid partitioner is selected for at least one sideset. "
          "centroid_partitioner_directions parameter must have same length as sidesets 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.");
 
  MeshGeneratorName input = getParam<MeshGeneratorName>("final_mesh_generator");
 
  for (unsigned int j = 0; j < _boundary_ids.size(); ++j)
  {
    boundary_id_type bid = _boundary_ids[j];
 
    // create the name of this PatchSidesetGenerator
    std::stringstream ss;
    ss << "patch_side_set_generator_" << bid;
    MeshGeneratorName mg_name = ss.str();
 
    InputParameters params = _factory.getValidParams("PatchSidesetGenerator");
    params.set<MeshGeneratorName>("input") = input;
    params.set<boundary_id_type>("sideset") = bid;
    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.addMeshGenerator("PatchSidesetGenerator", mg_name, params);
 
    // reset input parameter to last one added
    input = mg_name;
  }
}

Referenced by act().

addRadiationBCs()

void RadiationTransferAction::addRadiationBCs ( ) const

protected

Definition at line 89 of file RadiationTransferAction.C.

{
  InputParameters params = _factory.getValidParams("GrayLambertNeumannBC");
 
  // set boundary
  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);
  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 145 of file RadiationTransferAction.C.

{
  std::vector<std::vector<std::string>> radiation_patch_names = radiationPatchNames();
 
  // input parameter check
  std::vector<Real> emissivity = getParam<std::vector<Real>>("emissivity");
  if (emissivity.size() != _boundary_ids.size())
    mooseError("emissivity parameter needs to be the same size as the sidesets 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<Real> extended_emissivity;
  for (unsigned int j = 0; j < _boundary_ids.size(); ++j)
    for (unsigned int i = 0; i < _n_patches[j]; ++i)
      extended_emissivity.push_back(emissivity[j]);
  params.set<std::vector<Real>>("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_sidesets"))
  {
    std::vector<boundary_id_type> adiabatic_boundary_ids =
        getParam<std::vector<boundary_id_type>>("adiabatic_sidesets");
    std::vector<BoundaryName> adiabatic_boundary_names;
    for (unsigned int k = 0; k < adiabatic_boundary_ids.size(); ++k)
    {
      boundary_id_type abid = adiabatic_boundary_ids[k];
 
      // find the right entry in _boundary_ids
      auto it = std::find(_boundary_ids.begin(), _boundary_ids.end(), abid);
 
      // check if entry was found: it must be found or an error would occur later
      if (it == _boundary_ids.end())
        mooseError("Adiabatic sideset ", abid, " not present in sidesets.");
 
      // this is the position in the _boundary_ids vector; this is what
      // we are really after
      auto index = std::distance(_boundary_ids.begin(), it);
 
      // collect the correct boundary names
      for (auto & e : radiation_patch_names[index])
        adiabatic_boundary_names.push_back(e);
    }
    params.set<std::vector<BoundaryName>>("adiabatic_boundary") = adiabatic_boundary_names;
  }
 
  // add isothermal sidesets if required
  if (isParamValid("fixed_temperature_sidesets"))
  {
    if (!isParamValid("fixed_boundary_temperatures"))
      mooseError("fixed_temperature_sidesets is provided so fixed_boundary_temperatures must be "
                 "provided too");
 
    std::vector<boundary_id_type> fixed_T_boundary_ids =
        getParam<std::vector<boundary_id_type>>("fixed_temperature_sidesets");
 
    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_ids.size())
      mooseError("Size of parameter fixed_boundary_temperatures and fixed_temperature_sidesets "
                 "must be equal.");
 
    std::vector<BoundaryName> fixed_T_boundary_names;
    std::vector<FunctionName> fixed_T_function_names;
    for (unsigned int k = 0; k < fixed_T_boundary_ids.size(); ++k)
    {
      boundary_id_type bid = fixed_T_boundary_ids[k];
 
      // find the right entry in _boundary_ids
      auto it = std::find(_boundary_ids.begin(), _boundary_ids.end(), bid);
 
      // check if entry was found: it must be found or an error would occur later
      if (it == _boundary_ids.end())
        mooseError("Fixed temperature sideset ", bid, " not present in sidesets.");
 
      // this is the position in the _boundary_ids vector; this is what
      // we are really after
      auto index = std::distance(_boundary_ids.begin(), it);
 
      // collect the correct boundary names
      for (auto & e : radiation_patch_names[index])
      {
        fixed_T_boundary_names.push_back(e);
        fixed_T_function_names.push_back(fixed_T_funcs[k]);
      }
    }
    params.set<std::vector<BoundaryName>>("fixed_temperature_boundary") = fixed_T_boundary_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().

addViewFactorObject()

void RadiationTransferAction::addViewFactorObject ( ) const

protected

Definition at line 111 of file RadiationTransferAction.C.

{
  // add the view factor userobject; currently there is only one object implemented so no choices
  // in the future this section will allow switching different types
  InputParameters params = _factory.getValidParams("UnobstructedPlanarViewFactor");
 
  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);
  params.set<std::vector<BoundaryName>>("boundary") = boundary_names;
 
  // this userobject is only executed on initial
  ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
  exec_enum = {EXEC_INITIAL};
  params.set<ExecFlagEnum>("execute_on") = exec_enum;
 
  _problem->addUserObject("UnobstructedPlanarViewFactor", viewFactorObjectName(), params);
}

Referenced by act().

radiationObjectName()

UserObjectName RadiationTransferAction::radiationObjectName ( ) const

protected

Definition at line 139 of file RadiationTransferAction.C.

{
  return "view_factor_surface_radiation_" + _name;
}

Referenced by addRadiationBCs(), and addRadiationObject().

radiationPatchNames()

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

protected

Definition at line 259 of file RadiationTransferAction.C.

{
  std::vector<std::vector<std::string>> radiation_patch_names(_boundary_ids.size());
  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 < _n_patches[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 act(), addRadiationBCs(), addRadiationObject(), and addViewFactorObject().

viewFactorObjectName()

UserObjectName RadiationTransferAction::viewFactorObjectName ( ) const

protected

Definition at line 133 of file RadiationTransferAction.C.

{
  return "view_factor_uo_" + _name;
}

Referenced by addRadiationObject(), and addViewFactorObject().

Member Data Documentation

_boundary_ids

std::vector<boundary_id_type> RadiationTransferAction::_boundary_ids

protected

the boundary ids participating in the radiative heat transfer

Definition at line 33 of file RadiationTransferAction.h.

Referenced by addMeshGenerator(), addRadiationObject(), and radiationPatchNames().

_n_patches

std::vector<unsigned int> RadiationTransferAction::_n_patches

protected

the number of radiation patches per boundary

Definition at line 36 of file RadiationTransferAction.h.

Referenced by addMeshGenerator(), addRadiationObject(), and radiationPatchNames().

---

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

• heat_conduction/include/actions/RadiationTransferAction.h
• heat_conduction/src/actions/RadiationTransferAction.C