GrayLambertSurfaceRadiationBase computes the heat flux on a set of surfaces in radiative heat transfer with each other. More...

#include <GrayLambertSurfaceRadiationBase.h>

Inheritance diagram for GrayLambertSurfaceRadiationBase:

[legend]

Public Types
enum	RAD_BND_TYPE { VARIABLE_TEMPERATURE = 0, FIXED_TEMPERATURE = 4, ADIABATIC = 8 }
	Define enum for boundary type. More...

Public Member Functions
	GrayLambertSurfaceRadiationBase (const InputParameters &parameters)

virtual void	execute () override

virtual void	initialize () override

virtual void	finalize () override


Real	getSurfaceIrradiation (BoundaryID id) const
	public interface of this UserObject More...

Real	getSurfaceHeatFluxDensity (BoundaryID id) const

Real	getSurfaceTemperature (BoundaryID id) const

Real	getSurfaceRadiosity (BoundaryID id) const

Real	getSurfaceEmissivity (BoundaryID id) const

Real	getViewFactor (BoundaryID from_id, BoundaryID to_id) const

std::set< BoundaryID >	getSurfaceIDs () const

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	threadJoin (const UserObject &y) override

virtual std::vector< std::vector< Real > >	setViewFactors ()=0
	a purely virtual function that defines where view factors come from More...

Protected Attributes
const Real	_sigma_stefan_boltzmann
	Stefan-Boltzmann constant. More...

unsigned int	_n_sides
	number of active boundary ids More...

const VariableValue &	_temperature
	the coupled temperature variable More...

const std::vector< Real >	_emissivity
	constant emissivity for each boundary More...

std::vector< const Function * >	_fixed_side_temperature
	side id to index map, side ids can have holes or be out of order More...

std::vector< Real >	_radiosity
	the radiosity of each surface More...

std::vector< Real >	_heat_flux_density
	the heat flux density qdot More...

std::vector< Real >	_side_temperature
	the average temperature: this could be important for adiabatic walls More...

std::vector< enum RAD_BND_TYPE >	_side_type
	the type of the side, allows lookup index -> type More...

std::map< BoundaryID, unsigned int >	_side_id_index
	side id to index map, side ids can have holes or be out of order More...

std::vector< Real >	_areas
	the area by participating side set More...

std::vector< Real >	_beta
	the average value of sigma * eps * T^4 More...

std::vector< Real >	_surface_irradiation
	the irradiation into each surface More...

std::map< unsigned int, unsigned int >	_fixed_side_id_index
	side id to index map for isothermal boundaries, side ids can have holes or be out of order More...

std::set< unsigned int >	_adiabatic_side_ids
	the set of adiabatic boundaries More...

std::vector< std::vector< Real > >	_view_factors
	the view factors which are set by setViewFactors by derived classes More...

Detailed Description

GrayLambertSurfaceRadiationBase computes the heat flux on a set of surfaces in radiative heat transfer with each other.

Definition at line 25 of file GrayLambertSurfaceRadiationBase.h.

Member Enumeration Documentation

◆ RAD_BND_TYPE

enum GrayLambertSurfaceRadiationBase::RAD_BND_TYPE

Define enum for boundary type.

Enumerator
VARIABLE_TEMPERATURE
FIXED_TEMPERATURE
ADIABATIC

Definition at line 37 of file GrayLambertSurfaceRadiationBase.h.

   {
     VARIABLE_TEMPERATURE = 0,
     FIXED_TEMPERATURE = 4,
     ADIABATIC = 8
   };

Constructor & Destructor Documentation

◆ GrayLambertSurfaceRadiationBase()

GrayLambertSurfaceRadiationBase::GrayLambertSurfaceRadiationBase ( const InputParameters & parameters )

