Flow123d  JS_before_hm-1804-gf2ad740aa
field.hh
Go to the documentation of this file.
1 /*!
2  *
3  * Copyright (C) 2015 Technical University of Liberec. All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify it under
6  * the terms of the GNU General Public License version 3 as published by the
7  * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12  *
13  *
14  * @file field.hh
15  * @brief
16  */
17 
18 #ifndef FIELD_HH_
19 #define FIELD_HH_
20 
21 #include <stdio.h> // for sprintf
22 #include <string.h> // for memcpy
23 #include <algorithm> // for find, min
24 #include <boost/circular_buffer.hpp>
25 #include <memory> // for dynamic_pointe...
26 #include <new> // for operator new[]
27 #include <ostream> // for basic_ostream:...
28 #include <string> // for basic_string
29 #include <utility> // for pair
30 #include <vector> // for vector
31 #include <armadillo>
32 #include "fields/field_algo_base.hh" // for FieldAlgorithm...
33 #include "fields/field_common.hh" // for FieldCommon::T...
34 #include "fields/field_values.hh" // for FieldValue<>::...
35 #include "fields/field_value_cache.hh" // for FieldValueCache
36 #include "input/accessors.hh" // for ExcTypeMismatch
37 #include "input/accessors_impl.hh" // for Record::opt_val
38 #include "input/factory_impl.hh" // for Factory::create
39 #include "input/input_exception.hh" // for FieldCommon::E...
40 #include "input/storage.hh" // for ExcStorageType...
41 #include "input/type_base.hh" // for Array
42 #include "input/type_generic.hh" // for Instance
43 #include "input/type_record.hh" // for Record::ExcRec...
44 #include "input/input_exception.hh" // for Input::Exception
45 #include "io/output_time.hh" // for OutputTime
46 #include "mesh/elements.h" // for Element::dim
47 #include "mesh/region.hh" // for RegionDB::ExcU...
48 #include "system/asserts.hh" // for Assert, ASSERT
49 #include "system/exc_common.hh" // for ExcAssertMsg
50 #include "system/exceptions.hh" // for ExcAssertMsg::...
51 #include "system/global_defs.h" // for OLD_ASSERT, msg
52 #include "tools/time_governor.hh" // for TimeStep
53 
54 class Mesh;
55 class Observe;
56 class EvalPoints;
57 class BulkPoint;
58 class EdgePoint;
59 class CouplingPoint;
60 class BoundaryPoint;
61 class FieldSet;
62 template <int spacedim> class ElementAccessor;
63 template <int spacedim, class Value> class FieldFE;
64 namespace detail
65 {
66  template< typename CALLABLE, typename TUPLE, int INDEX >
68 }
69 
70 using namespace std;
71 namespace IT=Input::Type;
72 
73 /**
74  * @brief Class template representing a field with values dependent on: point, element, and region.
75  *
76  * By "field" we mean a mapping of a a pair (Point, Time) to a @p Value, where
77  * Point is from @p spacedim dimensional ambient space, Time is real number (set by @p set_time method),
78  * and @p Value type representing range of the field, which can be: real scalar, integer scalar (a discrete value),
79  * real vector of fixed (compile time) size, real vector of runtime size, or a matrix of fixed dimensions.
80  * Extensions to vectors or matrices of integers, or to variable tensors are possible. For vector and matrix values
81  * we use classes provided by Armadillo library for linear algebra.
82  * The @p Value template parameter should FieldValue<> template, usual choices are:
83  * FieldValue<spacedim>::Scalar, FieldValue<spacedim>::Integer, FieldValue<spacedim>::Enum,
84  * FieldValue<spacedim>::VectorFixed, FieldValue<spacedim>::TensorFixed.
85  *
86  * This class assign particular fields (instances of descendants of FiledBase) to the regions. It keeps a table of pointers to fields for every possible bulk
87  * region index (very same functionality, but for boundary regions is provided by @p BCField class). This class has interface very similar to FiledBase, however
88  * key methods @p value, and @p value_list are not virtual in this class by contrast these methods are inlined to minimize overhead for
89  * simplest fields like FieldConstant.
90  *
91  * TODO: currently it works only for spacedim==3 since we have only mesh in 3D ambient space.
92  *
93  */
94 template<int spacedim, class Value>
95 class Field : public FieldCommon {
96 public:
97 
99  typedef std::shared_ptr< FieldBaseType > FieldBasePtr;
101  typedef Value ValueType;
102 
103  static const unsigned int space_dim = spacedim;
104 
105 
106  /**
107  * Factory class that creates an instance of FieldBase for field
108  * with name @p field_name based on data in field descriptor @p rec.
109  *
110  * Default implementation in method @p create_field just reads key given by
111  * @p field_name and creates instance using @p FieldBase<...>::function_factory.
112  * Function should return empty SharedField (that is shared_ptr to FieldBase).
113  *
114  * Implementation of these descendants is necessary:
115  * 1) for backward compatibility with old BCD input files
116  * 2) for setting pressure values are piezometric head values
117  */
118  /**
119  * Note for future:
120  * We pass through parameter @p field information about field that holds the factory which are necessary
121  * for interpreting user input and create particular field instance. It would be clearer to pass these information
122  * when the factory is assigned to a field. Moreover some information may not be set to field at all but directly passed
123  * to the factory.
124  */
125  class FactoryBase {
126  public:
127  /**
128  * Default method that creates an instance of FieldBase for field.
129  *
130  * Reads key given by @p field_name and creates the field instance using
131  * @p FieldBase<...>::function_factory.
132  */
133  virtual FieldBasePtr create_field(Input::Record rec, const FieldCommon &field);
134 
135  /**
136  * Check if Input::Record accessor contains data of field given by input_name.
137  *
138  * Returns true when ever the method create_field returns non-null pointer, otherwise returns false.
139  */
140  virtual bool is_active_field_descriptor(const Input::Record &in_rec, const std::string &input_name);
141  };
142 
143  /**
144  * Default constructor.
145  *
146  */
147  Field();
148 
149  Field(const string &name, bool bc = false);
150 
151  /**
152  * Constructor that must be used for create of MultiField components.
153  *
154  * Set parameters @p component_index_, @p shared_->input_name_ and @p name_.
155  * Parameter name_ of Field is consisted of component name and MultiField name.
156  */
157  Field(unsigned int component_index, string input_name, string name = "", bool bc = false);
158 
159  /**
160  * Copy constructor. Keeps shared history, declaration data, mesh.
161  */
162  Field(const Field &other);
163 
164  /**
165  * Assignment operator. Same properties as copy constructor, but class member name_ is not copied.
166  *
167  * Question: do we really need this, isn't copy constructor enough?
168  * Answer: It is necessary in (usual) case when Field instance is created as the class member
169  * but is filled later by assignment possibly from other class.
170  * TODO: operator can be merged with copy constructor, but we must provide to set correct value
171  * of name in method copy_from
172  */
173  Field &operator=(const Field &other);
174 
175 
176  /// Return appropriate value to BulkPoint in FieldValueCache
177  typename Value::return_type operator() (BulkPoint &p);
178 
179 
180  /// Return appropriate value to EdgePoint in FieldValueCache
181  typename Value::return_type operator() (EdgePoint &p);
182 
183 
184  /// Return appropriate value to CouplingPoint in FieldValueCache
185  typename Value::return_type operator() (CouplingPoint &p);
186 
187 
188  /// Return appropriate value to BoundaryPoint in FieldValueCache
189  typename Value::return_type operator() (BoundaryPoint &p);
190 
191 
192  /**
193  * Returns reference to input type of particular field instance, this is static member @p input_type of the corresponding FieldBase class
194  * (i.e. with same template parameters). However, for fields returning "Enum" we have to create whole unique Input::Type hierarchy using following method
195  * @p make_input_tree.
196  * every instance since every such field use different Selection for initialization, even if all returns just unsigned int.
197  */
198  IT::Instance get_input_type() override;
199 
200  IT::Array get_multifield_input_type() override;
201 
202 
203  /**
204  * By this method you can allow that the field need not to be set on regions (and times) where the given @p control_field is
205  * FieldConstant and has value in given @p value_list. We check this in the set_time method. Through this mechanism we
206  * can switch of e.g. boundary data fields according to the type of the boundary condition.
207  */
208  auto disable_where(
209  const Field<spacedim, typename FieldValue<spacedim>::Enum > &control_field,
210  const vector<FieldEnum> &value_list) -> Field &;
211 
212 
213 
214  /**
215  * Set mesh pointer and resize region arrays.
216  *
217  * Implements abstract method.
218  */
219  void set_mesh(const Mesh &mesh) override;
220 
221 
222  /**
223  * Direct read access to the table of Field pointers on regions.
224  */
225  //std::shared_ptr< FieldBaseType > operator[] (Region reg);
226 
227  /**
228  * Implementation of @p FieldCommonBase::is_constant().
229  * See also Field<>::field_result which provide better information about special field values.
230  */
231  bool is_constant(Region reg) override;
232 
233  /**
234  * Assigns given @p field to all regions in region set given by @p region_set_names.
235  * Field is added to the history with given time and possibly used in the next call of the set_time method.
236  * Caller is responsible for correct construction of given field.
237  *
238  * Use this method only if necessary.
239  */
240  void set(FieldBasePtr field, double time, std::vector<std::string> region_set_names = {"ALL"});
241 
242  /**
243  * Same as before but the field is first created using FieldBase::function_factory(), from
244  * given abstract record accessor @p a_rec.
245  */
246  void set(const Input::AbstractRecord &a_rec, double time, std::vector<std::string> region_set_names = {"ALL"});
247 
248  /**
249  * Check that whole field list is set, possibly use default values for unset regions
250  * and call set_time for every field in the field list.
251  *
252  * Returns true if the field has been changed.
253  */
254  bool set_time(const TimeStep &time, LimitSide limit_side) override;
255 
256  /**
257  * Check that other has same type and assign from it.
258  */
259  void copy_from(const FieldCommon & other) override;
260 
261  /**
262  * Implementation of FieldCommonBase::output().
263  */
264  void field_output(std::shared_ptr<OutputTime> stream, OutputTime::DiscreteSpaceFlags type) override;
265 
266  /**
267  * Implementation of FieldCommonBase::observe_output().
268  */
269  void observe_output(std::shared_ptr<Observe> observe) override;
270 
271  /**
272  * Returns true, if field is currently set to a time in which it is discontinuous.
273  */
274  //bool is_jump_time();
275 
276 
277  /**
278  * @brief Indicates special field states.
279  *
280  * Return possible values from the enum @p FieldResult, see description there.
281  * The initial state is @p field_none, if the field is correctly set on all regions of the @p region_set given as parameter
282  * we return state @p field_other
283  * - Special field values spatially constant. Could allow optimization of tensor multiplication and
284  * tensor or vector addition. field_result_ should be set in constructor and in set_time method of particular Field implementation.
285  * We return value @p result_none, if the field is not initialized on the region of the given element accessor @p elm.
286  * Other possible results are: result_zeros, result_eye, result_ones, result_constant, result_other
287  * see @p FieldResult for explanation.
288  */
289  FieldResult field_result( RegionSet region_set) const override;
290 
291  /**
292  * Return value of input type attribute 'field_value_shape' that is appended to the
293  * input type of this field in FieldSet::make_field_descriptor_type and also to the output field selection
294  * created in EquationOutput::make_output_type.
295  * This attribute is used by GeoMop to have semantics of the input and output field data.
296  *
297  * Attribute value is a valid JSON (and/or flow style YAML) with keys:
298  * 'subfields' - value True for multifields, False or not presented for single value fields
299  * 'shape' - [ NRows, Ncols] ... given by FieldValue
300  * 'type' - <element type> (Double or Integer) ... given by FieldValue
301  * 'limit' - bounds of the field values.
302  *
303  */
304  std::string get_value_attribute() const override;
305 
306  /**
307  * Returns one value in one given point @p on an element given by ElementAccessor @p elm.
308  * It returns reference to he actual value in order to avoid temporaries for vector and tensor values.
309  */
310  virtual typename Value::return_type const &value(const Point &p, const ElementAccessor<spacedim> &elm) const;
311 
312  /**
313  * Returns std::vector of scalar values in several points at once. The base class implements
314  * trivial implementation using the @p value(,,) method. This is not optimal as it involves lot of virtual calls,
315  * but this overhead can be negligible for more complex fields as Python of Formula.
316  */
317  virtual void value_list(const Armor::array &point_list, const ElementAccessor<spacedim> &elm,
318  std::vector<typename Value::return_type> &value_list) const;
319 
320  /**
321  * Add a new factory for creating Field algorithms on individual regions.
322  * The last factory is tried first, the last one is always the default implementation
323  * Field<...>::FactoryBase.
324  *
325  * The Field<...> object keeps a list of such factories. When the instance of a new field algorithm
326  * has to be created from the input field descriptor, we pass through the list of factories backward
327  * and let factories to create the field algorithm instance from the actual input field descriptor.
328  * The first instance (non-null pointer) is used.
329  */
330  void add_factory(std::shared_ptr<FactoryBase> factory);
331 
332  void set_input_list(const Input::Array &list, const TimeGovernor &tg) override;
333 
334  /**
335  * Interpolate given field into output discrete @p space_type and store the values
336  * into storage of output time @p stream for postponed output.
337  */
338  void compute_field_data(OutputTime::DiscreteSpaceFlags space_type, std::shared_ptr<OutputTime> stream);
339 
340  /// Implements FieldCommon::cache_allocate
341  void cache_reallocate(const ElementCacheMap &cache_map, unsigned int region_idx) const override;
342 
343  /// Implements FieldCommon::cache_update
344  void cache_update(ElementCacheMap &cache_map, unsigned int region_patch_idx) const override;
345 
346  /// Implements FieldCommon::value_cache
347  FieldValueCache<double> * value_cache() override;
348 
349  /// Implements FieldCommon::value_cache
350  const FieldValueCache<double> * value_cache() const override;
351 
352  /**
353  * Implementation of FieldCommon::set_dependency().
354  */
355  std::vector<const FieldCommon *> set_dependency(FieldSet &field_set, unsigned int i_reg) const override;
356 
357 protected:
358 
359  /// Return item of @p value_cache_ given by i_cache_point.
360  typename Value::return_type operator[] (unsigned int i_cache_point) const;
361 
362  /**
363  * Read input into @p regions_history_ possibly pop some old values from the
364  * history queue to keep its size less then @p history_length_limit_.
365  */
366  void update_history(const TimeStep &time);
367 
368  /// Fills acutally the data cache with field values, used in @p compute_field_data
369  void fill_data_cache(OutputTime::DiscreteSpace space_type,
370  std::shared_ptr<OutputTime> stream,
371  std::shared_ptr<ElementDataCache<typename Value::element_type>> data_cache);
372 
373  /**
374  * Check that whole field list (@p region_fields_) is set, possibly use default values for unset regions.
375  */
376  void check_initialized_region_fields_();
377 
378  /**
379  * Check that the field is in fact FieldFE set on all bulk regions, return shared pointer to that FieldFE or NULL
380  * if the Field is not FieldFE.
381  */
382  std::shared_ptr< FieldFE<spacedim, Value> > get_field_fe();
383 
384  /**************** Shared data **************/
385 
386  /// Pair: time, pointer to FieldBase instance
387  typedef pair<double, FieldBasePtr> HistoryPoint;
388  /// Nearest history of one region.
389  typedef boost::circular_buffer<HistoryPoint> RegionHistory;
390 
391  struct SharedData {
392 
393  /**
394  * History for every region. Shared among copies.
395  */
397  };
398 
399  /**************** Data per copy **************/
400 
401  std::shared_ptr<SharedData> data_;
402 
403  /**
404  * If this pointer is set, turn off check of initialization in the
405  * @p set_time method on the regions where the method @p get_constant_enum_value
406  * of the control field returns value from @p no_check_values_. This
407  * field is private copy, its set_time method is called from the
408  * set_Time method of actual object.
409  */
411  std::shared_ptr<ControlField> no_check_control_field_;
412 
413  /**
414  * Table with pointers to fields on individual regions.
415  */
417 
419 
420  /**
421  * Field value data cache
422  *
423  * Data is ordered like three dimensional table. The highest level is determinated by subsets,
424  * those data ranges are holds in subset_starts. Data block size of each subset is determined
425  * by number of eval_points (of subset) and maximal number of stored elements.
426  * The table is allocated to hold all subsets, but only those marked in used_subsets are updated.
427  * Order of subsets is same as in eval_points.
428  */
430 
431 
432 
433  template<int dim, class Val>
434  friend class MultiField;
435 
436  template< typename CALLABLE, typename TUPLE, int INDEX >
438 
439 };
440 
441 
442 
443 
444 
445 
446 
447 /****************************************************************************************
448  * Inlined methods of Field< ... >
449  */
450 
451 template<int spacedim, class Value>
452 inline typename Value::return_type const & Field<spacedim,Value>::value(const Point &p, const ElementAccessor<spacedim> &elm) const
453 {
454 
455  ASSERT(this->set_time_result_ != TimeStatus::unknown)(this->name()).error("Unknown time status.\n");
456  OLD_ASSERT(elm.region_idx().idx() < region_fields_.size(), "Region idx %u out of range %lu, field: %s\n",
457  elm.region_idx().idx(), (unsigned long int) region_fields_.size(), name().c_str());
458  OLD_ASSERT( region_fields_[elm.region_idx().idx()] ,
459  "Null field ptr on region id: %d, idx: %d, field: %s\n", elm.region().id(), elm.region_idx().idx(), name().c_str());
460  return region_fields_[elm.region_idx().idx()]->value(p,elm);
461 }
462 
463 
464 
465 template<int spacedim, class Value>
468 {
469  ASSERT(this->set_time_result_ != TimeStatus::unknown)(this->name()).error("Unknown time status.\n");
470  OLD_ASSERT(elm.region_idx().idx() < region_fields_.size(), "Region idx %u out of range %lu, field: %s\n",
471  elm.region_idx().idx(), (unsigned long int) region_fields_.size(), name().c_str());
472  OLD_ASSERT( region_fields_[elm.region_idx().idx()] ,
473  "Null field ptr on region id: %d, field: %s\n", elm.region().id(), name().c_str());
474  ASSERT_DBG(point_list.n_rows() == spacedim && point_list.n_cols() == 1).error("Invalid point size.\n");
475 
476  region_fields_[elm.region_idx().idx()]->value_list(point_list,elm, value_list);
477 }
478 
479 
480 
481 
482 
483 
484 #endif /* FIELD_HH_ */
detail::model_cache_item
base case for building up arguments for the function call
Definition: field.hh:67
Observe
Definition: observe.hh:198
CouplingPoint
Point accessor allow iterate over quadrature points of given side defined in local element coordinate...
Definition: eval_subset.hh:183
Field::SharedData::region_history_
std::vector< RegionHistory > region_history_
Definition: field.hh:396
Field::HistoryPoint
pair< double, FieldBasePtr > HistoryPoint
Pair: time, pointer to FieldBase instance.
Definition: field.hh:387
time_governor.hh
Basic time management class.
field_algo_base.hh
Field::value_cache_
FieldValueCache< typename Value::element_type > value_cache_
Definition: field.hh:429
ElementDataCache
Definition: element_data_cache.hh:44
ASSERT
#define ASSERT(expr)
Allow use shorter versions of macro names if these names is not used with external library.
Definition: asserts.hh:347
string.h
ElementCacheMap
Directing class of FieldValueCache.
Definition: field_value_cache.hh:151
asserts.hh
Definitions of ASSERTS.
value
static constexpr bool value
Definition: json.hpp:87
ASSERT_DBG
#define ASSERT_DBG(expr)
Definition: include_fadbad.hh:28
FieldResult
FieldResult
Definition: field_algo_base.hh:70
BulkPoint
Base point accessor class.
Definition: eval_subset.hh:55
detail
Definition: field.hh:64
std::vector< FieldEnum >
ElementAccessor
Definition: dh_cell_accessor.hh:32
EdgePoint
Point accessor allow iterate over quadrature points of given side defined in local element coordinate...
Definition: eval_subset.hh:159
RegionIdx::idx
unsigned int idx() const
Returns a global index of the region.
Definition: region.hh:82
type_base.hh
FieldAlgorithmBase::Point
Space< spacedim >::Point Point
Definition: field_algo_base.hh:115
Field::FactoryBase
Definition: field.hh:125
storage.hh
exceptions.hh
type_record.hh
Region::id
unsigned int id() const
Returns id of the region (using RegionDB)
Definition: region.cc:37
Armor::Array::n_rows
uint n_rows() const
Definition: armor.hh:715
Region
Definition: region.hh:146
OutputTime::DiscreteSpaceFlags
std::array< bool, 4 > DiscreteSpaceFlags
Definition: output_time.hh:122
Field::Point
FieldAlgorithmBase< spacedim, Value >::Point Point
Definition: field.hh:100
Input::Record
Accessor to the data with type Type::Record.
Definition: accessors.hh:291
elements.h
type_generic.hh
accessors.hh
TimeStep
Representation of one time step..
Definition: time_governor.hh:123
TimeGovernor
Basic time management functionality for unsteady (and steady) solvers (class Equation).
Definition: time_governor.hh:310
output_time.hh
field_values.hh
Input::AbstractRecord
Accessor to the polymorphic input data of a type given by an AbstracRecord object.
Definition: accessors.hh:458
FieldCommon
Common abstract parent of all Field<...> classes.
Definition: field_common.hh:74
Field::data_
std::shared_ptr< SharedData > data_
Definition: field.hh:401
Field::factories_
std::vector< std::shared_ptr< FactoryBase > > factories_
Definition: field.hh:418
Input::Type::Instance
Helper class that stores data of generic types.
Definition: type_generic.hh:89
LimitSide
LimitSide
Definition: field_common.hh:61
input_exception.hh
Field::region_fields_
std::vector< FieldBasePtr > region_fields_
Definition: field.hh:416
FieldSet
Container for various descendants of FieldCommonBase.
Definition: field_set.hh:159
Field::RegionHistory
boost::circular_buffer< HistoryPoint > RegionHistory
Nearest history of one region.
Definition: field.hh:389
Armor::Array::n_cols
uint n_cols() const
Definition: armor.hh:720
FieldValue_
Definition: field_values.hh:248
Input::Type
Definition: balance.hh:41
exc_common.hh
Field::value
virtual const Value::return_type & value(const Point &p, const ElementAccessor< spacedim > &elm) const
Definition: field.hh:452
Value
@ Value
Definition: finite_element.hh:43
Field::FieldBasePtr
std::shared_ptr< FieldBaseType > FieldBasePtr
Definition: field.hh:99
Field::FieldBaseType
FieldAlgorithmBase< spacedim, Value > FieldBaseType
Definition: field.hh:98
FieldFE
Definition: field.hh:63
Mesh
Definition: mesh.h:98
BoundaryPoint
Point accessor allow iterate over quadrature points of given side defined in local element coordinate...
Definition: eval_subset.hh:209
Field::no_check_control_field_
std::shared_ptr< ControlField > no_check_control_field_
Definition: field.hh:411
FieldAlgorithmBase
Definition: field_algo_base.hh:112
Input::Type::Array
Class for declaration of inputs sequences.
Definition: type_base.hh:339
accessors_impl.hh
factory_impl.hh
OLD_ASSERT
#define OLD_ASSERT(...)
Definition: global_defs.h:108
Field::value_list
virtual void value_list(const Armor::array &point_list, const ElementAccessor< spacedim > &elm, std::vector< typename Value::return_type > &value_list) const
Definition: field.hh:466
Input::Array
Accessor to input data conforming to declared Array.
Definition: accessors.hh:566
global_defs.h
Global macros to enhance readability and debugging, general constants.
std
Definition: doxy_dummy_defs.hh:5
ElementAccessor::region
Region region() const
Definition: accessors.hh:201
MultiField
Class for representation of a vector of fields of the same physical quantity.
Definition: multi_field.hh:87
field_value_cache.hh
Field::SharedData
Definition: field.hh:391
region.hh
Field::ValueType
Value ValueType
Definition: field.hh:101
Armor::Array< double >
OutputTime::DiscreteSpace
DiscreteSpace
Definition: output_time.hh:108
Field
Class template representing a field with values dependent on: point, element, and region.
Definition: field.hh:95
std::list
Definition: doxy_dummy_defs.hh:9
field_common.hh
ElementAccessor::region_idx
RegionIdx region_idx() const
Definition: accessors.hh:204
Field::ControlField
Field< spacedim, typename FieldValue< spacedim >::Enum > ControlField
Definition: field.hh:410
EvalPoints
Class holds local coordinations of evaluating points (bulk and sides) specified by element dimension.
Definition: eval_points.hh:43