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 <map>
#include <set>
#include <string>
#include <vector>

namespace Moose::MFEM
{

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() { 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 = Moose::MFEM::NamedFieldsMap<mfem::FiniteElementCollection>;
using FESpaces = Moose::MFEM::NamedFieldsMap<mfem::ParFiniteElementSpace>;
using SubMeshes = Moose::MFEM::NamedFieldsMap<mfem::ParSubMesh>;
using GridFunctions = Moose::MFEM::NamedFieldsMap<mfem::ParGridFunction>;
using ComplexGridFunctions = Moose::MFEM::NamedFieldsMap<mfem::ParComplexGridFunction>;

} // namespace Moose::MFEM

#endif