Definition at line 42 of file GrayLambertSurfaceRadiationBase.C.

   : SideUserObject(parameters),
     _sigma_stefan_boltzmann(getParam<Real>("stefan_boltzmann_constant")),
     _n_sides(boundaryIDs().size()),
     _temperature(coupledValue("temperature")),
     _emissivity(getParam<std::vector<Real>>("emissivity")),
     _radiosity(_n_sides),
     _heat_flux_density(_n_sides),
     _side_temperature(_n_sides),
     _side_type(_n_sides),
     _areas(_n_sides),
     _beta(_n_sides),
     _surface_irradiation(_n_sides)
 {
   // set up the map from the side id to the local index & check
   // note that boundaryIDs is not in the right order anymore!
   {
     std::vector<BoundaryName> boundary_names = getParam<std::vector<BoundaryName>>("boundary");
  
     for (unsigned int j = 0; j < boundary_names.size(); ++j)
     {
       if (boundary_names[j] == "ANY_BOUNDARY_ID")
         paramError("boundary", "boundary must be explicitly provided.");
  
       _side_id_index[_mesh.getBoundaryID(boundary_names[j])] = j;
       _side_type[j] = VARIABLE_TEMPERATURE;
     }
  
     // consistency check on emissivity, must be as many entries as boundary
     if (boundary_names.size() != _emissivity.size())
       paramError("emissivity", "The number of entries must match the number of boundary entries.");
   }
  
   // get the fixed boundaries of the system if any are provided
   if (isParamValid("fixed_temperature_boundary"))
   {
     // if fixed_temperature_boundary is valid, then fixed_side_temperatures must be
     // valid, too
     if (!isParamValid("fixed_boundary_temperatures"))
       paramError("fixed_boundary_temperatures",
                  "fixed_temperature_boundary is provided, but fixed_boundary_temperatures is not.");
  
     auto fst_fn = getParam<std::vector<FunctionName>>("fixed_boundary_temperatures");
     for (auto & fn : fst_fn)
       _fixed_side_temperature.push_back(&getFunctionByName(fn));
  
     // get the fixed boundaries and temperatures
     std::vector<BoundaryName> boundary_names =
         getParam<std::vector<BoundaryName>>("fixed_temperature_boundary");
  
     if (boundary_names.size() != _fixed_side_temperature.size())
       paramError(
           "fixed_boundary_temperatures",
           "fixed_boundary_temperatures and fixed_temperature_boundary must have the same length.");
  
     unsigned int index = 0;
     for (auto & name : boundary_names)
     {
       _fixed_side_id_index[_mesh.getBoundaryID(name)] = index;
       index++;
     }
  
     // check that fixed side ids is a subset of boundary ids
     // and update _side_type info
     for (auto & p : _fixed_side_id_index)
     {
       if (_side_id_index.find(p.first) == _side_id_index.end())
         paramError("fixed_temperature_boundary",
                    "fixed_temperature_boundary must be a subset of boundary.");
       _side_type[_side_id_index.find(p.first)->second] = FIXED_TEMPERATURE;
     }
   }
  
   // get the fixed boundaries of the system if any are provided
   if (isParamValid("adiabatic_boundary"))
   {
     // get the adiabatic boundaries and temperatures
     std::vector<BoundaryName> boundary_names =
         getParam<std::vector<BoundaryName>>("adiabatic_boundary");
  
     for (auto & name : boundary_names)
       _adiabatic_side_ids.insert(_mesh.getBoundaryID(name));
  
     // check that adiabatic side ids is a subset of boundary ids
     // and update _side_type info
     for (auto & id : _adiabatic_side_ids)
     {
       if (_side_id_index.find(id) == _side_id_index.end())
         paramError("adiabatic_boundary", "adiabatic_boundary must be a subset of boundary.");
       _side_type[_side_id_index.find(id)->second] = ADIABATIC;
     }
  
     // make sure that adiabatic boundaries are not already fixed boundaries
     for (auto & id : _adiabatic_side_ids)
       if (_fixed_side_id_index.find(id) != _fixed_side_id_index.end())
         paramError("adiabatic_boundary", "Isothermal boundary cannot also be adiabatic boundary.");
   }
 }

Member Function Documentation

◆ execute()

void GrayLambertSurfaceRadiationBase::execute ( )

overridevirtual

Definition at line 142 of file GrayLambertSurfaceRadiationBase.C.

 {
   mooseAssert(_side_id_index.find(_current_boundary_id) != _side_id_index.end(),
               "Current boundary id not in _side_id_index.");
   unsigned int index = _side_id_index.find(_current_boundary_id)->second;
  
   for (unsigned int qp = 0; qp < _qrule->n_points(); qp++)
   {
     _areas[index] += _JxW[qp] * _coord[qp];
  
     Real temp = 0;
     if (_side_type[index] == ADIABATIC)
       continue;
     else if (_side_type[index] == VARIABLE_TEMPERATURE)
       temp = _temperature[qp];
     else if (_side_type[index] == FIXED_TEMPERATURE)
     {
       unsigned int iso_index = _fixed_side_id_index.find(_current_boundary_id)->second;
       temp = _fixed_side_temperature[iso_index]->value(_t, _q_point[qp]);
     }
  
     _beta[index] += _JxW[qp] * _coord[qp] * _sigma_stefan_boltzmann * _emissivity[index] *
                     MathUtils::pow(temp, 4);
     _side_temperature[index] += _JxW[qp] * _coord[qp] * temp;
   }
 }

