Computes the view factors for planar faces in unobstructed radiative heat transfer. More...

#include <UnobstructedPlanarViewFactor.h>

Inheritance diagram for UnobstructedPlanarViewFactor:

Public Member Functions
	UnobstructedPlanarViewFactor (const InputParameters &parameters)

virtual void	execute () override

virtual void	initialize () override

virtual void	finalize () override final


Real	getViewFactor (BoundaryID from_id, BoundaryID to_id) const
	public interface for obtaining view factors More...

Real	getViewFactor (BoundaryName from_name, BoundaryName to_name) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	threadJoinViewFactor (const UserObject &y) override
	a purely virtural function called in finalize, must be overriden by derived class More...

virtual void	finalizeViewFactor () override
	a purely virtural function called in finalize, must be overriden by derived class More...

void	reinitFace (dof_id_type elem_id, unsigned int side)
	helper function that reinits an element face More...

virtual void	threadJoin (const UserObject &y) override final

void	checkAndNormalizeViewFactor ()
	this function checks & normalizes view factors to sum to one, this is not always More...

Protected Attributes
BoundaryInfo *	_boundary_info

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	_side_list

unsigned int	_exponent

Real	_divisor

unsigned int	_n_sides
	number of boundaries of this side uo More...

std::vector< Real >	_areas
	area of the sides i More...

const Real	_view_factor_tol
	view factor tolerance More...

const bool	_normalize_view_factor
	whether to normalize view factors so vf[from][:] sums to one More...

std::vector< std::vector< Real > >	_view_factors
	the view factor from side i to side j More...

std::unordered_map< std::string, unsigned int >	_side_name_index
	boundary name to index map More...


std::unique_ptr< const Elem >	_current_remote_side
	data of the to_elem side being initialized More...

std::unique_ptr< FEBase >	_current_remote_fe

Real	_current_remote_side_volume

const std::vector< Real > *	_current_remote_JxW

const std::vector< Point > *	_current_remote_xyz

const std::vector< Point > *	_current_remote_normals

std::vector< Real >	_current_remote_coord

Detailed Description

Computes the view factors for planar faces in unobstructed radiative heat transfer.

Definition at line 23 of file UnobstructedPlanarViewFactor.h.

Constructor & Destructor Documentation

◆ UnobstructedPlanarViewFactor()

UnobstructedPlanarViewFactor::UnobstructedPlanarViewFactor ( const InputParameters & parameters )

Definition at line 36 of file UnobstructedPlanarViewFactor.C.

   : ViewFactorBase(parameters),
     _boundary_info(nullptr),
     _current_remote_side(nullptr),
     _current_remote_fe(nullptr),
     _current_remote_JxW(nullptr),
     _current_remote_xyz(nullptr),
     _current_remote_normals(nullptr)
 {
   _mesh.errorIfDistributedMesh("UnobstructedPlanarViewFactor");
  
   if (_mesh.dimension() == 1)
     mooseError("View factor calculations for 1D geometry makes no sense");
   else if (_mesh.dimension() == 2)
   {
     _exponent = 1;
     _divisor = 2;
   }
   else
   {
     _exponent = 2;
     _divisor = libMesh::pi;
   }
 }

Member Function Documentation

◆ checkAndNormalizeViewFactor()

void ViewFactorBase::checkAndNormalizeViewFactor ( )

protectedinherited

this function checks & normalizes view factors to sum to one, this is not always

Definition at line 106 of file ViewFactorBase.C.

 {
   for (unsigned int from = 0; from < _n_sides; ++from)
   {
     Real s = 0;
     for (unsigned int to = 0; to < _n_sides; ++to)
       s += _view_factors[from][to];
  
     if (std::abs(1 - s) > _view_factor_tol)
       mooseError("View factor from boundary ", boundaryNames()[from], " add to ", s);
  
     if (_normalize_view_factor)
       for (unsigned int to = 0; to < _n_sides; ++to)
         _view_factors[from][to] /= s;
   }
 }

Referenced by ViewFactorBase::finalize().

◆ execute()

void UnobstructedPlanarViewFactor::execute ( )

overridevirtual

