ComputeFVFluxThread< RangeType, AttributeTagType > Class Template Reference

Base class for assembly-like calculations. More...

#include <ComputeFVFluxThread.h>

Inheritance diagram for ComputeFVFluxThread< RangeType, AttributeTagType >:

Public Member Functions
	ComputeFVFluxThread (FEProblemBase &fe_problem, const unsigned int nl_system_num, const std::set< TagID > &tags, bool on_displaced)
	ComputeFVFluxThread (ComputeFVFluxThread &x, Threads::split split)
virtual	~ComputeFVFluxThread ()
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)
virtual void	postFace (const FaceInfo &)
	This is called once for each face after all face and boundary callbacks have been finished for that face. More...
void	caughtMooseException (MooseException &e)
	Called if a MooseException is caught anywhere during the computation. More...

Protected Member Functions
virtual void	compute (FVFaceResidualObject &ro, const FaceInfo &fi)=0
	call either computeResidual, computeJacobian, or computeResidualAndJacobian on the provided residual object depending on what derived class of this class is instantiated More...
virtual void	setup (SetupInterface &obj)=0
	call either residualSetup or jacobianSetup depending on what derived class of this class is instantiated More...
virtual void	addCached ()=0
	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 = 0
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...

Private Member Functions
void	reinitVariables (const FaceInfo &fi)
void	finalizeContainers ()
virtual void	printGeneralExecutionInformation () const override
	Print list of object types executed and in which order. More...
virtual void	printBlockExecutionInformation () const override
	Print ordering of objects executed on each block. More...
virtual void	printBoundaryExecutionInformation (const BoundaryID bnd_id) const override
	Print ordering of objects exected on each boundary. More...
std::pair< SubdomainName, SubdomainName >	getBlockNames () const
	Utility to get the subdomain names from the ids. More...

Private Attributes
std::set< MooseVariableFieldBase * >	_fv_vars
	Variables. More...
std::set< MooseVariableFieldBase * >	_elem_sub_fv_vars
std::set< MooseVariableFieldBase * >	_neigh_sub_fv_vars
std::set< FVFluxKernel * >	_fv_flux_kernels
	FVFluxKernels. More...
std::set< FVFluxKernel * >	_elem_sub_fv_flux_kernels
std::set< FVFluxKernel * >	_neigh_sub_fv_flux_kernels
std::vector< std::shared_ptr< MaterialBase > >	_elem_face_mats
	Element face materials. More...
std::vector< std::shared_ptr< MaterialBase > >	_elem_sub_elem_face_mats
std::vector< std::shared_ptr< MaterialBase > >	_neigh_sub_elem_face_mats
std::vector< std::shared_ptr< MaterialBase > >	_neigh_face_mats
std::vector< std::shared_ptr< MaterialBase > >	_elem_sub_neigh_face_mats
std::vector< std::shared_ptr< MaterialBase > >	_neigh_sub_neigh_face_mats
const bool	_scaling_jacobian
const bool	_scaling_residual

Detailed Description

template<typename RangeType, typename AttributeTagType>
class ComputeFVFluxThread< RangeType, AttributeTagType >

Base class for assembly-like calculations.

Definition at line 344 of file ComputeFVFluxThread.h.

Constructor & Destructor Documentation

ComputeFVFluxThread() [1/2]

template<typename RangeType , typename AttributeTagType >

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

Definition at line 438 of file ComputeFVFluxThread.h.

  : ThreadedFaceLoop<RangeType>(fe_problem, nl_system_num, tags, on_displaced),
    _scaling_jacobian(fe_problem.computingScalingJacobian()),
    _scaling_residual(fe_problem.computingScalingResidual())
{
}

ComputeFVFluxThread() [2/2]

template<typename RangeType , typename AttributeTagType >

ComputeFVFluxThread< RangeType, AttributeTagType >::ComputeFVFluxThread	(	ComputeFVFluxThread< RangeType, AttributeTagType > &	x,
		Threads::split	split
	)

