ComputeFVFluxResidualThread< RangeType > Class Template Reference

#include <ComputeFVFluxThread.h>

Inheritance diagram for ComputeFVFluxResidualThread< RangeType >:

Public Member Functions
	ComputeFVFluxResidualThread (FEProblemBase &fe_problem, const unsigned int nl_system_num, const std::set< TagID > &tags, bool on_displaced)
	ComputeFVFluxResidualThread (ComputeFVFluxResidualThread &x, Threads::split split)
virtual void	onFace (const FaceInfo &fi) override
virtual void	pre () override
	This is called once before all face-looping. More...
virtual void	post () override
	This is called once after all face-looping is finished. More...
virtual void	onBoundary (const FaceInfo &fi, BoundaryID boundary) override
	This is called once for every face that is on a boundary after onFace is called for the face. More...
virtual void	subdomainChanged () override
	Called every time the current subdomain changes (i.e. More...
virtual void	neighborSubdomainChanged () override
	Called every time the neighbor subdomain changes (i.e. More...
virtual void	operator() (const RangeType &range, bool bypass_threading=false)
void	join (const ThreadedFaceLoop &y)
void	caughtMooseException (MooseException &e)
	Called if a MooseException is caught anywhere during the computation. More...

Protected Member Functions
void	postFace (const FaceInfo &fi) override
	This is called once for each face after all face and boundary callbacks have been finished for that face. More...
void	compute (FVFaceResidualObject &ro, const FaceInfo &fi) override
	call either computeResidual, computeJacobian, or computeResidualAndJacobian on the provided residual object depending on what derived class of this class is instantiated More...
void	setup (SetupInterface &obj) override
	call either residualSetup or jacobianSetup depending on what derived class of this class is instantiated More...
void	addCached () override
	call either addCachedJacobian or addCachedResidual or both depending on what derived class of this class is instantiated More...
void	resetExecutionPrinting ()
	Reset lists of blocks and boundaries for which execution printing has been done. More...

Protected Attributes
unsigned int	_num_cached
FEProblemBase &	_fe_problem
MooseMesh &	_mesh
const std::set< TagID > &	_tags
THREAD_ID	_tid
const unsigned int	_nl_system_num
const bool	_on_displaced
	Whether this loop is operating on the displaced mesh. More...
SubProblem &	_subproblem
	FEProblemBase or DisplacedProblem depending on _on_displaced. More...
SubdomainID	_subdomain
	The subdomain for the current element. More...
SubdomainID	_old_subdomain
	The subdomain for the last element. More...
SubdomainID	_neighbor_subdomain
	The subdomain for the current neighbor. More...
SubdomainID	_old_neighbor_subdomain
	The subdomain for the last neighbor. More...
std::set< std::pair< const SubdomainID, const SubdomainID > >	_blocks_exec_printed
	Set to keep track of blocks for which we have printed the execution pattern. More...
std::set< BoundaryID >	_boundaries_exec_printed
	Set to keep track of boundaries for which we have printed the execution pattern. More...
std::string	_error_message
	Holds caught runtime error messages. More...

Detailed Description

template<typename RangeType>
class ComputeFVFluxResidualThread< RangeType >

Definition at line 818 of file ComputeFVFluxThread.h.

Constructor & Destructor Documentation

ComputeFVFluxResidualThread() [1/2]

template<typename RangeType >

ComputeFVFluxResidualThread< RangeType >::ComputeFVFluxResidualThread	(	FEProblemBase &	fe_problem,
		const unsigned int	nl_system_num,
		const std::set< TagID > &	tags,
		bool	on_displaced
	)

Definition at line 842 of file ComputeFVFluxThread.h.

  : ComputeFVFluxThread<RangeType, AttribVectorTags>(fe_problem, nl_system_num, tags, on_displaced)
{
}

ComputeFVFluxResidualThread() [2/2]

template<typename RangeType >

ComputeFVFluxResidualThread< RangeType >::ComputeFVFluxResidualThread	(	ComputeFVFluxResidualThread< RangeType > &	x,
		Threads::split	split
	)

Definition at line 852 of file ComputeFVFluxThread.h.

  : ComputeFVFluxThread<RangeType, AttribVectorTags>(x, split)
{
}

Member Function Documentation

addCached()

template<typename RangeType>

void ComputeFVFluxResidualThread< RangeType >::addCached ( )

inlineoverrideprotectedvirtual

call either addCachedJacobian or addCachedResidual or both depending on what derived class of this class is instantiated

Implements ComputeFVFluxThread< RangeType, AttribVectorTags >.

Definition at line 838 of file ComputeFVFluxThread.h.

{ this->_subproblem.SubProblem::addCachedResidual(_tid); }

caughtMooseException()

template<typename RangeType>

void ThreadedFaceLoop< RangeType >::caughtMooseException ( MooseException &  e )

inlineinherited

Called if a MooseException is caught anywhere during the computation.

Definition at line 116 of file ComputeFVFluxThread.h.

  {
    Threads::spin_mutex::scoped_lock lock(threaded_element_mutex);
    std::string what(e.what());
    _fe_problem.setException(what);
  }

compute()

template<typename RangeType>

void ComputeFVFluxResidualThread< RangeType >::compute ( FVFaceResidualObject &  ro, const FaceInfo &  fi  )

inlineoverrideprotectedvirtual

call either computeResidual, computeJacobian, or computeResidualAndJacobian on the provided residual object depending on what derived class of this class is instantiated

Implements ComputeFVFluxThread< RangeType, AttribVectorTags >.

Definition at line 836 of file ComputeFVFluxThread.h.

{ ro.computeResidual(fi); }

join()

template<typename RangeType >

void ThreadedFaceLoop< RangeType >::join ( const ThreadedFaceLoop< RangeType > &  y )

inherited

Definition at line 227 of file ComputeFVFluxThread.h.

{
  if (_error_message.empty() && !y._error_message.empty())
    _error_message = y._error_message;
}

neighborSubdomainChanged()

void ComputeFVFluxThread< RangeType, AttribVectorTags >::neighborSubdomainChanged ( )

overridevirtualinherited

Called every time the neighbor subdomain changes (i.e.

the subdomain of this face's neighbor element is not the same as the subdomain of the last face's neighbor element).

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 694 of file ComputeFVFluxThread.h.

{
  ThreadedFaceLoop<RangeType>::neighborSubdomainChanged();

  // Clear variables
  _fv_vars.clear();
  _neigh_sub_fv_vars.clear();

  // Clear kernels
  _fv_flux_kernels.clear();
  _neigh_sub_fv_flux_kernels.clear();

  // Clear element face materials
  _elem_face_mats.clear();
  _neigh_sub_elem_face_mats.clear();

  // Clear neighbor face materials
  _neigh_face_mats.clear();
  _neigh_sub_neigh_face_mats.clear();

  // TODO: do this for other relevant objects - like FV BCs, FV source term
  // kernels, etc. - but we don't need to add them for other types of objects
  // like FE or DG kernels because those kernels don't run in this loop. Do we
  // really want to integrate fv source kernels into this loop?
  std::vector<FVFluxKernel *> kernels;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_nl_system_num)
      .template condition<AttribSystem>("FVFluxKernel")
      .template condition<AttribDisplaced>(_on_displaced)
      .template condition<AttribSubdomains>(_neighbor_subdomain)
      .template condition<AttribThread>(_tid)
      .template condition<AttributeTagType>(_tags)
      .queryInto(kernels);

  _neigh_sub_fv_flux_kernels = std::set<FVFluxKernel *>(kernels.begin(), kernels.end());

  for (auto * k : _neigh_sub_fv_flux_kernels)
  {
    // TODO: we need a better way to do this - especially when FE objects begin to
    // couple to FV vars.  This code shoud be refactored out into one place
    // where it is easy for users to say initialize all materials and
    // variables needed by these objects for me.
    const auto & deps = k->getMooseVariableDependencies();
    for (auto var : deps)
    {
      mooseAssert(var->isFV(),
                  "We do not currently support coupling of FE variables into FV objects");
      _neigh_sub_fv_vars.insert(var);
    }
  }

  _fe_problem.getFVMatsAndDependencies(_neighbor_subdomain,
                                       _neigh_sub_elem_face_mats,
                                       _neigh_sub_neigh_face_mats,
                                       _neigh_sub_fv_vars,
                                       _tid);

  finalizeContainers();
}

onBoundary()

void ComputeFVFluxThread< RangeType, AttribVectorTags >::onBoundary ( const FaceInfo &  fi, BoundaryID  boundary  )

overridevirtualinherited

This is called once for every face that is on a boundary after onFace is called for the face.

Implements ThreadedFaceLoop< RangeType >.

Definition at line 530 of file ComputeFVFluxThread.h.

{
  if (_scaling_jacobian || _scaling_residual)
    return;

  std::vector<FVFluxBC *> bcs;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_nl_system_num)
      .template condition<AttribSystem>("FVFluxBC")
      .template condition<AttribDisplaced>(_on_displaced)
      .template condition<AttribThread>(_tid)
      .template condition<AttributeTagType>(_tags)
      .template condition<AttribBoundaries>(bnd_id)
      .queryInto(bcs);

  for (auto * const bc : bcs)
    compute(*bc, fi);

  std::vector<FVInterfaceKernel *> iks;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_nl_system_num)
      .template condition<AttribSystem>("FVInterfaceKernel")
      .template condition<AttribDisplaced>(_on_displaced)
      .template condition<AttribThread>(_tid)
      .template condition<AttributeTagType>(_tags)
      .template condition<AttribBoundaries>(bnd_id)
      .queryInto(iks);

  for (auto * const ik : iks)
    compute(*ik, fi);
}

