You are here: Concepts>Concepts Web>Class documentation

Class documentation of Concepts

Loading...
Searching...
No Matches
mesh_p.hh
Go to the documentation of this file.
1
7#ifndef mesh_p_hh
8#define mesh_p_hh
9
10#include <memory>
11
12#include "basics/exceptions.hh"
13#include "basics/outputOperator.hh"
14#include "geometry/elementMaps.hh"
15#include "geometry/elementMaps3D.hh"
16#include "geometry/mesh.hh"
17#include "toolbox_p/using_p.hh"
18#include "toolbox_p/communicators.hh"
19
20namespace concepts {
21
22 // ******************************************* Scanners **
23
25 template <>
26 class Scan<Connector0> :
27 public Scan<Connector> {
28 public:
30 Connector0& operator++(int) = 0;
31 };
32
34 template <>
35 class Scan<Connector1> :
36 public Scan<Connector> {
37 public:
39 Connector1& operator++(int) = 0;
40 };
41
43 template <>
44 class Scan<Connector2> :
45 public Scan<Connector> {
46 public:
48 Connector2& operator++(int) = 0;
49 };
50
51 typedef Scan<Connector0> ScanCntr0;
52 typedef Scan<Connector1> ScanCntr1;
53 typedef Scan<Connector2> ScanCntr2;
54
55} // namespace concepts
56
57
58
59namespace parallel {
60
61 // ********************************************** Lists **
62
65 template<class T>
66 class ListElm {
67 private:
68 ListElm<T>* lnk_;
69 T* elm_;
70
71 public:
72 inline ListElm(T* elm, ListElm<T>* lnk = 0) : lnk_(lnk), elm_(elm) {};
73
74 inline ListElm<T>** linkp() {return &lnk_;};
75 inline ListElm<T>* link() const {return lnk_;};
76 inline T* elm() const {return elm_;}
77 };
78
81 template<class ListNode>
82 class ListHead : public concepts::OutputOperator {
83 private:
84 ListNode* root_;
85
86 public:
87 inline ListHead(ListNode* root = 0) : root_(root) {};
88 inline ~ListHead() {
89 while (root_)
90 {ListNode* foo = root_; root_ = root_->link(); delete foo;}
91 };
92
93 inline ListNode** rootp() {return &root_;};
94 inline ListNode* root() const {return root_;};
95 };
96
97 typedef ListElm<Connector0> Cntr0LstEl;
98 typedef ListElm<Connector1> Cntr1LstEl;
99 typedef ListElm<Connector2> Cntr2LstEl;
100 typedef ListElm<Cell1> Cell1LstEl;
101 typedef ListElm<Cell2> Cell2LstEl;
102 typedef ListElm<Cell3> Cell3LstEl;
103
104 typedef ListHead<Cntr0LstEl> Cntr0Lst;
105 typedef ListHead<Cntr1LstEl> Cntr1Lst;
106 typedef ListHead<Cntr2LstEl> Cntr2Lst;
107 typedef ListHead<Cell1LstEl> Cell1Lst;
108 typedef ListHead<Cell2LstEl> Cell2Lst;
109 typedef ListHead<Cell3LstEl> Cell3Lst;
110
111
112
113 // *********************************************** Mesh **
114
122 class Mesh : public concepts::OutputOperator {
123 private:
124 const Communicator& com_;
125 public:
126 Mesh(const Communicator& com) : com_(com) {};
127 virtual ~Mesh() {};
128
129 inline const Communicator& comm() const {return com_;};
130
132 virtual uint nglobcell() const = 0;
133
135 virtual uint nloccell() const = 0;
136
141 virtual Scan<Cell>* globscan() = 0;
142
147 virtual Scan<Cell>* locscan() = 0;
148
149 protected:
150 virtual std::ostream& info(std::ostream& os) const;
151 };
152
153
154 // ********************************************** Mesh1 **
155
158 class Mesh1 : public Mesh {
159 private:
161 class LocalS : public Scan<Cell1> {
162 uint n_;
163 uint idx_;
164 Array<unique_ptr<Cell1> > *cell_;
165 public:
166 inline LocalS(uint n, Array<unique_ptr<Cell1> > *cell)
167 : n_(n), idx_(0), cell_(cell) {};
168 inline LocalS(const LocalS& scan) : n_(scan.n_), idx_(scan.idx_),
169 cell_(scan.cell_) {};
170 inline bool eos() const {return idx_ == n_;};
171 inline Cell1& operator++(int) {return *((*cell_)[idx_++]);};
172 inline concepts::Scan1* clone() const {return new LocalS(*this);};
173 };
174
176 class GlobalS : public Scan<Cell1> {
177 uint n_;
178 uint idx_;
179 Array<unique_ptr<Cell1> > *cell_;
180 public:
181 inline GlobalS(uint n, Array<unique_ptr<Cell1> > *cell)
182 : n_(n), idx_(0), cell_(cell) {
183 throw conceptsException(MissingFeature("GlobalS not yet implemented"));
184 };
185 inline GlobalS(const GlobalS& scan) {
186 throw conceptsException(MissingFeature("GlobalS not yet implemented"));
187 };
188 inline bool eos() const {return 1;};
189 inline Cell1& operator++(int) {return *((*cell_)[idx_++]);};
190 inline concepts::Scan1* clone() const {return new GlobalS(*this);};
191 };
192
194 template<class T>
195 class CapS : public Scan<T> {
196 private:
197 ListElm<T>* cntr_;
198 public:
199 inline CapS(ListElm<T>* cntr) : cntr_(cntr) {};
200 inline CapS(const CapS<T>& scan) : cntr_(scan.cntr_) {};
201 inline bool eos() const {return (!cntr_);};
202 inline T& operator++(int) {
203 ListElm<T>* foo = cntr_; cntr_ = cntr_->link();
204 return *(foo->elm());};
205 inline Scan<T>* clone() const {return new CapS(*this);};
206 };
207
209 uint ngcell_;
211 uint nlcell_;
212
214 Array<unique_ptr<Connector0> >* cntr0_;
215 uint ncntr0_;
216
218 Array<unique_ptr<Connector1> >* cntr1_;
220 Array<unique_ptr<Cell1> >* cell_;
221
223 Array<unique_ptr<concepts::Map1d> >* map_;
224 uint nmap_;
225
227 Array<Cntr0Lst>* cap0_;
229 Array<Cell1Lst>* cap1_;
230
231 public:
250 inline Mesh1(Array<unique_ptr<Connector0> >* cntr0,
251 Array<unique_ptr<Connector1> >* cntr1,
252 Array<unique_ptr<Cell1> >* cell, uint ngcell,
253 Array<unique_ptr<concepts::Map1d> >* map,
254 Array<Cntr0Lst>* cap0, Array<Cell1Lst>* cap1,
255 const Communicator& com);
256 inline ~Mesh1();
257
259 inline uint nglobcell() const {return ngcell_;};
261 inline uint nloccell() const {return nlcell_;};
262
264 inline concepts::Scan1* globscan() {return new GlobalS(nlcell_, cell_);};
265
267 inline concepts::Scan1* locscan() {return new LocalS(nlcell_, cell_);};
268
272 inline concepts::ScanCntr0* cap0scan(uint i) {
273 return new CapS<Connector0>((*cap0_)[i].root());
274 };
278 inline concepts::Scan1* cap1scan(uint i) {
279 return new CapS<Cell1>((*cap1_)[i].root());
280 };
281
282 protected:
283 std::ostream& info(std::ostream& os) const;
284 };
285
286
287 Mesh1::Mesh1(Array<unique_ptr<Connector0> >* cntr0,
288 Array<unique_ptr<Connector1> >* cntr1,
289 Array<unique_ptr<Cell1> >* cell, uint ngcell,
290 Array<unique_ptr<concepts::Map1d> >* map,
291 Array<Cntr0Lst>* cap0, Array<Cell1Lst>* cap1,
292 const Communicator& com)
293 : Mesh(com), ngcell_(ngcell), nlcell_(cell->cursize()), cntr0_(cntr0),
294 ncntr0_(cntr0->cursize()), cntr1_(cntr1), cell_(cell), map_(map),
295 nmap_(map ? map->cursize() : 0), cap0_(cap0), cap1_(cap1) {
296 }
297
298 Mesh1::~Mesh1() {
299 delete cap0_;
300 delete cap1_;
301 delete cell_; delete map_;
302 delete cntr1_; delete cntr0_;
303 }
304
305
306 // ********************************************** Mesh2 **
307
310 class Mesh2 : public Mesh {
311 private:
313 class LocalS : public Scan<Cell2> {
314 uint n_;
315 uint idx_;
316 Array<unique_ptr<Cell2> > *cell_;
317 public:
318 inline LocalS(uint n, Array<unique_ptr<Cell2> > *cell)
319 : n_(n), idx_(0), cell_(cell) {};
320 inline LocalS(const LocalS& scan) : n_(scan.n_), idx_(scan.idx_),
321 cell_(scan.cell_) {};
322 inline bool eos() const {return idx_ == n_;};
323 inline Cell2& operator++(int) {return *((*cell_)[idx_++]);};
324 inline concepts::Scan2* clone() const {return new LocalS(*this);};
325 };
326
328 class GlobalS : public Scan<Cell2> {
329 uint n_;
330 uint idx_;
331 Array<unique_ptr<Cell2> > *cell_;
332 public:
333 inline GlobalS(uint n, Array<unique_ptr<Cell2> > *cell)
334 : n_(n), idx_(0), cell_(cell) {
335 throw conceptsException(MissingFeature("GlobalS not yet implemented"));
336 };
337 inline GlobalS(const GlobalS& scan) {
338 throw conceptsException(MissingFeature("GlobalS not yet implemented"));
339 };
340 inline bool eos() const {return 1;};
341 inline Cell2& operator++(int) {return *((*cell_)[idx_++]);};
342 inline concepts::Scan2* clone() const {return new GlobalS(*this);};
343 };
344
346 template<class T>
347 class CapS : public Scan<T> {
348 private:
349 ListElm<T>* cntr_;
350 public:
351 inline CapS(ListElm<T>* cntr) : cntr_(cntr) {};
352 inline CapS(const CapS<T>& scan) : cntr_(scan.cntr_) {};
353 inline bool eos() const {return (!cntr_);};
354 inline T& operator++(int) {
355 ListElm<T>* foo = cntr_; cntr_ = cntr_->link();
356 return *(foo->elm());};
357 inline Scan<T>* clone() const {return new CapS(*this);};
358 };
359
360
362 uint ngcell_;
364 uint nlcell_;
365
367 Array<unique_ptr<Connector0> >* cntr0_;
368 uint ncntr0_;
370 Array<unique_ptr<Connector1> >* cntr1_;
371 uint ncntr1_;
372
374 Array<unique_ptr<Connector2> >* cntr2_;
376 Array<unique_ptr<Cell2> >* cell_;
377
379 Array<unique_ptr<concepts::Map2d> >* map_;
380 uint nmap_;
381
383 Array<Cntr0Lst>* cap0_;
385 Array<Cntr1Lst>* cap1_;
387 Array<Cell2Lst>* cap2_;
388
389 public:
414 inline Mesh2(Array<unique_ptr<Connector0> >* cntr0,
415 Array<unique_ptr<Connector1> >* cntr1,
416 Array<unique_ptr<Connector2> >* cntr2,
417 Array<unique_ptr<Cell2> >* cell, uint ngcell,
418 Array<unique_ptr<concepts::Map2d> >* map,
419 Array<Cntr0Lst>* cap0, Array<Cntr1Lst>* cap1,
420 Array<Cell2Lst>* cap2, const Communicator& com);
421 inline ~Mesh2();
422
424 inline uint nglobcell() const {return ngcell_;};
426 inline uint nloccell() const {return nlcell_;};
427
429 inline concepts::Scan2* globscan() {return new GlobalS(nlcell_, cell_);};
430
432 inline concepts::Scan2* locscan() {return new LocalS(nlcell_, cell_);};
433
437 inline concepts::ScanCntr0* cap0scan(uint i) {
438 return new CapS<Connector0>((*cap0_)[i].root());
439 };
443 inline concepts::ScanCntr1* cap1scan(uint i) {
444 return new CapS<Connector1>((*cap1_)[i].root());
445 };
449 inline concepts::Scan2* cap2scan(uint i) {
450 return new CapS<Cell2>((*cap2_)[i].root());
451 };
452
453 protected:
454 std::ostream& info(std::ostream& os) const;
455 };
456
457
458 Mesh2::Mesh2(Array<unique_ptr<Connector0> >* cntr0,
459 Array<unique_ptr<Connector1> >* cntr1,
460 Array<unique_ptr<Connector2> >* cntr2,
461 Array<unique_ptr<Cell2> >* cell, uint ngcell,
462 Array<unique_ptr<concepts::Map2d> >* map,
463 Array<Cntr0Lst>* cap0, Array<Cntr1Lst>* cap1,
464 Array<Cell2Lst>* cap2, const Communicator& com)
465 : Mesh(com), ngcell_(ngcell), nlcell_(cell->cursize()), cntr0_(cntr0),
466 ncntr0_(cntr0->cursize()), cntr1_(cntr1), ncntr1_(cntr1->cursize()),
467 cntr2_(cntr2), cell_(cell), map_(map), nmap_(map ? map->cursize() : 0),
468 cap0_(cap0), cap1_(cap1), cap2_(cap2) {
469 }
470
471 Mesh2::~Mesh2() {
472 delete cap2_; delete cap1_; delete cap0_;
473 delete cell_; delete map_;
474 delete cntr2_; delete cntr1_; delete cntr0_;
475 }
476
477
478 // ********************************************** Mesh3 **
479
482 class Mesh3 : public Mesh {
483 private:
485 class LocalS : public concepts::Scan<Cell3> {
486 uint n_;
487 uint idx_;
488 Array<unique_ptr<Cell3> > *cell_;
489 public:
490 inline LocalS(uint n, Array<unique_ptr<Cell3> > *cell)
491 : n_(n), idx_(0), cell_(cell) {};
492 inline LocalS(const LocalS& scan) : n_(scan.n_), idx_(scan.idx_),
493 cell_(scan.cell_) {};
494 inline bool eos() const {return idx_ == n_;};
495 inline Cell3& operator++(int) {return *((*cell_)[idx_++]);};
496 inline concepts::Scan3* clone() const {return new LocalS(*this);};
497 };
498
500 class GlobalS : public concepts::Scan<Cell3> {
501 uint n_;
502 uint idx_;
503 Array<unique_ptr<Cell3> > *cell_;
504 public:
505 inline GlobalS(uint n, Array<unique_ptr<Cell3> > *cell)
506 : n_(n), idx_(0), cell_(cell) {
507 throw conceptsException(MissingFeature("GlobalS not yet implemented"));
508 };
509 inline GlobalS(const GlobalS& scan) {
510 throw conceptsException(MissingFeature("GlobalS not yet implemented"));
511 };
512 inline bool eos() const {return 1;};
513 inline Cell3& operator++(int) {return *((*cell_)[idx_++]);};
514 inline concepts::Scan3* clone() const {return new GlobalS(*this);};
515 };
516
518 template<class T>
519 class CapS : public Scan<T> {
520 private:
521 ListElm<T>* cntr_;
522 public:
523 inline CapS(ListElm<T>* cntr) : cntr_(cntr) {};
524 inline CapS(const CapS<T>& scan) : cntr_(scan.cntr_) {};
525 inline bool eos() const {return (!cntr_);};
526 inline T& operator++(int) {
527 ListElm<T>* foo = cntr_; cntr_ = cntr_->link();
528 return *(foo->elm());};
529 inline concepts::Scan<T>* clone() const {return new CapS(*this);};
530 };
531
533 uint ngcell_;
535 uint nlcell_;
536
538 Array<unique_ptr<Connector0> >* cntr0_;
539 uint ncntr0_;
541 Array<unique_ptr<Connector1> >* cntr1_;
542 uint ncntr1_;
544 Array<unique_ptr<Connector2> >* cntr2_;
545 uint ncntr2_;
546
548 Array<unique_ptr<Connector3> >* cntr3_;
550 Array<unique_ptr<Cell3> >* cell_;
551
553 Array<unique_ptr<concepts::Map3d> >* map_;
554 uint nmap_;
555
557 Array<Cntr0Lst>* cap0_;
559 Array<Cntr1Lst>* cap1_;
561 Array<Cntr2Lst>* cap2_;
563 Array<Cell3Lst>* cap3_;
564
565 public:
596 inline Mesh3(Array<unique_ptr<Connector0> >* cntr0,
597 Array<unique_ptr<Connector1> >* cntr1,
598 Array<unique_ptr<Connector2> >* cntr2,
599 Array<unique_ptr<Connector3> >* cntr3,
600 Array<unique_ptr<Cell3> >* cell, uint ngcell,
601 Array<unique_ptr<concepts::Map3d> >* map,
602 Array<Cntr0Lst>* cap0, Array<Cntr1Lst>* cap1,
603 Array<Cntr2Lst>* cap2, Array<Cell3Lst>* cap3_,
604 const Communicator& com);
605 inline ~Mesh3();
606
608 inline uint nglobcell() const {return ngcell_;};
610 inline uint nloccell() const {return nlcell_;};
611
613 inline concepts::Scan3* globscan() {return new GlobalS(nlcell_, cell_);};
614
616 inline concepts::Scan3* locscan() {return new LocalS(nlcell_, cell_);};
617
621 inline concepts::ScanCntr0* cap0scan(uint i) {
622 return new CapS<Connector0>((*cap0_)[i].root());
623 };
627 inline concepts::ScanCntr1* cap1scan(uint i) {
628 return new CapS<Connector1>((*cap1_)[i].root());
629 };
633 inline concepts::ScanCntr2* cap2scan(uint i) {
634 return new CapS<Connector2>((*cap2_)[i].root());
635 };
639 inline concepts::Scan3* cap3scan(uint i) {
640 return new CapS<Cell3>((*cap3_)[i].root());
641 };
642
643 protected:
644 std::ostream& info(std::ostream& os) const;
645 };
646
647
648 Mesh3::Mesh3(Array<unique_ptr<Connector0> >* cntr0,
649 Array<unique_ptr<Connector1> >* cntr1,
650 Array<unique_ptr<Connector2> >* cntr2,
651 Array<unique_ptr<Connector3> >* cntr3,
652 Array<unique_ptr<Cell3> >* cell, uint ngcell,
653 Array<unique_ptr<concepts::Map3d> >* map,
654 Array<Cntr0Lst>* cap0, Array<Cntr1Lst>* cap1,
655 Array<Cntr2Lst>* cap2, Array<Cell3Lst>* cap3,
656 const Communicator& com)
657 : Mesh(com), ngcell_(ngcell), nlcell_(cell->cursize()), cntr0_(cntr0),
658 ncntr0_(cntr0->cursize()), cntr1_(cntr1), ncntr1_(cntr1->cursize()),
659 cntr2_(cntr2), ncntr2_(cntr2->cursize()), cntr3_(cntr3), cell_(cell),
660 map_(map), nmap_(map ? map->cursize() : 0), cap0_(cap0), cap1_(cap1),
661 cap2_(cap2), cap3_(cap3) {
662 }
663
664 Mesh3::~Mesh3() {
665 delete cap3_; delete cap2_; delete cap1_; delete cap0_;
666 delete cell_; delete map_;
667 delete cntr3_; delete cntr2_; delete cntr1_; delete cntr0_;
668 }
669
670
671} // namespace parallel
672
673#endif // mesh_p_hh
conceptsException
#define conceptsException(exc)
Definition exceptions.hh:344
concepts::Cell1
One dimensional cell.
Definition cell.hh:75
concepts::Cell2
Two dimensional cell.
Definition cell.hh:89
concepts::Cell3
Three dimensional cell.
Definition cell.hh:112
concepts::Scan< Cell1 >
A scanner for a 1D mesh.
Definition mesh.hh:36
concepts::Scan< Cell2 >
A scanner for a 2D mesh.
Definition mesh.hh:44
concepts::Scan< Cell3 >
A scanner for a 3D mesh.
Definition mesh.hh:52
concepts::Scan< Connector0 >
A scanner for 0D connectors on the processor intersection (cap)
Definition mesh_p.hh:27
concepts::Scan< Connector0 >::operator++
Connector0 & operator++(int)=0
Returns the next connnector of the cap.
concepts::Scan< Connector1 >
A scanner for 1D connectors on the processor intersection (cap)
Definition mesh_p.hh:36
concepts::Scan< Connector1 >::operator++
Connector1 & operator++(int)=0
Returns the next connector of the cap.
concepts::Scan< Connector2 >
A scanner for 2D connectors on the processor intersection (cap)
Definition mesh_p.hh:45
concepts::Scan< Connector2 >::operator++
Connector2 & operator++(int)=0
Returns the next connector of the cap.
parallel::Mesh1::nglobcell
uint nglobcell() const
Returns global number of cells.
Definition mesh_p.hh:259
parallel::Mesh1::cap1scan
concepts::Scan1 * cap1scan(uint i)
Definition mesh_p.hh:278
parallel::Mesh1::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
parallel::Mesh1::nloccell
uint nloccell() const
Returns local number of cells.
Definition mesh_p.hh:261
parallel::Mesh1::cap0scan
concepts::ScanCntr0 * cap0scan(uint i)
Definition mesh_p.hh:272
parallel::Mesh1::Mesh1
Mesh1(Array< unique_ptr< Connector0 > > *cntr0, Array< unique_ptr< Connector1 > > *cntr1, Array< unique_ptr< Cell1 > > *cell, uint ngcell, Array< unique_ptr< concepts::Map1d > > *map, Array< Cntr0Lst > *cap0, Array< Cell1Lst > *cap1, const Communicator &com)
Definition mesh_p.hh:287
parallel::Mesh1::locscan
concepts::Scan1 * locscan()
Returns a scanner over the own cells.
Definition mesh_p.hh:267
parallel::Mesh1::globscan
concepts::Scan1 * globscan()
Returns a scanner over all cells (not yet implemented).
Definition mesh_p.hh:264
parallel::Mesh2::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
parallel::Mesh2::locscan
concepts::Scan2 * locscan()
Returns a scanner over the own cells.
Definition mesh_p.hh:432
parallel::Mesh2::cap1scan
concepts::ScanCntr1 * cap1scan(uint i)
Definition mesh_p.hh:443
parallel::Mesh2::nloccell
uint nloccell() const
Returns local number of cells.
Definition mesh_p.hh:426
parallel::Mesh2::globscan
concepts::Scan2 * globscan()
Returns a scanner over all cells (not yet implemented).
Definition mesh_p.hh:429
parallel::Mesh2::Mesh2
Mesh2(Array< unique_ptr< Connector0 > > *cntr0, Array< unique_ptr< Connector1 > > *cntr1, Array< unique_ptr< Connector2 > > *cntr2, Array< unique_ptr< Cell2 > > *cell, uint ngcell, Array< unique_ptr< concepts::Map2d > > *map, Array< Cntr0Lst > *cap0, Array< Cntr1Lst > *cap1, Array< Cell2Lst > *cap2, const Communicator &com)
Definition mesh_p.hh:458
parallel::Mesh2::cap2scan
concepts::Scan2 * cap2scan(uint i)
Definition mesh_p.hh:449
parallel::Mesh2::nglobcell
uint nglobcell() const
Returns global number of cells.
Definition mesh_p.hh:424
parallel::Mesh2::cap0scan
concepts::ScanCntr0 * cap0scan(uint i)
Definition mesh_p.hh:437
parallel::Mesh3::cap1scan
concepts::ScanCntr1 * cap1scan(uint i)
Definition mesh_p.hh:627
parallel::Mesh3::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
parallel::Mesh3::cap0scan
concepts::ScanCntr0 * cap0scan(uint i)
Definition mesh_p.hh:621
parallel::Mesh3::cap2scan
concepts::ScanCntr2 * cap2scan(uint i)
Definition mesh_p.hh:633
parallel::Mesh3::globscan
concepts::Scan3 * globscan()
Returns a scanner over all cells (not yet implemented).
Definition mesh_p.hh:613
parallel::Mesh3::locscan
concepts::Scan3 * locscan()
Returns a scanner over the own cells.
Definition mesh_p.hh:616
parallel::Mesh3::nglobcell
uint nglobcell() const
Returns global number of cells.
Definition mesh_p.hh:608
parallel::Mesh3::Mesh3
Mesh3(Array< unique_ptr< Connector0 > > *cntr0, Array< unique_ptr< Connector1 > > *cntr1, Array< unique_ptr< Connector2 > > *cntr2, Array< unique_ptr< Connector3 > > *cntr3, Array< unique_ptr< Cell3 > > *cell, uint ngcell, Array< unique_ptr< concepts::Map3d > > *map, Array< Cntr0Lst > *cap0, Array< Cntr1Lst > *cap1, Array< Cntr2Lst > *cap2, Array< Cell3Lst > *cap3_, const Communicator &com)
Definition mesh_p.hh:648
parallel::Mesh3::nloccell
uint nloccell() const
Returns local number of cells.
Definition mesh_p.hh:610
parallel::Mesh3::cap3scan
concepts::Scan3 * cap3scan(uint i)
Definition mesh_p.hh:639
parallel::Mesh::nglobcell
virtual uint nglobcell() const =0
Returns the global number of cells in the mesh.
parallel::Mesh::info
virtual std::ostream & info(std::ostream &os) const
Returns information in an output stream.
parallel::Mesh::locscan
virtual Scan< Cell > * locscan()=0
parallel::Mesh::nloccell
virtual uint nloccell() const =0
Returns the local number of cells in the mesh.
parallel::Mesh::globscan
virtual Scan< Cell > * globscan()=0
using_p.hh
Generated on Wed Sep 13 2023 21:06:20 for Concepts by doxygen 1.9.8