Definition at line 449 of file ComputeFVFluxThread.h.

  : ThreadedFaceLoop<RangeType>(x, split),
    _fv_vars(x._fv_vars),
    _scaling_jacobian(x._scaling_jacobian),
    _scaling_residual(x._scaling_residual)
{
}

~ComputeFVFluxThread()

template<typename RangeType , typename AttributeTagType >

ComputeFVFluxThread< RangeType, AttributeTagType >::~ComputeFVFluxThread ( )

virtual

Definition at line 459 of file ComputeFVFluxThread.h.

{
}

Member Function Documentation

addCached()

template<typename RangeType, typename AttributeTagType>

virtual void ComputeFVFluxThread< RangeType, AttributeTagType >::addCached ( )

protectedpure virtual

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

Implemented in ComputeFVFluxRJThread< RangeType >, ComputeFVFluxJacobianThread< RangeType >, and ComputeFVFluxResidualThread< RangeType >.

caughtMooseException()

template<typename RangeType>

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

inlineinherited

Called if a MooseException is caught anywhere during the computation.

Definition at line 114 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, typename AttributeTagType>

virtual void ComputeFVFluxThread< RangeType, AttributeTagType >::compute ( FVFaceResidualObject &  ro, const FaceInfo &  fi  )

protectedpure virtual

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

Implemented in ComputeFVFluxRJThread< RangeType >, ComputeFVFluxJacobianThread< RangeType >, and ComputeFVFluxResidualThread< RangeType >.

finalizeContainers()

template<typename RangeType , typename AttributeTagType >

void ComputeFVFluxThread< RangeType, AttributeTagType >::finalizeContainers ( )

private

Definition at line 569 of file ComputeFVFluxThread.h.

{
  //
  // Finalize our variables
  //
  std::set_union(_elem_sub_fv_vars.begin(),
                 _elem_sub_fv_vars.end(),
                 _neigh_sub_fv_vars.begin(),
                 _neigh_sub_fv_vars.end(),
                 std::inserter(_fv_vars, _fv_vars.begin()));

  //
  // Finalize our kernels
  //
  const bool same_kernels = _elem_sub_fv_flux_kernels == _neigh_sub_fv_flux_kernels;
  if (same_kernels)
    _fv_flux_kernels = _elem_sub_fv_flux_kernels;
  else
    std::set_union(_elem_sub_fv_flux_kernels.begin(),
                   _elem_sub_fv_flux_kernels.end(),
                   _neigh_sub_fv_flux_kernels.begin(),
                   _neigh_sub_fv_flux_kernels.end(),
                   std::inserter(_fv_flux_kernels, _fv_flux_kernels.begin()));
  const bool need_ghosting = !same_kernels;

  //
  // Finalize our element face materials
  //
  _elem_face_mats = _elem_sub_elem_face_mats;

  if (need_ghosting)
    // Add any element face materials from the neighboring subdomain that do not exist on the
    // element subdomain
    for (std::shared_ptr<MaterialBase> neigh_sub_elem_face_mat : _neigh_sub_elem_face_mats)
      if (std::find(_elem_sub_elem_face_mats.begin(),
                    _elem_sub_elem_face_mats.end(),
                    neigh_sub_elem_face_mat) == _elem_sub_elem_face_mats.end())
        _elem_face_mats.push_back(neigh_sub_elem_face_mat);

  //
  // Finalize our neighbor face materials
  //
  _neigh_face_mats = _neigh_sub_neigh_face_mats;

  if (need_ghosting)
    // Add any neighbor face materials from the element subdomain that do not exist on the
    // neighbor subdomain
    for (std::shared_ptr<MaterialBase> elem_sub_neigh_face_mat : _elem_sub_neigh_face_mats)
      if (std::find(_neigh_sub_neigh_face_mats.begin(),
                    _neigh_sub_neigh_face_mats.end(),
                    elem_sub_neigh_face_mat) == _neigh_sub_neigh_face_mats.end())
        _neigh_face_mats.push_back(elem_sub_neigh_face_mat);
}