onFace()

void ComputeFVFluxThread< RangeType, AttribVectorTags >::onFace ( const FaceInfo &  fi )

overridevirtualinherited

Implements ThreadedFaceLoop< RangeType >.

Definition at line 520 of file ComputeFVFluxThread.h.

{
  reinitVariables(fi);

  for (auto * const k : _fv_flux_kernels)
    compute(*k, fi);
}

operator()()

template<typename RangeType >

void ThreadedFaceLoop< RangeType >::operator() ( const RangeType &  range, bool  bypass_threading = false  )

virtualinherited

Definition at line 241 of file ComputeFVFluxThread.h.

{
  // TODO: make this query fv flux kernel specific or somehow integrate the
  // fv source kernels into this loop. Also this check will need to increase
  // in generality if/when other systems and objects besides FV stuff get
  // added to this loop.
  std::vector<FVKernel *> kernels;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_nl_system_num)
      .template condition<AttribSystem>("FVFluxKernel")
      .template condition<AttribDisplaced>(_on_displaced)
      .queryInto(kernels);
  if (kernels.size() == 0)
    return;

  try
  {
    try
    {
      ParallelUniqueId puid;
      _tid = bypass_threading ? 0 : puid.id;

      pre();
      printGeneralExecutionInformation();

      _subdomain = Moose::INVALID_BLOCK_ID;
      _neighbor_subdomain = Moose::INVALID_BLOCK_ID;

      typename RangeType::const_iterator faceinfo = range.begin();
      for (faceinfo = range.begin(); faceinfo != range.end(); ++faceinfo)
      {
        const Elem & elem = (*faceinfo)->elem();

        _fe_problem.setCurrentSubdomainID(&elem, _tid);

        _old_subdomain = _subdomain;
        _subdomain = elem.subdomain_id();
        if (_subdomain != _old_subdomain)
        {
          subdomainChanged();
          printBlockExecutionInformation();
        }

        _old_neighbor_subdomain = _neighbor_subdomain;
        if (const Elem * const neighbor = (*faceinfo)->neighborPtr())
        {
          _fe_problem.setNeighborSubdomainID(neighbor, _tid);
          _neighbor_subdomain = neighbor->subdomain_id();
        }
        else
          _neighbor_subdomain = Moose::INVALID_BLOCK_ID;

        if (_neighbor_subdomain != _old_neighbor_subdomain)
        {
          neighborSubdomainChanged();
          // This is going to cause a lot more printing
          printBlockExecutionInformation();
        }

        onFace(**faceinfo);
        // Cache data now because onBoundary may clear it. E.g. there was a nasty bug for two
        // variable FV systems where if one variable was executing an FVFluxKernel on a boundary
        // while the other was executing an FVFluxBC, the FVFluxKernel data would get lost because
        // onBoundary would clear the residual/Jacobian data before it was cached
        postFace(**faceinfo);

        const std::set<BoundaryID> boundary_ids = (*faceinfo)->boundaryIDs();
        for (auto & it : boundary_ids)
        {
          printBoundaryExecutionInformation(it);
          onBoundary(**faceinfo, it);
        }

        postFace(**faceinfo);

      } // range
      post();

      // Clear execution printing sets to start printing on every block and boundary again
      resetExecutionPrinting();
    }
    catch (MetaPhysicL::LogicError & e)
    {
      moose::translateMetaPhysicLError(e);
    }
    catch (std::exception & e)
    {
      // Continue if we find a libMesh degenerate map exception, but
      // just throw for any real error
      if (!strstr(e.what(), "Jacobian") && !strstr(e.what(), "singular") &&
          !strstr(e.what(), "det != 0"))
        throw;

      mooseException("We caught a libMesh degeneracy exception in ComputeFVFluxThread:\n",
                     e.what());
    }
  }
  catch (MooseException & e)
  {
    caughtMooseException(e);
  }
  catch (std::runtime_error & e)
  {
    _error_message = e.what();
  }
}

