You are here: Concepts>Concepts Web>Class documentation

Class documentation of Concepts

Loading...
Searching...
No Matches
frmE_sum.hh
Go to the documentation of this file.
1
8#ifndef sumelementformula_hh
9#define sumelementformula_hh
10
11#include "basics/typedefs.hh"
12#include "basics/output.hh"
13#include "basics/vectorsMatricesForward.hh"
14#include "elementFormulaContainer.hh"
15#include "exceptions.hh"
16
17#define SumElemFormConstr_D 0
18#define SumElemFormDestr_D 0
19#define SumElemFormClone_D 0
20
21namespace concepts {
22
23
24 // **************************************************************** FrmE_Sum **
25
34 template<class F, class H = F, class J = F,
35 class G = typename Realtype<F>::type>
36 class FrmE_Sum : public ElementFormula<F,G> {
37 public:
38 FrmE_Sum(const ElementFormulaContainer<H> frm1,
39 const ElementFormulaContainer<J> frm2)
40 : frm1_(frm1), frm2_(frm2), a_(0.0)
41 {
42 if (frm1.empty()) throw(PointerToEmptyElementFormula());
43 if (frm2.empty()) throw(PointerToEmptyElementFormula());
44 }
45 FrmE_Sum(const ElementFormulaContainer<H> frm1,
46 const F a)
47 : frm1_(frm1), frm2_(), a_(a)
48 {
49 DEBUGL(SumElemFormConstr_D, "frm1 = " << frm1);
50 if (frm1.empty()) throw(PointerToEmptyElementFormula());
51 }
52 virtual ~FrmE_Sum() {
53 DEBUGL(SumElemFormDestr_D, "Delete " << *this)
54 }
55
56
57 virtual F operator() (const ElementWithCell<G>& elm, const Real p,
58 const Real t = 0.0) const
59 {
60 F v = frm1_(elm, p,t);
61 if (!frm2_.empty())
62 v += frm2_(elm, p,t);
63
64 return v + a_;
65 }
66 virtual F operator() (const ElementWithCell<G>& elm, const Real2d& p,
67 const Real t = 0.0) const
68 {
69 F v = frm1_(elm, p,t);
70 if (!frm2_.empty())
71 v += frm2_(elm, p,t);
72
73 return v + a_;
74 }
75 virtual F operator() (const ElementWithCell<G>& elm, const Real3d& p,
76 const Real t = 0.0) const
77 {
78 F v = frm1_(elm, p,t);
79 if (!frm2_.empty())
80 v += frm2_(elm, p,t);
81
82 return v + a_;
83 }
84
85 virtual FrmE_Sum<F,H,J,G>* clone() const {
86 DEBUGL(SumElemFormClone_D, *this << " = *" << this);
87 return new FrmE_Sum<F,H,J,G>(frm1_, frm2_, a_);
88 }
89 protected:
90 virtual std::ostream& info(std::ostream& os) const {
91 os << typeOf(*this) << "(" << frm1_;
92 if (!frm2_.empty())
93 os << " + " << frm2_;
94 if (!(a_ == F(0.0)))
95 os << " + " << a_;
96 return os << ")";
97 }
98 private:
100 ElementFormulaContainer<H> frm1_;
102 ElementFormulaContainer<J> frm2_;
104 F a_;
105
107 FrmE_Sum(const ElementFormulaContainer<H> frm1,
108 const ElementFormulaContainer<J> frm2,
109 const F a)
110 : frm1_(frm1), frm2_(frm2), a_(a)
111 {
112 DEBUGL(SumElemFormConstr_D,
113 "frm1 = " << frm1 << ", frm2 = " << frm2 << ", a = " << a);
114 if (frm1.empty()) throw(PointerToEmptyElementFormula());
115 }
116 };
117
118
119 // ************************************************************ operator+ **
120
122
123 ElementFormulaContainer<Real>
124 operator+(const ElementFormulaContainer<Real> frm, const Real a);
125
126 ElementFormulaContainer<Cmplx>
127 operator+(const ElementFormulaContainer<Cmplx> frm, const Real a);
128
129 ElementFormulaContainer<Cmplx>
130 operator+(const ElementFormulaContainer<Cmplx> frm, const Cmplx a);
131
132 ElementFormulaContainer<Cmplx>
133 operator+(const ElementFormulaContainer<Real> frm, const Cmplx a);
134
135 // ************
136
137 ElementFormulaContainer<Real2d>
138 operator+(const ElementFormulaContainer<Real2d> frm, const Real2d a);
139
140 ElementFormulaContainer<Cmplx2d>
141 operator+(const ElementFormulaContainer<Cmplx2d> frm, const Real2d a);
142
143 ElementFormulaContainer<Cmplx2d>
144 operator+(const ElementFormulaContainer<Cmplx2d> frm, const Cmplx2d a);
145
146 ElementFormulaContainer<Cmplx2d>
147 operator+(const ElementFormulaContainer<Real2d> frm, const Cmplx2d a);
148
149
152 ElementFormulaContainer<Real>
153 operator+(const ElementFormulaContainer<Real> frm1,
154 const ElementFormulaContainer<Real> frm2);
155
156 ElementFormulaContainer<Cmplx>
157 operator+(const ElementFormulaContainer<Cmplx> frm1,
158 const ElementFormulaContainer<Real> frm2);
159
160 ElementFormulaContainer<Cmplx>
161 operator+(const ElementFormulaContainer<Real> frm1,
162 const ElementFormulaContainer<Cmplx> frm2);
163
164 ElementFormulaContainer<Cmplx>
165 operator+(const ElementFormulaContainer<Cmplx> frm1,
166 const ElementFormulaContainer<Cmplx> frm2);
167
168 // ************
169
170 ElementFormulaContainer<Real2d>
171 operator+(const ElementFormulaContainer<Real2d> frm1,
172 const ElementFormulaContainer<Real2d> frm2);
173
174 ElementFormulaContainer<Cmplx2d>
175 operator+(const ElementFormulaContainer<Cmplx2d> frm1,
176 const ElementFormulaContainer<Real2d> frm2);
177
178 ElementFormulaContainer<Cmplx2d>
179 operator+(const ElementFormulaContainer<Real2d> frm1,
180 const ElementFormulaContainer<Cmplx2d> frm2);
181
182 ElementFormulaContainer<Cmplx2d>
183 operator+(const ElementFormulaContainer<Cmplx2d> frm1,
184 const ElementFormulaContainer<Cmplx2d> frm2);
185
187
188 ElementFormulaContainer<Real>
189 operator-(const ElementFormulaContainer<Real> frm, const Real a);
190
191 ElementFormulaContainer<Cmplx>
192 operator-(const ElementFormulaContainer<Cmplx> frm, const Real a);
193
194 ElementFormulaContainer<Cmplx>
195 operator-(const ElementFormulaContainer<Cmplx> frm, const Cmplx a);
196
197 ElementFormulaContainer<Cmplx>
198 operator-(const ElementFormulaContainer<Real> frm, const Cmplx a);
199
200 // ************
201
202 ElementFormulaContainer<Real2d>
203 operator-(const ElementFormulaContainer<Real2d> frm, const Real2d a);
204
205 ElementFormulaContainer<Cmplx2d>
206 operator-(const ElementFormulaContainer<Cmplx2d> frm, const Real2d a);
207
208 ElementFormulaContainer<Cmplx2d>
209 operator-(const ElementFormulaContainer<Cmplx2d> frm, const Cmplx2d a);
210
211 ElementFormulaContainer<Cmplx2d>
212 operator-(const ElementFormulaContainer<Real2d> frm, const Cmplx2d a);
213
216 ElementFormulaContainer<Real>
217 operator-(const ElementFormulaContainer<Real> frm1,
218 const ElementFormulaContainer<Real> frm2);
219
220 ElementFormulaContainer<Cmplx>
221 operator-(const ElementFormulaContainer<Cmplx> frm1,
222 const ElementFormulaContainer<Real> frm2);
223
224 ElementFormulaContainer<Cmplx>
225 operator-(const ElementFormulaContainer<Real> frm1,
226 const ElementFormulaContainer<Cmplx> frm2);
227
228 ElementFormulaContainer<Cmplx>
229 operator-(const ElementFormulaContainer<Cmplx> frm1,
230 const ElementFormulaContainer<Cmplx> frm2);
231
232 // ************
233
234 ElementFormulaContainer<Real2d>
235 operator-(const ElementFormulaContainer<Real2d> frm1,
236 const ElementFormulaContainer<Real2d> frm2);
237
238 ElementFormulaContainer<Cmplx2d>
239 operator-(const ElementFormulaContainer<Cmplx2d> frm1,
240 const ElementFormulaContainer<Real2d> frm2);
241
242 ElementFormulaContainer<Cmplx2d>
243 operator-(const ElementFormulaContainer<Real2d> frm1,
244 const ElementFormulaContainer<Cmplx2d> frm2);
245
246 ElementFormulaContainer<Cmplx2d>
247 operator-(const ElementFormulaContainer<Cmplx2d> frm1,
248 const ElementFormulaContainer<Cmplx2d> frm2);
249
250} // namespace concepts
251
252
253#endif // sumelementformula_hh
concepts::FrmE_Sum
Definition frmE_sum.hh:36
concepts::FrmE_Sum::info
virtual std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition frmE_sum.hh:90
concepts::FrmE_Sum::operator()
virtual F operator()(const ElementWithCell< G > &elm, const Real p, const Real t=0.0) const
Definition frmE_sum.hh:57
concepts::FrmE_Sum::clone
virtual FrmE_Sum< F, H, J, G > * clone() const
Virtual copy constructor.
Definition frmE_sum.hh:85
DEBUGL
#define DEBUGL(doit, msg)
Definition debug.hh:40
concepts::operator-
ElementFormulaContainer< Real > operator-(const ElementFormulaContainer< Real > frm, const Real a)
Simple subtracting of a element formulas and a constant via –operator.
concepts::typeOf
std::string typeOf(const T &t)
Definition output.hh:43
concepts::operator+
Frm_Sum< Real > operator+(const Formula< Real > &frm, const Real a)
concepts::Real
double Real
Definition typedefs.hh:39
concepts::makeSet
Set< F > makeSet(uint n, const F &first,...)
Definition set.hh:320
concepts::Cmplx
std::complex< Real > Cmplx
Type for a complex number. It also depends on the setting of Real.
Definition typedefs.hh:42
Generated on Wed Sep 13 2023 21:06:19 for Concepts by doxygen 1.9.8