Moose::MFEM::CoefficientManager Class Reference

Front-end class for creating and storing MFEM coefficients. More...

#include <CoefficientManager.h>

Public Member Functions
	CoefficientManager ()=default
mfem::Coefficient &	declareScalar (const std::string &name, const std::string &existing_or_literal)
	Declare an alias to an existing scalar coefficient or, if it does not exist, try interpreting the name as a number with which to create a new constant coefficient.
template<class P , class... Args>
P &	declareScalar (const std::string &name, Args &&... args)
	Create a new scalar coefficient, constructed from the argument pack.
mfem::Coefficient &	declareScalarProperty (const std::string &name, const std::vector< std::string > &blocks, const std::string &existing_or_literal)
	Use an existing scalar coefficient for a property on some blocks of the mesh.
template<class P , class... Args>
mfem::Coefficient &	declareScalarProperty (const std::string &name, const std::vector< std::string > &blocks, Args &&... args)
	Use a new scalar coefficient, constructed from the argument pack, for a property on some blocks of the mesh.
mfem::VectorCoefficient &	declareVector (const std::string &name, const std::string &existing_or_literal)
	Declare an alias to an existing vector coefficientor or, if it does not exist, try interpreting the name as a vector of numbers with which to create a new constant vector coefficient.
template<class P , class... Args>
P &	declareVector (const std::string &name, Args &&... args)
	Create a new vector coefficient, constructed from the argument pack.
mfem::VectorCoefficient &	declareVectorProperty (const std::string &name, const std::vector< std::string > &blocks, const std::string &existing_or_literal)
	Use an existing vector coefficient for a property on some blocks of the mesh.
template<class P , class... Args>
mfem::VectorCoefficient &	declareVectorProperty (const std::string &name, const std::vector< std::string > &blocks, Args &&... args)
	Use a new vector coefficient, constructed from the argument pack, for a property on some blocks of the mesh.
mfem::MatrixCoefficient &	declareMatrix (const std::string &name, const std::string &existing_coef)
	Declare an alias to an existing matrix coefficient.
template<class P , class... Args>
P &	declareMatrix (const std::string &name, Args &&... args)
	Create a new matrix coefficient, constructed from the argument pack.
mfem::MatrixCoefficient &	declareMatrixProperty (const std::string &name, const std::vector< std::string > &blocks, const std::string &existing_coef)
	Use an existing matrix coefficient for a property on some blocks of the mesh.
template<class P , class... Args>
mfem::MatrixCoefficient &	declareMatrixProperty (const std::string &name, const std::vector< std::string > &blocks, Args &&... args)
	Use a new matrix coefficient, constructed from the argument pack, for a property on some blocks of the mesh.
mfem::Coefficient &	getScalarCoefficient (const std::string &name)
	Return a scalar coefficient with the given name or, if that doesn't exists, try interpreting the name as a number with which to build a new constant coefficient.
mfem::VectorCoefficient &	getVectorCoefficient (const std::string &name)
	Return a vector coefficient with the given name or, if that doesn't exists, try interpreting the name as a vector of number with which to build a new constant vector coefficient.
mfem::MatrixCoefficient &	getMatrixCoefficient (const std::string &name)
	Return scalar coefficient with the given name.
bool	scalarPropertyIsDefined (const std::string &name, const std::string &block) const
bool	vectorPropertyIsDefined (const std::string &name, const std::string &block) const
bool	matrixPropertyIsDefined (const std::string &name, const std::string &block) const
void	setTime (const mfem::real_t time)
void	markSolutionChanged ()
	Notify quadrature function coefficients that solution variables have changed, marking the stored values of those with a NONLINEAR update policy as stale so their source coefficients are re-projected on next use.

