You are here: Concepts>Concepts Web>Class documentation

Class documentation of Concepts

Loading...
Searching...
No Matches
frmE_product.hh
Go to the documentation of this file.
1
8#ifndef productelementformula_hh
9#define productelementformula_hh
10
11#include "basics/debug.hh"
12#include "basics/output.hh"
13#include "toolbox/sharedPointer.hh"
14#include "elementFormulaContainer.hh"
15#include "exceptions.hh"
16
17#define ProdElemFormConstr_D 0
18#define ProdElemFormDestr_D 0
19#define ProdElemFormClone_D 0
20
21namespace concepts {
22
23
24 // *********************************************************** FrmE_Product **
25
35 template<typename F,
36 typename H = F,
37 typename J = typename Datatype<F>::type,
38 typename G = typename Realtype<F>::type>
39 class FrmE_Product : public ElementFormula<F,G> {
40 public:
41 FrmE_Product(const ElementFormulaContainer<H> frm1,
42 const ElementFormulaContainer<J> frm2)
43 : frm1_(frm1), frm2_(frm2)
44 {
45 if (frm1.empty()) throw(PointerToEmptyElementFormula());
46 if (frm2.empty()) throw(PointerToEmptyElementFormula());
47 }
48 FrmE_Product(const ElementFormulaContainer<H> frm1,
49 const J a)
50 : frm1_(frm1), frm2_(), a_(makeRCP(new J(a)))
51 {
52 DEBUGL(ProdElemFormConstr_D, "frm1 = " << frm1);
53 if (frm1.empty()) throw(PointerToEmptyElementFormula());
54 }
56 FrmE_Product(const FrmE_Product<F,H,J,G>& frm)
57 : frm1_(frm.frm1_), frm2_(frm.frm2_), a_(frm.a_) {}
58
59 virtual ~FrmE_Product() {
60 DEBUGL(ProdElemFormDestr_D, "Delete " << *this)
61 }
62
63 virtual F operator() (const ElementWithCell<G>& elm,
64 const Real p, const Real t = 0.0) const {
65 H v = frm1_(elm, p,t);
66
67 conceptsAssert(!frm2_.empty() xor (a_.get() != 0), Assertion());
68
69 if (frm2_.empty())
70 return v * *a_;
71
72 return v * frm2_(elm, p,t);
73 }
74 virtual F operator() (const ElementWithCell<G>& elm,
75 const Real2d& p, const Real t = 0.0) const {
76 H v = frm1_(elm, p,t);
77
78 conceptsAssert(!frm2_.empty() xor (a_.get() != 0), Assertion());
79
80 if (frm2_.empty())
81 return v * *a_;
82
83 return v * frm2_(elm, p,t);
84 }
85 virtual F operator() (const ElementWithCell<G>& elm,
86 const Real3d& p, const Real t = 0.0) const {
87 H v = frm1_(elm, p,t);
88
89 conceptsAssert(!frm2_.empty() xor (a_.get() != 0), Assertion());
90
91 if (frm2_.empty())
92 return v * *a_;
93
94 return v * frm2_(elm, p,t);
95 }
96 virtual FrmE_Product<F,H,J,G>* clone() const {
97 DEBUGL(ProdElemFormClone_D, *this << " = *" << this);
98 return new FrmE_Product<F,H,J,G>(frm1_, frm2_, a_);
99 }
100 protected:
101 virtual std::ostream& info(std::ostream& os) const {
102 os << concepts::typeOf(*this) << "(" << frm1_;
103 conceptsAssert(!frm2_.empty() xor (a_.get() != 0), Assertion());
104 if (!frm2_.empty())
105 os << " * " << frm2_;
106 if (a_.get())
107 os << " * " << *a_;
108 return os << ")";
109 }
110 private:
112 ElementFormulaContainer<H> frm1_;
114 ElementFormulaContainer<J> frm2_;
116 RCP<J> a_;
117
119 FrmE_Product(const ElementFormulaContainer<H> frm1,
120 const ElementFormulaContainer<J> frm2,
121 const RCP<J> a)
122 : frm1_(frm1), frm2_(frm2), a_(a)
123 {
124 DEBUGL(ProdElemFormConstr_D,
125 "frm1 = " << frm1 << ", frm2 = " << frm2 << ", a = " << a);
126 if (frm1.empty()) throw(PointerToEmptyElementFormula());
127 }
128 };
129
130 // ************************************************************ operator* **
131
133
134 ElementFormulaContainer<Real>
135 operator*(const ElementFormulaContainer<Real> frm, const Real a);
136
137 ElementFormulaContainer<Cmplx>
138 operator*(const ElementFormulaContainer<Cmplx> frm, const Real a);
139
140 ElementFormulaContainer<Cmplx>
141 operator*(const ElementFormulaContainer<Cmplx> frm, const Cmplx a);
142
143 ElementFormulaContainer<Cmplx>
144 operator*(const ElementFormulaContainer<Real> frm, const Cmplx a);
145
146 // ************
147
148 ElementFormulaContainer<Real2d>
149 operator*(const ElementFormulaContainer<Real2d> frm, const Real a);
150
151 ElementFormulaContainer<Cmplx2d>
152 operator*(const ElementFormulaContainer<Cmplx2d> frm, const Real a);
153
154 ElementFormulaContainer<Cmplx2d>
155 operator*(const ElementFormulaContainer<Cmplx2d> frm, const Cmplx a);
156
157 ElementFormulaContainer<Cmplx2d>
158 operator*(const ElementFormulaContainer<Real2d> frm, const Cmplx a);
159
160 // ************
161
162 ElementFormulaContainer<Real2d>
163 operator*(const ElementFormulaContainer<Real> frm, const Real2d a);
164
165 ElementFormulaContainer<Cmplx2d>
166 operator*(const ElementFormulaContainer<Cmplx> frm, const Real2d a);
167
168 ElementFormulaContainer<Cmplx2d>
169 operator*(const ElementFormulaContainer<Cmplx> frm, const Cmplx2d a);
170
171 ElementFormulaContainer<Cmplx2d>
172 operator*(const ElementFormulaContainer<Real> frm, const Cmplx2d a);
173
174 // ************
175
176 ElementFormulaContainer<MapReal2d>
177 operator*(const ElementFormulaContainer<MapReal2d> frm, const Real a);
178
179 ElementFormulaContainer<MapCmplx2d>
180 operator*(const ElementFormulaContainer<MapCmplx2d> frm, const Real a);
181
182 ElementFormulaContainer<MapCmplx2d>
183 operator*(const ElementFormulaContainer<MapCmplx2d> frm, const Cmplx a);
184
185 ElementFormulaContainer<MapCmplx2d>
186 operator*(const ElementFormulaContainer<MapReal2d> frm, const Cmplx a);
187
188 // ************
189
190 ElementFormulaContainer<MapReal2d>
191 operator*(const Real a, const ElementFormulaContainer<MapReal2d> frm);
192
193 ElementFormulaContainer<MapCmplx2d>
194 operator*(const Real a, const ElementFormulaContainer<MapCmplx2d> frm);
195
196 ElementFormulaContainer<MapCmplx2d>
197 operator*(const Cmplx a, const ElementFormulaContainer<MapCmplx2d> frm);
198
199 ElementFormulaContainer<MapCmplx2d>
200 operator*(const Cmplx a, const ElementFormulaContainer<MapReal2d> frm);
201
202 // ************
203 // The vector in CONCEPTS is columnwise, therefore only A*a is valid
204
205 // @author Mengyu Wang, 2012
206
207 ElementFormulaContainer<Real2d>
208 operator*(const ElementFormulaContainer<MapReal2d> frm, const Real2d a);
209
210 ElementFormulaContainer<Cmplx2d>
211 operator*(const ElementFormulaContainer<MapCmplx2d> frm, const Real2d a);
212
213 ElementFormulaContainer<Cmplx2d>
214 operator*(const ElementFormulaContainer<MapCmplx2d> frm, const Cmplx2d a);
215
216 ElementFormulaContainer<Cmplx2d>
217 operator*(const ElementFormulaContainer<MapReal2d> frm, const Cmplx2d a);
218
220
221 ElementFormulaContainer<Real>
222 operator*(const ElementFormulaContainer<Real> frm1,
223 const ElementFormulaContainer<Real> frm2);
224
225 ElementFormulaContainer<Cmplx>
226 operator*(const ElementFormulaContainer<Cmplx> frm1,
227 const ElementFormulaContainer<Real> frm2);
228
229 ElementFormulaContainer<Cmplx>
230 operator*(const ElementFormulaContainer<Real> frm1,
231 const ElementFormulaContainer<Cmplx> frm2);
232
233 ElementFormulaContainer<Cmplx>
234 operator*(const ElementFormulaContainer<Cmplx> frm1,
235 const ElementFormulaContainer<Cmplx> frm2);
236
237 // ************
238
239 ElementFormulaContainer<Real2d>
240 operator*(const ElementFormulaContainer<Real2d> frm1,
241 const ElementFormulaContainer<Real> frm2);
242
243 ElementFormulaContainer<Cmplx2d>
244 operator*(const ElementFormulaContainer<Cmplx2d> frm1,
245 const ElementFormulaContainer<Real> frm2);
246
247 ElementFormulaContainer<Cmplx2d>
248 operator*(const ElementFormulaContainer<Real2d> frm1,
249 const ElementFormulaContainer<Cmplx> frm2);
250
251 ElementFormulaContainer<Cmplx2d>
252 operator*(const ElementFormulaContainer<Cmplx2d> frm1,
253 const ElementFormulaContainer<Cmplx> frm2);
254
255 // ************
256
257 ElementFormulaContainer<Real2d>
258 operator*(const ElementFormulaContainer<Real> frm1,
259 const ElementFormulaContainer<Real2d> frm2);
260
261 ElementFormulaContainer<Cmplx2d>
262 operator*(const ElementFormulaContainer<Cmplx> frm1,
263 const ElementFormulaContainer<Real2d> frm2);
264
265 ElementFormulaContainer<Cmplx2d>
266 operator*(const ElementFormulaContainer<Real> frm1,
267 const ElementFormulaContainer<Cmplx2d> frm2);
268
269 ElementFormulaContainer<Cmplx2d>
270 operator*(const ElementFormulaContainer<Cmplx> frm1,
271 const ElementFormulaContainer<Cmplx2d> frm2);
272
273 // ************
274
275 ElementFormulaContainer<Real>
276 operator*(const ElementFormulaContainer<Real2d> frm1,
277 const ElementFormulaContainer<Real2d> frm2);
278
279 ElementFormulaContainer<Cmplx>
280 operator*(const ElementFormulaContainer<Cmplx2d> frm1,
281 const ElementFormulaContainer<Real2d> frm2);
282
283 ElementFormulaContainer<Cmplx>
284 operator*(const ElementFormulaContainer<Real2d> frm1,
285 const ElementFormulaContainer<Cmplx2d> frm2);
286
287 ElementFormulaContainer<Cmplx>
288 operator*(const ElementFormulaContainer<Cmplx2d> frm1,
289 const ElementFormulaContainer<Cmplx2d> frm2);
290
291 // ************
292
293 ElementFormulaContainer<MapReal2d>
294 operator*(const ElementFormulaContainer<MapReal2d> frm1,
295 const ElementFormulaContainer<Real> frm2);
296
297 ElementFormulaContainer<MapCmplx2d>
298 operator*(const ElementFormulaContainer<MapCmplx2d> frm1,
299 const ElementFormulaContainer<Real> frm2);
300
301 ElementFormulaContainer<MapCmplx2d>
302 operator*(const ElementFormulaContainer<MapCmplx2d> frm1,
303 const ElementFormulaContainer<Cmplx> frm2);
304
305 ElementFormulaContainer<MapCmplx2d>
306 operator*(const ElementFormulaContainer<MapReal2d> frm1,
307 const ElementFormulaContainer<Cmplx> frm2);
308
309 // ************
310
311 ElementFormulaContainer<MapReal2d>
312 operator*(const ElementFormulaContainer<Real> frm1,
313 const ElementFormulaContainer<MapReal2d> frm2);
314
315 ElementFormulaContainer<MapCmplx2d>
316 operator*(const ElementFormulaContainer<Real> frm1,
317 const ElementFormulaContainer<MapCmplx2d> frm2);
318
319 ElementFormulaContainer<MapCmplx2d>
320 operator*(const ElementFormulaContainer<Cmplx> frm1,
321 const ElementFormulaContainer<MapCmplx2d> frm2);
322
323 ElementFormulaContainer<MapCmplx2d>
324 operator*(const ElementFormulaContainer<Cmplx> frm1,
325 const ElementFormulaContainer<MapReal2d> frm2);
326
327 // ************
328 // The vector in CONCEPTS is columnwise, therefore only A*v is valid
329
330 // @author Mengyu Wang, 2012
331
332 ElementFormulaContainer<Real2d>
333 operator*(const ElementFormulaContainer<MapReal2d> frm1,
334 const ElementFormulaContainer<Real2d> frm2);
335
336 ElementFormulaContainer<Cmplx2d>
337 operator*(const ElementFormulaContainer<MapCmplx2d> frm1,
338 const ElementFormulaContainer<Real2d> frm2);
339
340 ElementFormulaContainer<Cmplx2d>
341 operator*(const ElementFormulaContainer<MapCmplx2d> frm1,
342 const ElementFormulaContainer<Cmplx2d> frm2);
343
344 ElementFormulaContainer<Cmplx2d>
345 operator*(const ElementFormulaContainer<MapReal2d> frm1,
346 const ElementFormulaContainer<Cmplx2d> frm2);
347
348 // ************************************************************ operator/ **
349
351
352 ElementFormulaContainer<Real>
353 operator/(const ElementFormulaContainer<Real> frm1,
354 const ElementFormulaContainer<Real> frm2);
355
356 ElementFormulaContainer<Cmplx>
357 operator/(const ElementFormulaContainer<Cmplx> frm1,
358 const ElementFormulaContainer<Real> frm2);
359
360 ElementFormulaContainer<Cmplx>
361 operator/(const ElementFormulaContainer<Real> frm1,
362 const ElementFormulaContainer<Cmplx> frm2);
363
364 ElementFormulaContainer<Cmplx>
365 operator/(const ElementFormulaContainer<Cmplx> frm1,
366 const ElementFormulaContainer<Cmplx> frm2);
367
369
370 ElementFormulaContainer<Real2d>
371 operator/(const ElementFormulaContainer<Real2d> frm1,
372 const ElementFormulaContainer<Real> frm2);
373
374 ElementFormulaContainer<Cmplx2d>
375 operator/(const ElementFormulaContainer<Cmplx2d> frm1,
376 const ElementFormulaContainer<Real> frm2);
377
378 ElementFormulaContainer<Cmplx2d>
379 operator/(const ElementFormulaContainer<Real2d> frm1,
380 const ElementFormulaContainer<Cmplx> frm2);
381
382 ElementFormulaContainer<Cmplx2d>
383 operator/(const ElementFormulaContainer<Cmplx2d> frm1,
384 const ElementFormulaContainer<Cmplx> frm2);
385
386
387} // namespace concepts
388
389
390#endif // productelementformula_hh
concepts::FrmE_Product
Definition frmE_product.hh:39
concepts::FrmE_Product::FrmE_Product
FrmE_Product(const FrmE_Product< F, H, J, G > &frm)
Copy constructor.
Definition frmE_product.hh:56
concepts::FrmE_Product::operator()
virtual F operator()(const ElementWithCell< G > &elm, const Real p, const Real t=0.0) const
Definition frmE_product.hh:63
concepts::FrmE_Product::clone
virtual FrmE_Product< F, H, J, G > * clone() const
Virtual copy constructor.
Definition frmE_product.hh:96
concepts::FrmE_Product::info
virtual std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition frmE_product.hh:101
conceptsAssert
#define conceptsAssert(cond, exc)
Definition exceptions.hh:394
DEBUGL
#define DEBUGL(doit, msg)
Definition debug.hh:40
concepts::typeOf
std::string typeOf(const T &t)
Definition output.hh:43
concepts::operator/
ElementFormulaContainer< Real > operator/(const ElementFormulaContainer< Real > frm1, const ElementFormulaContainer< Real > frm2)
Division of a element formulas by a scalar element formula via /-operator.
concepts::Real
double Real
Definition typedefs.hh:39
concepts::makeRCP
RCP< T > makeRCP(T *x)
Definition sharedPointer_boost.hh:102
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