This class provides an interface for managing conjugate heat transfer (CHT) between fluid and solid domains. More...

#include <CHTHandler.h>

Inheritance diagram for NS::FV::CHTHandler:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	CHTHandler (const InputParameters &parameters)
	Constructor with initialization parameters.

void	linkEnergySystems (SystemBase solid_energy_system, SystemBase fluid_energy_system, std::vector< SystemBase * > pm_radiation_systems)
	Link energy systems.

void	setupConjugateHeatTransferContainers ()
	Set up the boundary condition pairs, functor maps, and every other necessary structure for the conjugate heat transfer routines.

void	deduceCHTBoundaryCoupling ()
	Run error checks and make sure everything works.

void	updateCHTBoundaryCouplingFields (const NS::CHTSide side)
	Update the coupling fields for.

void	initializeCHTCouplingFields ()
	Initialize the coupling fields for the conjugate heat transfer routines.

bool	converged () const
	Check if CHT iteration converged.

void	resetCHTConvergence ()
	Reset the convergence data.

void	incrementCHTIterators ()
	Increment CHT iterators in the loop.

void	sumIntegratedFluxes ()
	Sum the integrated fluxes over all processors.

void	printIntegratedFluxes () const
	Print the integrated heat fluxes.

void	resetIntegratedFluxes ()
	Reset the heat fluxes to 0.

virtual bool	enabled () const override final
	Check if CHT treatment is needed.

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

UserObjectName	getUserObjectName (const std::string &param_name) const

const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const

const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

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)

static std::string	deduceFunctorName (const std::string &name, const InputParameters &params)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
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

Protected Member Functions
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

virtual void	addUserObjectDependencyHelper (const UserObjectBase &) const

std::string	deduceFunctorName (const std::string &name) const

const Moose::Functor< T > &	getFunctor (const std::string &name)

const Moose::Functor< T > &	getFunctor (const std::string &name, THREAD_ID tid)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem, THREAD_ID tid)

bool	isFunctor (const std::string &name) const

bool	isFunctor (const std::string &name, const SubProblem &subproblem) const

Moose::ElemArg	makeElemArg (const Elem *elem, bool correct_skewnewss=false) const

void	checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)

const Moose::Functor< T > &	getFunctorByName (const std::string &name)

Protected Attributes
FEProblemBase &	_problem
	Reference to FEProblem.

MooseMesh &	_mesh
	Mesh.

SystemBase *	_energy_system
	The energy system.

SystemBase *	_solid_energy_system
	The solid energy system.

std::vector< SystemBase * >	_pm_radiation_systems
	The solid energy system.

const MooseLinearVariableFVReal *	_fluid_variable = nullptr
	The fluid-side temperature variable.

const MooseLinearVariableFVReal *	_solid_variable = nullptr
	The solid-side temperature variable.

std::vector< BoundaryName >	_cht_boundary_names
	The names of the CHT boundaries.

std::vector< BoundaryID >	_cht_boundary_ids
	The IDs of the CHT boundaries.

const unsigned int	_max_cht_fpi
	Maximum number of CHT fixed point iterations.

const Real	_cht_heat_flux_tolerance
	Tolerance for heat flux at the CHT interfaces.

const GrayLambertSurfaceRadiationBase *	_surface_radiation_uo
	Optional surface-to-surface radiation model supplying net outward wall heat fluxes.

std::set< BoundaryID >	_surface_radiation_boundary_ids
	Boundaries represented by the surface-to-surface radiation model.

std::vector< const Moose::Functor< Real > * >	_thermal_resistance
	Thermal resistance functors, one per CHT interface.

std::vector< std::vector< Real > >	_cht_flux_relaxation_factor
	The relaxation factors for flux fields for the CHT boundaries first index is solid/fluid second is the interface.

std::vector< std::vector< Real > >	_cht_temperature_relaxation_factor
	The relaxation factors for temperature fields for the CHT boundaries first index is solid/fluid second is the interface.

std::vector< unsigned int >	_cht_system_numbers
	The solid (0) and fluid (1) system numbers.

std::vector< unsigned int >	_cht_pm_radiation_system_numbers
	The participating media radiation system numbers.

std::vector< std::vector< const FaceInfo * > >	_cht_face_info
	The subset of the FaceInfo objects that belong to the given boundaries.

std::vector< LinearFVFluxKernel * >	_cht_conduction_kernels
	The conduction kernels from the solid/fluid domains. Can't be const, considering we are updating the inner structures for every face.

std::vector< LinearFVFluxKernel * >	_cht_pm_radiation_kernels
	The conduction radiation kernels from the fluid domains.

std::vector< std::vector< LinearFVBoundaryCondition * > >	_cht_boundary_conditions
	Vector of boundary conditions that describe the conjugate heat transfer from each side.

std::vector< std::vector< LinearFVBoundaryCondition * > >	_cht_pm_radiation_boundary_conditions
	Vector of boundary conditions that describe the radiation pm bcs from each side.

std::vector< std::vector< FaceCenteredMapFunctor< Real, std::unordered_map< dof_id_type, Real > > > >	_boundary_heat_flux
	Functors describing the heat flux on the conjugate heat transfer interfaces.

std::vector< std::vector< Real > >	_integrated_boundary_heat_flux
	Integrated source-domain flux for each boundary and solid/fluid transfer direction.

std::vector< Real >	_integrated_boundary_surface_radiation_heat_flux
	Integrated net outward surface-radiation flux, kept separate for the CHT energy balance.

std::vector< std::vector< FaceCenteredMapFunctor< Real, std::unordered_map< dof_id_type, Real > > > >	_boundary_temperature
	Functors describing the raw wall temperatures on the conjugate heat transfer interfaces.

std::vector< std::vector< FaceCenteredMapFunctor< Real, std::unordered_map< dof_id_type, Real > > > >	_boundary_effective_temperature
	Functors describing the effective wall temperatures after applying thermal resistance.

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const Parallel::Communicator &	_communicator

Private Member Functions
const UserObjectBase &	getUserObjectFromFEProblem (const UserObjectName &object_name, const THREAD_ID tid=0) const

const T &	castUserObject (const UserObjectBase &uo_base, const std::string &param_name="") const