◆ finalize()

void GrayLambertSurfaceRadiationBase::finalize ( )

overridevirtual

Definition at line 186 of file GrayLambertSurfaceRadiationBase.C.

 {
   // need to do some parallel communiction here
   gatherSum(_areas);
   gatherSum(_beta);
   gatherSum(_side_temperature);
  
   // first compute averages from the totals
   for (unsigned int j = 0; j < _n_sides; ++j)
   {
     _beta[j] /= _areas[j];
     _side_temperature[j] /= _areas[j];
   }
  
   // matrix and rhs vector for the view factor calculation
   DenseMatrix<Real> matrix(_n_sides, _n_sides);
   DenseVector<Real> rhs(_n_sides);
   DenseVector<Real> radiosity(_n_sides);
   for (unsigned int i = 0; i < _n_sides; ++i)
   {
     rhs(i) = _beta[i];
     matrix(i, i) = 1;
     for (unsigned int j = 0; j < _n_sides; ++j)
     {
       if (_side_type[i] == ADIABATIC)
         matrix(i, j) -= _view_factors[i][j];
       else
         matrix(i, j) -= (1 - _emissivity[i]) * _view_factors[i][j];
     }
   }
  
   // compute the radiosityes
   matrix.lu_solve(rhs, radiosity);
  
   // store the radiosity, temperatures and heat flux density for each surface
   for (unsigned int i = 0; i < _n_sides; ++i)
   {
     _radiosity[i] = radiosity(i);
  
     // _heat_flux_density is obtained from a somewhat cumbersome relation
     // but it has the advantage that we do not divide by 1 - emissivity
     // which blows up for black bodies
     _heat_flux_density[i] = radiosity(i);
     for (unsigned int j = 0; j < _n_sides; ++j)
       _heat_flux_density[i] -= _view_factors[i][j] * radiosity(j);
  
     if (_side_type[i] == ADIABATIC)
       _side_temperature[i] =
           std::pow((radiosity(i) + (1 - _emissivity[i]) / _emissivity[i] * _heat_flux_density[i]) /
                        _sigma_stefan_boltzmann,
                    0.25);
  
     // compute the surface irradiation into i from the radiosities
     _surface_irradiation[i] = 0;
     for (unsigned int j = 0; j < _n_sides; ++j)
       _surface_irradiation[i] += _view_factors[i][j] * radiosity(j);
   }
 }

◆ getSurfaceEmissivity()

Real GrayLambertSurfaceRadiationBase::getSurfaceEmissivity ( BoundaryID id ) const

Definition at line 301 of file GrayLambertSurfaceRadiationBase.C.

 {
   if (_side_id_index.find(id) == _side_id_index.end())
     return 1;
   return _emissivity[_side_id_index.find(id)->second];
 }

Referenced by GrayLambertNeumannBC::computeQpJacobian(), GrayLambertNeumannBC::computeQpResidual(), and SurfaceRadiationVectorPostprocessor::execute().

◆ getSurfaceHeatFluxDensity()

Real GrayLambertSurfaceRadiationBase::getSurfaceHeatFluxDensity ( BoundaryID id ) const

Definition at line 277 of file GrayLambertSurfaceRadiationBase.C.

 {
   if (_side_id_index.find(id) == _side_id_index.end())
     return 0;
   return _heat_flux_density[_side_id_index.find(id)->second];
 }

Referenced by GrayLambertNeumannBC::computeQpResidual(), SurfaceRadiationVectorPostprocessor::execute(), and GrayLambertSurfaceRadiationPP::getValue().

◆ getSurfaceIDs()

std::set< BoundaryID > GrayLambertSurfaceRadiationBase::getSurfaceIDs ( ) const

Definition at line 260 of file GrayLambertSurfaceRadiationBase.C.

 {
   std::set<BoundaryID> surface_ids;
   for (auto & p : _side_id_index)
     surface_ids.insert(p.first);
   return surface_ids;
 }

Referenced by SurfaceRadiationVectorPostprocessor::initialize(), and ViewfactorVectorPostprocessor::initialize().

◆ getSurfaceIrradiation()

Real GrayLambertSurfaceRadiationBase::getSurfaceIrradiation ( BoundaryID id ) const

public interface of this UserObject