post()

void ComputeFVFluxThread< RangeType, AttribVectorTags >::post ( )

overridevirtualinherited

This is called once after all face-looping is finished.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 566 of file ComputeFVFluxThread.h.

{
  // make sure we add any remaining cached residuals/jacobians to add/record
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  addCached();

  _fe_problem.clearActiveElementalMooseVariables(_tid);
  _fe_problem.clearActiveMaterialProperties(_tid);
}

postFace()

template<typename RangeType >

void ComputeFVFluxResidualThread< RangeType >::postFace ( const FaceInfo &  )

overrideprotectedvirtual

This is called once for each face after all face and boundary callbacks have been finished for that face.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 860 of file ComputeFVFluxThread.h.

{
  _num_cached++;
  // TODO: do we need both calls - or just the neighbor one? - confirm this
  this->_subproblem.SubProblem::cacheResidual(_tid);
  this->_subproblem.SubProblem::cacheResidualNeighbor(_tid);

  this->_subproblem.SubProblem::addCachedResidual(_tid);
}

pre()

void ComputeFVFluxThread< RangeType, AttribVectorTags >::pre ( )

overridevirtualinherited

This is called once before all face-looping.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 757 of file ComputeFVFluxThread.h.

{
  std::vector<FVFluxBC *> bcs;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_nl_system_num)
      .template condition<AttribSystem>("FVFluxBC")
      .template condition<AttribDisplaced>(_on_displaced)
      .template condition<AttribThread>(_tid)
      .template condition<AttributeTagType>(_tags)
      .queryInto(bcs);

  std::vector<FVInterfaceKernel *> iks;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_nl_system_num)
      .template condition<AttribSystem>("FVInterfaceKernel")
      .template condition<AttribDisplaced>(_on_displaced)
      .template condition<AttribThread>(_tid)
      .template condition<AttributeTagType>(_tags)
      .queryInto(iks);

  std::vector<FVFluxKernel *> kernels;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_nl_system_num)
      .template condition<AttribSystem>("FVFluxKernel")
      .template condition<AttribDisplaced>(_on_displaced)
      .template condition<AttribThread>(_tid)
      .template condition<AttributeTagType>(_tags)
      .queryInto(kernels);

  for (auto * const bc : bcs)
    setup(*bc);
  for (auto * const ik : iks)
    setup(*ik);
  for (auto * const kernel : kernels)
    setup(*kernel);

  // Clear variables
  _fv_vars.clear();
  _elem_sub_fv_vars.clear();
  _neigh_sub_fv_vars.clear();

  // Clear kernels
  _fv_flux_kernels.clear();
  _elem_sub_fv_flux_kernels.clear();
  _neigh_sub_fv_flux_kernels.clear();

  // Clear element face materials
  _elem_face_mats.clear();
  _elem_sub_elem_face_mats.clear();
  _neigh_sub_elem_face_mats.clear();

  // Clear neighbor face materials
  _neigh_face_mats.clear();
  _elem_sub_neigh_face_mats.clear();
  _neigh_sub_neigh_face_mats.clear();
}

