https://mooseframework.inl.gov
CellCenteredMapFunctor.h
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #pragma once
11 
12 #include "MooseFunctor.h"
13 #include "GreenGaussGradient.h"
14 #include "MathFVUtils.h"
15 #include "libmesh/utility.h"
16 #include "libmesh/type_tensor.h"
17 #include "libmesh/compare_types.h"
18 #include "libmesh/threads.h"
19 
25 template <typename T, typename Map>
26 class CellCenteredMapFunctor : public Moose::FunctorBase<T>, public Map
27 {
28 public:
29  using typename Moose::FunctorBase<T>::ValueType;
31  using typename Moose::FunctorBase<T>::DotType;
39 
43  CellCenteredMapFunctor(const MooseMesh & mesh,
44  const std::string & name,
45  const bool extrapolated_boundary);
46 
51  CellCenteredMapFunctor(const MooseMesh & mesh,
52  const std::set<SubdomainID> & sub_ids,
53  const std::string & name,
54  const bool extrapolated_boundary);
55 
56  bool isExtrapolatedBoundaryFace(const FaceInfo & fi,
57  const Elem * elem,
58  const StateArg & state) const override;
59  bool hasBlocks(SubdomainID sub_id) const override;
60 
64  bool hasBlocks(const Elem * elem) const;
65 
66  bool supportsFaceArg() const override final { return true; }
67  bool supportsElemSideQpArg() const override final { return false; }
68 
69 private:
71  const MooseMesh & _mesh;
72 
75  const std::set<SubdomainID> _sub_ids;
76 
78 
79  ValueType evaluate(const ElemArg & elem_arg, const StateArg &) const override;
80  ValueType evaluate(const ElemPointArg & elem_point, const StateArg & state) const override;
81  ValueType evaluate(const FaceArg & face, const StateArg &) const override;
82  ValueType evaluate(const ElemQpArg &, const StateArg &) const override;
83  ValueType evaluate(const ElemSideQpArg &, const StateArg &) const override;
84  ValueType evaluate(const NodeArg & elem_arg, const StateArg &) const override;
85 
87  GradientType evaluateGradient(const ElemArg & elem_arg, const StateArg & state) const override;
88  GradientType evaluateGradient(const FaceArg & face, const StateArg & state) const override;
89 };
90 
91 template <typename T, typename Map>
93  const std::string & name,
94  const bool extrapolated_boundary)
95  : Moose::FunctorBase<T>(name), _mesh(mesh), _extrapolated_boundary(extrapolated_boundary)
96 {
97 }
98 
99 template <typename T, typename Map>
101  const std::set<SubdomainID> & sub_ids,
102  const std::string & name,
103  const bool extrapolated_boundary)
104  : Moose::FunctorBase<T>(name),
105  _mesh(mesh),
106  _sub_ids(sub_ids == mesh.meshSubdomains() ? std::set<SubdomainID>() : sub_ids),
107  _extrapolated_boundary(extrapolated_boundary)
108 {
109 }
110 
111 template <typename T, typename Map>
112 bool
114  const Elem *,
115  const StateArg &) const
116 {
117  const bool defined_on_elem = hasBlocks(&fi.elem());
118  const bool defined_on_neighbor = hasBlocks(fi.neighborPtr());
119  const bool extrapolated = (defined_on_elem + defined_on_neighbor) == 1;
120 
121  mooseAssert(defined_on_elem || defined_on_neighbor,
122  "This shouldn't be called if we aren't defined on either side.");
123  return extrapolated;
124 }
125 
126 template <typename T, typename Map>
127 bool
128 CellCenteredMapFunctor<T, Map>::hasBlocks(const Elem * const elem) const
129 {
130  if (!elem)
131  return false;
132 
133  return hasBlocks(elem->subdomain_id());
134 }
135 
136 template <typename T, typename Map>
137 bool
139 {
140  return _sub_ids.empty() || _sub_ids.count(sub_id);
141 }
142 
143 template <typename T, typename Map>
146 {
147  const Elem * const elem = elem_arg.elem;
148 
149  try
150  {
151  return libmesh_map_find(*this, elem->id());
152  }
153  catch (libMesh::LogicError &)
154  {
155  if (!_sub_ids.empty() && !_sub_ids.count(elem->subdomain_id()))
156  mooseError("Attempted to evaluate CellCenteredMapFunctor '",
157  this->functorName(),
158  "' with an element subdomain id of '",
159  elem->subdomain_id(),
160  "' but that subdomain id is not one of the subdomain ids the functor is "
161  "restricted to.");
162  else
163  mooseError("Attempted access into CellCenteredMapFunctor '",
164  this->functorName(),
165  "' with a key that does not yet exist in the map. Make sure to fill your "
166  "CellCenteredMapFunctor for all elements you will attempt to access later.");
167  }
168 }
169 
170 template <typename T, typename Map>
173  const StateArg & state) const
174 {
175  return (*this)(elem_point.makeElem(), state) +
176  (elem_point.point - elem_point.elem->vertex_average()) *
177  this->gradient(elem_point.makeElem(), state);
178 }
179 
180 template <typename T, typename Map>
183 {
184  const auto & fi = *face.fi;
186  "this implementation currently only supports linear interpolations");
187 
188  const bool defined_on_elem = hasBlocks(&fi.elem());
189  const bool defined_on_neighbor = hasBlocks(fi.neighborPtr());
190  if (defined_on_elem && defined_on_neighbor)
191  return Moose::FV::linearInterpolation(*this, face, state);
192 
193  if (defined_on_elem)
194  {
195  const auto elem_arg = face.makeElem();
196  const auto elem_value = (*this)(elem_arg, state);
197  if (!_extrapolated_boundary)
198  return elem_value;
199  // Two term expansion
200  return elem_value + this->gradient(elem_arg, state) * (fi.faceCentroid() - fi.elemCentroid());
201  }
202  else
203  {
204  mooseAssert(defined_on_neighbor, "We should be defined on one of the sides");
205  const auto neighbor_arg = face.makeNeighbor();
206  const auto neighbor_value = (*this)(neighbor_arg, state);
207  if (!_extrapolated_boundary)
208  return neighbor_value;
209 
210  // Two term expansion
211  return neighbor_value +
212  this->gradient(neighbor_arg, state) * (fi.faceCentroid() - fi.neighborCentroid());
213  }
214 }
215 
216 template <typename T, typename Map>
219 {
220  mooseError("not implemented");
221 }
222 
223 template <typename T, typename Map>
226 {
227  mooseError("not implemented");
228 }
229 
230 template <typename T, typename Map>
233 {
234  mooseError("not implemented");
235 }
236 
237 template <typename T, typename Map>
240  const StateArg & state) const
241 {
242  return Moose::FV::greenGaussGradient(elem_arg, state, *this, _extrapolated_boundary, _mesh);
243 }
244 
245 template <typename T, typename Map>
248 {
249  return Moose::FV::greenGaussGradient(face, state, *this, _extrapolated_boundary, _mesh);
250 }
libMesh::Point point
const std::set< SubdomainID > _sub_ids
The subdomain IDs that this functor lives on.
const MooseMesh & _mesh
The mesh that this functor lives on.
void mooseError(Args &&... args)
const Elem & elem() const
libMesh::VectorValue< T > greenGaussGradient(const ElemArg &elem_arg, const StateArg &state_arg, const FunctorBase< T > &functor, const bool two_term_boundary_expansion, const MooseMesh &mesh, const bool force_green_gauss=false)
bool isExtrapolatedBoundaryFace(const FaceInfo &fi, const Elem *elem, const StateArg &state) const override
MeshBase & mesh
libMesh::CompareTypes< T, T2 >::supertype linearInterpolation(const T &value1, const T2 &value2, const FaceInfo &fi, const bool one_is_elem, const InterpMethod interp_method=InterpMethod::Average)
typename FunctorReturnType< T, FunctorEvaluationKind::Gradient >::type GradientType
GradientType evaluateGradient(const ElemArg &elem_arg, const StateArg &state) const override
const Elem * neighborPtr() const
CellCenteredMapFunctor(const MooseMesh &mesh, const std::string &name, const bool extrapolated_boundary)
Use this constructor when you want the object to live everywhere on the mesh.
const FaceInfo * fi
bool supportsElemSideQpArg() const override final
const std::string name
Definition: Setup.h:20
const libMesh::Elem * elem
const libMesh::Elem * elem
Moose::FV::LimiterType limiter_type
ElemArg makeNeighbor() const
bool hasBlocks(SubdomainID sub_id) const override
ValueType evaluate(const ElemArg &elem_arg, const StateArg &) const override
ElemArg makeElem() const
bool supportsFaceArg() const override final
ElemArg makeElem() const
Point vertex_average() const
A functor whose evaluation relies on querying a map where the keys are element ids and the values cor...