Private Member Functions
mfem::Coefficient &	declareScalar (const std::string &name, std::shared_ptr< mfem::Coefficient > coef)
mfem::Coefficient &	declareScalarProperty (const std::string &name, const std::vector< std::string > &blocks, std::shared_ptr< mfem::Coefficient > coef)
mfem::VectorCoefficient &	declareVector (const std::string &name, std::shared_ptr< mfem::VectorCoefficient > coef)
mfem::VectorCoefficient &	declareVectorProperty (const std::string &name, const std::vector< std::string > &blocks, std::shared_ptr< mfem::VectorCoefficient > coef)
mfem::MatrixCoefficient &	declareMatrix (const std::string &name, std::shared_ptr< mfem::MatrixCoefficient > coef)
mfem::MatrixCoefficient &	declareMatrixProperty (const std::string &name, const std::vector< std::string > &blocks, std::shared_ptr< mfem::MatrixCoefficient > coef)
std::shared_ptr< mfem::Coefficient >	getScalarCoefficientPtr (const std::string &name)
std::shared_ptr< mfem::VectorCoefficient >	getVectorCoefficientPtr (const std::string &name)
std::shared_ptr< mfem::MatrixCoefficient >	getMatrixCoefficientPtr (const std::string &name)

Private Attributes
ScalarMap	_scalar_coeffs
VectorMap	_vector_coeffs
MatrixMap	_matrix_coeffs

Detailed Description

Front-end class for creating and storing MFEM coefficients.

They can be created so they are global (defined across the entire domain) or as piecewise material properties.

Definition at line 32 of file CoefficientManager.h.

Constructor & Destructor Documentation

CoefficientManager()

Moose::MFEM::CoefficientManager::CoefficientManager ( )

default

Member Function Documentation

declareMatrix() [1/3]

template<class P , class... Args>

P & Moose::MFEM::CoefficientManager::declareMatrix ( const std::string &  name, Args &&...  args  )

inline

Create a new matrix coefficient, constructed from the argument pack.

Definition at line 122 of file CoefficientManager.h.

  {
    auto coef = _matrix_coeffs.make<P>(args...);
    this->declareMatrix(name, coef);
    return *coef;
  }

declareMatrix() [2/3]

mfem::MatrixCoefficient & Moose::MFEM::CoefficientManager::declareMatrix	(	const std::string &	name,
		const std::string &	existing_coef
	)

Declare an alias to an existing matrix coefficient.

Unlike for the scalar and vector counterparts, there is currently no way to try interpreting the name as numbers with which to construct a constant matrix coefficient.

Definition at line 97 of file CoefficientManager.C.

{
  return this->declareMatrix(name, this->getMatrixCoefficientPtr(existing_coef));
}

Referenced by declareMatrix(), and declareMatrix().

declareMatrix() [3/3]

mfem::MatrixCoefficient & Moose::MFEM::CoefficientManager::declareMatrix ( const std::string &  name, std::shared_ptr< mfem::MatrixCoefficient >  coef  )

private

Definition at line 89 of file CoefficientManager.C.

{
  this->_matrix_coeffs.addCoefficient(name, coef);
  return *coef;
}

declareMatrixProperty() [1/3]

template<class P , class... Args>

mfem::MatrixCoefficient & Moose::MFEM::CoefficientManager::declareMatrixProperty ( const std::string &  name, const std::vector< std::string > &  blocks, Args &&...  args  )

inline

Use a new matrix coefficient, constructed from the argument pack, for a property on some blocks of the mesh.

The property will be a piecewise coefficient and it will have the value of the new coefficient on these blocks.

Definition at line 147 of file CoefficientManager.h.

  {
    return this->declareMatrixProperty(name, blocks, _matrix_coeffs.make<P>(args...));
  }

declareMatrixProperty() [2/3]

mfem::MatrixCoefficient & Moose::MFEM::CoefficientManager::declareMatrixProperty	(	const std::string &	name,
		const std::vector< std::string > &	blocks,
		const std::string &	existing_coef
	)

Use an existing matrix coefficient for a property on some blocks of the mesh.

The property will be a piecewise coefficient and it will have the value of existing_coef on these blocks. Unlike for the scalar and vector counterparts, there is currently no way to try interpreting the name as numbers with which to construct a constant matrix coefficient.

