Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
geo.cc
Go to the documentation of this file.
1
21#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
29namespace rheolef {
30using namespace std;
31
32// =========================================================================
33// cstors
34// =========================================================================
35template <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}
59template <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}
84template <class T>
89template <class T>
91 : geo_base_rep<T,sequential>(omega)
92{
93 trace_macro ("*** PHYSICAL COPY OF GEO_REP<seq> ***");
94}
95template <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}
103template <class T>
106{
107 static const geo_element_map_type dummy;
108 return dummy;
109}
110#ifdef _RHEOLEF_HAVE_MPI
111template <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}
122template <class T>
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}
134template <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// =========================================================================
146template<class T, class M>
148
149template<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)); }
159static
160bool
161is_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}
175template<class T, class M>
176geo_basic<T,M>
177geo_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// ==============================================================================
217template <class T, class M>
218geo_basic<T,M>
220{
221 if (gamma.variant() != geo_abstract_base_rep<T>::geo_domain_indirect) {
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) \
239template <class T> \
240void \
241geo_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) \
248template <class T> \
249void \
250geo_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) \
258template <class T> \
259void \
260geo_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) \
268template <class T> \
269void \
270geo_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) \
277template <class T> \
278void \
279geo_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) \
286template <class T> \
287void \
288geo_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) \
295template <class T> \
296void \
297geo_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) \
304template <class T> \
305void \
306geo_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) \
315template <class T> \
316void \
317geo_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
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) \
363template <class T> \
364void \
365geo_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}
380#ifdef _RHEOLEF_HAVE_MPI
382#endif // _RHEOLEF_HAVE_MPI
383#undef _RHEOLEF_reset_order
384// =========================================================================
385// geo_base_rep destructor
386// =========================================================================
387template <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// =========================================================================
406template <class T, class M>
407std::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}
415template <class T, class M>
416bool
417geo_base_rep<T,M>::have_domain_indirect (const std::string& name) const
418{
419 for (typename std::vector<domain_indirect_basic<M> >::const_iterator
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}
426template <class T, class M>
427const domain_indirect_basic<M>&
428geo_base_rep<T,M>::get_domain_indirect (const std::string& name) const
429{
430 for (typename std::vector<domain_indirect_basic<M> >::const_iterator
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}
438template <class T, class M>
439void
441{
442 for (typename std::vector<domain_indirect_basic<M> >::iterator
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}
454template <class T, class M>
457{
458 size_type sz = 0;
460 variant < reference_element:: last_variant_by_dimension(dim); variant++) {
461 sz += _geo_element [variant].size();
462 }
463 return sz;
464}
465template <class T, class M>
468{
469 size_type sz = 0;
471 variant < reference_element:: last_variant_by_dimension(dim); variant++) {
472 sz += _geo_element [variant].dis_size();
473 }
474 return sz;
475}
476template <class T, class M>
477void
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}
484template <class T, class M>
485void
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}
531template <class T, class M>
534{
535 size_type first_ige = 0, last_ige = 0;
537 variant < reference_element:: last_variant_by_dimension(dim); variant++) {
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}
545template <class T, class M>
548{
549 size_type first_ige = 0, last_ige = 0;
551 variant < reference_element:: last_variant_by_dimension(dim); variant++) {
552 last_ige += _geo_element [variant].size();
553 if (ige < last_ige) return _geo_element [variant] [ige - first_ige];
554 first_ige = last_ige;
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// =========================================================================
563template <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}
570template <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// --------------------------------------------------------------------------
580template <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
591 size_type variant;
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// -------------------------------------------------------------------
599template <class T, class M>
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}
618template <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}
638template <class T, class M>
639void 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) \
661template class geo_base_rep<T,M>; \
662template class geo_rep<T,M>; \
663template class geo_basic<T,M>; \
664template geo_basic<T,M> geo_load (const std::string& name); \
665template geo_basic<T,M> compact (const geo_basic<T,M>&); \
666template void boundary_guard (const geo_basic<T,M>&); \
667template void internal_sides_guard (const geo_basic<T,M>&); \
668template void sides_guard (const geo_basic<T,M>&);
669
671#ifdef _RHEOLEF_HAVE_MPI
673#endif // _RHEOLEF_HAVE_MPI
674
675} // namespace rheolef
#define _RHEOLEF_instanciation(T, M, A)
Definition asr.cc:223
field::size_type size_type
Definition branch.cc:430
see the Float page for the full documentation
see the communicator page for the full documentation
the finite element boundary domain
abstract base interface class
Definition geo.h:248
abstract interface class
Definition geo.h:401
base class for M=sequential or distributed meshes representations
Definition geo.h:528
std::string name() const
Definition geo.cc:408
size_type dis_size() const
Definition geo.h:645
void dis_inod(const geo_element &K, std::vector< size_type > &dis_inod) const
Definition geo.cc:478
size_type dis_iv2dis_inod(size_type dis_iv) const
Definition geo.cc:572
void insert_domain_indirect(const domain_indirect_basic< M > &dom) const
Definition geo.cc:440
const domain_indirect_basic< M > & get_domain_indirect(size_type i) const
Definition geo.h:597
size_type size() const
Definition geo.h:643
base::size_type size_type
Definition geo.h:533
std::unordered_map< std::string, void * > loaded_map_t
Definition geo.h:698
const_reference get_geo_element(size_type dim, size_type ige) const
Definition geo.cc:533
base::const_reference const_reference
Definition geo.h:541
const_reference dis_get_geo_element(size_type dim, size_type dis_ige) const
Definition geo.cc:582
size_type dis_inod2dis_iv(size_type dis_inod) const
Definition geo.cc:565
static loaded_map_t & loaded_map()
Definition geo.cc:151
base::reference reference
Definition geo.h:540
void compute_bbox()
Definition geo.cc:486
bool have_domain_indirect(const std::string &name) const
Definition geo.cc:417
generic mesh with rerefence counting
Definition geo.h:1089
see the geo_element page for the full documentation
size_type master(bool i) const
base::size_type size_type
Definition geo.h:791
base::geo_element_map_type geo_element_map_type
Definition geo.h:801
sequential mesh representation
Definition geo.h:778
static variant_type last_variant_by_dimension(size_type dim)
static variant_type first_variant_by_dimension(size_type dim)
#define trace_macro(message)
Definition dis_macros.h:111
#define error_macro(message)
Definition dis_macros.h:49
#define dis_warning_macro(message)
Definition dis_macros.h:66
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)")
#define _RHEOLEF_set_name(M)
Definition geo.cc:247
#define _RHEOLEF_build_by_subdividing(M)
Definition geo.cc:303
#define _RHEOLEF_set_dimension(M)
Definition geo.cc:294
#define _RHEOLEF_set_coordinate_system(M)
Definition geo.cc:285
#define _RHEOLEF_save(M)
Definition geo.cc:238
#define _RHEOLEF_build_from_data(M)
Definition geo.cc:314
#define _RHEOLEF_reset_order(M)
Definition geo.cc:267
#define _RHEOLEF_set_serial_number(M)
Definition geo.cc:257
#define _RHEOLEF_set_nodes(M)
Definition geo.cc:276
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.
string delete_suffix(const string &name, const string &suffix)
delete_suffix: see the rheostream page for the full documentation
void boundary_guard(const geo_basic< T, M > &omega)
Definition geo.cc:600
geo_basic< T, M > compact(const geo_basic< T, M > &gamma)
Definition geo.cc:219
string get_basename(const string &name)
get_basename: see the rheostream page for the full documentation
void sides_guard(const geo_basic< T, M > &omega)
Definition geo.cc:639
geo_basic< T, M > geo_load(const std::string &filename)
sequential mesh with reference counting
Definition geo.cc:177
T dist(const point_basic< T > &x, const point_basic< T > &y)
Definition point.h:298
void internal_sides_guard(const geo_basic< T, M > &omega)
Definition geo.cc:619
STL namespace.
Expr1::memory_type M