Rheolef  7.1
an efficient C++ finite element environment
geo.cc
Go to the documentation of this file.
1 #include "rheolef/geo.h"
22 #include "rheolef/geo_domain.h"
23 #include "rheolef/space_numbering.h"
24 #include "rheolef/rheostream.h"
25 #include "rheolef/iorheo.h"
26 
27 #include "geo_header.h"
28 
29 namespace rheolef {
30 using namespace std;
31 
32 // =========================================================================
33 // cstors
34 // =========================================================================
35 template <class T, class M>
37  : geo_abstract_rep<T,M>(),
38  _name("*nogeo*"),
39  _version(0),
40  _serial_number(0),
41  _geo_element(),
42  _gs(),
43  _domains(),
44  _have_connectivity(false),
45  _have_neighbour(false),
46  _node(),
47  _dimension(0),
48  _sys_coord(space_constant::cartesian),
49  _xmin(),
50  _xmax(),
51  _hmin(),
52  _hmax(),
53  _piola_basis("P1"),
54  _locator(),
55  _tracer_ray_boundary(),
56  _nearestor()
57 {
58 }
59 template <class T, class M>
61  : geo_abstract_rep<T,M>(o),
62  _name (o._name),
63  _version (o._version),
64  _serial_number (o._serial_number),
65  _geo_element (o._geo_element),
66  _gs (o._gs),
67  _domains (o._domains),
68  _have_connectivity (o._have_connectivity),
69  _have_neighbour (o._have_neighbour),
70  _node (o._node),
71  _dimension (o._dimension),
72  _sys_coord (o._sys_coord),
73  _xmin (o._xmin),
74  _xmax (o._xmax),
75  _hmin (o._hmin),
76  _hmax (o._hmax),
77  _piola_basis (o._piola_basis),
78  _locator (o._locator),
79  _tracer_ray_boundary (o._tracer_ray_boundary),
80  _nearestor (o._nearestor)
81 {
82  trace_macro ("*** PHYSICAL COPY OF GEO_BASE_REP ***");
83 }
84 template <class T>
87 {
88 }
89 template <class T>
91  : geo_base_rep<T,sequential>(omega)
92 {
93  trace_macro ("*** PHYSICAL COPY OF GEO_REP<seq> ***");
94 }
95 template <class T>
98 {
99  trace_macro ("*** CLONE OF GEO_REP<seq> ***");
100  typedef geo_rep<T,sequential> rep;
101  return new_macro (rep(*this));
102 }
103 template <class T>
106 {
107  static const geo_element_map_type dummy;
108  return dummy;
109 }
110 #ifdef _RHEOLEF_HAVE_MPI
111 template <class T>
114  _inod2ios_dis_inod(),
115  _ios_inod2dis_inod(),
116  _ios_ige2dis_ige(),
117  _ios_gs(),
118  _igev2ios_dis_igev(),
119  _ios_igev2dis_igev()
120 {
121 }
122 template <class T>
124  : geo_base_rep<T,distributed>(o),
125  _inod2ios_dis_inod(o._inod2ios_dis_inod),
126  _ios_inod2dis_inod(o._ios_inod2dis_inod),
127  _ios_ige2dis_ige (o._ios_ige2dis_ige),
128  _ios_gs (o._ios_gs),
129  _igev2ios_dis_igev(o._igev2ios_dis_igev),
130  _ios_igev2dis_igev(o._ios_igev2dis_igev)
131 {
132  trace_macro ("*** PHYSICAL COPY OF GEO_REP<dis> ***");
133 }
134 template <class T>
137 {
138  trace_macro ("*** CLONE OF GEO_REP<dis> ***");
139  typedef geo_rep<T,distributed> rep;
140  return new_macro (rep(*this));
141 }
142 #endif // _RHEOLEF_HAVE_MPI
143 // =========================================================================
144 // global table of preloaded geos
145 // =========================================================================
146 template<class T, class M>
148 
149 template<class T, class M>
152 {
153  return _loaded_map;
154 }
155 // =========================================================================
156 // geo_load(name): handle name as "square[boundary]"
157 // =========================================================================
158 // geo(name) { base::operaor=(geo_load(name)); }
159 static
160 bool
161 is_domain (const std::string& name, std::string& bgd_name, std::string& dom_name)
162 {
163  size_t n = name.length();
164  if (n <= 2 || name[n-1] != ']') return false;
165  size_t i = n-2;
166  for (; i > 0 && name[i] != '[' && name[i] != '/'; i--) ;
167  // ../../nfem/ptst/triangle_p10-v2 => name[i] == '/' : stop before "../../"
168  if (i == 0 || i == n-2 || name[i] == '/') return false;
169  // name[i] == '[' as "square[right]"
170  bgd_name = name.substr(0,i); // range [0:i[
171  dom_name = name.substr(i+1); // range [i+1:end[
172  dom_name = dom_name.substr(0,dom_name.length()-1); // range [0:end-1[ : skip ']'
173  return true;
174 }
175 template<class T, class M>
176 geo_basic<T,M>
177 geo_load (const std::string& filename)
178 {
179  typedef typename geo_basic<T,M>::base base;
180  std::string root_name = delete_suffix (delete_suffix(filename, "gz"), "geo");
181  std::string bgd_name, dom_name;
182  if (is_domain(root_name,bgd_name,dom_name)) {
183  geo_basic<T,M> omega (bgd_name);
184  return omega[dom_name];
185  }
186  std::string name = get_basename (root_name);
187 
188  // check for previously loaded geo:
189  auto iter = geo_base_rep<T,M>::loaded_map().find (name);
190  if (iter != geo_base_rep<T,M>::loaded_map().end()) {
191  // geo(name) was already loaded: reuse it from table
192 #ifdef DEBUG_LOADED_TABLE_TRACE
193  dis_warning_macro ("geo::geo_load("<<name<<"): REUSE");
194 #endif // DEBUG_LOADED_TABLE_TRACE
195  geo_basic<T,M> omega;
196  omega.base::operator= (base((*iter).second,typename base::internal()));
197  return omega;
198  }
199  // allocate a new geo_rep<mpi> and load it from file
200  geo_rep<T,M>* ptr = new_macro((geo_rep<T,M>));
201  ptr->load (filename, communicator());
202  geo_basic<T,M> omega;
203  omega.geo_basic<T,M>::base::operator= (ptr);
204 
205  // store the new created geo in the loaded map:
206 #ifdef DEBUG_LOADED_TABLE_TRACE
207  dis_warning_macro ("geo::geo_load("<<name<<"): NEW");
208 #endif // DEBUG_LOADED_TABLE_TRACE
209  geo_base_rep<T,M>::loaded_map().insert (std::make_pair(name, omega.base::get_count()));
210  return omega;
211 }
212 // ==============================================================================
213 // compact: convert a geo_domain_indirect to a geo_domain
214 // by compacting elements and node numbering to refer only to those used
215 // by the domain: can then be used to solve a pb by FEM on this domain
216 // ==============================================================================
217 template <class T, class M>
218 geo_basic<T,M>
220 {
222  return gamma;
223  }
224  /* allocate a new geo_rep object */
225  const geo_domain_indirect_rep<T,M>* dom_ptr
226  = dynamic_cast<const geo_domain_indirect_rep<T,M>*>(gamma.operator->());
227  geo_domain_rep<T,M>* geo_ptr = new_macro((geo_domain_rep<T,M>)(*dom_ptr));
228  geo_basic<T,M> new_gamma;
229  new_gamma.geo_basic<T,M>::base::operator= (geo_ptr);
230  return new_gamma;
231 }
232 // ==============================================================================
233 // geo interface for non-const members that are specific to geo_rep
234 // - check that pointer to geo_abstract_rep points to a geo_rep
235 // - as non-const, manage also entries in the table
236 // ==============================================================================
237 
238 #define _RHEOLEF_save(M) \
239 template <class T> \
240 void \
241 geo_basic<T,M>::save (std::string filename) const \
242 { \
243  if (filename == "") filename = name(); \
244  odiststream out (filename, "geo"); \
245  put (out); \
246 }
247 #define _RHEOLEF_set_name(M) \
248 template <class T> \
249 void \
250 geo_basic<T,M>::set_name (std::string new_name) \
251 { \
252  geo_rep<T,M>* ptr = dynamic_cast<geo_rep<T,M>*>(base::pointer()); \
253  check_macro (ptr != 0, "cannot set_name on geo_domains"); \
254  ptr->set_name(new_name); \
255  geo_base_rep<T,M>::loaded_map().insert (make_pair(name(), base::get_count()));\
256 }
257 #define _RHEOLEF_set_serial_number(M) \
258 template <class T> \
259 void \
260 geo_basic<T,M>::set_serial_number (size_type i) \
261 { \
262  geo_rep<T,M>* ptr = dynamic_cast<geo_rep<T,M>*>(base::pointer()); \
263  check_macro (ptr != 0, "cannot set_serial_number on geo_domains"); \
264  ptr->set_serial_number(i); \
265  geo_base_rep<T,M>::loaded_map().insert (make_pair(name(), base::get_count()));\
266 }
267 #define _RHEOLEF_reset_order(M) \
268 template <class T> \
269 void \
270 geo_basic<T,M>::reset_order (size_type order) \
271 { \
272  geo_rep<T,M>* ptr = dynamic_cast<geo_rep<T,M>*>(base::pointer()); \
273  check_macro (ptr != 0, "cannot reset_order on geo_domains"); \
274  ptr->reset_order(order); \
275 }
276 #define _RHEOLEF_set_nodes(M) \
277 template <class T> \
278 void \
279 geo_basic<T,M>::set_nodes (const disarray<node_type,M>& x) \
280 { \
281  geo_rep<T,M>* ptr = dynamic_cast<geo_rep<T,M>*>(base::pointer()); \
282  check_macro (ptr != 0, "cannot set_nodes on geo_domains"); \
283  ptr->set_nodes(x); \
284 }
285 #define _RHEOLEF_set_coordinate_system(M) \
286 template <class T> \
287 void \
288 geo_basic<T,M>::set_coordinate_system (coordinate_type sys_coord) \
289 { \
290  geo_rep<T,M>* ptr = dynamic_cast<geo_rep<T,M>*>(base::pointer()); \
291  check_macro (ptr != 0, "cannot set_coordinate_system on geo_domains"); \
292  ptr->set_coordinate_system(sys_coord); \
293 }
294 #define _RHEOLEF_set_dimension(M) \
295 template <class T> \
296 void \
297 geo_basic<T,M>::set_dimension (size_type dim) \
298 { \
299  geo_rep<T,M>* ptr = dynamic_cast<geo_rep<T,M>*>(base::pointer()); \
300  check_macro (ptr != 0, "cannot set_dimension on geo_domains"); \
301  ptr->set_dimension(dim); \
302 }
303 #define _RHEOLEF_build_by_subdividing(M) \
304 template <class T> \
305 void \
306 geo_basic<T,M>::build_by_subdividing ( \
307  const geo_basic<T,M>& omega, \
308  size_type k) \
309 { \
310  geo_rep<T,M>* ptr = dynamic_cast<geo_rep<T,M>*>(base::pointer()); \
311  check_macro (ptr != 0, "cannot build_by_subdividing on geo_domains"); \
312  ptr->build_by_subdividing (omega, k); \
313 }
314 #define _RHEOLEF_build_from_data(M) \
315 template <class T> \
316 void \
317 geo_basic<T,M>::build_from_data ( \
318  const geo_header& hdr, \
319  const disarray<node_type, M>& node, \
320  std::array<disarray<geo_element_auto<>,M>, reference_element::max_variant>& tmp_geo_element, \
321  bool do_upgrade) \
322 { \
323  geo_rep<T,M>* ptr = dynamic_cast<geo_rep<T,M>*>(base::pointer()); \
324  check_macro (ptr != 0, "cannot build_from_data on geo_domains"); \
325  ptr->build_from_data (hdr, node, tmp_geo_element, do_upgrade); \
326 }
327 
328 _RHEOLEF_save(sequential)
329 _RHEOLEF_set_name(sequential)
330 _RHEOLEF_set_serial_number(sequential)
331 _RHEOLEF_reset_order(sequential)
332 _RHEOLEF_set_nodes(sequential)
334 _RHEOLEF_set_dimension(sequential)
336 _RHEOLEF_build_from_data(sequential)
337 #ifdef _RHEOLEF_HAVE_MPI
346 #ifdef TODO
348 #endif // TODO
349 #endif // _RHEOLEF_HAVE_MPI
350 #undef _RHEOLEF_set_nodes
351 #undef _RHEOLEF_reset_order
352 #undef _RHEOLEF_set_coordinate_system
353 #undef _RHEOLEF_set_dimension
354 #undef _RHEOLEF_set_name
355 #undef _RHEOLEF_build_from_data
356 #undef _RHEOLEF_build_by_subdividing
357 // ----------------------------------------------------------------------------
358 // set order: resize node disarray ; internal node are not computed
359 // since they depend on the curved boundary information (cad data)
360 // that is not aivailable here
361 // ----------------------------------------------------------------------------
362 #define _RHEOLEF_reset_order(M) \
363 template <class T> \
364 void \
365 geo_rep<T,M>::reset_order (size_type new_order) \
366 { \
367  if (new_order == base::_piola_basis.degree()) return; \
368  base::_piola_basis.reset_family_index (new_order); \
369  size_type dis_nnod = space_numbering::dis_ndof (base::_piola_basis, base::_gs, base::_gs._map_dimension); \
370  size_type nnod = space_numbering::ndof (base::_piola_basis, base::_gs, base::_gs._map_dimension); \
371  base::_gs.node_ownership = distributor (nnod, base::comm(), nnod); \
372  disarray<point_basic<T>, M> new_node (base::_gs.node_ownership); \
373  for (size_type iv = 0, nv = base::_gs.ownership_by_dimension[0].size(); iv < nv; iv++) { \
374  new_node [iv] = base::_node [iv]; \
375  } \
376  base::_node = new_node; \
377  build_external_entities (); \
378 }
379 _RHEOLEF_reset_order(sequential)
380 #ifdef _RHEOLEF_HAVE_MPI
382 #endif // _RHEOLEF_HAVE_MPI
383 #undef _RHEOLEF_reset_order
384 // =========================================================================
385 // geo_base_rep destructor
386 // =========================================================================
387 template <class T, class M>
389 {
390  size_t n_erased = geo_base_rep<T,M>::loaded_map().erase (name());
391  if (_name == "*nogeo*" || _name == "unnamed") {
392  return;
393  }
394 #ifdef DEBUG_LOADED_TABLE_TRACE
395  if (n_erased != 1) {
396  dis_warning_macro ("geo::~geo(\""<<name()<<"\"): was not present in the preloaded table");
397  }
398  if (n_erased == 1) {
399  dis_warning_macro ("geo::~geo("<<name()<<"): ERASED from table");
400  }
401 #endif // DEBUG_LOADED_TABLE_TRACE
402 }
403 // =========================================================================
404 // geo_base_rep members
405 // =========================================================================
406 template <class T, class M>
407 std::string
409 {
410  if (_serial_number == 0) return _name;
411  char buffer [100];
412  sprintf (buffer, "%.3d", int(_serial_number));
413  return _name + "-" + buffer;
414 }
415 template <class T, class M>
416 bool
418 {
420  iter = _domains.begin(), last = _domains.end(); iter != last; iter++) {
421  const domain_indirect_basic<M>& dom = *iter;
422  if (name == dom.name()) return true;
423  }
424  return false;
425 }
426 template <class T, class M>
429 {
431  iter = _domains.begin(), last = _domains.end(); iter != last; iter++) {
432  const domain_indirect_basic<M>& dom = *iter;
433  if (name == dom.name()) return dom;
434  }
435  error_macro ("undefined domain \""<<name<<"\" in mesh \"" << _name << "\"");
436  return *(_domains.begin()); // not reached
437 }
438 template <class T, class M>
439 void
441 {
443  iter = _domains.begin(), last = _domains.end(); iter != last; iter++) {
444  domain_indirect_basic<M>& curr_dom = *iter;
445  if (dom.name() == curr_dom.name()) {
446  // a domain with the same name already exists: replace it
447  curr_dom = dom;
448  return;
449  }
450  }
451  // insert a new domain:
452  _domains.push_back (dom);
453 }
454 template <class T, class M>
457 {
458  size_type sz = 0;
461  sz += _geo_element [variant].size();
462  }
463  return sz;
464 }
465 template <class T, class M>
468 {
469  size_type sz = 0;
472  sz += _geo_element [variant].dis_size();
473  }
474  return sz;
475 }
476 template <class T, class M>
477 void
479  const geo_element& K,
480  std::vector<size_type>& dis_inod) const
481 {
482  space_numbering::dis_idof (_piola_basis, _gs, K, dis_inod);
483 }
484 template <class T, class M>
485 void
487 {
488  // first, compute bbox sequentialy:
489  for (size_type j = 0; j < _dimension; j++) {
490  _xmin[j] = std::numeric_limits<T>::max();
491  _xmax[j] = -std::numeric_limits<T>::max();
492  }
493  for (size_type j = _dimension+1; j < 3; j++) {
494  _xmin [j] = _xmax [j] = T(0);
495  }
496  for (size_type inod = 0, nnod = _node.size(); inod < nnod; inod++) {
497  const point_basic<T>& x = _node [inod];
498  for (size_type j = 0 ; j < _dimension; j++) {
499  _xmin[j] = min(x[j], _xmin[j]);
500  _xmax[j] = max(x[j], _xmax[j]);
501  }
502  }
503  // distributed case: min & max are grouped across procs
504 #ifdef _RHEOLEF_HAVE_MPI
506  for (size_type j = 0 ; j < _dimension; j++) {
507  _xmin[j] = mpi::all_reduce (comm(), _xmin[j], mpi::minimum<T>());
508  _xmax[j] = mpi::all_reduce (comm(), _xmax[j], mpi::maximum<T>());
509  }
510  }
511 #endif // _RHEOLEF_HAVE_MPI
512 
513  // next, compute hmin & hmax
514  _hmin = std::numeric_limits<T>::max();
515  _hmax = T(0);
516  for (size_t iedg = 0, nedg = geo_element_ownership(1).size(); iedg < nedg; ++iedg) {
517  const geo_element& E = get_geo_element (1, iedg);
518  const point_basic<T>& x0 = dis_node(E[0]);
519  const point_basic<T>& x1 = dis_node(E[1]);
520  T hloc = dist(x0,x1);
521  _hmin = min(_hmin, hloc);
522  _hmax = max(_hmax, hloc);
523  }
524 #ifdef _RHEOLEF_HAVE_MPI
526  _hmin = mpi::all_reduce (comm(), _hmin, mpi::minimum<T>());
527  _hmax = mpi::all_reduce (comm(), _hmax, mpi::maximum<T>());
528  }
529 #endif // _RHEOLEF_HAVE_MPI
530 }
531 template <class T, class M>
534 {
535  size_type first_ige = 0, last_ige = 0;
538  last_ige += _geo_element [variant].size();
539  if (ige < last_ige) return _geo_element [variant] [ige - first_ige];
540  first_ige = last_ige;
541  }
542  error_macro ("geo_element index " << ige << " out of range [0:"<< last_ige << "[");
543  return _geo_element [0][0]; // not reached
544 }
545 template <class T, class M>
548 {
549  size_type first_ige = 0, last_ige = 0;
552  last_ige += _geo_element [variant].size();
553  if (ige < last_ige) return _geo_element [variant] [ige - first_ige];
554  first_ige = last_ige;
555  }
556  error_macro ("geo_element index " << ige << " out of range [0:"<< last_ige << "[");
557  return _geo_element [0][0]; // not reached
558 }
559 // =========================================================================
560 // utility: vertex ownership follows node ownership, but dis_numbering differ
561 // for high order > 1 meshes. This function converts numbering.
562 // =========================================================================
563 template <class T, class M>
566 {
567  if (is_sequential<M>::value || order() == 1) return dis_inod;
568  return _gs.dis_inod2dis_iv (dis_inod);
569 }
570 template <class T, class M>
573 {
574  if (is_sequential<M>::value || order() == 1) return dis_iv;
575  return _gs.dis_iv2dis_inod (dis_iv);
576 }
577 // --------------------------------------------------------------------------
578 // accessors to distributed data
579 // --------------------------------------------------------------------------
580 template <class T, class M>
583 {
584  if (is_sequential<M>::value) return get_geo_element (dim, dis_ige);
585  if (_gs.ownership_by_dimension[dim].is_owned (dis_ige)) {
586  size_type first_dis_ige = _gs.ownership_by_dimension[dim].first_index();
587  size_type ige = dis_ige - first_dis_ige;
588  return get_geo_element (dim, ige);
589  }
590  // element is owned by another proc ; get its variant and its index-variant igev
592  size_type dis_igev = _gs.dis_ige2dis_igev_by_dimension (dim, dis_ige, variant);
593  typename geo_base_rep<T,M>::const_reference res = _geo_element [variant].dis_at (dis_igev);
594  return res;
595 }
596 // -------------------------------------------------------------------
597 // guards for omega.boundary() and omega.internal_sides()
598 // -------------------------------------------------------------------
599 template <class T, class M>
600 void boundary_guard (const geo_basic<T,M>& omega)
601 {
602  typedef typename geo_basic<T,M>::size_type size_type;
603  if (omega.have_domain_indirect ("boundary")) return;
604  omega.neighbour_guard();
605  size_type map_dim = omega.map_dimension();
606  check_macro (map_dim > 0, "undefined boundary for 0D geometry");
607  size_type sid_dim = map_dim-1;
608  std::vector<size_type> isid_list;
609  for (size_type isid = 0, nsid = omega.size(sid_dim); isid < nsid; isid++) {
610  const geo_element& S = omega.get_geo_element (sid_dim, isid);
611  if (S.master(1) != std::numeric_limits<size_type>::max()) continue; // S is an internal side
612  isid_list.push_back (isid);
613  }
614  communicator comm = omega.sizes().ownership_by_dimension[sid_dim].comm();
615  domain_indirect_basic<M> isid_dom (omega, "boundary", sid_dim, comm, isid_list);
616  omega.insert_domain_indirect (isid_dom);
617 }
618 template <class T, class M>
620 {
621  typedef typename geo_basic<T,M>::size_type size_type;
622  if (omega.have_domain_indirect ("internal_sides")) return;
623  omega.neighbour_guard();
624  size_type map_dim = omega.map_dimension();
625  check_macro (map_dim > 0, "undefined internal_sides for 0D geometry");
626  size_type sid_dim = map_dim-1;
627  std::vector<size_type> isid_list;
628  for (size_type isid = 0, nsid = omega.size(sid_dim); isid < nsid; isid++) {
629  const geo_element& S = omega.get_geo_element (sid_dim, isid);
630  if (S.master(1) == std::numeric_limits<size_type>::max()) continue; // S is on boundary
631  isid_list.push_back (isid);
632  }
633  communicator comm = omega.sizes().ownership_by_dimension[sid_dim].comm();
634  domain_indirect_basic<M> isid_dom (omega, "internal_sides", sid_dim, comm, isid_list);
635  isid_dom.set_broken (true);
636  omega.insert_domain_indirect (isid_dom);
637 }
638 template <class T, class M>
639 void sides_guard (const geo_basic<T,M>& omega)
640 {
641  typedef typename geo_basic<T,M>::size_type size_type;
642  if (omega.have_domain_indirect ("sides")) return;
643  omega.neighbour_guard();
644  size_type map_dim = omega.map_dimension();
645  check_macro (map_dim > 0, "undefined sides for 0D geometry");
646  size_type sid_dim = map_dim-1;
647  std::vector<size_type> isid_list;
648  for (size_type isid = 0, nsid = omega.size(sid_dim); isid < nsid; isid++) {
649  const geo_element& S = omega.get_geo_element (sid_dim, isid);
650  isid_list.push_back (isid);
651  }
652  communicator comm = omega.sizes().ownership_by_dimension[sid_dim].comm();
653  domain_indirect_basic<M> isid_dom (omega, "sides", sid_dim, comm, isid_list);
654  isid_dom.set_broken (true);
655  omega.insert_domain_indirect (isid_dom);
656 }
657 // ----------------------------------------------------------------------------
658 // instanciation in library
659 // ----------------------------------------------------------------------------
660 #define _RHEOLEF_instanciation(T,M) \
661 template class geo_base_rep<T,M>; \
662 template class geo_rep<T,M>; \
663 template class geo_basic<T,M>; \
664 template geo_basic<T,M> geo_load (const std::string& name); \
665 template geo_basic<T,M> compact (const geo_basic<T,M>&); \
666 template void boundary_guard (const geo_basic<T,M>&); \
667 template void internal_sides_guard (const geo_basic<T,M>&); \
668 template void sides_guard (const geo_basic<T,M>&);
669 
670 _RHEOLEF_instanciation(Float,sequential)
671 #ifdef _RHEOLEF_HAVE_MPI
673 #endif // _RHEOLEF_HAVE_MPI
674 
675 } // namespace rheolef
rheolef::reference_element::last_variant_by_dimension
static variant_type last_variant_by_dimension(size_type dim)
Definition: reference_element.h:150
rheolef::geo_domain_indirect_rep
Definition: geo.h:187
rheolef::geo_base_rep::dis_iv2dis_inod
size_type dis_iv2dis_inod(size_type dis_iv) const
Definition: geo.cc:572
rheolef::compact
geo_basic< T, M > compact(const geo_basic< T, M > &gamma)
Definition: geo.cc:219
rheolef::geo_base_rep::size_type
base::size_type size_type
Definition: geo.h:533
rheolef::geo_basic
generic mesh with rerefence counting
Definition: domain_indirect.h:64
_RHEOLEF_set_coordinate_system
#define _RHEOLEF_set_coordinate_system(M)
Definition: geo.cc:285
_RHEOLEF_set_name
#define _RHEOLEF_set_name(M)
Definition: geo.cc:247
rheolef::geo_domain_rep
Definition: geo_domain.h:53
rheolef::delete_suffix
string delete_suffix(const string &name, const string &suffix)
delete_suffix: see the rheostream page for the full documentation
Definition: rheostream.cc:222
rheolef::point_basic
Definition: point.h:87
check_macro
check_macro(expr1.have_homogeneous_space(Xh1), "dual(expr1,expr2); expr1 should have homogeneous space. HINT: use dual(interpolate(Xh, expr1),expr2)")
rheolef::geo_element::master
size_type master(bool i) const
Definition: geo_element.h:165
_RHEOLEF_build_by_subdividing
#define _RHEOLEF_build_by_subdividing(M)
Definition: geo.cc:303
rheolef::geo_base_rep::dis_size
size_type dis_size() const
Definition: geo.h:645
rheolef::geo_rep< T, distributed >
distributed mesh representation
Definition: geo.h:929
rheolef::geo_abstract_base_rep::size_type
geo_element_hack::size_type size_type
Definition: geo.h:260
rheolef::_RHEOLEF_instanciation
_RHEOLEF_instanciation(Float, sequential, std::allocator< Float >) _RHEOLEF_instanciation(Float
rheolef::geo_rep< T, sequential >
Definition: geo.h:786
rheolef::dummy
static iorheo::force_initialization dummy
Definition: iorheo.cc:147
rheolef::sequential
Definition: distributed.h:28
rheolef::geo_base_rep::~geo_base_rep
~geo_base_rep()
Definition: geo.cc:388
rheolef::geo_base_rep
base class for M=sequential or distributed meshes representations
Definition: geo.h:528
rheolef::space_constant::cartesian
@ cartesian
Definition: space_constant.h:122
rheolef::_RHEOLEF_save
_RHEOLEF_save(sequential) _RHEOLEF_set_name(sequential) _RHEOLEF_set_serial_number(sequential) _RHEOLEF_reset_order(sequential) _RHEOLEF_set_nodes(sequential) _RHEOLEF_set_coordinate_system(sequential) _RHEOLEF_set_dimension(sequential) _RHEOLEF_build_by_subdividing(sequential) _RHEOLEF_build_from_data(sequential) _RHEOLEF_save(distributed) _RHEOLEF_set_name(distributed) _RHEOLEF_set_serial_number(distributed) _RHEOLEF_reset_order(distributed) _RHEOLEF_set_nodes(distributed) _RHEOLEF_set_coordinate_system(distributed) _RHEOLEF_set_dimension(distributed) _RHEOLEF_build_by_subdividing(distributed) _RHEOLEF_reset_order(sequential) _RHEOLEF_reset_order(distributed) template< class T
geo_header.h
rheolef::geo_base_rep::dis_inod2dis_iv
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition: geo.cc:565
rheolef::get_basename
string get_basename(const string &name)
get_basename: see the rheostream page for the full documentation
Definition: rheostream.cc:254
rheolef::geo_base_rep::reference
base::reference reference
Definition: geo.h:540
mkgeo_ball.order
order
Definition: mkgeo_ball.sh:343
rheolef::geo_element
see the geo_element page for the full documentation
Definition: geo_element.h:102
rheolef::geo_rep
sequential mesh representation
Definition: domain_indirect.h:63
rheolef::geo_base_rep::get_geo_element
const_reference get_geo_element(size_type dim, size_type ige) const
Definition: geo.cc:533
rheolef::geo_base_rep::geo_base_rep
geo_base_rep()
Definition: geo.cc:36
rheolef::size_type
size_t size_type
Definition: basis_get.cc:76
rheolef::space_numbering::dis_idof
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)
Definition: space_numbering.cc:187
rheolef::geo_load
geo_basic< T, M > geo_load(const std::string &filename)
sequential mesh with reference counting
Definition: geo.cc:177
rk::gamma
Float gamma[][pmax+1]
Definition: runge_kutta_semiimplicit.icc:70
_RHEOLEF_reset_order
#define _RHEOLEF_reset_order(M)
Definition: geo.cc:267
rheolef::geo_base_rep::have_domain_indirect
bool have_domain_indirect(const std::string &name) const
Definition: geo.cc:417
_RHEOLEF_set_nodes
#define _RHEOLEF_set_nodes(M)
Definition: geo.cc:276
rheolef::reference_element::first_variant_by_dimension
static variant_type first_variant_by_dimension(size_type dim)
Definition: reference_element.h:148
rheolef::is_distributed
Definition: distributed.h:36
rheolef::sides_guard
void sides_guard(const geo_basic< T, M > &omega)
Definition: geo.cc:639
rheolef::geo_base_rep::dis_inod
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition: geo.cc:478
rheolef::geo_abstract_base_rep
abstract base interface class
Definition: geo.h:248
rheolef::is_sequential
Definition: distributed.h:32
rheolef::geo_base_rep::get_domain_indirect
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
Definition: geo.h:597
mkgeo_ball.variant
variant
Definition: mkgeo_ball.sh:149
dis_warning_macro
#define dis_warning_macro(message)
Definition: dis_macros.h:66
rheolef::distributed
Definition: distributed.h:88
rheolef::geo_abstract_rep
abstract interface class
Definition: domain_indirect.h:62
rheolef::geo_abstract_rep< T, sequential >
Definition: geo.h:404
rheolef::geo_base_rep::name
std::string name() const
Definition: geo.cc:408
rheolef::geo_base_rep::dis_get_geo_element
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition: geo.cc:582
rheolef::geo_base_rep::insert_domain_indirect
void insert_domain_indirect(const domain_indirect_basic< M > &dom) const
Definition: geo.cc:440
rheolef::geo_base_rep::size
size_type size() const
Definition: geo.h:643
rheolef::geo_base_rep::compute_bbox
void compute_bbox()
Definition: geo.cc:486
rheolef::boundary_guard
void boundary_guard(const geo_basic< T, M > &omega)
Definition: geo.cc:600
rheolef::geo_base_rep::loaded_map
static loaded_map_t & loaded_map()
Definition: geo.cc:151
rheolef::geo_iterator
geo iterator
Definition: geo.h:193
_RHEOLEF_set_serial_number
#define _RHEOLEF_set_serial_number(M)
Definition: geo.cc:257
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
_RHEOLEF_build_from_data
#define _RHEOLEF_build_from_data(M)
Definition: geo.cc:314
error_macro
#define error_macro(message)
Definition: dis_macros.h:49
rheolef::internal_sides_guard
void internal_sides_guard(const geo_basic< T, M > &omega)
Definition: geo.cc:619
rheolef::geo_base_rep::loaded_map_t
std::unordered_map< std::string, void * > loaded_map_t
Definition: geo.h:698
rheolef::space_numbering::dis_inod
void dis_inod(const basis_basic< T > &b, const geo_size &gs, const geo_element &K, typename std::vector< size_type >::iterator dis_inod_tab)
Definition: space_numbering.cc:177
Float
see the Float page for the full documentation
rheolef::geo_base_rep::const_reference
base::const_reference const_reference
Definition: geo.h:541
rheolef::space_numbering::nnod
size_type nnod(const basis_basic< T > &b, const geo_size &gs, size_type map_dim)
Definition: space_numbering.cc:54
rheolef::space_constant::vector
@ vector
Definition: space_constant.h:137
rheolef::geo_abstract_rep< T, distributed >
Definition: geo.h:457
mkgeo_ball.n
n
Definition: mkgeo_ball.sh:150
_RHEOLEF_set_dimension
#define _RHEOLEF_set_dimension(M)
Definition: geo.cc:294
size_type
field::size_type size_type
Definition: branch.cc:425
mkgeo_ball.map_dim
map_dim
Definition: mkgeo_ball.sh:337
rheolef::distributed
distributed
Definition: asr.cc:228
rheolef::geo_abstract_base_rep::geo_element_map_type
std::map< size_type, geo_element_auto<> > geo_element_map_type
Definition: geo.h:266
mkgeo_ball.dim
dim
Definition: mkgeo_ball.sh:307
rheolef::domain_indirect_basic
the finite element boundary domain
Definition: domain_indirect.h:335
mkgeo_contraction.name
name
Definition: mkgeo_contraction.sh:133
M
Expr1::memory_type M
Definition: vec_expr_v2.h:385
T
Expr1::float_type T
Definition: field_expr.h:218
rheolef::dist
T dist(const point_basic< T > &x, const point_basic< T > &y)
Definition: point.h:299
trace_macro
#define trace_macro(message)
Definition: dis_macros.h:111