Definition at line 112 of file CoefficientManager.C.

{
  std::shared_ptr<mfem::MatrixCoefficient> coef = this->getMatrixCoefficientPtr(existing_coef);
  if (std::dynamic_pointer_cast<mfem::PWMatrixCoefficient>(coef))
    mooseError("Properties must not be defined out of other properties or piecewise coefficients.");
  return this->declareMatrixProperty(name, blocks, coef);
}

Referenced by declareMatrixProperty(), and declareMatrixProperty().

declareMatrixProperty() [3/3]

mfem::MatrixCoefficient & Moose::MFEM::CoefficientManager::declareMatrixProperty ( const std::string &  name, const std::vector< std::string > &  blocks, std::shared_ptr< mfem::MatrixCoefficient >  coef  )

private

Definition at line 103 of file CoefficientManager.C.

{
  this->_matrix_coeffs.addPiecewiseBlocks(name, coef, blocks);
  return getMatrixCoefficient(name);
}

declareScalar() [1/3]

template<class P , class... Args>

P & Moose::MFEM::CoefficientManager::declareScalar ( const std::string &  name, Args &&...  args  )

inline

Create a new scalar coefficient, constructed from the argument pack.

Definition at line 44 of file CoefficientManager.h.

  {
    auto coef = _scalar_coeffs.make<P>(args...);
    this->declareScalar(name, coef);
    return *coef;
  }

declareScalar() [2/3]

mfem::Coefficient & Moose::MFEM::CoefficientManager::declareScalar	(	const std::string &	name,
		const std::string &	existing_or_literal
	)

Declare an alias to an existing scalar coefficient or, if it does not exist, try interpreting the name as a number with which to create a new constant coefficient.

Definition at line 28 of file CoefficientManager.C.

{
  return this->declareScalar(name, this->getScalarCoefficientPtr(existing_or_literal));
}

Referenced by MFEMProblem::addFunction(), MFEMProblem::addPostprocessor(), MFEMComplexVariable::declareCoefficients(), MFEMVariable::declareCoefficients(), declareScalar(), declareScalar(), and MFEMScalarQuadratureFunction::MFEMScalarQuadratureFunction().

declareScalar() [3/3]

mfem::Coefficient & Moose::MFEM::CoefficientManager::declareScalar ( const std::string &  name, std::shared_ptr< mfem::Coefficient >  coef  )

private

Definition at line 21 of file CoefficientManager.C.

{
  this->_scalar_coeffs.addCoefficient(name, coef);
  return *coef;
}

declareScalarProperty() [1/3]

template<class P , class... Args>

mfem::Coefficient & Moose::MFEM::CoefficientManager::declareScalarProperty ( const std::string &  name, const std::vector< std::string > &  blocks, Args &&...  args  )

inline

Use a new scalar coefficient, constructed from the argument pack, for a property on some blocks of the mesh.

The property will be a piecewise coefficient and it will have the value of the new coefficient on these blocks.

Definition at line 68 of file CoefficientManager.h.

  {
    return this->declareScalarProperty(name, blocks, _scalar_coeffs.make<P>(args...));
  }

declareScalarProperty() [2/3]

mfem::Coefficient & Moose::MFEM::CoefficientManager::declareScalarProperty	(	const std::string &	name,
		const std::vector< std::string > &	blocks,
		const std::string &	existing_or_literal
	)

Use an existing scalar coefficient for a property on some blocks of the mesh.

The property will be a piecewise coefficient and it will have the value of existing_coef on these blocks. If no such scalar coefficient exists, try interpreting the name as a number with which to create a new constant coefficient.

Definition at line 43 of file CoefficientManager.C.

{
  std::shared_ptr<mfem::Coefficient> coef = this->getScalarCoefficientPtr(existing_or_literal);
  if (std::dynamic_pointer_cast<mfem::PWCoefficient>(coef))
    mooseError("Properties must not be defined out of other properties or piecewise coefficients.");
  return this->declareScalarProperty(name, blocks, coef);
}