void	mooseObjectError (const std::string &param_name, std::stringstream &oss) const

const std::string &	userObjectType (const UserObjectBase &uo) const

const std::string &	userObjectName (const UserObjectBase &uo) const

const Moose::Functor< T > *	defaultFunctor (const std::string &name)

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

const Moose::Functor< T > &	getFunctorByName (const std::string &name, SubProblem &subproblem, THREAD_ID tid)

virtual bool	isADObject () const override

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
unsigned int	_fpi_it
	CHT fixed point iteration counter.

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

const MooseObject &	_uoi_moose_object

const FEProblemBase &	_uoi_feproblem

const THREAD_ID	_uoi_tid

const InputParameters &	_fi_params

const std::string	_fi_name

SubProblem *const	_fi_subproblem

const THREAD_ID	_fi_tid

std::vector< std::unique_ptr< Moose::Functor< Real > > >	_default_real_functors

std::vector< std::unique_ptr< Moose::Functor< ADReal > > >	_default_ad_real_functors

Detailed Description

This class provides an interface for managing conjugate heat transfer (CHT) between fluid and solid domains.

Definition at line 35 of file CHTHandler.h.

Constructor & Destructor Documentation

◆ CHTHandler()

NS::FV::CHTHandler::CHTHandler ( const InputParameters & parameters )

Constructor with initialization parameters.

Definition at line 91 of file CHTHandler.C.

  : MooseObject(params),
    UserObjectInterface(this),
    NonADFunctorInterface(this),
    _problem(*getCheckedPointerParam<FEProblemBase *>(
        "_fe_problem_base", "This might happen if you don't have a mesh")),
    _mesh(_problem.mesh()),
    _cht_boundary_names(getParam<std::vector<BoundaryName>>("cht_interfaces")),
    _cht_boundary_ids(_mesh.getBoundaryIDs(_cht_boundary_names)),
    _max_cht_fpi(getParam<unsigned int>("max_cht_fpi")),
    _cht_heat_flux_tolerance(getParam<Real>("cht_heat_flux_tolerance")),
    _surface_radiation_uo(nullptr)
{
  if (isParamSetByUser("cht_interfaces") && !_cht_boundary_names.size())
    paramError("cht_interfaces", "You must declare at least one interface!");
  if (isParamValid("surface_radiation_object_name") && _cht_boundary_names.empty())
    paramError("surface_radiation_object_name",
               "Surface radiation coupling requires at least one entry in 'cht_interfaces'.");
 
  const auto & thermal_resistance_names =
      getParam<std::vector<MooseFunctorName>>("thermal_resistance");
  if (thermal_resistance_names.size() != 1 &&
      thermal_resistance_names.size() != _cht_boundary_names.size())
    paramError("thermal_resistance",
               "Provide either one thermal resistance for all CHT interfaces or one value per "
               "entry in cht_interfaces.");
 
  _thermal_resistance.reserve(_cht_boundary_names.size());
  for (const auto bd_index : index_range(_cht_boundary_names))
  {
    const auto & thermal_resistance_name = thermal_resistance_names.size() == 1
                                               ? thermal_resistance_names[0]
                                               : thermal_resistance_names[bd_index];
    _thermal_resistance.push_back(&getFunctorByName<Real>(thermal_resistance_name));
  }
}

Member Function Documentation

◆ converged()

bool NS::FV::CHTHandler::converged ( ) const

Check if CHT iteration converged.

Definition at line 625 of file CHTHandler.C.