resetExecutionPrinting()

template<typename RangeType>

void ThreadedFaceLoop< RangeType >::resetExecutionPrinting ( )

inlineprotectedinherited

Reset lists of blocks and boundaries for which execution printing has been done.

Definition at line 134 of file ComputeFVFluxThread.h.

  {
    _blocks_exec_printed.clear();
    _boundaries_exec_printed.clear();
  }

setup()

template<typename RangeType>

void ComputeFVFluxResidualThread< RangeType >::setup ( SetupInterface &  obj )

inlineoverrideprotectedvirtual

call either residualSetup or jacobianSetup depending on what derived class of this class is instantiated

Implements ComputeFVFluxThread< RangeType, AttribVectorTags >.

Definition at line 837 of file ComputeFVFluxThread.h.

{ obj.residualSetup(); }

subdomainChanged()

void ComputeFVFluxThread< RangeType, AttribVectorTags >::subdomainChanged ( )

overridevirtualinherited

Called every time the current subdomain changes (i.e.

the subdomain of this face's elem element is not the same as the subdomain of the last face's elem element).

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 634 of file ComputeFVFluxThread.h.

{
  ThreadedFaceLoop<RangeType>::subdomainChanged();

  // Clear variables
  _fv_vars.clear();
  _elem_sub_fv_vars.clear();

  // Clear kernels
  _fv_flux_kernels.clear();
  _elem_sub_fv_flux_kernels.clear();

  // Clear element face materials
  _elem_face_mats.clear();
  _elem_sub_elem_face_mats.clear();

  // Clear neighbor face materials
  _neigh_face_mats.clear();
  _elem_sub_neigh_face_mats.clear();

  // TODO: do this for other relevant objects - like FV BCs, FV source term
  // kernels, etc. - but we don't need to add them for other types of objects
  // like FE or DG kernels because those kernels don't run in this loop. Do we
  // really want to integrate fv source kernels into this loop?
  std::vector<FVFluxKernel *> kernels;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_nl_system_num)
      .template condition<AttribSystem>("FVFluxKernel")
      .template condition<AttribDisplaced>(_on_displaced)
      .template condition<AttribSubdomains>(_subdomain)
      .template condition<AttribThread>(_tid)
      .template condition<AttributeTagType>(_tags)
      .queryInto(kernels);

  _elem_sub_fv_flux_kernels = std::set<FVFluxKernel *>(kernels.begin(), kernels.end());

  for (auto * k : _elem_sub_fv_flux_kernels)
  {
    // TODO: we need a better way to do this - especially when FE objects begin to
    // couple to FV vars.  This code shoud be refactored out into one place
    // where it is easy for users to say initialize all materials and
    // variables needed by these objects for me.
    const auto & deps = k->getMooseVariableDependencies();
    for (auto var : deps)
    {
      mooseAssert(var->isFV(),
                  "We do not currently support coupling of FE variables into FV objects");
      _elem_sub_fv_vars.insert(var);
    }
  }

  _fe_problem.getFVMatsAndDependencies(
      _subdomain, _elem_sub_elem_face_mats, _elem_sub_neigh_face_mats, _elem_sub_fv_vars, _tid);

  finalizeContainers();
}

