MFEMContainers.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 "MooseError.h"
 
#include <map>
#include <string>
#include <vector>
 
namespace mfem
{
class FiniteElementCollection;
class ParFiniteElementSpace;
class ParSubMesh;
class ParGridFunction;
class ParComplexGridFunction;
class ParFiniteElementSpaceHierarchy;
}
 
class MFEMKernel;
class MFEMBoundaryCondition;
 
namespace Moose::MFEM
{
class EquationSystem;
 
template <typename T>
class NamedFieldsMap
{
public:
  using MapType = std::map<std::string, std::shared_ptr<T>>;
  using const_iterator = typename MapType::const_iterator;
 
  NamedFieldsMap() = default;
 
  ~NamedFieldsMap() { DeregisterAll(); }
 
  template <class FieldType, class... FieldArgs>
  void Register(const std::string & field_name, FieldArgs &&... args)
  {
    Register(field_name, std::make_shared<FieldType>(std::forward<FieldArgs>(args)...));
  }
 
  void Register(const std::string & field_name, std::shared_ptr<T> field)
  {
    CheckFieldIsRegistrable(field_name, field.get());
 
    Deregister(field_name);
 
    _field_map[field_name] = std::move(field);
  }
 
  void Deregister(const std::string & field_name) { _field_map.erase(field_name); }
 
  [[nodiscard]] inline bool Has(const std::string & field_name) const
  {
    return FindField(field_name) != end();
  }
 
  [[nodiscard]] inline std::shared_ptr<T> GetShared(const std::string & field_name) const
  {
    CheckFieldIsRegistered(field_name);
 
    auto it = FindField(field_name);
 
    return EnsureFieldPointerIsNonNull(it);
  }
 
  [[nodiscard]] inline T & GetRef(const std::string & field_name) const
  {
    return *GetShared(field_name);
  }
 
  [[nodiscard]] inline T * Get(const std::string & field_name) const
  {
    return GetShared(field_name).get();
  }
 
  template <typename TDerived>
  [[nodiscard]] inline TDerived * Get(const std::string & field_name) const
  {
    auto ptr = Get(field_name);
 
    return EnsurePointerCastIsNonNull<TDerived>(ptr);
  }
 
  [[nodiscard]] std::vector<T *> Get(const std::vector<std::string> & keys) const
  {
    std::vector<T *> values;
 
    for (const auto & key : keys)
    {
      values.push_back(Get(key));
    }
 
    values.shrink_to_fit();
    return values;
  }
 
  // NOLINTNEXTLINE(readability-identifier-naming)
  [[nodiscard]] inline const_iterator begin() const { return _field_map.begin(); }
 
  // NOLINTNEXTLINE(readability-identifier-naming)
  [[nodiscard]] inline const_iterator end() const { return _field_map.end(); }
 
  int size() const { return _field_map.size(); }
 
protected:
  [[nodiscard]] inline const_iterator FindField(const std::string & field_name) const
  {
    return _field_map.find(field_name);
  }
 
  void CheckFieldIsRegistrable([[maybe_unused]] const std::string & field_name,
                               [[maybe_unused]] T * field) const
  {
    mooseAssert(field, "Cannot register NULL field with name '" + field_name + "'.");
    mooseAssert(!Has(field_name) || Get(field_name) != field,
                "The field '" + field_name + "' is already registered.");
  }
 
  void CheckFieldIsRegistered(const std::string & field_name) const
  {
    if (!Has(field_name))
      mooseError("The field '" + field_name + "' has not been registered.");
  }
 
  inline std::shared_ptr<T> EnsureFieldPointerIsNonNull(const_iterator & iterator) const
  {
    auto owned_ptr = iterator->second;
    mooseAssert(owned_ptr, "The field '" + iterator->first + "' is NULL.");
    return owned_ptr;
  }
 
  template <typename TDerived>
  inline TDerived * EnsurePointerCastIsNonNull(T * ptr) const
  {
    auto derived_ptr = dynamic_cast<TDerived *>(ptr);
    mooseAssert(derived_ptr, "The dynamic cast performed on the field pointer failed.");
    return derived_ptr;
  }
 
  void DeregisterAll() { _field_map.clear(); }
 
private:
  MapType _field_map{};
};
 
class TimeDerivativeMap
{
public:
  using MapType = std::map<std::string, std::string>;
  using const_iterator = typename MapType::const_iterator;
 
  inline void addTimeDerivativeAssociation(const std::string & var_name,
                                           const std::string & time_derivative_var_name)
  {
    _field_map.emplace(var_name, time_derivative_var_name);
  }
 
  inline bool isTimeDerivative(const std::string & time_derivative_var_name) const
  {
    for (auto const & [map_var_name, map_time_derivative_var_name] : _field_map)
    {
      if (map_time_derivative_var_name == time_derivative_var_name)
        return true;
    }
    return false;
  }
 
  inline bool hasTimeDerivative(const std::string & var_name) const
  {
    return _field_map.count(var_name);
  }
 
  inline const std::string & getTimeDerivativeName(const std::string & var_name) const
  {
    auto it = _field_map.find(var_name);
    if (it != _field_map.end())
      return it->second;
    else
    {
      mooseError("No variable representing the time derivative of ", var_name, " found.");
      return null_str;
    }
  }
 
  inline const std::string & getTimeIntegralName(const std::string & time_derivative_var_name) const
  {
    for (auto const & [map_var_name, map_time_derivative_var_name] : _field_map)
    {
      if (map_time_derivative_var_name == time_derivative_var_name)
        return map_var_name;
    }
    mooseError(
        "No variable representing the time integral of ", time_derivative_var_name, " found.");
    return null_str;
  }
 
  inline static std::string createTimeDerivativeName(std::string_view name)
  {
    return std::string("d") + std::string(name) + std::string("_dt");
  }
 
private:
  MapType _field_map;
  const std::string null_str;
};
 
using FECollections = NamedFieldsMap<mfem::FiniteElementCollection>;
using FESpaces = NamedFieldsMap<mfem::ParFiniteElementSpace>;
using SubMeshes = NamedFieldsMap<mfem::ParSubMesh>;
using GridFunctions = NamedFieldsMap<mfem::ParGridFunction>;
using ComplexGridFunctions = NamedFieldsMap<mfem::ParComplexGridFunction>;
using FESpaceHierarchies = NamedFieldsMap<mfem::ParFiniteElementSpaceHierarchy>;
using Kernels = NamedFieldsMap<MFEMKernel>;
using BoundaryConditions = NamedFieldsMap<MFEMBoundaryCondition>;
using EquationSystems = NamedFieldsMap<EquationSystem>;
 
} // namespace Moose::MFEM
 
#endif