CoefficientManager.h

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
 
#pragma once
 
#include <map>
#include <string>
#include <tuple>
#include <utility>
#include <variant>
#include <vector>
 
#include "MooseException.h"
 
#include "CoefficientMap.h"
 
namespace Moose::MFEM
{
class CoefficientManager
{
public:
  CoefficientManager() = default;
 
  mfem::Coefficient & declareScalar(const std::string & name,
                                    const std::string & existing_or_literal);
  template <class P, class... Args>
  P & declareScalar(const std::string & name, Args &&... args)
  {
    auto coef = _scalar_coeffs.make<P>(args...);
    this->declareScalar(name, coef);
    return *coef;
  }
 
  mfem::Coefficient & declareScalarProperty(const std::string & name,
                                            const std::vector<std::string> & blocks,
                                            const std::string & existing_or_literal);
  template <class P, class... Args>
  mfem::Coefficient & declareScalarProperty(const std::string & name,
                                            const std::vector<std::string> & blocks,
                                            Args &&... args)
  {
    return this->declareScalarProperty(name, blocks, _scalar_coeffs.make<P>(args...));
  }
 
  mfem::VectorCoefficient & declareVector(const std::string & name,
                                          const std::string & existing_or_literal);
  template <class P, class... Args>
  P & declareVector(const std::string & name, Args &&... args)
  {
    auto coef = _vector_coeffs.make<P>(args...);
    this->declareVector(name, coef);
    return *coef;
  }
 
  mfem::VectorCoefficient & declareVectorProperty(const std::string & name,
                                                  const std::vector<std::string> & blocks,
                                                  const std::string & existing_or_literal);
  template <class P, class... Args>
  mfem::VectorCoefficient & declareVectorProperty(const std::string & name,
                                                  const std::vector<std::string> & blocks,
                                                  Args &&... args)
  {
    return this->declareVectorProperty(name, blocks, _vector_coeffs.make<P>(args...));
  }
 
  mfem::MatrixCoefficient & declareMatrix(const std::string & name,
                                          const std::string & existing_coef);
  template <class P, class... Args>
  P & declareMatrix(const std::string & name, Args &&... args)
  {
    auto coef = _matrix_coeffs.make<P>(args...);
    this->declareMatrix(name, coef);
    return *coef;
  }
 
  mfem::MatrixCoefficient & declareMatrixProperty(const std::string & name,
                                                  const std::vector<std::string> & blocks,
                                                  const std::string & existing_coef);
  template <class P, class... Args>
  mfem::MatrixCoefficient & declareMatrixProperty(const std::string & name,
                                                  const std::vector<std::string> & blocks,
                                                  Args &&... args)
  {
    return this->declareMatrixProperty(name, blocks, _matrix_coeffs.make<P>(args...));
  }
 
  mfem::Coefficient & getScalarCoefficient(const std::string & name);
 
  mfem::VectorCoefficient & getVectorCoefficient(const std::string & name);
 
  mfem::MatrixCoefficient & getMatrixCoefficient(const std::string & 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();
 
private:
  ScalarMap _scalar_coeffs;
  VectorMap _vector_coeffs;
  MatrixMap _matrix_coeffs;
 
  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);
};
}
 
#endif