ComputeFVFluxJacobianThread< RangeType > Class Template Reference

#include <ComputeFVFluxThread.h>

Inheritance diagram for ComputeFVFluxJacobianThread< RangeType >:

Public Member Functions
	ComputeFVFluxJacobianThread (FEProblemBase &fe_problem, const unsigned int nl_system_num, const std::set< TagID > &tags, bool on_displaced)
	ComputeFVFluxJacobianThread (ComputeFVFluxJacobianThread &x, Threads::split split)
virtual void	onFace (const FaceInfo &fi) override
virtual void	pre () override
	This is called once before all face-looping.
virtual void	post () override
	This is called once after all face-looping is finished.
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.
virtual void	subdomainChanged () override
	Called every time the current subdomain changes (i.e.
virtual void	neighborSubdomainChanged () override
	Called every time the neighbor subdomain changes (i.e.
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.

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.
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
void	setup (SetupInterface &obj) override
	call either residualSetup or jacobianSetup depending on what derived class of this class is instantiated
void	addCached () override
	call either addCachedJacobian or addCachedResidual or both depending on what derived class of this class is instantiated
void	resetExecutionPrinting ()
	Reset lists of blocks and boundaries for which execution printing has been done.

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.
SubProblem &	_subproblem
	FEProblemBase or DisplacedProblem depending on _on_displaced.
SubdomainID	_subdomain
	The subdomain for the current element.
SubdomainID	_old_subdomain
	The subdomain for the last element.
SubdomainID	_neighbor_subdomain
	The subdomain for the current neighbor.
SubdomainID	_old_neighbor_subdomain
	The subdomain for the last neighbor.
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.
std::set< BoundaryID >	_boundaries_exec_printed
	Set to keep track of boundaries for which we have printed the execution pattern.
std::string	_error_message
	Holds caught runtime error messages.

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.
virtual void	printBlockExecutionInformation () const override
	Print ordering of objects executed on each block.
virtual void	printBoundaryExecutionInformation (const BoundaryID bnd_id) const override
	Print ordering of objects exected on each boundary.
std::pair< SubdomainName, SubdomainName >	getBlockNames () const
	Utility to get the subdomain names from the ids.

Private Attributes
std::set< MooseVariableFieldBase * >	_fv_vars
	Variables.
std::set< MooseVariableFieldBase * >	_elem_sub_fv_vars
std::set< MooseVariableFieldBase * >	_neigh_sub_fv_vars
std::set< FVFluxKernel * >	_fv_flux_kernels
	FVFluxKernels.
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.
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
const bool	_zeroth_copy
	Whether this is the zeroth threaded copy of this body.
const bool	_incoming_throw_on_error
	The value of Moose::_throw_on_error at the time of construction.

Detailed Description

template<typename RangeType>
class ComputeFVFluxJacobianThread< RangeType >

Definition at line 871 of file ComputeFVFluxThread.h.

Constructor & Destructor Documentation

ComputeFVFluxJacobianThread() [1/2]

template<typename RangeType >

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

Definition at line 893 of file ComputeFVFluxThread.h.

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

ComputeFVFluxJacobianThread() [2/2]

template<typename RangeType >

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

Definition at line 903 of file ComputeFVFluxThread.h.

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

Member Function Documentation

addCached()

template<typename RangeType >

void ComputeFVFluxJacobianThread< RangeType >::addCached ( )

inlineoverrideprotectedvirtual

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

Implements ComputeFVFluxThread< RangeType, AttribMatrixTags >.

Definition at line 889 of file ComputeFVFluxThread.h.

{ this->_subproblem.SubProblem::addCachedJacobian(_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 ComputeFVFluxJacobianThread< 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, AttribMatrixTags >.

Definition at line 887 of file ComputeFVFluxThread.h.

{ ro.computeJacobian(fi); }

finalizeContainers()

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

privateinherited

Definition at line 408 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()

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

privateinherited

Utility to get the subdomain names from the ids.

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

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

neighborSubdomainChanged()

void ComputeFVFluxThread< RangeType, AttribMatrixTags >::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 372 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, AttribMatrixTags >::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 369 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, AttribMatrixTags >::onFace ( const FaceInfo &  fi )

overridevirtualinherited

Implements ThreadedFaceLoop< RangeType >.

Definition at line 365 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, AttribMatrixTags >::post ( )

overridevirtualinherited

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

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 367 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 ComputeFVFluxJacobianThread< 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 911 of file ComputeFVFluxThread.h.

{
  _num_cached++;
  // FV objects do not store their Jacobian data in TaggingInterface data structures; instead they
  // add into the cache directly. So we do not need the same cache calls for the Jacobian that we
  // need for the residual
  if (_num_cached % 20 == 0)
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    this->_subproblem.SubProblem::addCachedJacobian(_tid);
  }
}

pre()

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

overridevirtualinherited

This is called once before all face-looping.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 366 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()

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

overrideprivatevirtualinherited

Print ordering of objects executed on each block.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 414 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()

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

overrideprivatevirtualinherited

Print ordering of objects exected on each boundary.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 417 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()

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

overrideprivatevirtualinherited

Print list of object types executed and in which order.

Reimplemented from ThreadedFaceLoop< RangeType >.

Definition at line 411 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()

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

privateinherited

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

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

setup()

template<typename RangeType >

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

inlineoverrideprotectedvirtual

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

Implements ComputeFVFluxThread< RangeType, AttribMatrixTags >.

Definition at line 888 of file ComputeFVFluxThread.h.

{ obj.jacobianSetup(); }

subdomainChanged()

void ComputeFVFluxThread< RangeType, AttribMatrixTags >::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 371 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().

_elem_face_mats

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

privateinherited

Element face materials.

Definition at line 433 of file ComputeFVFluxThread.h.

_elem_sub_elem_face_mats

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

privateinherited

Definition at line 434 of file ComputeFVFluxThread.h.

_elem_sub_fv_flux_kernels

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

privateinherited

Definition at line 429 of file ComputeFVFluxThread.h.

_elem_sub_fv_vars

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

privateinherited

Definition at line 424 of file ComputeFVFluxThread.h.

_elem_sub_neigh_face_mats

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

privateinherited

Definition at line 439 of file ComputeFVFluxThread.h.

_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().

_fv_flux_kernels

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

privateinherited

FVFluxKernels.

Definition at line 428 of file ComputeFVFluxThread.h.

_fv_vars

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

privateinherited

Variables.

Definition at line 423 of file ComputeFVFluxThread.h.

_incoming_throw_on_error

template<typename RangeType >

const bool ThreadedFaceLoop< RangeType >::_incoming_throw_on_error

privateinherited

The value of Moose::_throw_on_error at the time of construction.

This data member only has meaning and will only be read if this is the thread 0 copy of the class

Definition at line 179 of file ComputeFVFluxThread.h.

_mesh

template<typename RangeType >

MooseMesh& ThreadedFaceLoop< RangeType >::_mesh

protectedinherited

Definition at line 141 of file ComputeFVFluxThread.h.

_neigh_face_mats

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

privateinherited

Definition at line 438 of file ComputeFVFluxThread.h.

_neigh_sub_elem_face_mats

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

privateinherited

Definition at line 435 of file ComputeFVFluxThread.h.

_neigh_sub_fv_flux_kernels

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

privateinherited

Definition at line 430 of file ComputeFVFluxThread.h.

_neigh_sub_fv_vars

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

privateinherited

Definition at line 425 of file ComputeFVFluxThread.h.

_neigh_sub_neigh_face_mats

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

privateinherited

Definition at line 440 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, AttribMatrixTags >::_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.

_scaling_jacobian

const bool ComputeFVFluxThread< RangeType, AttribMatrixTags >::_scaling_jacobian

privateinherited

Definition at line 442 of file ComputeFVFluxThread.h.

_scaling_residual

const bool ComputeFVFluxThread< RangeType, AttribMatrixTags >::_scaling_residual

privateinherited

Definition at line 443 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().

_zeroth_copy

template<typename RangeType >

const bool ThreadedFaceLoop< RangeType >::_zeroth_copy

privateinherited

Whether this is the zeroth threaded copy of this body.

Definition at line 175 of file ComputeFVFluxThread.h.

---

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

• include/loops/ComputeFVFluxThread.h