Referenced by declareScalarProperty(), declareScalarProperty(), and MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial().

declareScalarProperty() [3/3]

mfem::Coefficient & Moose::MFEM::CoefficientManager::declareScalarProperty ( const std::string &  name, const std::vector< std::string > &  blocks, std::shared_ptr< mfem::Coefficient >  coef  )

private

Definition at line 34 of file CoefficientManager.C.

{
  this->_scalar_coeffs.addPiecewiseBlocks(name, coef, blocks);
  return getScalarCoefficient(name);
}

declareVector() [1/3]

template<class P , class... Args>

P & Moose::MFEM::CoefficientManager::declareVector ( const std::string &  name, Args &&...  args  )

inline

Create a new vector coefficient, constructed from the argument pack.

Definition at line 82 of file CoefficientManager.h.

  {
    auto coef = _vector_coeffs.make<P>(args...);
    this->declareVector(name, coef);
    return *coef;
  }

declareVector() [2/3]

mfem::VectorCoefficient & Moose::MFEM::CoefficientManager::declareVector	(	const std::string &	name,
		const std::string &	existing_or_literal
	)

Declare an alias to an existing vector coefficientor or, if it does not exist, try interpreting the name as a vector of numbers with which to create a new constant vector coefficient.

Definition at line 62 of file CoefficientManager.C.

{
  return this->declareVector(name, this->getVectorCoefficientPtr(existing_or_literal));
}

Referenced by MFEMProblem::addFunction(), MFEMComplexVariable::declareCoefficients(), MFEMVariable::declareCoefficients(), declareVector(), declareVector(), and MFEMVectorQuadratureFunction::MFEMVectorQuadratureFunction().

declareVector() [3/3]

mfem::VectorCoefficient & Moose::MFEM::CoefficientManager::declareVector ( const std::string &  name, std::shared_ptr< mfem::VectorCoefficient >  coef  )

private

Definition at line 54 of file CoefficientManager.C.

{
  this->_vector_coeffs.addCoefficient(name, coef);
  return *coef;
}

declareVectorProperty() [1/3]

template<class P , class... Args>

mfem::VectorCoefficient & Moose::MFEM::CoefficientManager::declareVectorProperty ( const std::string &  name, const std::vector< std::string > &  blocks, Args &&...  args  )

inline

Use a new vector coefficient, constructed from the argument pack, for a property on some blocks of the mesh.

The property will be a piecewise coefficient and it will have the value of the new coefficient on these blocks.

Definition at line 107 of file CoefficientManager.h.

  {
    return this->declareVectorProperty(name, blocks, _vector_coeffs.make<P>(args...));
  }

declareVectorProperty() [2/3]

mfem::VectorCoefficient & Moose::MFEM::CoefficientManager::declareVectorProperty	(	const std::string &	name,
		const std::vector< std::string > &	blocks,
		const std::string &	existing_or_literal
	)

Use an existing vector coefficient for a property on some blocks of the mesh.

The property will be a piecewise coefficient and it will have the value of existing_coef on these blocks. If no such vector coefficient exists, try interpreting the name as a vector of numbers with which to create a new constant vector coefficient.

Definition at line 77 of file CoefficientManager.C.

{
  std::shared_ptr<mfem::VectorCoefficient> coef =
      this->getVectorCoefficientPtr(existing_or_literal);
  if (std::dynamic_pointer_cast<mfem::PWVectorCoefficient>(coef))
    mooseError("Properties must not be defined out of other properties or piecewise coefficients.");
  return this->declareVectorProperty(name, blocks, coef);
}

Referenced by declareVectorProperty(), declareVectorProperty(), and MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial().

declareVectorProperty() [3/3]

mfem::VectorCoefficient & Moose::MFEM::CoefficientManager::declareVectorProperty ( const std::string &  name, const std::vector< std::string > &  blocks, std::shared_ptr< mfem::VectorCoefficient >  coef  )

