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 
21 namespace 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::FrmE_Product
FrmE_Product(const ElementFormulaContainer< H > frm1, const ElementFormulaContainer< J > frm2, const RCP< J > a)
Private constructor.
Definition: frmE_product.hh:119
concepts::FrmE_Product::frm1_
ElementFormulaContainer< H > frm1_
First ElementFormula.
Definition: frmE_product.hh:112
concepts::FrmE_Product::frm2_
ElementFormulaContainer< J > frm2_
Second ElementFormula.
Definition: frmE_product.hh:114
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::clone
virtual FrmE_Product< F, H, J, G > * clone() const
Virtual constructor.
Definition: frmE_product.hh:96
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.
ProdElemFormClone_D
#define ProdElemFormClone_D
Definition: frmE_product.hh:19
ProdElemFormDestr_D
#define ProdElemFormDestr_D
Definition: frmE_product.hh:18
concepts::operator*
Point< typename Combtype< F, Real >::type, dim > operator*(const Real x, const Point< F, dim > &y)
Definition: vectorsMatrices.hh:240
conceptsAssert
#define conceptsAssert(cond, exc)
Assert that a certain condition is fulfilled.
Definition: exceptions.hh:394
concepts::FrmE_Product::info
virtual std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition: frmE_product.hh:101
concepts::FrmE_Product::FrmE_Product
FrmE_Product(const ElementFormulaContainer< H > frm1, const J a)
Definition: frmE_product.hh:48
concepts::ElementWithCell
Element with cell.
Definition: elementFormula.hh:19
DEBUGL
#define DEBUGL(doit, msg)
concepts::ElementFormulaContainer::empty
bool empty() const
Returns true if no formula is stored.
Definition: elementFormulaContainer.hh:72
ProdElemFormConstr_D
#define ProdElemFormConstr_D
Definition: frmE_product.hh:17
concepts::Assertion
Exception class for assertions.
Definition: exceptions.hh:258
concepts::FrmE_Product::~FrmE_Product
virtual ~FrmE_Product()
Definition: frmE_product.hh:59
concepts::ElementFormula
Interface for a formula defined element by element.
Definition: elementFormula.hh:35
concepts::FrmE_Product
Product of two element formulas or an element formula and a factor.
Definition: frmE_product.hh:39
concepts::FrmE_Product::a_
RCP< J > a_
Constant factor instead of an ElementFormula (not necessary scalar)
Definition: frmE_product.hh:116
concepts::Cmplx
std::complex< Real > Cmplx
Type for a complex number. It also depends on the setting of Real.
Definition: typedefs.hh:39
concepts::makeRCP
RCP< T > makeRCP(T *x)
Function to create a RCP which deletes the object when no RCP points on it anymore.
Definition: sharedPointer_boost.hh:102
concepts::RCP
Reference-counting pointer.
Definition: bf_iddiv.hh:15
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::typeOf
std::string typeOf(const T &t)
Return the typeid name of a class object.
Definition: output.hh:43
concepts::FrmE_Product::FrmE_Product
FrmE_Product(const ElementFormulaContainer< H > frm1, const ElementFormulaContainer< J > frm2)
Definition: frmE_product.hh:41
concepts::Real
double Real
Type normally used for a floating point number.
Definition: typedefs.hh:36
concepts::PointerToEmptyElementFormula
Exception class to express that the RCP pointer points to 0.
Definition: exceptions.hh:55
concepts
Basic namespace for Concepts-2.
Definition: pml_formula.h:16
Page URL: http://wiki.math.ethz.ch/bin/view/Concepts/WebHome
21 August 2020
© 2020 Eidgenössische Technische Hochschule Zürich