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

#include <ComputeLinearFVElementalThread.h>

Public Types
using	ElemInfoRange = StoredRange< MooseMesh::const_elem_info_iterator, const ElemInfo * >

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

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

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

void	join (const ComputeLinearFVElementalThread &)
	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 contribution objects that belong to a specific spatial subdomain.

void	printGeneralExecutionInformation () const
	Print list of object types executed and in which 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 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.

THREAD_ID	_tid
	Thread ID.

SubdomainID	_subdomain
	The subdomain for the current element.

SubdomainID	_old_subdomain
	The subdomain for the last element.

std::vector< LinearFVElementalKernel * >	_fv_kernels
	The set of cached elemental kernels which will be executed on a given element.

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 volumetric terms discretized using the finite volume method to the matrix and right hand side of a linear system.

Definition at line 27 of file ComputeLinearFVElementalThread.h.

Member Typedef Documentation

◆ ElemInfoRange

using ComputeLinearFVElementalThread::ElemInfoRange = StoredRange<MooseMesh::const_elem_info_iterator, const ElemInfo *>

Definition at line 50 of file ComputeLinearFVElementalThread.h.

Constructor & Destructor Documentation

◆ ComputeLinearFVElementalThread() [1/2]

ComputeLinearFVElementalThread::ComputeLinearFVElementalThread	(	FEProblemBase &	fe_problem,
		const unsigned int	linear_system_num,
		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
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 ComputeLinearFVElementalThread.C.

  : _fe_problem(fe_problem),
    _system_number(system_num),
    _vector_tags(vector_tags),
    _matrix_tags(matrix_tags),
    _subdomain(Moose::INVALID_BLOCK_ID),
    _old_subdomain(Moose::INVALID_BLOCK_ID),
    _system_contrib_objects_ready(false)
{
}

◆ ComputeLinearFVElementalThread() [2/2]

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

Splitting constructor.

Parameters

x	Reference to the other thread
split	The thread split

Definition at line 31 of file ComputeLinearFVElementalThread.C.

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

Member Function Documentation

◆ fetchBlockSystemContributionObjects()

void ComputeLinearFVElementalThread::fetchBlockSystemContributionObjects ( )

protected

Fetch contribution objects that belong to a specific spatial subdomain.

Definition at line 119 of file ComputeLinearFVElementalThread.C.

{
  mooseAssert(_system_contrib_objects_ready,
              "The system contribution objects need to be set up before we fetch the "
              "block-restricted objects!");
 
  // Here we just filter based on subdomain ID on top of everything else
  std::vector<LinearFVElementalKernel *> kernels_after_vector;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_system_number)
      .template condition<AttribSystem>("LinearFVElementalKernel")
      .template condition<AttribKokkos>(false)
      .template condition<AttribThread>(_tid)
      .template condition<AttribVectorTags>(_vector_tags)
      .template condition<AttribSubdomains>(_subdomain)
      .queryInto(kernels_after_vector);
 
  std::vector<LinearFVElementalKernel *> kernels_after_matrix;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_system_number)
      .template condition<AttribSystem>("LinearFVElementalKernel")
      .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_kernels);
 
  _old_subdomain = _subdomain;
}

Referenced by operator()().

◆ join()

void ComputeLinearFVElementalThread::join ( const ComputeLinearFVElementalThread & )

Join threads at the end of the execution.

Definition at line 78 of file ComputeLinearFVElementalThread.C.

79{

80}

◆ operator()()

void ComputeLinearFVElementalThread::operator() ( const ElemInfoRange & range )

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

Parameters

range The range of ElemInfos which should be computed.

Definition at line 44 of file ComputeLinearFVElementalThread.C.

{
  ParallelUniqueId puid;
  _tid = puid.id;
 
  _old_subdomain = Moose::INVALID_BLOCK_ID;
 
  setupSystemContributionObjects();
  printGeneralExecutionInformation();
 
  // Iterate over all the elements in the range
  for (const auto & elem_info : range)
  {
    _subdomain = elem_info->subdomain_id();
    if (_subdomain != _old_subdomain)
    {
      fetchBlockSystemContributionObjects();
      printBlockExecutionInformation();
    }
 
    const Real elem_volume = elem_info->volume() * elem_info->coordFactor();
 
    // Time to add the contributions from the kernels
    for (auto kernel : _fv_kernels)
    {
      kernel->setCurrentElemInfo(elem_info);
      kernel->setCurrentElemVolume(elem_volume);
      kernel->addMatrixContribution();
      kernel->addRightHandSideContribution();
    }
  }
}

◆ printBlockExecutionInformation()

void ComputeLinearFVElementalThread::printBlockExecutionInformation ( ) const

protected

Print ordering of objects executed on each block.

Definition at line 170 of file ComputeLinearFVElementalThread.C.

{
  if (!_fe_problem.shouldPrintExecution(_tid) || _fv_kernels.empty())
    return;
 
  auto & console = _fe_problem.console();
  console << "[DBG] Linear FV elemental kernels on block "
          << _fe_problem.mesh().getSubdomainName(_subdomain);
 
  // Print the list of objects
  std::vector<MooseObject *> kernels_to_print;
  for (const auto & kernel : _fv_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 ComputeLinearFVElementalThread::printGeneralExecutionInformation ( ) const

protected

Print list of object types executed and in which order.

Definition at line 155 of file ComputeLinearFVElementalThread.C.

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

Referenced by operator()().

◆ setupSystemContributionObjects()

void ComputeLinearFVElementalThread::setupSystemContributionObjects ( )

protected

Setup the contribution objects before we start the loop.

Definition at line 83 of file ComputeLinearFVElementalThread.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<LinearFVElementalKernel *> kernels_after_vectors;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_system_number)
      .template condition<AttribSystem>("LinearFVElementalKernel")
      .template condition<AttribKokkos>(false)
      .template condition<AttribThread>(_tid)
      .template condition<AttribVectorTags>(_vector_tags)
      .queryInto(kernels_after_vectors);
 
  std::vector<LinearFVElementalKernel *> kernels_after_matrices;
  _fe_problem.theWarehouse()
      .query()
      .template condition<AttribSysNum>(_system_number)
      .template condition<AttribSystem>("LinearFVElementalKernel")
      .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<LinearFVElementalKernel *> 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;
}