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

Static Public Member Functions
static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	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

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.

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.

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 flux for the boundaries, first index is the boundary second is solid/fluid.

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

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

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

Detailed Description

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

Definition at line 29 of file CHTHandler.h.

Constructor & Destructor Documentation

◆ CHTHandler()

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

Constructor with initialization parameters.

Definition at line 76 of file CHTHandler.C.

  : MooseObject(params),
    _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"))
{
  if (isParamSetByUser("cht_interfaces") && !_cht_boundary_names.size())
    paramError("cht_interfaces", "You must declare at least one interface!");
}

Member Function Documentation

◆ converged()

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

Check if CHT iteration converged.

Definition at line 495 of file CHTHandler.C.

{
  if (_fpi_it >= _max_cht_fpi)
    return true;
 
  for (const auto & boundary_flux : _integrated_boundary_heat_flux)
  {
    const Real f1 = boundary_flux[0];
    const Real f2 = boundary_flux[1];
 
    // Special case: both are zero at startup not converged yet
    if (_fpi_it != 0 && (f1 == 0.0 && f2 == 0.0))
      return true;
 
    // These fluxes should be of opposite sign
    const Real diff = std::abs(f1 + f2);
    const Real denom = std::max({std::fabs(f1), std::fabs(f2), 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 106 of file CHTHandler.C.

{
  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 152 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 164 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 371 of file CHTHandler.C.

{
  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 region_index : make_range(2))
    {
      // Can't be const considering we will update members from here
      auto bc = _cht_boundary_conditions[bd_index][region_index];
      for (const auto & fi : bd_fi_container)
      {
        bc->setupFaceData(fi, fi->faceType(std::make_pair(0, _cht_system_numbers[region_index])));
        temperature_container[1 - region_index][fi->id()] = bc->computeBoundaryValue();
      }
    }
  }
}

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 91 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 476 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] << std::endl;
  }
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ resetCHTConvergence()

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

inline

Reset the convergence data.

Definition at line 158 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 488 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});
}

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 291 of file CHTHandler.C.

{
  // We already error in initialSetup if we have more variables
  const auto * fluid_variable =
      dynamic_cast<const MooseLinearVariableFVReal *>(&_energy_system->getVariable(0, 0));
  const auto * 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();
 
  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}));
 
    FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>> solid_bd_temperature(
        _problem.mesh(), combined_set, "interface_temperature_solid_" + bd_name);
    FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>> fluid_bd_temperature(
        _problem.mesh(), combined_set, "interface_temperature_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(libMesh::n_threads()))
    {
      _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_solid_" + bd_name, temperature_container[NS::CHTSide::SOLID], tid);
      _problem.addFunctor(
          "interface_temperature_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 465 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]);
  }
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ updateCHTBoundaryCouplingFields()

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

Update the coupling fields for.

Parameters

side

Definition at line 392 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
    const auto temperature_relaxation = _cht_flux_relaxation_factor[other_side][bd_index];
    const auto flux_relaxation = _cht_temperature_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];
    // Fetching the other side's contaienr here, if side is fluid we fetch the solid temperature
    auto & temperature_container = _boundary_temperature[bd_index][other_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;
 
    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])));
 
      // T_new = relaxation * T_boundary + (1-relaxation) * T_old
      temperature_container[fi->id()] =
          temperature_relaxation * other_bc->computeBoundaryValue() +
          (1 - temperature_relaxation) * temperature_container[fi->id()];
 
      // Flux_new = relaxation * Flux_boundary + (1-relaxation) * Flux_old,
      // minus sign is due to the normal differences
 
      // Conductive flux
      auto 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])));
          flux += _cht_pm_radiation_kernels[sys_i]->computeBoundaryFlux(
              *_cht_pm_radiation_boundary_conditions[bd_index][sys_i]);
        }
 
      flux_container[fi->id()] =
          flux_relaxation * flux + (1 - flux_relaxation) * flux_container[fi->id()];
 
      // We do the integral here
      integrated_flux += flux * fi->faceArea() * fi->faceCoord();
    }
  }
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ validParams()

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

static

Definition at line 25 of file CHTHandler.C.

{
  auto params = emptyInputParameters();
  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.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",
      "Conjugate Heat Transfer");
 
  return params;
}

Referenced by LinearAssemblySegregatedSolve::validParams().

Member Data Documentation

◆ _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 136 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 heat flux on the conjugate heat transfer interfaces.

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

Definition at line 144 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 128 of file CHTHandler.h.

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

◆ _cht_boundary_ids

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

protected

The IDs of the CHT boundaries.

Definition at line 96 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 93 of file CHTHandler.h.

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

◆ _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 122 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 119 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 106 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 102 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 131 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 125 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 116 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 113 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), initializeCHTCouplingFields(), 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 110 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _energy_system

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

protected

The energy system.

Definition at line 84 of file CHTHandler.h.

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

◆ _fpi_it

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

private

CHT fixed point iteration counter.

Definition at line 148 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 flux for the boundaries, first index is the boundary second is solid/fluid.

Definition at line 139 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 99 of file CHTHandler.h.

Referenced by converged().

◆ _mesh

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

protected

Mesh.

Definition at line 81 of file CHTHandler.h.

◆ _pm_radiation_systems

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

protected

The solid energy system.

Definition at line 90 of file CHTHandler.h.

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

◆ _problem

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

protected

Reference to FEProblem.

Definition at line 78 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 87 of file CHTHandler.h.

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

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

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_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

◆ _fpi_it

◆ _integrated_boundary_heat_flux

◆ _max_cht_fpi

◆ _mesh

◆ _pm_radiation_systems

◆ _problem

◆ _solid_energy_system