private

Definition at line 68 of file CoefficientManager.C.

{
  this->_vector_coeffs.addPiecewiseBlocks(name, coef, blocks);
  return getVectorCoefficient(name);
}

getMatrixCoefficient()

mfem::MatrixCoefficient & Moose::MFEM::CoefficientManager::getMatrixCoefficient

(

const std::string &

name

)

Return scalar coefficient with the given name.

Unlike for the scalar and vector counterparts, there is currently no way to try interpreting the name as numbers with which to construct a constant matrix coefficient.

Definition at line 174 of file CoefficientManager.C.

{
  return *this->getMatrixCoefficientPtr(name);
}

Referenced by declareMatrixProperty(), and MFEMObject::getMatrixCoefficientByName().

getMatrixCoefficientPtr()

std::shared_ptr< mfem::MatrixCoefficient > Moose::MFEM::CoefficientManager::getMatrixCoefficientPtr ( const std::string &  name )

private

Definition at line 155 of file CoefficientManager.C.

{
  return this->_matrix_coeffs.getCoefficientPtr(name);
  // TODO: Work out how to parse literal matrices from input.
}

Referenced by declareMatrix(), declareMatrixProperty(), and getMatrixCoefficient().

getScalarCoefficient()

mfem::Coefficient & Moose::MFEM::CoefficientManager::getScalarCoefficient

(

const std::string &

name

)

Return a scalar coefficient with the given name or, if that doesn't exists, try interpreting the name as a number with which to build a new constant coefficient.

Definition at line 162 of file CoefficientManager.C.

{
  return *this->getScalarCoefficientPtr(name);
}

Referenced by declareScalarProperty(), MFEMObject::getScalarCoefficientByName(), MFEMParsedFunction::initialSetup(), and MFEMParaViewDataCollection::registerScalarCoefficients().

getScalarCoefficientPtr()

std::shared_ptr< mfem::Coefficient > Moose::MFEM::CoefficientManager::getScalarCoefficientPtr ( const std::string &  name )

private

Definition at line 123 of file CoefficientManager.C.

{
  if (this->_scalar_coeffs.hasCoefficient(name))
    return this->_scalar_coeffs.getCoefficientPtr(name);
  // If name not present, check if it can be parsed cleanly into a real number
  std::istringstream ss(MooseUtils::trim(name));
  mfem::real_t real_value;
  if (ss >> real_value && ss.eof())
  {
    this->declareScalar<mfem::ConstantCoefficient>(name, real_value);
    return this->_scalar_coeffs.getCoefficientPtr(name);
  }
  mooseError("Scalar coefficient with name '" + name + "' has not been declared.");
}

Referenced by declareScalar(), declareScalarProperty(), and getScalarCoefficient().

getVectorCoefficient()

mfem::VectorCoefficient & Moose::MFEM::CoefficientManager::getVectorCoefficient

(

const std::string &

name

)

Return a vector coefficient with the given name or, if that doesn't exists, try interpreting the name as a vector of number with which to build a new constant vector coefficient.

Definition at line 168 of file CoefficientManager.C.

{
  return *this->getVectorCoefficientPtr(name);
}

Referenced by MFEMComplexVariable::declareCoefficients(), MFEMVariable::declareCoefficients(), declareVectorProperty(), MFEMObject::getVectorCoefficientByName(), and MFEMParaViewDataCollection::registerVectorCoefficients().

getVectorCoefficientPtr()

std::shared_ptr< mfem::VectorCoefficient > Moose::MFEM::CoefficientManager::getVectorCoefficientPtr ( const std::string &  name )

private

Definition at line 139 of file CoefficientManager.C.