Definition at line 269 of file GrayLambertSurfaceRadiationBase.C.

 {
   if (_side_id_index.find(id) == _side_id_index.end())
     return 0;
   return _surface_irradiation[_side_id_index.find(id)->second];
 }

Referenced by GrayLambertNeumannBC::computeQpResidual().

◆ getSurfaceRadiosity()

Real GrayLambertSurfaceRadiationBase::getSurfaceRadiosity ( BoundaryID id ) const

Definition at line 293 of file GrayLambertSurfaceRadiationBase.C.

 {
   if (_side_id_index.find(id) == _side_id_index.end())
     return 0;
   return _radiosity[_side_id_index.find(id)->second];
 }

Referenced by SurfaceRadiationVectorPostprocessor::execute(), and GrayLambertSurfaceRadiationPP::getValue().

◆ getSurfaceTemperature()

Real GrayLambertSurfaceRadiationBase::getSurfaceTemperature ( BoundaryID id ) const

Definition at line 285 of file GrayLambertSurfaceRadiationBase.C.

 {
   if (_side_id_index.find(id) == _side_id_index.end())
     return 0;
   return _side_temperature[_side_id_index.find(id)->second];
 }

Referenced by SurfaceRadiationVectorPostprocessor::execute(), and GrayLambertSurfaceRadiationPP::getValue().

◆ getViewFactor()

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

Definition at line 309 of file GrayLambertSurfaceRadiationBase.C.

 {
   if (_side_id_index.find(from_id) == _side_id_index.end())
     return 0;
   if (_side_id_index.find(to_id) == _side_id_index.end())
     return 0;
   return _view_factors[_side_id_index.find(from_id)->second][_side_id_index.find(to_id)->second];
 }

Referenced by ViewfactorVectorPostprocessor::execute().

◆ initialize()

void GrayLambertSurfaceRadiationBase::initialize ( )

overridevirtual

Reimplemented in ConstantViewFactorSurfaceRadiation.

Definition at line 170 of file GrayLambertSurfaceRadiationBase.C.

 {
   // view factors are obtained here to make sure that another object had
   // time to compute them on exec initial
   _view_factors = setViewFactors();
  
   // initialize areas, beta, side temps
   for (unsigned int j = 0; j < _n_sides; ++j)
   {
     _areas[j] = 0;
     _beta[j] = 0;
     _side_temperature[j] = 0;
   }
 }

Referenced by ConstantViewFactorSurfaceRadiation::initialize().

◆ setViewFactors()

virtual std::vector<std::vector<Real> > GrayLambertSurfaceRadiationBase::setViewFactors ( )

protectedpure virtual

a purely virtual function that defines where view factors come from

Implemented in ConstantViewFactorSurfaceRadiation, and ViewFactorObjectSurfaceRadiation.

Referenced by initialize().

◆ threadJoin()

void GrayLambertSurfaceRadiationBase::threadJoin ( const UserObject & y )

overrideprotectedvirtual

Definition at line 246 of file GrayLambertSurfaceRadiationBase.C.

 {
   const GrayLambertSurfaceRadiationBase & pps =
       static_cast<const GrayLambertSurfaceRadiationBase &>(y);
  
   for (unsigned int j = 0; j < _n_sides; ++j)
   {
     _areas[j] += pps._areas[j];
     _side_temperature[j] += pps._side_temperature[j];
     _beta[j] += pps._beta[j];
   }
 }

◆ validParams()

InputParameters GrayLambertSurfaceRadiationBase::validParams ( )

static

Definition at line 20 of file GrayLambertSurfaceRadiationBase.C.

 {
   InputParameters params = SideUserObject::validParams();
   params.addParam<Real>(
       "stefan_boltzmann_constant",
       5.670367e-8,
       "The Stefan-Boltzmann constant. Default value is in units of [W / m^2 K^4].");
   params.addRequiredCoupledVar("temperature", "The coupled temperature variable.");
   params.addRequiredParam<std::vector<Real>>("emissivity", "Emissivities for each boundary.");
   params.addParam<std::vector<BoundaryName>>(
       "fixed_temperature_boundary",
       "The list of boundary IDs from the mesh with fixed temperatures.");
   params.addParam<std::vector<FunctionName>>("fixed_boundary_temperatures",
                                              "The temperatures of the fixed boundary.");
   params.addParam<std::vector<BoundaryName>>(
       "adiabatic_boundary", "The list of boundary IDs from the mesh that are adiabatic.");
  
   params.addClassDescription(
       "This object implements the exchange of heat by radiation between sidesets.");
   return params;
 }