Member Data Documentation

_blocks_exec_printed

template<typename RangeType>

std::set<std::pair<const SubdomainID, const SubdomainID> > ThreadedFaceLoop< RangeType >::_blocks_exec_printed

mutableprotectedinherited

Set to keep track of blocks for which we have printed the execution pattern.

Definition at line 165 of file ComputeFVFluxThread.h.

Referenced by ThreadedFaceLoop< RangeType >::resetExecutionPrinting().

_boundaries_exec_printed

template<typename RangeType>

std::set<BoundaryID> ThreadedFaceLoop< RangeType >::_boundaries_exec_printed

mutableprotectedinherited

Set to keep track of boundaries for which we have printed the execution pattern.

Definition at line 168 of file ComputeFVFluxThread.h.

Referenced by ThreadedFaceLoop< RangeType >::resetExecutionPrinting().

_error_message

template<typename RangeType>

std::string ThreadedFaceLoop< RangeType >::_error_message

protectedinherited

Holds caught runtime error messages.

Definition at line 171 of file ComputeFVFluxThread.h.

Referenced by ThreadedFaceLoop< RangeType >::join().

_fe_problem

template<typename RangeType>

FEProblemBase& ThreadedFaceLoop< RangeType >::_fe_problem

protectedinherited

Definition at line 140 of file ComputeFVFluxThread.h.

