FaceCenteredMapFunctor.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
 
#pragma once
 
#include "MooseFunctor.h"
#include "MooseMesh.h"
#include "MooseError.h"
 
#include <set>
 
template <typename T, typename Map>
class FaceCenteredMapFunctor : public Moose::FunctorBase<T>, public Map
{
public:
  using typename Moose::FunctorBase<T>::ValueType;
  using typename Moose::FunctorBase<T>::GradientType;
  using typename Moose::FunctorBase<T>::DotType;
  using ElemArg = Moose::ElemArg;
  using FaceArg = Moose::FaceArg;
  using ElemQpArg = Moose::ElemQpArg;
  using ElemSideQpArg = Moose::ElemSideQpArg;
  using ElemPointArg = Moose::ElemPointArg;
  using StateArg = Moose::StateArg;
  using NodeArg = Moose::NodeArg;
 
  FaceCenteredMapFunctor(const MooseMesh & mesh, const std::string & name);
 
  FaceCenteredMapFunctor(const MooseMesh & mesh,
                         const std::set<SubdomainID> & sub_ids,
                         const std::string & name);
 
  bool hasBlocks(SubdomainID sub_id) const override;
 
  ValueType evaluate(const FaceInfo * const fi) const;
 
  bool supportsFaceArg() const override final { return true; }
  bool supportsElemSideQpArg() const override final { return false; }
 
private:
  const MooseMesh & _mesh;
 
  const std::set<SubdomainID> _sub_ids;
 
  // Keep the public evaluate(const FaceInfo *) from hiding the base class overloads
  using Moose::FunctorBase<T>::evaluate;
  ValueType evaluate(const ElemArg &, const StateArg &) const override final;
  ValueType evaluate(const FaceArg &, const StateArg &) const override final;
  ValueType evaluate(const ElemPointArg &, const StateArg &) const override;
  ValueType evaluate(const ElemQpArg &, const StateArg &) const override;
  ValueType evaluate(const ElemSideQpArg &, const StateArg &) const override;
  ValueType evaluate(const NodeArg &, const StateArg &) const override final;
};
 
template <typename T, typename Map>
FaceCenteredMapFunctor<T, Map>::FaceCenteredMapFunctor(const MooseMesh & mesh,
                                                       const std::string & name)
  : Moose::FunctorBase<T>(name), _mesh(mesh)
{
}
 
template <typename T, typename Map>
FaceCenteredMapFunctor<T, Map>::FaceCenteredMapFunctor(const MooseMesh & mesh,
                                                       const std::set<SubdomainID> & sub_ids,
                                                       const std::string & name)
  : Moose::FunctorBase<T>(name),
    _mesh(mesh),
    _sub_ids(sub_ids == mesh.meshSubdomains() ? std::set<SubdomainID>() : sub_ids)
{
}
 
template <typename T, typename Map>
bool
FaceCenteredMapFunctor<T, Map>::hasBlocks(const SubdomainID sub_id) const
{
  return _sub_ids.empty() || _sub_ids.count(sub_id);
}
 
template <typename T, typename Map>
typename FaceCenteredMapFunctor<T, Map>::ValueType
FaceCenteredMapFunctor<T, Map>::evaluate(const ElemPointArg &, const StateArg &) const
{
  mooseError("not implemented");
}
 
template <typename T, typename Map>
typename FaceCenteredMapFunctor<T, Map>::ValueType
FaceCenteredMapFunctor<T, Map>::evaluate(const ElemQpArg &, const StateArg &) const
{
  mooseError("not implemented");
}
 
template <typename T, typename Map>
typename FaceCenteredMapFunctor<T, Map>::ValueType
FaceCenteredMapFunctor<T, Map>::evaluate(const ElemSideQpArg &, const StateArg &) const
{
  mooseError("not implemented");
}
 
template <typename T, typename Map>
typename FaceCenteredMapFunctor<T, Map>::ValueType
FaceCenteredMapFunctor<T, Map>::evaluate(const NodeArg &, const StateArg &) const
{
  mooseError("not implemented");
}
 
extern template class FaceCenteredMapFunctor<ADRealVectorValue,
                                             std::unordered_map<dof_id_type, ADRealVectorValue>>;
extern template class FaceCenteredMapFunctor<RealVectorValue,
                                             std::unordered_map<dof_id_type, RealVectorValue>>;
extern template class FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>>;
 
template <typename T, typename Map>
inline void
dataStore(std::ostream & stream, FaceCenteredMapFunctor<T, Map> & m, void * context)
{
  Map & m_map = m;
  dataStore(stream, m_map, context);
}
 
template <typename T, typename Map>
inline void
dataLoad(std::istream & stream, FaceCenteredMapFunctor<T, Map> & m, void * context)
{
  Map & m_map = m;
  dataLoad(stream, m_map, context);
}