getBlockNames()

template<typename RangeType , typename AttributeTagType >

std::pair< SubdomainName, SubdomainName > ComputeFVFluxThread< RangeType, AttributeTagType >::getBlockNames ( ) const

private

Utility to get the subdomain names from the ids.

Definition at line 1086 of file ComputeFVFluxThread.h.

{
  auto block_names = std::make_pair(_mesh.getSubdomainName(_subdomain),
                                    _mesh.getSubdomainName(_neighbor_subdomain));
  if (block_names.first == "")
    block_names.first = Moose::stringify(_subdomain);
  if (block_names.second == "")
    block_names.second = Moose::stringify(_neighbor_subdomain);
  return block_names;
}

join()

template<typename RangeType >

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

inherited

Definition at line 225 of file ComputeFVFluxThread.h.

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

neighborSubdomainChanged()

template<typename RangeType , typename AttributeTagType >

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

overridevirtual

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 685 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()

template<typename RangeType , typename AttributeTagType >

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

overridevirtual

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 521 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()

template<typename RangeType , typename AttributeTagType >

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

overridevirtual

Implements ThreadedFaceLoop< RangeType >.

Definition at line 511 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 239 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 (libMesh::LogicError & e)
    {
      mooseException("We caught a libMesh error: ", e.what());
    }
    catch (MetaPhysicL::LogicError & e)
    {
      moose::translateMetaPhysicLError(e);
    }
  }
  catch (MooseException & e)
  {
    caughtMooseException(e);
  }
  catch (std::runtime_error & e)
  {
    _error_message = e.what();
  }
}

post()

template<typename RangeType , typename AttributeTagType >

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

overridevirtual

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

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 557 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>

virtual void ThreadedFaceLoop< RangeType >::postFace ( const FaceInfo &  )

inlinevirtualinherited

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

Reimplemented in ComputeFVFluxRJThread< RangeType >, ComputeFVFluxJacobianThread< RangeType >, and ComputeFVFluxResidualThread< RangeType >.

Definition at line 92 of file ComputeFVFluxThread.h.

{}

pre()

template<typename RangeType , typename AttributeTagType >

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

overridevirtual

This is called once before all face-looping.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 748 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();
}

printBlockExecutionInformation()

template<typename RangeType , typename AttributeTagType >

void ComputeFVFluxThread< RangeType, AttributeTagType >::printBlockExecutionInformation ( ) const

overrideprivatevirtual

Print ordering of objects executed on each block.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 1000 of file ComputeFVFluxThread.h.

{
  if (!_fe_problem.shouldPrintExecution(_tid) || !_fv_flux_kernels.size())
    return;

  // Print the location of the execution
  const auto block_pair = std::make_pair(_subdomain, _neighbor_subdomain);
  const auto block_pair_names = this->getBlockNames();
  if (_blocks_exec_printed.count(block_pair))
    return;
  auto & console = _fe_problem.console();
  console << "[DBG] Flux kernels on block " << block_pair_names.first;
  if (_neighbor_subdomain != Moose::INVALID_BLOCK_ID)
    console << " and neighbor " << block_pair_names.second << std::endl;
  else
    console << " with no neighbor block" << std::endl;

  // Print the list of objects
  std::vector<MooseObject *> fv_flux_kernels;
  for (const auto & fv_kernel : _fv_flux_kernels)
    fv_flux_kernels.push_back(dynamic_cast<MooseObject *>(fv_kernel));
  console << ConsoleUtils::formatString(ConsoleUtils::mooseObjectVectorToString(fv_flux_kernels),
                                        "[DBG]")
          << std::endl;
  _blocks_exec_printed.insert(block_pair);
}