{
  if (_fpi_it >= _max_cht_fpi)
    return true;
 
  for (const auto i : index_range(_integrated_boundary_heat_flux))
  {
    const auto & boundary_flux = _integrated_boundary_heat_flux[i];
    const Real f1 = boundary_flux[0];
    const Real f2 = boundary_flux[1];
    const Real radiation_flux =
        _surface_radiation_uo ? _integrated_boundary_surface_radiation_heat_flux[i] : 0.0;
 
    // An interface whose fluxes are all zero after the first iteration is balanced. Skip it so
    // that the remaining interfaces are still checked.
    if (_fpi_it != 0 && f1 == 0.0 && f2 == 0.0 && radiation_flux == 0.0)
      continue;
 
    // Surface radiation leaves the solid but is not deposited in a transparent fluid, giving the
    // interface balance Q_s,out + Q_f,out - Q_rad,out = 0.
    const Real diff = std::abs(f1 + f2 - radiation_flux);
    const Real denom =
        std::max({std::fabs(f1), std::fabs(f2), std::fabs(radiation_flux), Real(1e-14)});
    const Real rel_diff = diff / denom;
 
    if (rel_diff >= _cht_heat_flux_tolerance)
      return false;
  }
 
  return _fpi_it;
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ deduceCHTBoundaryCoupling()

void NS::FV::CHTHandler::deduceCHTBoundaryCoupling ( )

Run error checks and make sure everything works.

Definition at line 144 of file CHTHandler.C.

{
  // CHTHandler is constructed with the segregated solve object, potentially before user objects
  // exist. Resolve the optional surface-radiation object here, during initial setup.
  _surface_radiation_uo = nullptr;
  _surface_radiation_boundary_ids.clear();
  if (isParamValid("surface_radiation_object_name"))
  {
    _surface_radiation_uo =
        &getUserObject<GrayLambertSurfaceRadiationBase>("surface_radiation_object_name");
    _surface_radiation_boundary_ids = _surface_radiation_uo->getSurfaceIDs();
 
    const bool has_cht_surface =
        std::any_of(_cht_boundary_ids.begin(),
                    _cht_boundary_ids.end(),
                    [this](const auto boundary_id)
                    { return _surface_radiation_boundary_ids.count(boundary_id); });
 
    if (!has_cht_surface)
      paramError("surface_radiation_object_name",
                 "The supplied surface-radiation user object does not contain any of the "
                 "boundaries listed in 'cht_interfaces'.");
  }
 
  if (_solid_energy_system->nVariables() != 1)
    mooseError("We should have only one variable in the solid energy system: ",
               _energy_system->name(),
               "! Right now we have: ",
               Moose::stringify(_solid_energy_system->getVariableNames()));
  if (_energy_system->nVariables() != 1)
    mooseError("We should have only one variable in the fluid energy system: ",
               _energy_system->name(),
               "! Right now we have: ",
               Moose::stringify(_energy_system->getVariableNames()));
  const std::vector<std::string> solid_fluid({"solid", "fluid"});
 
  // We do some setup at the beginning to make sure the container sizes are good
  _cht_system_numbers =
      std::vector<unsigned int>({_solid_energy_system->number(), _energy_system->number()});
  _cht_conduction_kernels = std::vector<LinearFVFluxKernel *>({nullptr, nullptr});
  _cht_boundary_conditions.clear();
  _cht_boundary_conditions.resize(_cht_boundary_names.size(), {nullptr, nullptr});
 
  // Populate the PM radiation system numbers
  if (!_pm_radiation_systems.empty())
  {
    for (const auto sys_i : index_range(_pm_radiation_systems))
      _cht_pm_radiation_system_numbers.push_back(_pm_radiation_systems[sys_i]->number());
 
    // Reserve space for _cht_pm_radiation_kernels based on the size of
    // _cht_pm_radiation_system_numbers
    _cht_pm_radiation_kernels.reserve(_cht_pm_radiation_system_numbers.size());
    // Reserve space for pm radiation boundary conditions
    _cht_pm_radiation_boundary_conditions.clear();
    _cht_pm_radiation_boundary_conditions.resize(
        _cht_boundary_names.size(),
        std::vector<LinearFVBoundaryCondition *>(_cht_pm_radiation_system_numbers.size(), nullptr));
  }
 
  const auto flux_relaxation_param_names =
      std::vector<std::string>({"cht_solid_flux_relaxation", "cht_fluid_flux_relaxation"});
  const auto temperature_relaxation_param_names = std::vector<std::string>(
      {"cht_solid_temperature_relaxation", "cht_fluid_temperature_relaxation"});
  _cht_flux_relaxation_factor.clear();
  _cht_flux_relaxation_factor.resize(2, std::vector<Real>(_cht_boundary_names.size(), 1.0));
  _cht_temperature_relaxation_factor.clear();
  _cht_temperature_relaxation_factor.resize(2, std::vector<Real>(_cht_boundary_names.size(), 1.0));
 
  for (const auto region_index : index_range(solid_fluid))
  {
    // First thing, we fetch the relaxation parameter values
    const auto & flux_param_value =
        getParam<std::vector<Real>>(flux_relaxation_param_names[region_index]);
    if (flux_param_value.empty() || (flux_param_value.size() != _cht_boundary_names.size()))
      paramError(flux_relaxation_param_names[region_index],
                 "The number of relaxation factors is not the same as the number of interfaces!");
 
    _cht_flux_relaxation_factor[region_index] = flux_param_value;
    // We have to do the range check here because the intput parameter check errors if the vector is
    // empty
    for (const auto param : _cht_flux_relaxation_factor[region_index])
      if (param <= 0 || param > 1.0)
        paramError(flux_relaxation_param_names[region_index],
                   "The relaxation parameter should be between 0 and 1!");
 
    const auto & temperature_param_value =
        getParam<std::vector<Real>>(temperature_relaxation_param_names[region_index]);
    if (temperature_param_value.empty() ||
        (temperature_param_value.size() != _cht_boundary_names.size()))
      paramError(temperature_relaxation_param_names[region_index],
                 "The number of relaxation factors is not the same as the number of interfaces!");
 
    _cht_temperature_relaxation_factor[region_index] = temperature_param_value;
    // We have to do the range check here because the intput parameter check errors if the vector is
    // empty
    for (const auto param : _cht_temperature_relaxation_factor[region_index])
      if (param <= 0 || param > 1.0)
        paramError(temperature_relaxation_param_names[region_index],
                   "The relaxation parameter should be between 0 and 1!");
 
    // We then fetch the conduction kernels
    std::vector<LinearFVFluxKernel *> flux_kernels;
    _app.theWarehouse()
        .query()
        .template condition<AttribSystem>("LinearFVFluxKernel")
        .template condition<AttribVar>(0)
        .template condition<AttribSysNum>(_cht_system_numbers[region_index])
        .queryInto(flux_kernels);
 
    // We then fetch the radiation conduction kernels in the fluid region
    if (!_pm_radiation_systems.empty() && region_index == 1)
      for (const auto sys_i : index_range(_pm_radiation_systems))
      {
        // We then fetch the radiation conduction kernels
        std::vector<LinearFVFluxKernel *> radiation_kernels;
        _app.theWarehouse()
            .query()
            .template condition<AttribSystem>("LinearFVFluxKernel")
            .template condition<AttribVar>(0)
            .template condition<AttribSysNum>(_cht_pm_radiation_system_numbers[sys_i])
            .queryInto(radiation_kernels);
 
        if (radiation_kernels.size() > 1)
          mooseError(
              "We already have a kernel that describes the participating media radiation diffusion "
              "with the name: ",
              radiation_kernels[0]->name(),
              ". Make sure that you have only one conduction kernel.");
        else if (radiation_kernels.empty())
          mooseError("We did not find a diffusion kernel for the participating media radiation "
                     "diffusion to compute the "
                     "radiative heat flux. Please add a diffusion kernel.");
        else
          _cht_pm_radiation_kernels.push_back(radiation_kernels[0]);
      }
 
    for (auto kernel : flux_kernels)
    {
      auto check_diff = dynamic_cast<LinearFVDiffusion *>(kernel);
      auto check_aniso_diff = dynamic_cast<LinearFVAnisotropicDiffusion *>(kernel);
      if (_cht_conduction_kernels[region_index] && (check_diff || check_aniso_diff))
        mooseError("We already have a kernel that describes the heat conduction for the ",
                   solid_fluid[region_index],
                   " domain: ",
                   _cht_conduction_kernels[region_index]->name(),
                   " We found another one with the name: ",
                   (check_diff ? check_diff->name() : check_aniso_diff->name()),
                   " Make sure that you have only one conduction kernel on the ",
                   solid_fluid[region_index],
                   " side!");
 
      if (check_diff || check_aniso_diff)
        _cht_conduction_kernels[region_index] = kernel;
    }
 
    // Then we check the boundary conditions, to make sure at least there is something defined
    // from both sides
    for (const auto bd_index : index_range(_cht_boundary_names))
    {
      const auto & boundary_name = _cht_boundary_names[bd_index];
      const auto boundary_id = _cht_boundary_ids[bd_index];
 
      std::vector<LinearFVBoundaryCondition *> bcs;
      _problem.getMooseApp()
          .theWarehouse()
          .query()
          .template condition<AttribSystem>("LinearFVBoundaryCondition")
          .template condition<AttribVar>(0)
          .template condition<AttribSysNum>(_cht_system_numbers[region_index])
          .template condition<AttribBoundaries>(boundary_id)
          .queryInto(bcs);
 
      // We then fetch the radiation conduction bcs in the fluid region (i.e MarshakBC in P1)
      if (!_pm_radiation_systems.empty() && region_index == 1)
        for (const auto sys_i : index_range(_pm_radiation_systems))
        {
          std::vector<LinearFVBoundaryCondition *> rad_bcs;
          _app.theWarehouse()
              .query()
              .template condition<AttribSystem>("LinearFVBoundaryCondition")
              .template condition<AttribVar>(0)
              .template condition<AttribSysNum>(_cht_pm_radiation_system_numbers[sys_i])
              .template condition<AttribBoundaries>(boundary_id)
              .queryInto(rad_bcs);
 
          if (!rad_bcs.empty())
            _cht_pm_radiation_boundary_conditions[bd_index][sys_i] = rad_bcs[0];
          else
            mooseError("No LinearFVBoundaryCondition found for the given boundary or system.");
        }
 
      if (bcs.size() != 1)
        mooseError("We found multiple or no boundary conditions for solid energy on boundary ",
                   boundary_name,
                   " (ID: ",
                   boundary_id,
                   "). Make sure you define exactly one for conjugate heat transfer applications!");
      _cht_boundary_conditions[bd_index][region_index] = bcs[0];
 
      if (!dynamic_cast<LinearFVCHTBCInterface *>(_cht_boundary_conditions[bd_index][region_index]))
        mooseError("The selected boundary condition cannot be used with CHT problems! Make sure it "
                   "inherits from LinearFVCHTBCInterface!");
    }
  }
}

Referenced by LinearAssemblySegregatedSolve::initialSetup().

◆ enabled()

bool NS::FV::CHTHandler::enabled ( ) const

inlinefinaloverridevirtual

Check if CHT treatment is needed.

Reimplemented from MooseObject.

Definition at line 182 of file CHTHandler.h.

{
  return !_cht_boundary_names.empty();
}

Referenced by LinearAssemblySegregatedSolve::initialSetup(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ incrementCHTIterators()

void NS::FV::CHTHandler::incrementCHTIterators ( )

inline

Increment CHT iterators in the loop.

Definition at line 194 of file CHTHandler.h.

{
  _fpi_it++;
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ initializeCHTCouplingFields()

void NS::FV::CHTHandler::initializeCHTCouplingFields ( )

Initialize the coupling fields for the conjugate heat transfer routines.

Definition at line 436 of file CHTHandler.C.

{
  // We seed the coupling fields directly from the current solution field on each side of the
  // interface, using the raw cell value adjacent to the face.
 
  for (const auto bd_index : index_range(_cht_boundary_ids))
  {
    const auto & bd_fi_container = _cht_face_info[bd_index];
    auto & temperature_container = _boundary_temperature[bd_index];
 
    for (const auto & fi : bd_fi_container)
    {
      const bool solid_on_elem = _solid_variable->hasFaceSide(*fi, true);
      const auto & solid_elem_info = solid_on_elem ? *fi->elemInfo() : *fi->neighborInfo();
      const Real solid_face_value =
          _solid_variable->getElemValue(solid_elem_info, Moose::currentState());
 
      const bool fluid_on_elem = _fluid_variable->hasFaceSide(*fi, true);
      const auto & fluid_elem_info = fluid_on_elem ? *fi->elemInfo() : *fi->neighborInfo();
      const Real fluid_face_value =
          _fluid_variable->getElemValue(fluid_elem_info, Moose::currentState());
 
      temperature_container[NS::CHTSide::FLUID][fi->id()] = solid_face_value;
      temperature_container[NS::CHTSide::SOLID][fi->id()] = fluid_face_value;
    }
  }
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ linkEnergySystems()

void NS::FV::CHTHandler::linkEnergySystems	(	SystemBase *	solid_energy_system,
		SystemBase *	fluid_energy_system,
		std::vector< SystemBase * >	pm_radiation_systems
	)

Link energy systems.

Definition at line 129 of file CHTHandler.C.

{
  _energy_system = fluid_energy_system;
  _solid_energy_system = solid_energy_system;
  _pm_radiation_systems = pm_radiation_systems;
 
  if (!_energy_system || !_solid_energy_system)
    paramError("cht_interfaces",
               "You selected to do conjugate heat transfer treatment, but it needs two energy "
               "systems: a solid and a fluid. One of these systems is missing.");
}

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve().

◆ printIntegratedFluxes()

void NS::FV::CHTHandler::printIntegratedFluxes ( ) const

Print the integrated heat fluxes.

Definition at line 598 of file CHTHandler.C.

{
  for (const auto i : index_range(_integrated_boundary_heat_flux))
  {
    auto & integrated_fluxes = _integrated_boundary_heat_flux[i];
    _console << " Iteration " << _fpi_it << " Boundary " << _cht_boundary_names[i]
             << " flux on solid side " << integrated_fluxes[NS::CHTSide::SOLID]
             << " flux on fluid side: " << integrated_fluxes[NS::CHTSide::FLUID];
    if (_surface_radiation_uo)
      _console << " net outward surface-radiation flux: "
               << _integrated_boundary_surface_radiation_heat_flux[i];
    _console << std::endl;
  }
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ resetCHTConvergence()

void NS::FV::CHTHandler::resetCHTConvergence ( )

inline

Reset the convergence data.

Definition at line 188 of file CHTHandler.h.

{
  _fpi_it = 0;
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ resetIntegratedFluxes()

void NS::FV::CHTHandler::resetIntegratedFluxes ( )

Reset the heat fluxes to 0.

Definition at line 614 of file CHTHandler.C.

{
  for (const auto i : index_range(_integrated_boundary_heat_flux))
  {
    _integrated_boundary_heat_flux[i] = std::vector<Real>({0.0, 0.0});
    if (_surface_radiation_uo)
      _integrated_boundary_surface_radiation_heat_flux[i] = 0.0;
  }
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ setupConjugateHeatTransferContainers()

void NS::FV::CHTHandler::setupConjugateHeatTransferContainers ( )

Set up the boundary condition pairs, functor maps, and every other necessary structure for the conjugate heat transfer routines.

Definition at line 351 of file CHTHandler.C.

{
  // We already error in initialSetup if we have more variables
  _fluid_variable =
      dynamic_cast<const MooseLinearVariableFVReal *>(&_energy_system->getVariable(0, 0));
  _solid_variable =
      dynamic_cast<const MooseLinearVariableFVReal *>(&_solid_energy_system->getVariable(0, 0));
 
  _cht_face_info.clear();
  _cht_face_info.resize(_cht_boundary_ids.size());
  _boundary_heat_flux.clear();
  _boundary_temperature.clear();
  _integrated_boundary_heat_flux.clear();
  _integrated_boundary_surface_radiation_heat_flux.clear();
 
  for (const auto bd_index : index_range(_cht_boundary_ids))
  {
    const auto bd_id = _cht_boundary_ids[bd_index];
    const auto & bd_name = _cht_boundary_names[bd_index];
 
    // We populate the face infos for every interface
    auto & bd_fi_container = _cht_face_info[bd_index];
    for (auto & fi : _problem.mesh().faceInfo())
      if (fi->boundaryIDs().count(bd_id))
        bd_fi_container.push_back(fi);
 
    // We do this because the coupling functors should be evaluated on both sides
    // of the interface and there are rigorous checks if the functors don't support a subdomain
    std::set<SubdomainID> combined_set;
    std::set_union(_solid_variable->blockIDs().begin(),
                   _solid_variable->blockIDs().end(),
                   _fluid_variable->blockIDs().begin(),
                   _fluid_variable->blockIDs().end(),
                   std::inserter(combined_set, combined_set.begin()));
 
    // We instantiate the coupling fuctors for heat flux and temperature
    FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>> solid_bd_flux(
        _problem.mesh(), combined_set, "heat_flux_to_solid_" + bd_name);
    FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>> fluid_bd_flux(
        _problem.mesh(), combined_set, "heat_flux_to_fluid_" + bd_name);
 
    _boundary_heat_flux.push_back(
        std::vector<FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>>>(
            {std::move(solid_bd_flux), std::move(fluid_bd_flux)}));
    auto & flux_container = _boundary_heat_flux.back();
 
    _integrated_boundary_heat_flux.push_back(std::vector<Real>({0.0, 0.0}));
    if (_surface_radiation_uo)
      _integrated_boundary_surface_radiation_heat_flux.push_back(0.0);
 
    FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>> solid_bd_temperature(
        _problem.mesh(), combined_set, "interface_temperature_to_solid_" + bd_name);
    FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>> fluid_bd_temperature(
        _problem.mesh(), combined_set, "interface_temperature_to_fluid_" + bd_name);
 
    _boundary_temperature.push_back(
        std::vector<FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>>>(
            {std::move(solid_bd_temperature), std::move(fluid_bd_temperature)}));
    auto & temperature_container = _boundary_temperature.back();
 
    // Time to register the functors on all of the threads
    for (const auto tid : make_range(_problem.numThreads()))
    {
      _problem.addFunctor("heat_flux_to_solid_" + bd_name, flux_container[NS::CHTSide::SOLID], tid);
      _problem.addFunctor("heat_flux_to_fluid_" + bd_name, flux_container[NS::CHTSide::FLUID], tid);
      _problem.addFunctor("interface_temperature_to_solid_" + bd_name,
                          temperature_container[NS::CHTSide::SOLID],
                          tid);
      _problem.addFunctor("interface_temperature_to_fluid_" + bd_name,
                          temperature_container[NS::CHTSide::FLUID],
                          tid);
    }
 
    // Initialize the containers, they will be filled with correct values soon.
    // Before any solve happens.
    for (const auto region_index : make_range(2))
      for (auto & fi : bd_fi_container)
      {
        flux_container[region_index][fi->id()] = 0.0;
        temperature_container[region_index][fi->id()] = 0.0;
      }
  }
}

Referenced by LinearAssemblySegregatedSolve::initialSetup().

◆ sumIntegratedFluxes()

void NS::FV::CHTHandler::sumIntegratedFluxes ( )

Sum the integrated fluxes over all processors.

Definition at line 585 of file CHTHandler.C.

{
  for (const auto i : index_range(_integrated_boundary_heat_flux))
  {
    auto & integrated_fluxes = _integrated_boundary_heat_flux[i];
    _problem.comm().sum(integrated_fluxes[NS::CHTSide::SOLID]);
    _problem.comm().sum(integrated_fluxes[NS::CHTSide::FLUID]);
    if (_surface_radiation_uo)
      _problem.comm().sum(_integrated_boundary_surface_radiation_heat_flux[i]);
  }
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ updateCHTBoundaryCouplingFields()

void NS::FV::CHTHandler::updateCHTBoundaryCouplingFields ( const NS::CHTSide side )

Update the coupling fields for.

Parameters

side

Definition at line 465 of file CHTHandler.C.

{
  // Well we can just use the face that this enum casts into int very nicely
  // we can use it to get the index of the other side
  const NS::CHTSide other_side = static_cast<NS::CHTSide>(1 - side);
 
  for (const auto bd_index : index_range(_cht_boundary_ids))
  {
    auto & other_bc = _cht_boundary_conditions[bd_index][other_side];
    auto & other_kernel = _cht_conduction_kernels[other_side];
 
    // We get the relaxation from the other side, so if we are fluid side we get the solid
    // relaxation. Use each field's matching relaxation-factor family.
    const auto temperature_relaxation = _cht_temperature_relaxation_factor[other_side][bd_index];
    const auto flux_relaxation = _cht_flux_relaxation_factor[other_side][bd_index];
 
    // Fetching the right container here, if side is fluid we fetch "heat_flux_to_fluid"
    auto & flux_container = _boundary_heat_flux[bd_index][side];
    // Fetch the effective interface temperature supplied to this side.
    auto & temperature_container = _boundary_temperature[bd_index][side];
    // We will also update the integrated flux for output info
    auto & integrated_flux = _integrated_boundary_heat_flux[bd_index][side];
    // We are recomputing this so, time to zero this out
    integrated_flux = 0.0;
 
    // GrayLambertSurfaceRadiationBase returns one sideset-averaged net outward flux density.
    // It is therefore constant over all FaceInfo objects belonging to this CHT patch.
    Real surface_radiation_flux = 0.0;
    if (_surface_radiation_uo)
    {
      _integrated_boundary_surface_radiation_heat_flux[bd_index] = 0.0;
      if (_surface_radiation_boundary_ids.count(_cht_boundary_ids[bd_index]))
        surface_radiation_flux =
            _surface_radiation_uo->getSurfaceHeatFluxDensity(_cht_boundary_ids[bd_index]);
    }
 
    const auto & bd_fi_container = _cht_face_info[bd_index];
 
    // We enter the face loop to update the coupling fields
    for (const auto & fi : bd_fi_container)
    {
      other_kernel->setupFaceData(fi);
      // We will want the flux in W/m2 for the coupling so no face integral for now,
      // this can cause issues if we start using face area in the kernels
      // for more than just face integral multipliers.
      // Also, if we decide to not require overlapping meshes on the boundary
      // this will probably have to change.
      other_kernel->setCurrentFaceArea(1.0);
      other_bc->setupFaceData(fi, fi->faceType(std::make_pair(0, _cht_system_numbers[other_side])));
 
      const auto boundary_temperature = other_bc->computeBoundaryValue();
 
      const auto & resistance_functor = *_thermal_resistance[bd_index];
      const auto on_elem = resistance_functor.hasFaceSide(*fi, true);
      const auto on_neighbor = resistance_functor.hasFaceSide(*fi, false);
 
      if (!on_elem && !on_neighbor)
        mooseError("The thermal resistance functor '",
                   resistance_functor.functorName(),
                   "' is not defined on either side of CHT interface '",
                   _cht_boundary_names[bd_index],
                   "'.");
 
      auto resistance_face_arg = Moose::FaceArg{
          fi, Moose::FV::LimiterType::CentralDifference, true, false, nullptr, nullptr};
 
      if (on_elem != on_neighbor)
        resistance_face_arg.face_side = on_elem ? fi->elemPtr() : fi->neighborPtr();
 
      const auto thermal_resistance =
          resistance_functor(resistance_face_arg, Moose::currentState());
 
      if (thermal_resistance < 0.0)
        paramError("thermal_resistance", "Thermal resistance must be non-negative.");
 
      // Flux_new = relaxation * Flux_boundary + (1-relaxation) * Flux_old,
      // minus sign is due to the normal differences
 
      // Conductive flux
      auto source_flux = other_kernel->computeBoundaryFlux(*other_bc);
 
      // If participating media radiation system exists we add the heat flux from the fluid
      // to the solid region.
      if (!_pm_radiation_systems.empty() && side == NS::CHTSide::SOLID)
        for (const auto sys_i : index_range(_pm_radiation_systems))
        {
          _cht_pm_radiation_kernels[sys_i]->setupFaceData(fi);
          _cht_pm_radiation_kernels[sys_i]->setCurrentFaceArea(1.0);
          _cht_pm_radiation_boundary_conditions[bd_index][sys_i]->setupFaceData(
              fi, fi->faceType(std::make_pair(0, _cht_pm_radiation_system_numbers[sys_i])));
          source_flux += _cht_pm_radiation_kernels[sys_i]->computeBoundaryFlux(
              *_cht_pm_radiation_boundary_conditions[bd_index][sys_i]);
        }
 
      // source_flux is positive outward from the source domain, while surface_radiation_flux is
      // positive outward from the solid. The coupling functor is positive into the receiving
      // domain, so subtract the surface-to-surface radiation that bypasses the transparent fluid.
      const Real coupling_flux = source_flux - surface_radiation_flux;
      const auto relaxed_flux =
          flux_relaxation * coupling_flux + (1 - flux_relaxation) * flux_container[fi->id()];
      flux_container[fi->id()] = relaxed_flux;
 
      // Store the temperature seen by this side after the thermal resistance drop.
      // The minus sign matches the source-side outward-flux convention used here.
      temperature_container[fi->id()] =
          temperature_relaxation * (boundary_temperature - thermal_resistance * relaxed_flux) +
          (1 - temperature_relaxation) * temperature_container[fi->id()];
 
      // Integrate the source-domain and surface-radiation fluxes separately. This avoids counting
      // surface radiation twice when coupling fields are updated in both directions.
      const Real coordinate_area = fi->faceArea() * fi->faceCoord();
      integrated_flux += source_flux * coordinate_area;
      if (_surface_radiation_uo)
        _integrated_boundary_surface_radiation_heat_flux[bd_index] +=
            surface_radiation_flux * coordinate_area;
    }
  }
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ validParams()

InputParameters NS::FV::CHTHandler::validParams ( )

static

Definition at line 26 of file CHTHandler.C.

{
  auto params = emptyInputParameters();
  params += UserObjectInterface::validParams();
  params += NonADFunctorInterface::validParams();
  params.addParam<std::vector<BoundaryName>>(
      "cht_interfaces",
      {},
      "The interfaces where we would like to add conjugate heat transfer handling.");
 
  params.addRangeCheckedParam<unsigned int>(
      "max_cht_fpi",
      1,
      "max_cht_fpi >= 1",
      "Number of maximum fixed point iterations (FPI). Currently only applied to"
      " conjugate heat transfer simulations. The default value of 1 essentially keeps"
      " the FPI feature turned off. CHT iteration ends after this number of iteration even if the "
      "tolerance is not met.");
 
  params.addRangeCheckedParam<Real>(
      "cht_heat_flux_tolerance",
      1e-5,
      "cht_heat_flux_tolerance > 0 & cht_heat_flux_tolerance <= 1.0",
      "The relative tolerance for terminating conjugate heat transfer iteration before the maximum "
      "number of CHT iterations. Relative tolerance is ignore if the maximum number of CHT "
      "iterations is reached.");
 
  params.addParam<std::vector<Real>>(
      "cht_fluid_temperature_relaxation",
      {},
      "The relaxation factors for the boundary temperature when being updated on the fluid side.");
  params.addParam<std::vector<Real>>(
      "cht_solid_temperature_relaxation",
      {},
      "The relaxation factors for the boundary temperature when being updated on the solid side.");
  params.addParam<std::vector<Real>>(
      "cht_fluid_flux_relaxation",
      {},
      "The relaxation factors for the boundary flux when being updated on the fluid side.");
  params.addParam<std::vector<Real>>(
      "cht_solid_flux_relaxation",
      {},
      "The relaxation factors for the boundary flux when being updated on the solid side.");
  params.addParam<UserObjectName>(
      "surface_radiation_object_name",
      "Name of the Gray-Lambert surface-radiation user object. On matching CHT interfaces, "
      "its net outward heat flux density is removed from the heat flux transferred to the "
      "receiving domain.");
 
  params.addParam<std::vector<MooseFunctorName>>(
      "thermal_resistance",
      std::vector<MooseFunctorName>({"0"}),
      "The custom area-normalized thermal resistance at each interface, in m^2*K/W. "
      "Provide one value to use for all CHT interfaces or one value per entry in "
      "cht_interfaces.");
 
  params.addParamNamesToGroup(
      "cht_interfaces max_cht_fpi cht_heat_flux_tolerance cht_fluid_temperature_relaxation "
      "cht_solid_temperature_relaxation cht_fluid_flux_relaxation "
      "cht_solid_flux_relaxation surface_radiation_object_name thermal_resistance",
      "Conjugate Heat Transfer");
 
  return params;
}

Referenced by LinearAssemblySegregatedSolve::validParams().

Member Data Documentation

◆ _boundary_effective_temperature

std::vector<std::vector<FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real> > > > NS::FV::CHTHandler::_boundary_effective_temperature

protected

Functors describing the effective wall temperatures after applying thermal resistance.

Two functors per sideset, first is the temperature seen by the solid, second by the fluid.

Definition at line 174 of file CHTHandler.h.

◆ _boundary_heat_flux

std::vector<std::vector<FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real> > > > NS::FV::CHTHandler::_boundary_heat_flux

protected

Functors describing the heat flux on the conjugate heat transfer interfaces.

Two functors per sideset, first is solid second is fluid.

Definition at line 157 of file CHTHandler.h.

Referenced by setupConjugateHeatTransferContainers(), and updateCHTBoundaryCouplingFields().

◆ _boundary_temperature

std::vector<std::vector<FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real> > > > NS::FV::CHTHandler::_boundary_temperature

protected

Functors describing the raw wall temperatures on the conjugate heat transfer interfaces.

Two functors per sideset, first is solid second is fluid.

Definition at line 169 of file CHTHandler.h.

Referenced by initializeCHTCouplingFields(), setupConjugateHeatTransferContainers(), and updateCHTBoundaryCouplingFields().

◆ _cht_boundary_conditions

std::vector<std::vector<LinearFVBoundaryCondition *> > NS::FV::CHTHandler::_cht_boundary_conditions

protected

Vector of boundary conditions that describe the conjugate heat transfer from each side.

Definition at line 149 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _cht_boundary_ids

std::vector<BoundaryID> NS::FV::CHTHandler::_cht_boundary_ids

protected

The IDs of the CHT boundaries.

Definition at line 108 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), initializeCHTCouplingFields(), setupConjugateHeatTransferContainers(), and updateCHTBoundaryCouplingFields().

◆ _cht_boundary_names

std::vector<BoundaryName> NS::FV::CHTHandler::_cht_boundary_names

protected

The names of the CHT boundaries.

Definition at line 105 of file CHTHandler.h.

Referenced by CHTHandler(), deduceCHTBoundaryCoupling(), enabled(), printIntegratedFluxes(), setupConjugateHeatTransferContainers(), and updateCHTBoundaryCouplingFields().

◆ _cht_conduction_kernels

std::vector<LinearFVFluxKernel *> NS::FV::CHTHandler::_cht_conduction_kernels

protected

The conduction kernels from the solid/fluid domains. Can't be const, considering we are updating the inner structures for every face.

Definition at line 143 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _cht_face_info

std::vector<std::vector<const FaceInfo *> > NS::FV::CHTHandler::_cht_face_info

protected

The subset of the FaceInfo objects that belong to the given boundaries.

Definition at line 140 of file CHTHandler.h.

Referenced by initializeCHTCouplingFields(), setupConjugateHeatTransferContainers(), and updateCHTBoundaryCouplingFields().

◆ _cht_flux_relaxation_factor

std::vector<std::vector<Real> > NS::FV::CHTHandler::_cht_flux_relaxation_factor

protected

The relaxation factors for flux fields for the CHT boundaries first index is solid/fluid second is the interface.

Definition at line 127 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _cht_heat_flux_tolerance

const Real NS::FV::CHTHandler::_cht_heat_flux_tolerance

protected

Tolerance for heat flux at the CHT interfaces.

Definition at line 114 of file CHTHandler.h.

Referenced by converged().

◆ _cht_pm_radiation_boundary_conditions

std::vector<std::vector<LinearFVBoundaryCondition *> > NS::FV::CHTHandler::_cht_pm_radiation_boundary_conditions

protected

Vector of boundary conditions that describe the radiation pm bcs from each side.

Definition at line 152 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _cht_pm_radiation_kernels

std::vector<LinearFVFluxKernel *> NS::FV::CHTHandler::_cht_pm_radiation_kernels

protected

The conduction radiation kernels from the fluid domains.

Definition at line 146 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _cht_pm_radiation_system_numbers

std::vector<unsigned int> NS::FV::CHTHandler::_cht_pm_radiation_system_numbers

protected

The participating media radiation system numbers.

Definition at line 137 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _cht_system_numbers

std::vector<unsigned int> NS::FV::CHTHandler::_cht_system_numbers

protected

The solid (0) and fluid (1) system numbers.

Definition at line 134 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _cht_temperature_relaxation_factor

std::vector<std::vector<Real> > NS::FV::CHTHandler::_cht_temperature_relaxation_factor

protected

The relaxation factors for temperature fields for the CHT boundaries first index is solid/fluid second is the interface.

Definition at line 131 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _energy_system

SystemBase* NS::FV::CHTHandler::_energy_system

protected

The energy system.

Definition at line 90 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), linkEnergySystems(), and setupConjugateHeatTransferContainers().

◆ _fluid_variable

const MooseLinearVariableFVReal* NS::FV::CHTHandler::_fluid_variable = nullptr

protected

The fluid-side temperature variable.

Definition at line 99 of file CHTHandler.h.

Referenced by initializeCHTCouplingFields(), and setupConjugateHeatTransferContainers().

◆ _fpi_it

unsigned int NS::FV::CHTHandler::_fpi_it

private

CHT fixed point iteration counter.

Definition at line 178 of file CHTHandler.h.

Referenced by converged(), incrementCHTIterators(), printIntegratedFluxes(), and resetCHTConvergence().

◆ _integrated_boundary_heat_flux

std::vector<std::vector<Real> > NS::FV::CHTHandler::_integrated_boundary_heat_flux

protected

Integrated source-domain flux for each boundary and solid/fluid transfer direction.

Definition at line 160 of file CHTHandler.h.

Referenced by converged(), printIntegratedFluxes(), resetIntegratedFluxes(), setupConjugateHeatTransferContainers(), sumIntegratedFluxes(), and updateCHTBoundaryCouplingFields().

◆ _integrated_boundary_surface_radiation_heat_flux

std::vector<Real> NS::FV::CHTHandler::_integrated_boundary_surface_radiation_heat_flux

protected

Integrated net outward surface-radiation flux, kept separate for the CHT energy balance.

Only populated when a surface-radiation user object is supplied.

Definition at line 164 of file CHTHandler.h.

Referenced by converged(), printIntegratedFluxes(), resetIntegratedFluxes(), setupConjugateHeatTransferContainers(), sumIntegratedFluxes(), and updateCHTBoundaryCouplingFields().

◆ _max_cht_fpi

const unsigned int NS::FV::CHTHandler::_max_cht_fpi

protected

Maximum number of CHT fixed point iterations.

Definition at line 111 of file CHTHandler.h.

Referenced by converged().

◆ _mesh

MooseMesh& NS::FV::CHTHandler::_mesh

protected

Mesh.

Definition at line 87 of file CHTHandler.h.

◆ _pm_radiation_systems

std::vector<SystemBase *> NS::FV::CHTHandler::_pm_radiation_systems

protected

The solid energy system.

Definition at line 96 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), linkEnergySystems(), and updateCHTBoundaryCouplingFields().

◆ _problem

FEProblemBase& NS::FV::CHTHandler::_problem

protected

Reference to FEProblem.

Definition at line 84 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), setupConjugateHeatTransferContainers(), and sumIntegratedFluxes().

◆ _solid_energy_system

SystemBase* NS::FV::CHTHandler::_solid_energy_system

protected

The solid energy system.

Definition at line 93 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), linkEnergySystems(), and setupConjugateHeatTransferContainers().

◆ _solid_variable

const MooseLinearVariableFVReal* NS::FV::CHTHandler::_solid_variable = nullptr

protected

The solid-side temperature variable.

Definition at line 102 of file CHTHandler.h.

Referenced by initializeCHTCouplingFields(), and setupConjugateHeatTransferContainers().

◆ _surface_radiation_boundary_ids

std::set<BoundaryID> NS::FV::CHTHandler::_surface_radiation_boundary_ids

protected

Boundaries represented by the surface-to-surface radiation model.

Definition at line 120 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _surface_radiation_uo

const GrayLambertSurfaceRadiationBase* NS::FV::CHTHandler::_surface_radiation_uo

protected

Optional surface-to-surface radiation model supplying net outward wall heat fluxes.

Definition at line 117 of file CHTHandler.h.

Referenced by converged(), deduceCHTBoundaryCoupling(), printIntegratedFluxes(), resetIntegratedFluxes(), setupConjugateHeatTransferContainers(), sumIntegratedFluxes(), and updateCHTBoundaryCouplingFields().

◆ _thermal_resistance

std::vector<const Moose::Functor<Real> *> NS::FV::CHTHandler::_thermal_resistance

protected

Thermal resistance functors, one per CHT interface.

Definition at line 123 of file CHTHandler.h.

Referenced by CHTHandler(), and updateCHTBoundaryCouplingFields().

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

navier_stokes/include/utils/CHTHandler.h
navier_stokes/src/utils/CHTHandler.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CHTHandler()

Member Function Documentation

◆ converged()

◆ deduceCHTBoundaryCoupling()

◆ enabled()

◆ incrementCHTIterators()

◆ initializeCHTCouplingFields()

◆ linkEnergySystems()

◆ printIntegratedFluxes()

◆ resetCHTConvergence()

◆ resetIntegratedFluxes()

◆ setupConjugateHeatTransferContainers()

◆ sumIntegratedFluxes()

◆ updateCHTBoundaryCouplingFields()

◆ validParams()

Member Data Documentation

◆ _boundary_effective_temperature

◆ _boundary_heat_flux

◆ _boundary_temperature

◆ _cht_boundary_conditions

◆ _cht_boundary_ids

◆ _cht_boundary_names

◆ _cht_conduction_kernels

◆ _cht_face_info

◆ _cht_flux_relaxation_factor

◆ _cht_heat_flux_tolerance

◆ _cht_pm_radiation_boundary_conditions

◆ _cht_pm_radiation_kernels

◆ _cht_pm_radiation_system_numbers

◆ _cht_system_numbers

◆ _cht_temperature_relaxation_factor

◆ _energy_system

◆ _fluid_variable

◆ _fpi_it

◆ _integrated_boundary_heat_flux

◆ _integrated_boundary_surface_radiation_heat_flux

◆ _max_cht_fpi

◆ _mesh

◆ _pm_radiation_systems

◆ _problem

◆ _solid_energy_system

◆ _solid_variable

◆ _surface_radiation_boundary_ids

◆ _surface_radiation_uo

◆ _thermal_resistance