Adds contributions from face terms discretized using the finite volume method to the matrix and right hand side of a linear system. More...

#include <ComputeLinearFVFaceThread.h>

Public Types
using	FaceInfoRange = StoredRange< MooseMesh::const_face_info_iterator, const FaceInfo * >

Public Member Functions
	ComputeLinearFVFaceThread (FEProblemBase &fe_problem, const unsigned int linear_system_num, const Moose::FV::LinearFVComputationMode mode, const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
	Class constructor.

	ComputeLinearFVFaceThread (ComputeLinearFVFaceThread &x, Threads::split split)
	Splitting constructor.

void	operator() (const FaceInfoRange &range)
	Operator which is used to execute the thread over a certain iterator range.

void	join (const ComputeLinearFVFaceThread &)
	Join threads at the end of the execution.

Protected Member Functions
void	setupSystemContributionObjects ()
	Setup the contribution objects before we start the loop.

void	fetchBlockSystemContributionObjects ()
	Fetch LinearFVFluxKernels for a given block.

void	printGeneralExecutionInformation () const
	Print list of executed object types together with the execution order.

void	printBlockExecutionInformation () const
	Print ordering of objects executed on each block.

Protected Attributes
FEProblemBase &	_fe_problem
	Reference to the problem.

const unsigned int	_system_number
	The number of the linear system we are contributing to.

const Moose::FV::LinearFVComputationMode	_mode
	The mode in which this thread is operating.

const std::set< TagID > &	_vector_tags
	The vector tags this thread contributes to.

const std::set< TagID > &	_matrix_tags
	The matrix tags this thread contributes to.

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.

THREAD_ID	_tid
	Thread ID.

std::vector< LinearFVFluxKernel * >	_fv_flux_kernels_elem
	Kernels which will only contribute to a matrix from the element-side of the face.

std::vector< LinearFVFluxKernel * >	_fv_flux_kernels_neighbor
	Kernels which will only contribute to a matrix from the neighbor-side of the face.

std::set< LinearFVFluxKernel * >	_fv_flux_kernels
	Combined LinearFVFluxKernels which will be used to contribute to a system.

Private Attributes
bool	_system_contrib_objects_ready
	Boolean that is used to check if the kernels are ready to start contributing to the system.

Detailed Description

Adds contributions from face terms discretized using the finite volume method to the matrix and right hand side of a linear system.

Definition at line 27 of file ComputeLinearFVFaceThread.h.

Member Typedef Documentation

◆ FaceInfoRange

using ComputeLinearFVFaceThread::FaceInfoRange = StoredRange<MooseMesh::const_face_info_iterator, const FaceInfo *>

Definition at line 53 of file ComputeLinearFVFaceThread.h.

Constructor & Destructor Documentation

◆ ComputeLinearFVFaceThread() [1/2]

ComputeLinearFVFaceThread::ComputeLinearFVFaceThread	(	FEProblemBase &	fe_problem,
		const unsigned int	linear_system_num,
		const Moose::FV::LinearFVComputationMode	mode,
		const std::set< TagID > &	vector_tags,
		const std::set< TagID > &	matrix_tags
	)

Class constructor.

Parameters

fe_problem	Reference to the problem
linear_system_num	The number of the linear system which is assembled by this thread
mode	Computation mode (rhs, matrix or both)
vector_tags	The vector tags this thread should contribute to. These are used to query the warehouse for the objects that should contribute to the right hand side.
matrix_tags	The matrix tags this thread should contribute to. These are used to query the warehouse for the objects that should contribute to the matrix.

Definition at line 16 of file ComputeLinearFVFaceThread.C.

  : _fe_problem(fe_problem),
    _system_number(system_num),
    _mode(mode),
    _vector_tags(vector_tags),
    _matrix_tags(matrix_tags),
    _system_contrib_objects_ready(false)
{
}

◆ ComputeLinearFVFaceThread() [2/2]

ComputeLinearFVFaceThread::ComputeLinearFVFaceThread	(	ComputeLinearFVFaceThread &	x,
		Threads::split	split
	)

Splitting constructor.

Parameters

x	Reference to the other thread
split	The thread split

Definition at line 31 of file ComputeLinearFVFaceThread.C.

  : _fe_problem(x._fe_problem),
    _system_number(x._system_number),
    _mode(x._mode),
    _vector_tags(x._vector_tags),
    _matrix_tags(x._matrix_tags),
    _system_contrib_objects_ready(x._system_contrib_objects_ready)
{
}

Member Function Documentation

◆ fetchBlockSystemContributionObjects()

void ComputeLinearFVFaceThread::fetchBlockSystemContributionObjects ( )

protected

Fetch LinearFVFluxKernels for a given block.

We only call this when we transition from one block to another.

Definition at line 122 of file ComputeLinearFVFaceThread.C.

{
  mooseAssert(_system_contrib_objects_ready,
              "The system contribution objects need to be set up before we fetch the "
              "block-restricted objects!");
 
  _fv_flux_kernels.clear();
 
  if (_subdomain != _old_subdomain)
  {
    // We just filter based on subdomain ID on top of everything else
    std::vector<LinearFVFluxKernel *> kernels_after_vector;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSysNum>(_system_number)
        .template condition<AttribSystem>("LinearFVFluxKernel")
        .template condition<AttribKokkos>(false)
        .template condition<AttribThread>(_tid)
        .template condition<AttribVectorTags>(_vector_tags)
        .template condition<AttribSubdomains>(_subdomain)
        .queryInto(kernels_after_vector);
    std::vector<LinearFVFluxKernel *> kernels_after_matrix;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSysNum>(_system_number)
        .template condition<AttribSystem>("LinearFVFluxKernel")
        .template condition<AttribKokkos>(false)
        .template condition<AttribThread>(_tid)
        .template condition<AttribMatrixTags>(_matrix_tags)
        .template condition<AttribSubdomains>(_subdomain)
        .queryInto(kernels_after_matrix);
 
    // We populate the list of kernels with the union of the two vectors
    MooseUtils::getUnion(kernels_after_vector, kernels_after_matrix, _fv_flux_kernels_elem);
    _old_subdomain = _subdomain;
  }
  _fv_flux_kernels.insert(_fv_flux_kernels_elem.begin(), _fv_flux_kernels_elem.end());
 
  if (_neighbor_subdomain != _old_neighbor_subdomain)
  {
    // Here we just filter based on subdomain ID on top of everything else
    std::vector<LinearFVFluxKernel *> kernels_after_vector;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSysNum>(_system_number)
        .template condition<AttribSystem>("LinearFVFluxKernel")
        .template condition<AttribKokkos>(false)
        .template condition<AttribThread>(_tid)
        .template condition<AttribVectorTags>(_vector_tags)
        .template condition<AttribSubdomains>(_neighbor_subdomain)
        .queryInto(kernels_after_vector);
    std::vector<LinearFVFluxKernel *> kernels_after_matrix;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSysNum>(_system_number)
        .template condition<AttribSystem>("LinearFVFluxKernel")
        .template condition<AttribKokkos>(false)
        .template condition<AttribThread>(_tid)
        .template condition<AttribMatrixTags>(_matrix_tags)
        .template condition<AttribSubdomains>(_neighbor_subdomain)
        .queryInto(kernels_after_matrix);
 
    // We populate the list of kernels with the union of the two vectors
    MooseUtils::getUnion(kernels_after_vector, kernels_after_matrix, _fv_flux_kernels_neighbor);
    _old_neighbor_subdomain = _neighbor_subdomain;
  }
  _fv_flux_kernels.insert(_fv_flux_kernels_neighbor.begin(), _fv_flux_kernels_neighbor.end());
}

Referenced by operator()().

◆ join()

void ComputeLinearFVFaceThread::join ( const ComputeLinearFVFaceThread & )

Join threads at the end of the execution.

Definition at line 81 of file ComputeLinearFVFaceThread.C.

82{

83}

◆ operator()()

void ComputeLinearFVFaceThread::operator() ( const FaceInfoRange & range )

Operator which is used to execute the thread over a certain iterator range.

Parameters

range The range of FaceInfos which should be computed.

Definition at line 43 of file ComputeLinearFVFaceThread.C.

{
  ParallelUniqueId puid;
  _tid = puid.id;
 
  _old_subdomain = Moose::INVALID_BLOCK_ID;
  _old_neighbor_subdomain = Moose::INVALID_BLOCK_ID;
 
  setupSystemContributionObjects();
  printGeneralExecutionInformation();
 
  // Iterate over all the elements in the range
  for (const auto & face_info : range)
  {
    _subdomain = face_info->elem().subdomain_id();
    _neighbor_subdomain =
        face_info->neighborPtr() ? face_info->neighbor().subdomain_id() : _subdomain;
    if (_subdomain != _old_subdomain || _neighbor_subdomain != _old_neighbor_subdomain)
    {
      fetchBlockSystemContributionObjects();
      printBlockExecutionInformation();
    }
 
    const Real face_area = face_info->faceArea() * face_info->faceCoord();
 
    // Time to execute the kernels that contribute to the matrix and
    // right hand side
    for (auto & kernel : _fv_flux_kernels)
    {
      kernel->setupFaceData(face_info);
      kernel->setCurrentFaceArea(face_area);
      kernel->addMatrixContribution();
      kernel->addRightHandSideContribution();
    }
  }
}

◆ printBlockExecutionInformation()

void ComputeLinearFVFaceThread::printBlockExecutionInformation ( ) const

protected

Print ordering of objects executed on each block.

Definition at line 206 of file ComputeLinearFVFaceThread.C.

{
  if (!_fe_problem.shouldPrintExecution(_tid) || _fv_flux_kernels.empty())
    return;
 
  // Print the location of the execution
  auto & console = _fe_problem.console();
  console << "[DBG] Linear flux kernels on block "
          << _fe_problem.mesh().getSubdomainName(_subdomain);
  if (_neighbor_subdomain != Moose::INVALID_BLOCK_ID)
    console << " and neighbor " << _fe_problem.mesh().getSubdomainName(_neighbor_subdomain)
            << std::endl;
  else
    console << " with no neighbor block" << std::endl;
 
  // Print the list of objects
  std::vector<MooseObject *> kernels_to_print;
  for (const auto & kernel : _fv_flux_kernels)
    kernels_to_print.push_back(dynamic_cast<MooseObject *>(kernel));
  console << ConsoleUtils::formatString(ConsoleUtils::mooseObjectVectorToString(kernels_to_print),
                                        "[DBG]")
          << std::endl;
}

Referenced by operator()().

◆ printGeneralExecutionInformation()

void ComputeLinearFVFaceThread::printGeneralExecutionInformation ( ) const

protected

Print list of executed object types together with the execution order.

Definition at line 192 of file ComputeLinearFVFaceThread.C.

{
  if (!_fe_problem.shouldPrintExecution(_tid))
    return;
  auto & console = _fe_problem.console();
  auto execute_on = _fe_problem.getCurrentExecuteOnFlag();
  console << "[DBG] Beginning linear 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] - linear finite volume flux kernels" << std::endl);
}