printBoundaryExecutionInformation()

template<typename RangeType , typename AttributeTagType >

void ComputeFVFluxThread< RangeType, AttributeTagType >::printBoundaryExecutionInformation ( const BoundaryID  bnd_id ) const

overrideprivatevirtual

Print ordering of objects exected on each boundary.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 1029 of file ComputeFVFluxThread.h.

{
  if (!_fe_problem.shouldPrintExecution(_tid))
    return;
  if (_boundaries_exec_printed.count(bnd_id))
    return;
  std::vector<MooseObject *> bcs;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSystem>("FVFluxBC")
      .template condition<AttribDisplaced>(_on_displaced)
      .template condition<AttribThread>(_tid)
      .template condition<AttributeTagType>(_tags)
      .template condition<AttribBoundaries>(bnd_id)
      .queryInto(bcs);

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

  const auto block_pair_names = this->getBlockNames();
  if (bcs.size())
  {
    auto & console = _fe_problem.console();
    console << "[DBG] FVBCs on boundary " << bnd_id << " between subdomain "
            << block_pair_names.first;
    if (_neighbor_subdomain != Moose::INVALID_BLOCK_ID)
      console << " and neighbor " << block_pair_names.second << std::endl;
    else
      console << " and the exterior of the mesh " << std::endl;
    const std::string fv_bcs = ConsoleUtils::mooseObjectVectorToString(bcs);
    console << ConsoleUtils::formatString(fv_bcs, "[DBG]") << std::endl;
  }
  if (iks.size())
  {
    auto & console = _fe_problem.console();
    console << "[DBG] FVIKs on boundary " << bnd_id << " between subdomain "
            << block_pair_names.first;
    if (_neighbor_subdomain != Moose::INVALID_BLOCK_ID)
      console << " and neighbor " << block_pair_names.second << std::endl;
    else
      console << " and the exterior of the mesh " << std::endl;
    const std::string fv_iks = ConsoleUtils::mooseObjectVectorToString(iks);
    console << ConsoleUtils::formatString(fv_iks, "[DBG]") << std::endl;
  }
  _boundaries_exec_printed.insert(bnd_id);
}

printGeneralExecutionInformation()

template<typename RangeType , typename AttributeTagType >

void ComputeFVFluxThread< RangeType, AttributeTagType >::printGeneralExecutionInformation ( ) const

overrideprivatevirtual

Print list of object types executed and in which order.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 984 of file ComputeFVFluxThread.h.

{
  if (!_fe_problem.shouldPrintExecution(_tid))
    return;
  auto & console = _fe_problem.console();
  auto execute_on = _fe_problem.getCurrentExecuteOnFlag();
  console << "[DBG] Beginning finite volume flux objects loop on " << execute_on << std::endl;
  mooseDoOnce(console << "[DBG] Loop on faces (FaceInfo), objects ordered on each face: "
                      << std::endl;
              console << "[DBG] - (finite volume) flux kernels" << std::endl;
              console << "[DBG] - (finite volume) flux boundary conditions" << std::endl;
              console << "[DBG] - (finite volume) interface kernels" << std::endl;);
}

reinitVariables()

template<typename RangeType , typename AttributeTagType >

void ComputeFVFluxThread< RangeType, AttributeTagType >::reinitVariables ( const FaceInfo &  fi )

private

Definition at line 465 of file ComputeFVFluxThread.h.

