You are here: Concepts>Concepts Web>Class documentation

Class documentation of Concepts

Loading...
Searching...
No Matches
space.hh
Go to the documentation of this file.
1
6#ifndef bemSpace_hh
7#define bemSpace_hh
8
9#include <stack>
10
11#include "basics/output.hh"
12#include "toolbox/dynArray.hh"
13#include "toolbox/scannerConnectors.hh"
14#include "geometry/mesh.hh"
15#include "space/space.hh"
16#include "bem/element.hh"
17
18namespace bem {
19
20 // *************************************************************** Dirac3d **
21
32 template <class F = concepts::Real>
33 class Dirac3d : public concepts::Space<F> {
35 uint dim_;
37 uint nelm_;
39 concepts::Joiner<concepts::Element<F>*, 1>* elm_;
40
46 void constructor_(concepts::Triangle3d* cell, uint lvl,
47 concepts::DynArray<uint>& map);
48
49 protected:
50 std::ostream& info(std::ostream& os) const;
51
52 public:
58 Dirac3d(concepts::Mesh2& msh, uint lvl);
59 virtual ~Dirac3d();
60
62 inline uint dim() const {return dim_;}
64 inline uint nelm() const {return nelm_;}
66 inline concepts::Scan<concepts::Element<F> >* scan() const;
67 };
68
69 template <class F>
70 inline std::ostream& Dirac3d<F>::info(std::ostream& os) const {
71 os << typeOf(*this) << "(dim = " << dim_ << ", nelm = " << nelm_ << ')';
72 return os;
73 }
74
75 template <class F>
79
80 // ************************************************************** Linear3d **
81
92 template <class F = concepts::Real>
93 class Linear3d : public concepts::Space<F> {
95 uint dim_;
97 uint nelm_;
99 concepts::Joiner<concepts::Element<F>*, 1>* elm_;
100
106 void constructor_(concepts::Triangle3d* cell, uint lvl,
107 concepts::DynArray<uint>& map);
108
109 protected:
110 std::ostream& info(std::ostream& os) const {return info(os, 0);}
111
112 public:
118 Linear3d(concepts::Mesh2& msh, uint lvl);
119 virtual ~Linear3d();
120
122 inline uint dim() const {return dim_;}
124 inline uint nelm() const {return nelm_;}
126 inline concepts::Scan<concepts::Element<F> >* scan() const;
135 std::ostream& info(std::ostream& os, uint mode = 0) const;
136 };
137
138 template <class F>
142
143 // ************************************************************ Constant3d **
144
155 template <class F = concepts::Real>
156 class Constant3d : public concepts::Space<F> {
158 uint dim_;
160 uint nelm_;
162 uint elmType_;
164 concepts::Joiner<concepts::Element<F>*, 1>* elm_;
165
170 void constructor_(concepts::Triangle3d* cell, uint lvl);
171
172 protected:
173 std::ostream& info(std::ostream& os) const;
174
175 public:
184 Constant3d(concepts::Mesh2& msh, uint lvl, uint elmType = 0);
185 virtual ~Constant3d();
186
188 uint dim() const {return dim_;}
190 uint nelm() const {return nelm_;}
192 inline concepts::Scan<concepts::Element<F> >* scan() const;
193 };
194
195 template <class F>
199
200 template <class F>
201 inline std::ostream& Constant3d<F>::info(std::ostream& os) const {
202 os << "Constant3d(dim = " << dim_ << ", nelm = " << nelm_ << ')';
203 return os;
204 }
205
206 // ******************************************************** AdaptiveAdjust **
207
213 struct AdaptiveAdjust {
215 short l_;
216
218 AdaptiveAdjust() : l_(0) {}
222 AdaptiveAdjust(short l) : l_(l) {}
223
225 AdaptiveAdjust& operator=(const AdaptiveAdjust& adj) {
226 if (this != &adj) l_ = adj.l_;
227 return *this;
228 }
229 };
230
231 std::ostream& operator<<(std::ostream& os, const AdaptiveAdjust& adj);
232
233 // ********************************************************* AdaptiveSpace **
234
235 template<class F = concepts::Real>
236 class AdaptiveSpace :
237 public concepts::SpaceOnCells<F>,
238 public concepts::AdaptiveSpace<F, AdaptiveAdjust> {
239 protected:
240 std::ostream& info(std::ostream& os) const {
241 return os << "bem::" << typeOf(*this) ;
242 }
243 };
244
245 // ******************************************************* AdaptConst3d000 **
246
252 template<class F = concepts::Real>
253 class AdaptConst3d000 : public AdaptiveSpace<F> {
255 uint dim_;
257 uint nelm_;
259 concepts::Joiner<concepts::ElementWithCell<F>*, 1>* elm_;
260
262 concepts::Mesh2& msh_;
264 uint maxlvl_;
266 uint minlvl_;
268 concepts::DynArray<concepts::AdaptiveControl<> > ctrl_;
270 concepts::DynArray<AdaptiveAdjust> adj_;
272 bool rebuild_;
273
283 void rebuild0_(concepts::Connector2& cntr, int l, int& L);
284 void rebuild1_(concepts::Triangle3d& cell, uint l);
285
286 protected:
287 std::ostream& info(std::ostream& os) const {return info(os, 0);}
288
289 public:
297 AdaptConst3d000(concepts::Mesh2& msh, uint lvl);
298 ~AdaptConst3d000();
299
303 uint dim() const;
304 uint dim();
308 uint nelm() const;
309 uint nelm();
311 uint maxlevel();
313 uint minlevel();
317 concepts::Scan<concepts::ElementWithCell<F> >* scan() const;
318 concepts::Scan<concepts::ElementWithCell<F> >* scan();
320 short l(Constant3d001<F>& elm) {
321 AdaptiveAdjust& adj(adj_[elm.support().key()]);
322 return adj.l_;
323 }
330 void adjust(const concepts::Element<F>& elm,const AdaptiveAdjust& a);
331 void adjust(const Constant3d001<F>& elm, const AdaptiveAdjust& a);
341 void rebuild();
349 std::ostream& info(std::ostream& os, uint mode = 0) const;
350 };
351
352 template<class F>
353 inline uint AdaptConst3d000<F>::dim() const {
354 if (rebuild_) conceptsException(concepts::SpaceNotBuilt());
355 return dim_;
356 }
357
358 template<class F>
359 inline uint AdaptConst3d000<F>::dim() {
360 if (rebuild_) rebuild();
361 return dim_;
362 }
363
364 template<class F>
365 inline uint AdaptConst3d000<F>::nelm() const {
366 if (rebuild_) conceptsException(concepts::SpaceNotBuilt());
367 return nelm_;
368 }
369
370 template<class F>
371 inline uint AdaptConst3d000<F>::nelm() {
372 if (rebuild_) rebuild();
373 return nelm_;
374 }
375
376 template<class F>
377 inline uint AdaptConst3d000<F>::maxlevel() {
378 if (rebuild_) rebuild();
379 return maxlvl_;
380 }
381
382 template<class F>
383 inline uint AdaptConst3d000<F>::minlevel() {
384 if (rebuild_) rebuild();
385 return minlvl_;
386 }
387
388 template<class F>
389 inline concepts::Scan<concepts::ElementWithCell<F> >*
394
395 template<class F>
396 inline concepts::Scan<concepts::ElementWithCell<F> >*
397 AdaptConst3d000<F>::scan() {
398 if (rebuild_) rebuild();
399 return new concepts::PListScan<concepts::ElementWithCell<F> >(*elm_);
400 }
401
402 // *************************************************************** EdgeMap **
403
406 class EdgeMap {
407 friend std::ostream& operator<<(std::ostream& os, const EdgeMap& emp);
408 public:
409 inline EdgeMap() : pnl1(0), pnl2(0), lvl(0), prnt(0), tag(0) {};
410 std::ostream& info(std::ostream& os) const;
411
413 concepts::Connector2* pnl1;
415 concepts::Connector2* pnl2;
417 ushort lvl;
419 EdgeMap* prnt;
426 concepts::uchar tag;
427 };
428
429 // ******************************************************* AdaptConst3d001 **
430
437 template<class F = concepts::Real>
438 class AdaptConst3d001 : public AdaptiveSpace<F> {
440 uint dim_;
442 uint nelm_;
444 concepts::Joiner<concepts::ElementWithCell<F>*, 1>* elm_;
445
447 concepts::Mesh2& msh_;
449 uint maxlvl_;
451 uint minlvl_;
453 concepts::DynArray<concepts::AdaptiveControl<> > ctrl_;
455 concepts::DynArray<AdaptiveAdjust> adj_;
457 bool rebuild_;
461 ushort deltal_;
463 concepts::DynArray<EdgeMap> edgmap_;
467 std::stack<EdgeMap*> stk_;
468
480 void rebuild0_(concepts::Connector2& cntr, int l, int& L);
481 void rebuild1_(concepts::Connector2& cntr);
482 void rebuild2_();
483 void rebuild3_(concepts::Triangle3d& cell, uint l);
484
485 protected:
486 std::ostream& info(std::ostream& os) const {return info(os, 0);}
487
488 public:
497 AdaptConst3d001(concepts::Mesh2& msh, uint lvl, ushort deltal);
498 ~AdaptConst3d001();
499
503 uint dim() const;
504 uint dim();
508 uint nelm() const;
509 uint nelm();
511 uint maxlevel();
513 uint minlevel();
517 concepts::Scan<concepts::ElementWithCell<F> >* scan() const;
518 concepts::Scan<concepts::ElementWithCell<F> >* scan();
520 short l(Constant3d001<F>& elm) {
521 AdaptiveAdjust& adj(adj_[elm.support().key()]);
522 return adj.l_;
523 }
530 void adjust(const concepts::Element<F>& elm, const AdaptiveAdjust& a);
531 void adjust(const Constant3d001<F>& elm, const AdaptiveAdjust& a);
541 void rebuild();
549 std::ostream& info(std::ostream& os, uint mode = 0) const;
550 };
551
552 template<class F>
553 inline uint AdaptConst3d001<F>::dim() const {
554 if (rebuild_) conceptsException(concepts::SpaceNotBuilt());
555 return dim_;
556 }
557
558 template<class F>
559 inline uint AdaptConst3d001<F>::dim() {
560 if (rebuild_) rebuild();
561 return dim_;
562 }
563
564 template<class F>
565 inline uint AdaptConst3d001<F>::nelm() const {
566 if (rebuild_) conceptsException(concepts::SpaceNotBuilt());
567 return nelm_;
568 }
569
570 template<class F>
571 inline uint AdaptConst3d001<F>::nelm() {
572 if (rebuild_) rebuild();
573 return nelm_;
574 }
575
576 template<class F>
577 inline uint AdaptConst3d001<F>::maxlevel() {
578 if (rebuild_) rebuild();
579 return maxlvl_;
580 }
581
582 template<class F>
583 inline uint AdaptConst3d001<F>::minlevel() {
584 if (rebuild_) rebuild();
585 return minlvl_;
586 }
587
588 template<class F>
589 inline concepts::Scan<concepts::ElementWithCell<F> >*
594
595 template<class F>
596 inline concepts::Scan<concepts::ElementWithCell<F> >*
597 AdaptConst3d001<F>::scan() {
598 if (rebuild_) rebuild();
599 return new concepts::PListScan<concepts::ElementWithCell<F> >(*elm_);
600 }
601
602 // ******************************************************* AdaptConst3d002 **
603
612 template<class F = concepts::Real>
613 class AdaptConst3d002 : public AdaptiveSpace<F> {
615 uint dim_;
617 uint nelm_;
619 concepts::Joiner<concepts::ElementWithCell<F>*, 1>* elm_;
620
622 concepts::Mesh2& msh_;
624 uint maxlvl_;
626 uint minlvl_;
628 concepts::DynArray<concepts::AdaptiveControl<> > ctrl_;
630 concepts::DynArray<AdaptiveAdjust> adj_;
632 bool rebuild_;
636 ushort deltal_;
638 ushort deltaL_;
640 concepts::DynArray<EdgeMap> edgmap_;
644 std::stack<EdgeMap*> stk_;
645
657 void rebuild0_(concepts::Connector2& cntr, int l, int& L);
658 void rebuild1_(concepts::Connector2& cntr, uint l);
659 void rebuild2_();
660 void rebuild3_(concepts::Triangle3d& cell, uint l, ushort tag);
661
662 protected:
663 std::ostream& info(std::ostream& os) const {return info(os, 0);}
664
665 public:
675 AdaptConst3d002(concepts::Mesh2& msh, uint lvl, ushort deltal,
676 ushort deltaL);
677 ~AdaptConst3d002();
678
682 uint dim() const;
683 uint dim();
687 uint nelm() const;
688 uint nelm();
690 uint maxlevel();
692 uint minlevel();
696 concepts::Scan<concepts::ElementWithCell<F> >* scan() const;
697 concepts::Scan<concepts::ElementWithCell<F> >* scan();
699 short l(Constant3d001<F>& elm) {
700 AdaptiveAdjust& adj(adj_[elm.support().key()]);
701 return adj.l_;
702 }
709 void adjust(const concepts::Element<F>& elm, const AdaptiveAdjust& a);
710 void adjust(const Constant3d001<F>& elm, const AdaptiveAdjust& a);
720 void rebuild();
728 std::ostream& info(std::ostream& os, uint mode = 0) const;
729 };
730
731 template<class F>
732 inline uint AdaptConst3d002<F>::dim() const {
733 if (rebuild_) conceptsException(concepts::SpaceNotBuilt());
734 return dim_;
735 }
736
737 template<class F>
738 inline uint AdaptConst3d002<F>::dim() {
739 if (rebuild_) rebuild();
740 return dim_;
741 }
742
743 template<class F>
744 inline uint AdaptConst3d002<F>::nelm() const {
745 if (rebuild_) conceptsException(concepts::SpaceNotBuilt());
746 return nelm_;
747 }
748
749 template<class F>
750 inline uint AdaptConst3d002<F>::nelm() {
751 if (rebuild_) rebuild();
752 return nelm_;
753 }
754
755 template<class F>
756 inline uint AdaptConst3d002<F>::maxlevel() {
757 if (rebuild_) rebuild();
758 return maxlvl_;
759 }
760
761 template<class F>
762 inline uint AdaptConst3d002<F>::minlevel() {
763 if (rebuild_) rebuild();
764 return minlvl_;
765 }
766
767 template<class F>
768 inline concepts::Scan<concepts::ElementWithCell<F> >*
773
774 template<class F>
775 inline concepts::Scan<concepts::ElementWithCell<F> >*
776 AdaptConst3d002<F>::scan() {
777 if (rebuild_) rebuild();
778 return new concepts::PListScan<concepts::ElementWithCell<F> >(*elm_);
779 }
780
781} // namespace bem
782
783#endif // bemSpace_hh
conceptsException
#define conceptsException(exc)
Definition exceptions.hh:344
bem::AdaptConst3d000::AdaptConst3d000
AdaptConst3d000(concepts::Mesh2 &msh, uint lvl)
bem::AdaptConst3d000::dim
uint dim() const
Definition space.hh:353
bem::AdaptConst3d000::nelm
uint nelm() const
Definition space.hh:365
bem::AdaptConst3d000::info
std::ostream & info(std::ostream &os, uint mode=0) const
bem::AdaptConst3d000::l
short l(Constant3d001< F > &elm)
Returns the level of a element.
Definition space.hh:320
bem::AdaptConst3d000::maxlevel
uint maxlevel()
Returns the maximal level of all elements.
Definition space.hh:377
bem::AdaptConst3d000::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition space.hh:287
bem::AdaptConst3d000::adjust
void adjust(const concepts::Element< F > &elm, const AdaptiveAdjust &a)
bem::AdaptConst3d000::scan
concepts::Scan< concepts::ElementWithCell< F > > * scan() const
Definition space.hh:390
bem::AdaptConst3d000::minlevel
uint minlevel()
Returns the minimal level of all elements.
Definition space.hh:383
bem::AdaptConst3d001::AdaptConst3d001
AdaptConst3d001(concepts::Mesh2 &msh, uint lvl, ushort deltal)
bem::AdaptConst3d001::dim
uint dim() const
Definition space.hh:553
bem::AdaptConst3d001::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition space.hh:486
bem::AdaptConst3d001::minlevel
uint minlevel()
Returns the minimal level of all elements.
Definition space.hh:583
bem::AdaptConst3d001::nelm
uint nelm() const
Definition space.hh:565
bem::AdaptConst3d001::adjust
void adjust(const concepts::Element< F > &elm, const AdaptiveAdjust &a)
bem::AdaptConst3d001::scan
concepts::Scan< concepts::ElementWithCell< F > > * scan() const
Definition space.hh:590
bem::AdaptConst3d001::info
std::ostream & info(std::ostream &os, uint mode=0) const
bem::AdaptConst3d001::l
short l(Constant3d001< F > &elm)
Returns the level of a element.
Definition space.hh:520
bem::AdaptConst3d001::maxlevel
uint maxlevel()
Returns the maximal level of all elements.
Definition space.hh:577
bem::AdaptConst3d002::scan
concepts::Scan< concepts::ElementWithCell< F > > * scan() const
Definition space.hh:769
bem::AdaptConst3d002::info
std::ostream & info(std::ostream &os, uint mode=0) const
bem::AdaptConst3d002::adjust
void adjust(const concepts::Element< F > &elm, const AdaptiveAdjust &a)
bem::AdaptConst3d002::AdaptConst3d002
AdaptConst3d002(concepts::Mesh2 &msh, uint lvl, ushort deltal, ushort deltaL)
bem::AdaptConst3d002::dim
uint dim() const
Definition space.hh:732
bem::AdaptConst3d002::minlevel
uint minlevel()
Returns the minimal level of all elements.
Definition space.hh:762
bem::AdaptConst3d002::l
short l(Constant3d001< F > &elm)
Returns the level of a element.
Definition space.hh:699
bem::AdaptConst3d002::nelm
uint nelm() const
Definition space.hh:744
bem::AdaptConst3d002::maxlevel
uint maxlevel()
Returns the maximal level of all elements.
Definition space.hh:756
bem::AdaptConst3d002::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition space.hh:663
bem::AdaptiveSpace::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition space.hh:240
bem::Constant3d001::support
const concepts::Triangle & support() const
Returns the support.
Definition element.hh:414
bem::Constant3d::scan
concepts::Scan< concepts::Element< F > > * scan() const
Returns a scanner of the space.
Definition space.hh:196
bem::Constant3d::dim
uint dim() const
Returns the number of degrees of freedom.
Definition space.hh:188
bem::Constant3d::Constant3d
Constant3d(concepts::Mesh2 &msh, uint lvl, uint elmType=0)
bem::Constant3d::nelm
uint nelm() const
Returns the number of elements.
Definition space.hh:190
bem::Constant3d::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition space.hh:201
bem::Dirac3d::nelm
uint nelm() const
Returns number of elements in the space.
Definition space.hh:64
bem::Dirac3d::Dirac3d
Dirac3d(concepts::Mesh2 &msh, uint lvl)
bem::Dirac3d::scan
concepts::Scan< concepts::Element< F > > * scan() const
Returns a scanner of the space.
Definition space.hh:76
bem::Dirac3d::dim
uint dim() const
Returns dimension of the space.
Definition space.hh:62
bem::Dirac3d::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition space.hh:70
bem::EdgeMap::tag
concepts::uchar tag
Definition space.hh:426
bem::EdgeMap::pnl2
concepts::Connector2 * pnl2
neighbouring panel on the lower level
Definition space.hh:415
bem::EdgeMap::pnl1
concepts::Connector2 * pnl1
neighbouring panel on the higher level
Definition space.hh:413
bem::EdgeMap::prnt
EdgeMap * prnt
pointer to the EdgeMap of the parent edge
Definition space.hh:419
bem::EdgeMap::lvl
ushort lvl
level difference to the highest level on this edge
Definition space.hh:417
bem::Linear3d::scan
concepts::Scan< concepts::Element< F > > * scan() const
Returns a scanner of the space.
Definition space.hh:139
bem::Linear3d::Linear3d
Linear3d(concepts::Mesh2 &msh, uint lvl)
bem::Linear3d::info
std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition space.hh:110
bem::Linear3d::info
std::ostream & info(std::ostream &os, uint mode=0) const
bem::Linear3d::dim
uint dim() const
Returns the number of degrees of freedom.
Definition space.hh:122
bem::Linear3d::nelm
uint nelm() const
Returns the number of elements.
Definition space.hh:124
concepts::Connector::key
const Key & key() const
Returns the key of the connector.
Definition connector.hh:105
bem
Definition bem.hh:18
concepts::uchar
unsigned char uchar
Abbreviation for unsigned char.
Definition typedefs.hh:48
bem::AdaptiveAdjust::AdaptiveAdjust
AdaptiveAdjust(short l)
Definition space.hh:222
bem::AdaptiveAdjust::operator=
AdaptiveAdjust & operator=(const AdaptiveAdjust &adj)
Assignment operator.
Definition space.hh:225
bem::AdaptiveAdjust::l_
short l_
Level.
Definition space.hh:215
bem::AdaptiveAdjust::AdaptiveAdjust
AdaptiveAdjust()
Default constructor.
Definition space.hh:218
Generated on Wed Sep 13 2023 21:06:23 for Concepts by doxygen 1.9.8