Definition at line 62 of file UnobstructedPlanarViewFactor.C.

 {
   auto current_boundary_name = _mesh.getBoundaryName(_current_boundary_id);
   if (_side_name_index.find(current_boundary_name) == _side_name_index.end())
     mooseError("Current boundary name: ",
                current_boundary_name,
                " with id ",
                _current_boundary_id,
                " not in boundary parameter.");
   unsigned int index = _side_name_index.find(current_boundary_name)->second;
  
   _areas[index] += _current_side_volume;
  
   for (auto & side : _side_list)
   {
     auto remote_boundary_name = _mesh.getBoundaryName(std::get<2>(side));
     if (_side_name_index.find(remote_boundary_name) != _side_name_index.end() &&
         std::get<2>(side) != _current_boundary_id)
     {
       // this is the remote side index
       unsigned int remote_index = _side_name_index.find(remote_boundary_name)->second;
       Real & vf = _view_factors[index][remote_index];
  
       // compute some important quantities on the face
       reinitFace(std::get<0>(side), std::get<1>(side));
  
       // loop over pairs of the qps on the current side
       for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
       {
         // loop over the qps on the remote element
         for (unsigned int r_qp = 0; r_qp < _current_remote_JxW->size(); ++r_qp)
         {
           Point r2r = (_q_point[qp] - (*_current_remote_xyz)[r_qp]);
           Real distance = r2r.norm();
           Real cos1 = r2r * _normals[qp] / distance;
           Real cos2 = r2r * (*_current_remote_normals)[r_qp] / distance;
  
           vf += _JxW[qp] * _coord[qp] * (*_current_remote_JxW)[r_qp] * _current_remote_coord[r_qp] *
                 std::abs(cos1) * std::abs(cos2) / MathUtils::pow(distance, _exponent);
         }
       }
     }
   }
 }

◆ finalize()

void ViewFactorBase::finalize ( )

finaloverridevirtualinherited

Definition at line 83 of file ViewFactorBase.C.

 {
   // do some communication before finalizing view_factors
   for (unsigned int i = 0; i < _n_sides; ++i)
     gatherSum(_view_factors[i]);
  
   finalizeViewFactor();
   checkAndNormalizeViewFactor();
 }

◆ finalizeViewFactor()

void UnobstructedPlanarViewFactor::finalizeViewFactor ( )

overrideprotectedvirtual

a purely virtural function called in finalize, must be overriden by derived class

Implements ViewFactorBase.

Definition at line 126 of file UnobstructedPlanarViewFactor.C.

 {
   gatherSum(_areas);
  
   // divide view_factor Fij by Ai and pi
   for (unsigned int i = 0; i < _n_sides; ++i)
     for (auto & vf : _view_factors[i])
       vf /= (_areas[i] * _divisor);
 }

◆ getViewFactor() [1/2]

Real ViewFactorBase::getViewFactor	(	BoundaryID	from_id,
		BoundaryID	to_id
	)		const

inherited

public interface for obtaining view factors

Definition at line 52 of file ViewFactorBase.C.

 {
   auto from_name = _mesh.getBoundaryName(from_id);
   auto to_name = _mesh.getBoundaryName(to_id);
  
   return getViewFactor(from_name, to_name);
 }

Referenced by ViewFactorPP::getValue(), and ViewFactorObjectSurfaceRadiation::setViewFactors().

◆ getViewFactor() [2/2]

Real ViewFactorBase::getViewFactor	(	BoundaryName	from_name,
		BoundaryName	to_name
	)		const

inherited

Definition at line 61 of file ViewFactorBase.C.

 {
   auto from = _side_name_index.find(from_name);
   auto to = _side_name_index.find(to_name);
   if (from == _side_name_index.end())
     mooseError("Boundary id ",
                _mesh.getBoundaryID(from_name),
                " with name ",
                from_name,
                " not listed in boundary parameter.");
  
   if (to == _side_name_index.end())
     mooseError("Boundary id ",
                _mesh.getBoundaryID(to_name),
                " with name ",
                to_name,
                " not listed in boundary parameter.");
  
   return _view_factors[from->second][to->second];
 }

◆ initialize()

void UnobstructedPlanarViewFactor::initialize ( )