{
  // TODO: this skips necessary FE reinit.  In addition to this call, we need
  // to conditionally do some FE-specific reinit here if we have any active FE
  // variables.  However, we still want to keep/do FV-style quadrature.
  // Figure out how to do all this some day.
  this->_subproblem.reinitFVFace(_tid, fi);

  // TODO: for FE variables, this is handled via setting needed vars through
  // fe problem API which passes the value on to the system class.  Then
  // reinit is called on fe problem which forwards its calls to the system
  // function and then fe problem also calls displaced problem reinit.  All
  // the call forwarding seems silly, but it does allow the displaced problem
  // to be easily kept in sync.  However, the displaced problem has different
  // pointers for its own face info objects, etc, we can't just pass in fe
  // problem's face info down to the sub-problem -- centroids are different,
  // volumes are different, etc.  To support displaced meshes correctly, we
  // need to be able to reinit the subproblems variables using its equivalent
  // face info object.  How?  See https://github.com/idaholab/moose/issues/15064

  for (auto var : _fv_vars)
    var->computeFaceValues(fi);

  _fe_problem.resizeMaterialData(Moose::MaterialDataType::FACE_MATERIAL_DATA, /*nqp=*/1, _tid);

  for (std::shared_ptr<MaterialBase> mat : _elem_face_mats)
  {
    mat->setFaceInfo(fi);
    mat->computeProperties();
  }

  if (fi.neighborPtr())
  {
    _fe_problem.resizeMaterialData(
        Moose::MaterialDataType::NEIGHBOR_MATERIAL_DATA, /*nqp=*/1, _tid);

    for (std::shared_ptr<MaterialBase> mat : _neigh_face_mats)
    {
      mat->setFaceInfo(fi);
      mat->computeProperties();
    }
  }
}

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 132 of file ComputeFVFluxThread.h.

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

setup()

template<typename RangeType, typename AttributeTagType>

virtual void ComputeFVFluxThread< RangeType, AttributeTagType >::setup ( SetupInterface &  obj )

protectedpure virtual

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

Implemented in ComputeFVFluxRJThread< RangeType >, ComputeFVFluxJacobianThread< RangeType >, and ComputeFVFluxResidualThread< RangeType >.

subdomainChanged()

template<typename RangeType , typename AttributeTagType >

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

overridevirtual

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 625 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 163 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 166 of file ComputeFVFluxThread.h.

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

_elem_face_mats

template<typename RangeType, typename AttributeTagType>

std::vector<std::shared_ptr<MaterialBase> > ComputeFVFluxThread< RangeType, AttributeTagType >::_elem_face_mats

private

Element face materials.

Definition at line 424 of file ComputeFVFluxThread.h.

_elem_sub_elem_face_mats

template<typename RangeType, typename AttributeTagType>

std::vector<std::shared_ptr<MaterialBase> > ComputeFVFluxThread< RangeType, AttributeTagType >::_elem_sub_elem_face_mats

private

Definition at line 425 of file ComputeFVFluxThread.h.

_elem_sub_fv_flux_kernels

template<typename RangeType, typename AttributeTagType>

std::set<FVFluxKernel *> ComputeFVFluxThread< RangeType, AttributeTagType >::_elem_sub_fv_flux_kernels

private

Definition at line 420 of file ComputeFVFluxThread.h.

_elem_sub_fv_vars

template<typename RangeType, typename AttributeTagType>

std::set<MooseVariableFieldBase *> ComputeFVFluxThread< RangeType, AttributeTagType >::_elem_sub_fv_vars

private

Definition at line 415 of file ComputeFVFluxThread.h.

_elem_sub_neigh_face_mats

template<typename RangeType, typename AttributeTagType>

std::vector<std::shared_ptr<MaterialBase> > ComputeFVFluxThread< RangeType, AttributeTagType >::_elem_sub_neigh_face_mats

private

Definition at line 430 of file ComputeFVFluxThread.h.

_error_message

template<typename RangeType>

std::string ThreadedFaceLoop< RangeType >::_error_message

protectedinherited

Holds caught runtime error messages.

Definition at line 169 of file ComputeFVFluxThread.h.

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

_fe_problem

template<typename RangeType>

FEProblemBase& ThreadedFaceLoop< RangeType >::_fe_problem

protectedinherited

Definition at line 138 of file ComputeFVFluxThread.h.

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

_fv_flux_kernels