{
  if (this->_vector_coeffs.hasCoefficient(name))
    return this->_vector_coeffs.getCoefficientPtr(name);
  // If name not present, check if it can be parsed cleanly into a vector of real numbers
  std::vector<mfem::real_t> vec_values;
  if (MooseUtils::tokenizeAndConvert(name, vec_values) && vec_values.size() > 0)
  {
    this->declareVector<mfem::VectorConstantCoefficient>(
        name, mfem::Vector(vec_values.data(), vec_values.size()));
    return this->_vector_coeffs.getCoefficientPtr(name);
  }
  mooseError("Vector coefficient with name '" + name + "' has not been declared.");
}

Referenced by declareVector(), declareVectorProperty(), and getVectorCoefficient().

markSolutionChanged()

void Moose::MFEM::CoefficientManager::markSolutionChanged

(

)

Notify quadrature function coefficients that solution variables have changed, marking the stored values of those with a NONLINEAR update policy as stale so their source coefficients are re-projected on next use.

Definition at line 209 of file CoefficientManager.C.

{
  auto mark_solution_changed = [](auto & coef)
  {
    if (auto * const qf_coef = dynamic_cast<MFEMQuadratureFunctionCoefficientBase *>(&coef))
      qf_coef->MarkSolutionChanged();
  };
  this->_scalar_coeffs.apply(mark_solution_changed);
  this->_vector_coeffs.apply(mark_solution_changed);
}

Referenced by Moose::MFEM::EquationSystem::SetTrialVariablesFromTrueVectors(), and Moose::MFEM::ComplexEquationSystem::SetTrialVariablesFromTrueVectors().

matrixPropertyIsDefined()

bool Moose::MFEM::CoefficientManager::matrixPropertyIsDefined	(	const std::string &	name,
		const std::string &	block
	)		const

Definition at line 194 of file CoefficientManager.C.

{
  return this->_matrix_coeffs.propertyDefinedOnBlock(name, block);
}

scalarPropertyIsDefined()

bool Moose::MFEM::CoefficientManager::scalarPropertyIsDefined	(	const std::string &	name,
		const std::string &	block
	)		const

Definition at line 180 of file CoefficientManager.C.

{
  return this->_scalar_coeffs.propertyDefinedOnBlock(name, block);
}

setTime()

void Moose::MFEM::CoefficientManager::setTime

(

const mfem::real_t

time

)

Definition at line 201 of file CoefficientManager.C.

{
  this->_scalar_coeffs.setTime(time);
  this->_vector_coeffs.setTime(time);
  this->_matrix_coeffs.setTime(time);
}

Referenced by Moose::MFEM::TimeDependentEquationSystemProblemOperator::ImplicitSolve().

vectorPropertyIsDefined()

bool Moose::MFEM::CoefficientManager::vectorPropertyIsDefined	(	const std::string &	name,
		const std::string &	block
	)		const

Definition at line 187 of file CoefficientManager.C.

{
  return this->_vector_coeffs.propertyDefinedOnBlock(name, block);
}

Member Data Documentation

_matrix_coeffs

MatrixMap Moose::MFEM::CoefficientManager::_matrix_coeffs

private

Definition at line 183 of file CoefficientManager.h.

Referenced by declareMatrix(), declareMatrix(), declareMatrixProperty(), declareMatrixProperty(), getMatrixCoefficientPtr(), matrixPropertyIsDefined(), and setTime().

_scalar_coeffs

ScalarMap Moose::MFEM::CoefficientManager::_scalar_coeffs

private

Definition at line 181 of file CoefficientManager.h.

Referenced by declareScalar(), declareScalar(), declareScalarProperty(), declareScalarProperty(), getScalarCoefficientPtr(), markSolutionChanged(), scalarPropertyIsDefined(), and setTime().

_vector_coeffs

VectorMap Moose::MFEM::CoefficientManager::_vector_coeffs

private

Definition at line 182 of file CoefficientManager.h.

Referenced by declareVector(), declareVector(), declareVectorProperty(), declareVectorProperty(), getVectorCoefficientPtr(), markSolutionChanged(), setTime(), and vectorPropertyIsDefined().

---

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

• include/mfem/utils/CoefficientManager.h
• src/mfem/utils/CoefficientManager.C