Rheolef  7.2
an efficient C++ finite element environment
space_constitution.h
Go to the documentation of this file.
1 #ifndef _RHEOLEF_SPACE_CONSTITUTION_H
2 #define _RHEOLEF_SPACE_CONSTITUTION_H
23 
24 #include "rheolef/geo.h"
25 #include "rheolef/geo_domain.h"
26 #include "rheolef/space_constant.h"
27 
28 namespace rheolef {
29 
30 // forward declarations:
31 template <class T, class M> class space_mult_list;
32 template <class T, class M> class space_constitution;
33 
34 // =====================================================================
35 // space_act = a domain + an act (block, unblock)
36 // =====================================================================
37 
38 class space_act {
39 public:
40 
41 // typedefs:
42 
43  typedef size_t size_type;
44  static const size_type unset_index = std::numeric_limits<size_type>::max();
45 
46  enum act_type {
47  block = 0,
48  unblock = 1,
49  block_n = 2,
50  unblock_n = 3
51  };
52 
53 // allocators:
54 
55  space_act(const std::string& dom_name, act_type act)
56  : _dom_name(dom_name), _i_comp(unset_index), _act(act) {}
57  space_act(const std::string& dom_name, size_type i_comp, act_type act)
58  : _dom_name(dom_name), _i_comp(i_comp), _act(act) {}
60  : _dom_name(), _i_comp(unset_index), _act() {}
61  space_act(const space_act& x)
62  : _dom_name(x._dom_name), _i_comp(x._i_comp), _act(x._act) {}
63 
64 // accessors:
65 
66  const std::string& get_domain_name() const { return _dom_name; }
67  act_type get_act() const { return _act; }
69 
70 // data:
71 protected:
72  std::string _dom_name;
75 };
76 // =====================================================================
77 // space_constitution_terminal = a table of acts
78 // =====================================================================
79 
80 template <class T, class M>
82 public:
83  typedef typename std::vector<space_act> container_type;
85  typedef typename container_type::const_iterator const_iterator;
86 
87 // allocators:
88 
90  : _acts(), _omega(), _fem_basis() {}
91 
93  const geo_basic<T,M>& omega,
94  std::string approx);
95 
97  : _acts(scr._acts), _omega(scr._omega), _fem_basis(scr._fem_basis)
98  {
99  trace_macro ("physical copy of space_constitution_terminal_rep: size="<< size());
100  }
101 
102 // accessors:
103 
104  const geo_basic<T,M>& get_geo() const { return _omega; }
105  const geo_basic<T,M>& get_background_geo() const { return _omega.get_background_geo(); }
106  const basis_basic<T>& get_basis() const { return _fem_basis; }
107 
108  bool is_initialized() const { return _fem_basis.is_initialized(); }
109  size_type size() const { return _acts.size(); }
110  const_iterator begin() const { return _acts.begin(); }
111  const_iterator end() const { return _acts.end(); }
112 
113 // utility:
114 
115  void set_ios_permutations (
116  disarray<size_type,M>& idof2ios_dis_idof,
117  disarray<size_type,M>& ios_idof2dis_idof) const;
118 
119 // inquiries:
120 
121  size_type degree_max() const { return _fem_basis.degree(); }
122  bool have_compact_support_inside_element() const { return _fem_basis.have_compact_support_inside_element(); }
123  bool is_discontinuous() const { return ! _fem_basis.is_continuous(); }
124  void neighbour_guard() const { return get_geo().neighbour_guard(); }
125 
126 // modifiers
127 
128  void set_geo (const geo_basic<T,M>& omega) { _omega = omega; }
129  void set_basis (const basis_basic<T>& b) { _fem_basis = b; }
130  void do_act (const space_act& act);
131 
132 // comparator:
133 
134  bool operator== (const space_constitution_terminal_rep<T,M>& V2) const { return _omega == V2._omega && _fem_basis.name() == V2._fem_basis.name(); }
135 
136 // internal:
137  void build_blocked_flag (
138  disarray<size_type,M>& blocked_flag,
139  const distributor& comp_ownership,
140  const distributor& start_by_component) const;
141 protected:
142 // data:
143  std::vector<space_act> _acts;
146 };
147 template <class T, class M>
148 class space_constitution_terminal : public smart_pointer<space_constitution_terminal_rep<T,M> > {
149 public:
150 
153  typedef typename rep::size_type size_type;
155 
156 // allocators:
157 
159  : smart_pointer<rep>(new_macro(rep)) {}
160 
162  const geo_basic<T,M>& omega,
163  std::string approx)
164  : smart_pointer<rep>(new_macro(rep (omega,approx))) {}
165 
166 // accessors:
167 
168  const geo_basic<T,M>& get_geo() const { return base::data().get_geo(); }
169  const geo_basic<T,M>& get_background_geo() const { return base::data().get_background_geo(); }
170  const basis_basic<T>& get_basis() const { return base::data().get_basis(); }
171  size_type size() const { return base::data().size(); }
172  const_iterator begin() const { return base::data().begin(); }
173  const_iterator end() const { return base::data().end(); }
174 
175 // utility:
176 
178  disarray<size_type,M>& idof2ios_dis_idof,
179  disarray<size_type,M>& ios_idof2dis_idof) const
180  { base::data().set_ios_permutations (idof2ios_dis_idof, ios_idof2dis_idof); }
181 
182 // inquiries:
183 
184  bool have_compact_support_inside_element() const { return base::data().have_compact_support_inside_element(); }
185  bool is_discontinuous() const { return base::data().is_discontinuous(); }
186  size_type degree_max() const { return base::data().degree_max(); }
187  void neighbour_guard() const { return base::data().neighbour_guard(); }
188 
189 // comparator:
190 
191  bool operator== (const space_constitution_terminal<T,M>& V2) const { return base::data().operator==(V2.data()); }
192 
193 // modifiers
194 
195  void set_geo (const geo_basic<T,M>& omega) { base::data().set_geo (omega); }
196  void set_basis (const basis_basic<T>& b) { base::data().set_basis (b); }
197  void do_act (const space_act& act) { base::data().do_act(act); }
198 
199  void block (const domain_indirect_basic<M>& dom) { do_act (space_act(dom.name(), space_act::block)); }
203 };
204 // =======================================================================
205 // space_constitution = a recursive hierarchy of constitution
206 // =======================================================================
207 template <class T, class M>
209 public:
212  typedef std::vector<value_type> hierarchy_type;
215  typedef typename hierarchy_type::iterator iterator;
216  typedef typename hierarchy_type::const_iterator const_iterator;
218 
219 // allocator:
220 
223  space_constitution_rep (const geo_basic<T,M>& omega, std::string approx);
225 
226 // accessors & modifiers:
227 
228  const distributor& ownership() const { return _ownership; }
229  std::string name() const;
230  size_type ndof() const { return _ownership.size(); }
231  size_type dis_ndof() const { return _ownership.dis_size(); }
232  communicator comm() const { return _ownership.comm(); }
233  size_type ios_ndof() const;
234  void do_act (const space_act& act);
235  const geo_basic<T,M>& get_geo() const;
236  const geo_basic<T,M>& get_background_geo() const;
237  const basis_basic<T>& get_basis() const;
238  size_type loc_ndof (const reference_element& hat_K) const;
239  size_type assembly_loc_ndof (const geo_basic<T,M>& dom, const geo_element& bgd_K) const;
240  void assembly_dis_idof (const geo_basic<T,M>& dom,
241  const geo_element& bgd_K, std::vector<geo_element::size_type>& dis_idof) const;
242  void compute_external_dofs (std::set<size_type>& ext_dof_set) const;
245  const valued_type& valued_tag() const { return _valued_tag; }
246  const std::string& valued() const { return space_constant::valued_name (_valued_tag); }
247  bool is_hierarchical() const { return _is_hier; }
248  void set_hierarchy (bool hier) { _is_hier = hier; }
249 
250 // inquiries:
251 
253  bool is_discontinuous() const;
254  size_type degree_max() const;
255  void neighbour_guard() const;
256 
257 // scalar accessors & modifiers:
258 
261 
262 // hierarchy accessors & modifiers:
263 
266  size_type size() const { return _is_hier ? _hier_constit.size() : 0; }
268  const space_constitution<T,M>& operator[] (size_type i_comp) const { return get_hierarchy() [i_comp]; }
269 
271  size_type comp_dis_idof2dis_idof (size_type i_comp, size_type comp_dis_idof) const;
272 
273 // utility:
274 
275  void set_ios_permutations (
276  disarray<size_type,M>& idof2ios_dis_idof,
277  disarray<size_type,M>& ios_idof2dis_idof) const;
278 
279 // comparator:
280 
281  bool operator== (const space_constitution_rep<T,M>& V2) const;
282 
283 // internal:
284  void initialize() const;
285  void append_external_dof (
286  const geo_basic<T,M>& dom,
287  std::set<size_type>& ext_dof_set,
288  const distributor& dof_ownership,
289  const distributor& start_by_component) const;
290  void compute_external_dofs (
291  std::set<size_type>& ext_dof_set,
292  const distributor& dof_ownership,
293  const std::vector<distributor>& start_by_component,
294  size_type& i_comp) const;
296  disarray<size_type,M>& blocked_flag, // disarray<bool,M> not supported
297  const std::vector<distributor>& start_by_component,
298  size_type& i_comp) const;
300 
301 // io:
302  void put (std::ostream& out, size_type level = 0) const;
303 
304 protected:
305 // internals:
306  friend class space_constitution<T,M>;
307  void hierarchy_guard() const { check_macro ( _is_hier, "invalid access to a non-hierarchical constitution"); }
308  void scalar_guard() const { check_macro (!_is_hier, "invalid access to a hierarchical constitution"); }
310  disarray<size_type,M>& idof2ios_dis_idof,
311  size_type& comp_start_idof,
312  size_type& comp_start_dis_idof) const;
315  size_type& i_flat_comp,
316  size_type& start_flat_comp_idof,
317  size_type& dis_start_flat_comp_idof,
318  std::vector<distributor>& start_by_flattened_component) const;
319  void _init_start_by_component() const;
321  const geo_basic<T,M>& dom,
322  const geo_element& bgd_K,
323  typename std::vector<geo_element::size_type>::iterator& dis_idof_t,
324  const distributor& hier_ownership,
325  const std::vector<distributor>& start_by_flattened_component,
326  size_type& i_flat_comp) const;
327 
328 // data:
329  // union (hier,not hier):
330  mutable bool _is_initialized;
332  mutable std::vector<distributor> _start_by_flattened_component;
333  mutable std::vector<distributor> _start_by_component;
336  bool _is_hier;
339  mutable std::array<size_type, reference_element::max_variant> _loc_ndof; // working array
340 };
341 // ----------------------------------------------------------------------------
342 // inlined
343 // ----------------------------------------------------------------------------
344 // allocators: there are 4 allocators, here are 2, the 2 others are in .cc
345 template <class T, class M>
346 inline
348  : _is_initialized(false),
349  _flattened_size(0),
350  _start_by_flattened_component(),
351  _start_by_component(),
352  _ownership(),
353  _valued_tag(space_constant::mixed),
354  _is_hier(false),
355  _terminal_constit(),
356  _hier_constit(),
357  _loc_ndof()
358 {
359  _loc_ndof.fill (std::numeric_limits<size_type>::max());
360 }
361 template <class T, class M>
362 inline
364  : _is_initialized(x._is_initialized),
365  _flattened_size(x._flattened_size),
366  _start_by_flattened_component(x._start_by_flattened_component),
367  _start_by_component(x._start_by_component),
368  _ownership(x._ownership),
369  _valued_tag(x._valued_tag),
370  _is_hier(x._is_hier),
371  _terminal_constit(x._terminal_constit),
372  _hier_constit(x._hier_constit),
373  _loc_ndof()
374 {
375  _loc_ndof.fill (std::numeric_limits<size_type>::max());
376 }
377 template <class T, class M>
378 inline
380  const geo_basic<T,M>& omega,
381  std::string approx)
382  : _is_initialized(false),
383  _flattened_size(0),
384  _start_by_flattened_component(),
385  _start_by_component(),
386  _ownership(),
387  _valued_tag(space_constant::scalar),
388  _is_hier(false),
389  _terminal_constit(),
390  _hier_constit(),
391  _loc_ndof()
392 {
393  _loc_ndof.fill (std::numeric_limits<size_type>::max());
394  _terminal_constit = scalar_type (omega, approx);
395  if (_terminal_constit.get_basis().is_initialized()) {
396  _valued_tag = _terminal_constit.get_basis().valued_tag();
397  }
398  initialize();
399 }
400 // ----------------------------------------------------------------------------
401 // space_constitution
402 // ----------------------------------------------------------------------------
403 
404 template <class T, class M = rheo_default_memory_model>
405 class space_constitution : public smart_pointer<space_constitution_rep<T,M> > {
406 public:
407 
410  typedef typename rep::size_type size_type;
412  typedef typename rep::scalar_type scalar_type;
414  typedef typename rep::valued_type valued_type;
415 
416 // allocators:
417 
419  : base(new_macro(rep)) {}
420 
422  : base(b) {}
423 
425  const geo_basic<T,M>& omega,
426  std::string approx)
427  : base(new_macro(rep (omega,approx))) {}
428 
430  : base(new_macro(rep (expr))) {}
431 
432 // accessors & modifiers:
433 
434  const distributor& ownership() const { return base::data().ownership(); }
435  std::string name() const { return base::data().name(); }
436  size_type ndof() const { return base::data().ndof(); }
437  size_type dis_ndof() const { return base::data().dis_ndof(); }
438  size_type ios_ndof() const { return base::data().ios_ndof(); }
439  communicator comm() const { return base::data().comm(); }
440  const geo_basic<T,M>& get_geo() const { return base::data().get_geo(); }
441  const geo_basic<T,M>& get_background_geo() const { return base::data().get_background_geo(); }
442  const basis_basic<T>& get_basis() const { return base::data().get_basis(); }
443  size_type loc_ndof (const reference_element& hat_K) const { return base::data().loc_ndof (hat_K); }
444  size_type assembly_loc_ndof (const geo_basic<T,M>& dom, const geo_element& bgd_K) const {
445  return base::data().assembly_loc_ndof (dom, bgd_K); }
446  void assembly_dis_idof ( const geo_basic<T,M>& dom, const geo_element& bgd_K, std::vector<geo_element::size_type>& dis_idof) const {
447  base::data().assembly_dis_idof (dom, bgd_K, dis_idof); }
448  void do_act (const space_act& act) { base::data().do_act(act); }
449  void block (const domain_indirect_basic<M>& dom) { do_act (space_act(dom.name(), space_act::block)); }
453  disarray<size_type,M> build_blocked_flag() const { return base::data().build_blocked_flag(); }
454  void compute_external_dofs (std::set<size_type>& ext_dof_set) const
455  { base::data().compute_external_dofs(ext_dof_set); }
456  bool is_hierarchical() const { return base::data().is_hierarchical(); }
457 
458 // inquiries:
459 
460  bool have_compact_support_inside_element() const { return base::data().have_compact_support_inside_element(); }
461  bool is_discontinuous() const { return base::data().is_discontinuous(); }
462  size_type degree_max() const { return base::data().degree_max(); }
463  void neighbour_guard() const { return base::data().neighbour_guard(); }
464 
465 // scalar accessors & modifiers:
466 
467  const space_constitution_terminal<T,M>& get_terminal() const { return base::data().get_terminal(); }
469 
470 // hierarchy accessors & modifiers:
471 
472  void set_hierarchy(bool hier = true) { return base::data().set_hierarchy(hier); }
474  void set_valued (const std::string& valued){ base::data().set_valued (valued); }
475  const valued_type& valued_tag() const { return base::data().valued_tag(); }
476  const std::string& valued() const { return base::data().valued(); }
477  const hierarchy_type& get_hierarchy() const { return base::data().get_hierarchy(); }
478  hierarchy_type& get_hierarchy() { return base::data().get_hierarchy(); }
479  size_type size() const { return base::data().size(); }
480  space_constitution<T,M>& operator[] (size_type i_comp) { return base::data().operator[] (i_comp); }
481  const space_constitution<T,M>& operator[] (size_type i_comp) const { return base::data().operator[] (i_comp); }
482  size_type flattened_size() const { return base::data().flattened_size(); }
483  size_type comp_dis_idof2dis_idof (size_type i_comp, size_type comp_dis_idof) const
484  { return base::data().comp_dis_idof2dis_idof (i_comp, comp_dis_idof); }
485 
486 // utility:
487 
489  disarray<size_type,M>& idof2ios_dis_idof,
490  disarray<size_type,M>& ios_idof2dis_idof) const
491  { base::data().set_ios_permutations (idof2ios_dis_idof, ios_idof2dis_idof); }
492 
493 // comparator:
494 
495  bool operator== (const space_constitution<T,M>& V2) const { return base::data().operator==(V2.data()); }
496 
497 protected:
498 // internal:
499  friend class space_constitution_rep<T,M>;
501  disarray<size_type,M>& idof2ios_dis_idof,
502  size_type& comp_start_idof,
503  size_type& comp_start_dis_idof) const
504  { base::data().set_ios_permutation_recursion (idof2ios_dis_idof, comp_start_idof, comp_start_dis_idof); }
505 };
506 template<class T, class M>
507 idiststream&
508 operator>> (idiststream& ids, space_constitution<T,M>& constit);
509 
510 } // namespace rheolef
511 #endif // _RHEOLEF_SPACE_CONSTITUTION_H
field::size_type size_type
Definition: branch.cc:430
see the distributor page for the full documentation
Definition: distributor.h:69
size_type dis_size() const
global and local sizes
Definition: distributor.h:214
size_type size(size_type iproc) const
Definition: distributor.h:170
const communicator_type & comm() const
Definition: distributor.h:152
see the geo_element page for the full documentation
Definition: geo_element.h:102
see the reference_element page for the full documentation
see the smart_pointer page for the full documentation
const std::string & get_domain_name() const
size_type get_component_index() const
space_act(const std::string &dom_name, act_type act)
space_act(const space_act &x)
static const size_type unset_index
space_act(const std::string &dom_name, size_type i_comp, act_type act)
act_type get_act() const
void append_external_dof(const geo_basic< T, M > &dom, std::set< size_type > &ext_dof_set, const distributor &dof_ownership, const distributor &start_by_component) const
disarray< size_type, M > build_blocked_flag() const
space_constitution_terminal< T, M > scalar_type
void set_ios_permutations(disarray< size_type, M > &idof2ios_dis_idof, disarray< size_type, M > &ios_idof2dis_idof) const
const basis_basic< T > & get_basis() const
const geo_basic< T, M > & get_background_geo() const
const valued_type & valued_tag() const
std::array< size_type, reference_element::max_variant > _loc_ndof
void put(std::ostream &out, size_type level=0) const
std::vector< value_type > hierarchy_type
std::vector< distributor > _start_by_flattened_component
space_constitution_rep< T, M > this_type
void set_valued(const std::string &valued)
void build_blocked_flag_recursive(disarray< size_type, M > &blocked_flag, const std::vector< distributor > &start_by_component, size_type &i_comp) const
const std::string & valued() const
space_constant::valued_type valued_type
void _init_start_by_flattened_component(size_type &i_flat_comp, size_type &start_flat_comp_idof, size_type &dis_start_flat_comp_idof, std::vector< distributor > &start_by_flattened_component) const
void set_ios_permutation_recursion(disarray< size_type, M > &idof2ios_dis_idof, size_type &comp_start_idof, size_type &comp_start_dis_idof) const
hierarchy_type::iterator iterator
bool operator==(const space_constitution_rep< T, M > &V2) const
const distributor & ownership() const
void assembly_dis_idof(const geo_basic< T, M > &dom, const geo_element &bgd_K, std::vector< geo_element::size_type > &dis_idof) const
space_constitution< T, M > & operator[](size_type i_comp)
space_constitution< T, M > value_type
void _assembly_dis_idof_recursive(const geo_basic< T, M > &dom, const geo_element &bgd_K, typename std::vector< geo_element::size_type >::iterator &dis_idof_t, const distributor &hier_ownership, const std::vector< distributor > &start_by_flattened_component, size_type &i_flat_comp) const
size_type loc_ndof(const reference_element &hat_K) const
hierarchy_type::const_iterator const_iterator
std::vector< distributor > _start_by_component
hierarchy_type::size_type size_type
const scalar_type & get_terminal() const
const geo_basic< T, M > & get_geo() const
void set_valued_tag(valued_type valued_tag)
size_type assembly_loc_ndof(const geo_basic< T, M > &dom, const geo_element &bgd_K) const
void compute_external_dofs(std::set< size_type > &ext_dof_set) const
const hierarchy_type & get_hierarchy() const
void do_act(const space_act &act)
size_type comp_dis_idof2dis_idof(size_type i_comp, size_type comp_dis_idof) const
bool operator==(const space_constitution_terminal_rep< T, M > &V2) const
void set_ios_permutations(disarray< size_type, M > &idof2ios_dis_idof, disarray< size_type, M > &ios_idof2dis_idof) const
container_type::const_iterator const_iterator
space_constitution_terminal_rep(const space_constitution_terminal_rep< T, M > &scr)
const geo_basic< T, M > & get_geo() const
const geo_basic< T, M > & get_background_geo() const
void build_blocked_flag(disarray< size_type, M > &blocked_flag, const distributor &comp_ownership, const distributor &start_by_component) const
void set_basis(const basis_basic< T > &b)
void set_geo(const geo_basic< T, M > &omega)
const basis_basic< T > & get_basis() const
void set_ios_permutations(disarray< size_type, M > &idof2ios_dis_idof, disarray< size_type, M > &ios_idof2dis_idof) const
void block(const domain_indirect_basic< M > &dom)
const geo_basic< T, M > & get_geo() const
const geo_basic< T, M > & get_background_geo() const
void unblock_n(const domain_indirect_basic< M > &dom)
void set_basis(const basis_basic< T > &b)
void set_geo(const geo_basic< T, M > &omega)
bool operator==(const space_constitution_terminal< T, M > &V2) const
void block_n(const domain_indirect_basic< M > &dom)
void unblock(const domain_indirect_basic< M > &dom)
space_constitution_terminal(const geo_basic< T, M > &omega, std::string approx)
space_constitution_terminal_rep< T, M > rep
const basis_basic< T > & get_basis() const
hierarchy_type & get_hierarchy()
rep::const_iterator const_iterator
bool operator==(const space_constitution< T, M > &V2) const
space_constitution_rep< T, M > rep
bool have_compact_support_inside_element() const
void set_ios_permutations(disarray< size_type, M > &idof2ios_dis_idof, disarray< size_type, M > &ios_idof2dis_idof) const
const valued_type & valued_tag() const
void block(const domain_indirect_basic< M > &dom)
const geo_basic< T, M > & get_geo() const
rep::hierarchy_type hierarchy_type
const geo_basic< T, M > & get_background_geo() const
void set_valued(const std::string &valued)
size_type loc_ndof(const reference_element &hat_K) const
space_constitution(const space_mult_list< T, M > &expr)
void unblock_n(const domain_indirect_basic< M > &dom)
const space_constitution_terminal< T, M > & get_terminal() const
const std::string & valued() const
void set_ios_permutation_recursion(disarray< size_type, M > &idof2ios_dis_idof, size_type &comp_start_idof, size_type &comp_start_dis_idof) const
const distributor & ownership() const
size_type assembly_loc_ndof(const geo_basic< T, M > &dom, const geo_element &bgd_K) const
void set_hierarchy(bool hier=true)
void assembly_dis_idof(const geo_basic< T, M > &dom, const geo_element &bgd_K, std::vector< geo_element::size_type > &dis_idof) const
space_constitution< T, M > & operator[](size_type i_comp)
disarray< size_type, M > build_blocked_flag() const
space_constitution(const geo_basic< T, M > &omega, std::string approx)
void block_n(const domain_indirect_basic< M > &dom)
space_constitution_terminal< T, M > & get_terminal()
void unblock(const domain_indirect_basic< M > &dom)
size_type comp_dis_idof2dis_idof(size_type i_comp, size_type comp_dis_idof) const
void set_valued_tag(valued_type valued_tag)
void compute_external_dofs(std::set< size_type > &ext_dof_set) const
const hierarchy_type & get_hierarchy() const
void do_act(const space_act &act)
const basis_basic< T > & get_basis() const
#define trace_macro(message)
Definition: dis_macros.h:111
Expr1::float_type T
Definition: field_expr.h:230
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
const std::string & valued_name(valued_type valued_tag)
valued_type valued_tag(const std::string &name)
void dis_idof(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_idof_tab)
This file is part of Rheolef.
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition: catchmark.h:88
Expr1::memory_type M
Definition: vec_expr_v2.h:416