CoefficientManager.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#ifdef MOOSE_MFEM_ENABLED
 
#include "MooseStringUtils.h"
#include "CoefficientManager.h"
#include "MFEMQuadratureFunctionCoefficientBase.h"
#include <algorithm>
 
namespace Moose::MFEM
{
 
mfem::Coefficient &
CoefficientManager::declareScalar(const std::string & name, std::shared_ptr<mfem::Coefficient> coef)
{
  this->_scalar_coeffs.addCoefficient(name, coef);
  return *coef;
}
 
mfem::Coefficient &
CoefficientManager::declareScalar(const std::string & name, const std::string & existing_or_literal)
{
  return this->declareScalar(name, this->getScalarCoefficientPtr(existing_or_literal));
}
 
mfem::Coefficient &
CoefficientManager::declareScalarProperty(const std::string & name,
                                          const std::vector<std::string> & blocks,
                                          std::shared_ptr<mfem::Coefficient> coef)
{
  this->_scalar_coeffs.addPiecewiseBlocks(name, coef, blocks);
  return getScalarCoefficient(name);
}
 
mfem::Coefficient &
CoefficientManager::declareScalarProperty(const std::string & name,
                                          const std::vector<std::string> & blocks,
                                          const std::string & existing_or_literal)
{
  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);
}
 
mfem::VectorCoefficient &
CoefficientManager::declareVector(const std::string & name,
                                  std::shared_ptr<mfem::VectorCoefficient> coef)
{
  this->_vector_coeffs.addCoefficient(name, coef);
  return *coef;
}
 
mfem::VectorCoefficient &
CoefficientManager::declareVector(const std::string & name, const std::string & existing_or_literal)
{
  return this->declareVector(name, this->getVectorCoefficientPtr(existing_or_literal));
}
 
mfem::VectorCoefficient &
CoefficientManager::declareVectorProperty(const std::string & name,
                                          const std::vector<std::string> & blocks,
                                          std::shared_ptr<mfem::VectorCoefficient> coef)
{
  this->_vector_coeffs.addPiecewiseBlocks(name, coef, blocks);
  return getVectorCoefficient(name);
}
 
mfem::VectorCoefficient &
CoefficientManager::declareVectorProperty(const std::string & name,
                                          const std::vector<std::string> & blocks,
                                          const std::string & existing_or_literal)
{
  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);
}
 
mfem::MatrixCoefficient &
CoefficientManager::declareMatrix(const std::string & name,
                                  std::shared_ptr<mfem::MatrixCoefficient> coef)
{
  this->_matrix_coeffs.addCoefficient(name, coef);
  return *coef;
}
 
mfem::MatrixCoefficient &
CoefficientManager::declareMatrix(const std::string & name, const std::string & existing_coef)
{
  return this->declareMatrix(name, this->getMatrixCoefficientPtr(existing_coef));
}
 
mfem::MatrixCoefficient &
CoefficientManager::declareMatrixProperty(const std::string & name,
                                          const std::vector<std::string> & blocks,
                                          std::shared_ptr<mfem::MatrixCoefficient> coef)
{
  this->_matrix_coeffs.addPiecewiseBlocks(name, coef, blocks);
  return getMatrixCoefficient(name);
}
 
mfem::MatrixCoefficient &
CoefficientManager::declareMatrixProperty(const std::string & name,
                                          const std::vector<std::string> & blocks,
                                          const std::string & existing_coef)
{
  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);
}
 
std::shared_ptr<mfem::Coefficient>
CoefficientManager::getScalarCoefficientPtr(const std::string & name)
{
  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.");
}
 
std::shared_ptr<mfem::VectorCoefficient>
CoefficientManager::getVectorCoefficientPtr(const std::string & name)
{
  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.");
}
 
std::shared_ptr<mfem::MatrixCoefficient>
CoefficientManager::getMatrixCoefficientPtr(const std::string & name)
{
  if (this->_matrix_coeffs.hasCoefficient(name))
    return this->_matrix_coeffs.getCoefficientPtr(name);
  // If name not present, try to interpret it as a literal constant matrix. Rows are
  // separated by ';' and entries within a row by whitespace. Every row must
  // have the same number of entries; a string with no ';' is a single row.
  std::vector<std::string> row_strs;
  MooseUtils::tokenize(name, row_strs, 1, ";");
  std::vector<std::vector<mfem::real_t>> rows;
  for (const auto & row_str : row_strs)
  {
    std::vector<mfem::real_t> row_vals;
    if (MooseUtils::tokenizeAndConvert(row_str, row_vals) && row_vals.size() > 0)
    {
      rows.push_back(row_vals);
      if (rows.back().size() != rows.front().size())
        mooseError("Matrix coefficient literal '" + name + "' has rows of differing length.");
    }
  }
  if (rows.size() == static_cast<std::size_t>(std::count(name.begin(), name.end(), ';')) + 1)
  {
    const int nrows = static_cast<int>(rows.size());
    const int ncols = static_cast<int>(rows.front().size());
    mfem::DenseMatrix mat(nrows, ncols);
    for (int i = 0; i < nrows; ++i)
      for (int j = 0; j < ncols; ++j)
        mat(i, j) = rows[i][j];
    this->declareMatrix<mfem::MatrixConstantCoefficient>(name, mat);
    return this->_matrix_coeffs.getCoefficientPtr(name);
  }
  mooseError("Matrix coefficient with name '" + name + "' has not been declared.");
}
 
mfem::Coefficient &
CoefficientManager::getScalarCoefficient(const std::string & name)
{
  return *this->getScalarCoefficientPtr(name);
}
 
mfem::VectorCoefficient &
CoefficientManager::getVectorCoefficient(const std::string & name)
{
  return *this->getVectorCoefficientPtr(name);
}
 
mfem::MatrixCoefficient &
CoefficientManager::getMatrixCoefficient(const std::string & name)
{
  return *this->getMatrixCoefficientPtr(name);
}
 
bool
CoefficientManager::scalarPropertyIsDefined(const std::string & name,
                                            const std::string & block) const
{
  return this->_scalar_coeffs.propertyDefinedOnBlock(name, block);
}
 
bool
CoefficientManager::vectorPropertyIsDefined(const std::string & name,
                                            const std::string & block) const
{
  return this->_vector_coeffs.propertyDefinedOnBlock(name, block);
}
 
bool
CoefficientManager::matrixPropertyIsDefined(const std::string & name,
                                            const std::string & block) const
{
  return this->_matrix_coeffs.propertyDefinedOnBlock(name, block);
}
 
void
CoefficientManager::setTime(const mfem::real_t time)
{
  this->_scalar_coeffs.setTime(time);
  this->_vector_coeffs.setTime(time);
  this->_matrix_coeffs.setTime(time);
}
 
void
CoefficientManager::markSolutionChanged()
{
  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);
}
}
 
#endif