Referenced by ThreadedFaceLoop< RangeType >::caughtMooseException(), ThreadedFaceLoop< RangeType >::neighborSubdomainChanged(), and ThreadedFaceLoop< RangeType >::subdomainChanged().

_mesh

template<typename RangeType>

MooseMesh& ThreadedFaceLoop< RangeType >::_mesh

protectedinherited

Definition at line 141 of file ComputeFVFluxThread.h.

_neighbor_subdomain

template<typename RangeType>

SubdomainID ThreadedFaceLoop< RangeType >::_neighbor_subdomain

protectedinherited

The subdomain for the current neighbor.

Definition at line 159 of file ComputeFVFluxThread.h.

Referenced by ThreadedFaceLoop< RangeType >::neighborSubdomainChanged().

_nl_system_num

template<typename RangeType>

const unsigned int ThreadedFaceLoop< RangeType >::_nl_system_num

protectedinherited

Definition at line 144 of file ComputeFVFluxThread.h.

_num_cached

unsigned int ComputeFVFluxThread< RangeType, AttribVectorTags >::_num_cached

protectedinherited

Definition at line 393 of file ComputeFVFluxThread.h.

_old_neighbor_subdomain

template<typename RangeType>

SubdomainID ThreadedFaceLoop< RangeType >::_old_neighbor_subdomain

protectedinherited

The subdomain for the last neighbor.

Definition at line 162 of file ComputeFVFluxThread.h.

_old_subdomain

template<typename RangeType>

SubdomainID ThreadedFaceLoop< RangeType >::_old_subdomain

protectedinherited

The subdomain for the last element.

Definition at line 156 of file ComputeFVFluxThread.h.

_on_displaced

template<typename RangeType>

const bool ThreadedFaceLoop< RangeType >::_on_displaced

protectedinherited

Whether this loop is operating on the displaced mesh.

Definition at line 147 of file ComputeFVFluxThread.h.

_subdomain

template<typename RangeType>

SubdomainID ThreadedFaceLoop< RangeType >::_subdomain

protectedinherited

The subdomain for the current element.

Definition at line 153 of file ComputeFVFluxThread.h.

Referenced by ThreadedFaceLoop< RangeType >::subdomainChanged().

_subproblem

template<typename RangeType>

SubProblem& ThreadedFaceLoop< RangeType >::_subproblem

protectedinherited

FEProblemBase or DisplacedProblem depending on _on_displaced.

Definition at line 150 of file ComputeFVFluxThread.h.

Referenced by ComputeFVFluxResidualThread< RangeType >::addCached(), ComputeFVFluxJacobianThread< RangeType >::addCached(), and ComputeFVFluxRJThread< RangeType >::addCached().

_tags

template<typename RangeType>

const std::set<TagID>& ThreadedFaceLoop< RangeType >::_tags

protectedinherited

Definition at line 142 of file ComputeFVFluxThread.h.

_tid

template<typename RangeType>

THREAD_ID ThreadedFaceLoop< RangeType >::_tid

protectedinherited

Definition at line 143 of file ComputeFVFluxThread.h.

Referenced by ComputeFVFluxResidualThread< RangeType >::addCached(), ComputeFVFluxJacobianThread< RangeType >::addCached(), ComputeFVFluxRJThread< RangeType >::addCached(), ThreadedFaceLoop< RangeType >::neighborSubdomainChanged(), and ThreadedFaceLoop< RangeType >::subdomainChanged().

---

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

• include/loops/ComputeFVFluxThread.h