overridevirtual

Definition at line 108 of file UnobstructedPlanarViewFactor.C.

 {
   // get boundary info from the mesh
   _boundary_info = &_mesh.getMesh().get_boundary_info();
  
   // get a list of all sides
   _side_list = _boundary_info->build_active_side_list();
  
   // set view_factors to zero
   for (unsigned int j = 0; j < _n_sides; ++j)
   {
     _areas[j] = 0;
     for (auto & vf : _view_factors[j])
       vf = 0;
   }
 }

◆ reinitFace()

void UnobstructedPlanarViewFactor::reinitFace	(	dof_id_type	elem_id,
		unsigned int	side
	)

protected

helper function that reinits an element face

Definition at line 145 of file UnobstructedPlanarViewFactor.C.

 {
   const Elem * current_remote_elem = _mesh.getMesh().elem_ptr(elem_id);
   _current_remote_side = current_remote_elem->build_side_ptr(side);
   _current_remote_side_volume = _current_remote_side->volume();
  
   Order order = current_remote_elem->default_order();
   unsigned int dim = _mesh.getMesh().mesh_dimension();
   _current_remote_fe = FEBase::build(dim, FEType(order));
   QGauss qface(dim - 1, FEType(order).default_quadrature_order());
   _current_remote_fe->attach_quadrature_rule(&qface);
  
   _current_remote_JxW = &_current_remote_fe->get_JxW();
   _current_remote_normals = &_current_remote_fe->get_normals();
   _current_remote_xyz = &_current_remote_fe->get_xyz();
  
   _current_remote_fe->reinit(current_remote_elem, side);
  
   // set _coord
   unsigned int n_points = _current_remote_xyz->size();
   unsigned int rz_radial_coord = _subproblem.getAxisymmetricRadialCoord();
   _current_remote_coord.resize(n_points);
   switch (_assembly.coordSystem())
   {
     case Moose::COORD_XYZ:
       for (unsigned int qp = 0; qp < n_points; qp++)
         _current_remote_coord[qp] = 1.;
       break;
  
     case Moose::COORD_RZ:
       for (unsigned int qp = 0; qp < n_points; qp++)
         _current_remote_coord[qp] = 2 * M_PI * (*_current_remote_xyz)[qp](rz_radial_coord);
       break;
  
     case Moose::COORD_RSPHERICAL:
       for (unsigned int qp = 0; qp < n_points; qp++)
         _current_remote_coord[qp] =
             4 * M_PI * (*_current_remote_xyz)[qp](0) * (*_current_remote_xyz)[qp](0);
       break;
  
     default:
       mooseError("Unknown coordinate system");
       break;
   }
 }

Referenced by execute().

◆ threadJoin()

void ViewFactorBase::threadJoin ( const UserObject & y )

finaloverrideprotectedvirtualinherited

Definition at line 94 of file ViewFactorBase.C.

 {
   const ViewFactorBase & pps = static_cast<const ViewFactorBase &>(y);
   for (unsigned int i = 0; i < _n_sides; ++i)
   {
     for (unsigned int j = 0; j < _n_sides; ++j)
       _view_factors[i][j] += pps._view_factors[i][j];
   }
   threadJoinViewFactor(y);
 }

◆ threadJoinViewFactor()

void UnobstructedPlanarViewFactor::threadJoinViewFactor ( const UserObject & y )

overrideprotectedvirtual

a purely virtural function called in finalize, must be overriden by derived class

Implements ViewFactorBase.

Definition at line 137 of file UnobstructedPlanarViewFactor.C.

 {
   const UnobstructedPlanarViewFactor & pps = static_cast<const UnobstructedPlanarViewFactor &>(y);
   for (unsigned int i = 0; i < _n_sides; ++i)
     _areas[i] += pps._areas[i];
 }

◆ validParams()

InputParameters UnobstructedPlanarViewFactor::validParams ( )

static

Definition at line 28 of file UnobstructedPlanarViewFactor.C.

 {
   InputParameters params = ViewFactorBase::validParams();
   params.addClassDescription(
       "Computes the view factors for planar faces in unubstructed radiative heat transfer.");
   return params;
 }