Referenced by operator()().

◆ setupSystemContributionObjects()

void ComputeLinearFVFaceThread::setupSystemContributionObjects ( )

protected

Setup the contribution objects before we start the loop.

Definition at line 86 of file ComputeLinearFVFaceThread.C.

{
  // The reason why we need to grab vectors and matrices separately is that
  // we want to grab a union instead of an intersection.
  std::vector<LinearFVFluxKernel *> kernels_after_vectors;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_system_number)
      .template condition<AttribSystem>("LinearFVFluxKernel")
      .template condition<AttribKokkos>(false)
      .template condition<AttribThread>(_tid)
      .template condition<AttribVectorTags>(_vector_tags)
      .queryInto(kernels_after_vectors);
 
  std::vector<LinearFVFluxKernel *> kernels_after_matrices;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_system_number)
      .template condition<AttribSystem>("LinearFVFluxKernel")
      .template condition<AttribKokkos>(false)
      .template condition<AttribThread>(_tid)
      .template condition<AttribMatrixTags>(_matrix_tags)
      .queryInto(kernels_after_matrices);
 
  // We fetch the union of the available objects
  std::vector<LinearFVFluxKernel *> kernels;
  MooseUtils::getUnion(kernels_after_vectors, kernels_after_matrices, kernels);
 
  // As a last step, we make sure the kernels know which vectors/matrices they need to contribute to
  for (auto & kernel : kernels)
    kernel->linkTaggedVectorsAndMatrices(_vector_tags, _matrix_tags);
 
  _system_contrib_objects_ready = true;
}