template<typename RangeType, typename AttributeTagType>

std::set<FVFluxKernel *> ComputeFVFluxThread< RangeType, AttributeTagType >::_fv_flux_kernels

private

FVFluxKernels.

Definition at line 419 of file ComputeFVFluxThread.h.

_fv_vars

template<typename RangeType, typename AttributeTagType>

std::set<MooseVariableFieldBase *> ComputeFVFluxThread< RangeType, AttributeTagType >::_fv_vars

private

Variables.

Definition at line 414 of file ComputeFVFluxThread.h.

_mesh

template<typename RangeType>

MooseMesh& ThreadedFaceLoop< RangeType >::_mesh

protectedinherited

Definition at line 139 of file ComputeFVFluxThread.h.

_neigh_face_mats

template<typename RangeType, typename AttributeTagType>

std::vector<std::shared_ptr<MaterialBase> > ComputeFVFluxThread< RangeType, AttributeTagType >::_neigh_face_mats

private

Definition at line 429 of file ComputeFVFluxThread.h.

_neigh_sub_elem_face_mats

template<typename RangeType, typename AttributeTagType>

std::vector<std::shared_ptr<MaterialBase> > ComputeFVFluxThread< RangeType, AttributeTagType >::_neigh_sub_elem_face_mats

private

Definition at line 426 of file ComputeFVFluxThread.h.

_neigh_sub_fv_flux_kernels

template<typename RangeType, typename AttributeTagType>

std::set<FVFluxKernel *> ComputeFVFluxThread< RangeType, AttributeTagType >::_neigh_sub_fv_flux_kernels

private

Definition at line 421 of file ComputeFVFluxThread.h.

_neigh_sub_fv_vars

template<typename RangeType, typename AttributeTagType>

std::set<MooseVariableFieldBase *> ComputeFVFluxThread< RangeType, AttributeTagType >::_neigh_sub_fv_vars

private

Definition at line 416 of file ComputeFVFluxThread.h.

_neigh_sub_neigh_face_mats

template<typename RangeType, typename AttributeTagType>

std::vector<std::shared_ptr<MaterialBase> > ComputeFVFluxThread< RangeType, AttributeTagType >::_neigh_sub_neigh_face_mats

private

Definition at line 431 of file ComputeFVFluxThread.h.

_neighbor_subdomain

template<typename RangeType>

SubdomainID ThreadedFaceLoop< RangeType >::_neighbor_subdomain

protectedinherited

The subdomain for the current neighbor.

Definition at line 157 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 142 of file ComputeFVFluxThread.h.

_num_cached

template<typename RangeType, typename AttributeTagType>

unsigned int ComputeFVFluxThread< RangeType, AttributeTagType >::_num_cached = 0

protected

Definition at line 384 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 160 of file ComputeFVFluxThread.h.

_old_subdomain

template<typename RangeType>

SubdomainID ThreadedFaceLoop< RangeType >::_old_subdomain

protectedinherited

The subdomain for the last element.

Definition at line 154 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 145 of file ComputeFVFluxThread.h.

_scaling_jacobian

template<typename RangeType, typename AttributeTagType>

const bool ComputeFVFluxThread< RangeType, AttributeTagType >::_scaling_jacobian

private

Definition at line 433 of file ComputeFVFluxThread.h.

_scaling_residual

template<typename RangeType, typename AttributeTagType>

const bool ComputeFVFluxThread< RangeType, AttributeTagType >::_scaling_residual

private

Definition at line 434 of file ComputeFVFluxThread.h.

_subdomain

template<typename RangeType>

SubdomainID ThreadedFaceLoop< RangeType >::_subdomain

protectedinherited

The subdomain for the current element.

Definition at line 151 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 148 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 140 of file ComputeFVFluxThread.h.

_tid

template<typename RangeType>

THREAD_ID ThreadedFaceLoop< RangeType >::_tid

protectedinherited

Definition at line 141 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