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. More...

void	linkEnergySystems (SystemBase solid_energy_system, SystemBase fluid_energy_system)
	Link energy systems. More...

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

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

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

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

bool	converged () const
	Check if CHT iteration converged. More...

void	resetCHTConvergence ()
	Reset the convergence data. More...

void	incrementCHTIterators ()
	Increment CHT iterators in the loop. More...

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

void	printIntegratedFluxes () const
	Print the integrated heat fluxes. More...

void	resetIntegratedFluxes ()
	Reset the heat fluxes to 0. More...

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

std::shared_ptr< MooseObject >	getSharedPtr ()

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

bool	isKokkosObject (IsKokkosObjectKey &&) 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	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) 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)

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. More...

MooseMesh &	_mesh
	Mesh. More...

SystemBase *	_energy_system
	The energy system. More...

SystemBase *	_solid_energy_system
	The solid energy system. More...

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

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

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

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

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. More...

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. More...

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

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

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. More...

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

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. More...

std::vector< std::vector< Real > >	_integrated_boundary_heat_flux
	Integrated flux for the boundaries, first index is the boundary second is solid/fluid. More...

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. More...

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

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

Referenced by LinearAssemblySegregatedSolve::solve().

 {
   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;
 }

◆ deduceCHTBoundaryCoupling()

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

Run error checks and make sure everything works.

Definition at line 103 of file CHTHandler.C.

Referenced by LinearAssemblySegregatedSolve::initialSetup().

 {
   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});
 
   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);
 
     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);
 
       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!");
     }
   }
 }

◆ enabled()

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

inlinefinaloverridevirtual

Check if CHT treatment is needed.

Reimplemented from MooseObject.

Definition at line 138 of file CHTHandler.h.

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

 {
   return !_cht_boundary_names.empty();
 }

◆ incrementCHTIterators()

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

inline

Increment CHT iterators in the loop.

Definition at line 150 of file CHTHandler.h.

Referenced by LinearAssemblySegregatedSolve::solve().

 {
   _fpi_it++;
 }

◆ initializeCHTCouplingFields()

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

Initialize the coupling fields for the conjugate heat transfer routines.

Definition at line 306 of file CHTHandler.C.

Referenced by LinearAssemblySegregatedSolve::solve().

 {
   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();
       }
     }
   }
 }

◆ linkEnergySystems()

void NS::FV::CHTHandler::linkEnergySystems	(	SystemBase *	solid_energy_system,
		SystemBase *	fluid_energy_system
	)

Link energy systems.

Definition at line 91 of file CHTHandler.C.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve().

 {
   _energy_system = fluid_energy_system;
   _solid_energy_system = solid_energy_system;
 
   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.");
 }

◆ printIntegratedFluxes()

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

Print the integrated heat fluxes.

Definition at line 396 of file CHTHandler.C.

Referenced by LinearAssemblySegregatedSolve::solve().

 {
   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;
   }
 }

◆ resetCHTConvergence()

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

inline

Reset the convergence data.

Definition at line 144 of file CHTHandler.h.

Referenced by LinearAssemblySegregatedSolve::solve().

 {
   _fpi_it = 0;
 }

◆ resetIntegratedFluxes()

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

Reset the heat fluxes to 0.

Definition at line 408 of file CHTHandler.C.

Referenced by LinearAssemblySegregatedSolve::solve().

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

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

Referenced by LinearAssemblySegregatedSolve::initialSetup().

 {
   // 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;
       }
   }
 }

◆ sumIntegratedFluxes()

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

Sum the integrated fluxes over all processors.

Definition at line 385 of file CHTHandler.C.

Referenced by LinearAssemblySegregatedSolve::solve().

 {
   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]);
   }
 }

◆ updateCHTBoundaryCouplingFields()

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

Update the coupling fields for.

Parameters

side

Definition at line 327 of file CHTHandler.C.

Referenced by LinearAssemblySegregatedSolve::solve().

 {
   // 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
       const auto flux = flux_relaxation * other_kernel->computeBoundaryFlux(*other_bc) +
                         (1 - flux_relaxation) * flux_container[fi->id()];
 
       flux_container[fi->id()] = flux;
 
       // We do the integral here
       integrated_flux += flux * fi->faceArea() * fi->faceCoord();
     }
   }
 }

◆ validParams()

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

static

Definition at line 25 of file CHTHandler.C.

Referenced by LinearAssemblySegregatedSolve::validParams().

 {
   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;
 }

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 122 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 130 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 117 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 91 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 88 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 114 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 111 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 101 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 97 of file CHTHandler.h.

Referenced by converged().

◆ _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 108 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 105 of file CHTHandler.h.

Referenced by deduceCHTBoundaryCoupling(), and updateCHTBoundaryCouplingFields().

◆ _energy_system

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

protected

The energy system.

Definition at line 82 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 134 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 125 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 94 of file CHTHandler.h.

Referenced by converged().

◆ _mesh

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

protected

Mesh.

Definition at line 79 of file CHTHandler.h.

◆ _problem

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

protected

Reference to FEProblem.

Definition at line 76 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 85 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

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_system_numbers

◆ _cht_temperature_relaxation_factor

◆ _energy_system

◆ _fpi_it

◆ _integrated_boundary_heat_flux

◆ _max_cht_fpi

◆ _mesh

◆ _problem

◆ _solid_energy_system