00001
00002
00003
00004 #ifndef taylor_hh
00005 #define taylor_hh
00006
00007 #include <cstring>
00008
00009 #include "basics/exceptions.hh"
00010 #include "bem/element.hh"
00011 #include "cluster/expansion.hh"
00012
00013 namespace cluster {
00014
00015
00016
00020 template <class Fspc = concepts::Real>
00021 class TaylorX : public ExpansionXY<Fspc> {
00022
00024 uint m_;
00026 uint blksz_;
00028 uint gauss_;
00029
00030 protected:
00032 concepts::Real* foo_;
00033 Fspc* fee_;
00034
00035 public:
00040 TaylorX(uint m, uint gauss);
00041
00042 ~TaylorX() {delete[] foo_; delete[] fee_;}
00043
00044 uint blksz() const {return blksz_;}
00045 uint m() const {return m_;}
00046 uint gauss() const {return gauss_;}
00047 inline XYColReal* getCol(uint blksz, uint n) const;
00052 void evaluate(const concepts::Real3d& z, concepts::Real X[]) const;
00054 inline void shift(const concepts::Real3d& z, const concepts::Real src[],
00055 concepts::Real dst[]) const;
00056 inline void shift(const concepts::Real3d& z, const concepts::Cmplx src[],
00057 concepts::Cmplx dst[]) const;
00058 template<class F>
00059 void shift(const concepts::Real3d& z, const F src[], F dst[],
00060 uint foo) const;
00062 void apply(const concepts::Real X[], const Fspc src[], Fspc dst[]) const;
00063 inline void apply(const XYColExpPtr* X, const Fspc src[],
00064 Fspc dst[]) const;
00065
00072 void evaluate(const concepts::Element<Fspc>& elm,
00073 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00075 void evaluate(const bem::Dirac3d000<Fspc>& elm,
00076 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00078 void evaluate(const bem::Constant3d000<Fspc>& elm,
00079 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00081 void evaluate(const bem::Constant3d001<Fspc>& elm,
00082 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00084 void evaluate(const bem::Constant3d002<Fspc>& elm,
00085 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00087 void evaluate(const bem::Linear3d000<Fspc>& elm,
00088 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00089 };
00090
00091 template <class Fspc>
00092 inline XYColReal* TaylorX<Fspc>::getCol(uint blksz, uint n) const {
00093 return new XYColReal(blksz, n);
00094 }
00095
00096 template <class Fspc>
00097 inline void TaylorX<Fspc>::shift(const concepts::Real3d& z,
00098 const concepts::Real src[],
00099 concepts::Real dst[]) const {
00100 shift<concepts::Real>(z, src, dst, 0);
00101 }
00102
00103 template <class Fspc>
00104 void TaylorX<Fspc>::apply(const XYColExpPtr* X, const Fspc src[],
00105 Fspc dst[]) const {
00106 const XYColRealPtr* Xtay = dynamic_cast<const XYColRealPtr*>(X);
00107 if (Xtay) {apply(Xtay->value(), src, dst); return;}
00108
00109 throw
00110 conceptsException(concepts::MissingFeature("XYColExp not supported"));
00111 }
00112
00113
00114
00118 template <class Fspc = concepts::Real>
00119 class DTaylorX : public ExpansionXY<Fspc> {
00120
00122 TaylorX<Fspc> X_;
00123
00125 uint m_;
00127 uint blksz_;
00129 uint gauss_;
00130
00131 protected:
00133 concepts::Real* foo_;
00134 Fspc* fee_;
00135
00136 public:
00141 DTaylorX(uint m, uint gauss);
00142
00143 ~DTaylorX() {delete[] fee_; delete[] foo_;}
00144
00145 uint blksz() const {return blksz_;}
00146 uint m() const {return m_;}
00147 uint gauss() const {return gauss_;}
00148 inline XYColReal* getCol(uint blksz, uint n) const;
00154 void evaluate(const concepts::Real3d& z, const concepts::Unit3d& h,
00155 concepts::Real X[]) const;
00157 inline void shift(const concepts::Real3d& z, const concepts::Real src[],
00158 concepts::Real dst[]) const;
00159 inline void shift(const concepts::Real3d& z, const concepts::Cmplx src[],
00160 concepts::Cmplx dst[]) const;
00162 inline void apply(const XYColExpPtr* X, const Fspc src[],
00163 Fspc dst[]) const;
00164
00171 void evaluate(const concepts::Element<Fspc>& elm,
00172 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00174 void evaluate(const bem::Constant3d000<Fspc>& elm,
00175 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00177 void evaluate(const bem::Constant3d001<Fspc>& elm,
00178 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00180 void evaluate(const bem::Constant3d002<Fspc>& elm,
00181 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00183 void evaluate(const bem::Linear3d000<Fspc>& elm,
00184 const concepts::Real3d& c, XYColExpPtr* X[]) const;
00185 };
00186
00187 template <class Fspc>
00188 inline XYColReal* DTaylorX<Fspc>::getCol(uint blksz, uint n) const {
00189 return new XYColReal(blksz, n);
00190 }
00191
00192 template <class Fspc>
00193 inline void DTaylorX<Fspc>::shift(const concepts::Real3d& z,
00194 const concepts::Real src[],
00195 concepts::Real dst[]) const {
00196 X_.shift(z, src, dst);
00197 }
00198
00199 template <class Fspc>
00200 inline void DTaylorX<Fspc>::shift(const concepts::Real3d& z,
00201 const concepts::Cmplx src[],
00202 concepts::Cmplx dst[]) const {
00203 X_.shift(z, src, dst);
00204 }
00205
00206 template <class Fspc>
00207 inline void DTaylorX<Fspc>::apply(const XYColExpPtr* X,
00208 const Fspc src[], Fspc dst[]) const {
00209 const XYColRealPtr* Xtay = dynamic_cast<const XYColRealPtr*>(X);
00210 if (Xtay) {X_.apply(Xtay->value(), src, dst); return;}
00211
00212 throw
00213 conceptsException(concepts::MissingFeature("XYColExp not supported"));
00214 }
00215
00216
00217
00221 template <class Fspc = concepts::Real>
00222 class TaylorY : public ExpansionXY<Fspc> {
00223
00225 uint m_;
00227 uint blksz_;
00229 uint gauss_;
00230
00231 protected:
00233 concepts::Real* foo_;
00234 Fspc* fee_;
00235
00236 public:
00241 TaylorY(uint m, uint gauss);
00242
00243 ~TaylorY() {delete[] foo_; delete[] fee_;}
00244
00245 uint blksz() const {return blksz_;}
00246 uint m() const {return m_;}
00247 uint gauss() const {return gauss_;}
00248 inline XYColReal* getCol(uint blksz, uint n) const;
00253 void evaluate(const concepts::Real3d& z, concepts::Real Y[]) const;
00254 inline void shift(const concepts::Real3d& z, const concepts::Real src[],
00255 concepts::Real dst[]) const;
00256 inline void shift(const concepts::Real3d& z, const concepts::Cmplx src[],
00257 concepts::Cmplx dst[]) const;
00258 template<class F>
00259 void shift(const concepts::Real3d& z, const F src[], F dst[],
00260 uint foo) const;
00262 void apply(const concepts::Real Y[], const Fspc src[], Fspc dst[]) const;
00263 inline void apply(const XYColExpPtr* Y, const Fspc src[],
00264 Fspc dst[]) const;
00265
00272 void evaluate(const concepts::Element<Fspc>& elm,
00273 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00275 void evaluate(const bem::Dirac3d000<Fspc>& elm,
00276 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00278 void evaluate(const bem::Constant3d000<Fspc>& elm,
00279 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00281 void evaluate(const bem::Constant3d001<Fspc>& elm,
00282 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00284 void evaluate(const bem::Constant3d002<Fspc>& elm,
00285 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00287 void evaluate(const bem::Linear3d000<Fspc>& elm,
00288 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00289 };
00290
00291 template <class Fspc>
00292 inline XYColReal* TaylorY<Fspc>::getCol(uint blksz, uint n) const {
00293 return new XYColReal(blksz, n);
00294 }
00295
00296 template <class Fspc>
00297 inline void TaylorY<Fspc>::shift(const concepts::Real3d& z,
00298 const concepts::Real src[],
00299 concepts::Real dst[]) const {
00300 shift(z, src, dst, 0);
00301 }
00302
00303 template <class Fspc>
00304 inline void TaylorY<Fspc>::apply(const XYColExpPtr* Y, const Fspc src[],
00305 Fspc dst[]) const {
00306 const XYColRealPtr* Ytay = dynamic_cast<const XYColRealPtr*>(Y);
00307 if (Ytay) {apply(Ytay->value(), src, dst); return;}
00308
00309 throw
00310 conceptsException(concepts::MissingFeature("XYColExp not supported"));
00311 }
00312
00313
00314
00318 template <class Fspc = concepts::Real>
00319 class DTaylorY : public ExpansionXY<Fspc> {
00320
00322 TaylorY<Fspc> Y_;
00323
00325 uint m_;
00327 uint blksz_;
00329 uint gauss_;
00330
00331 protected:
00333 concepts::Real* foo_;
00334 concepts::Real* fee_;
00335
00336 public:
00341 DTaylorY(uint m, uint gauss);
00342
00343 ~DTaylorY() {delete[] fee_; delete[] foo_;}
00344
00345 uint blksz() const {return blksz_;}
00346 uint m() const {return m_;}
00347 uint gauss() const {return gauss_;}
00348 inline XYColReal* getCol(uint blksz, uint n) const;
00354 void evaluate(const concepts::Real3d& z, const concepts::Unit3d& h,
00355 concepts::Real Y[]) const;
00356 inline void shift(const concepts::Real3d& z, const concepts::Real src[],
00357 concepts::Real dst[]) const;
00358 inline void shift(const concepts::Real3d& z, const concepts::Cmplx src[],
00359 concepts::Cmplx dst[]) const;
00361 inline void apply(const XYColExpPtr* Y, const Fspc src[],
00362 Fspc dst[]) const;
00363
00370 void evaluate(const concepts::Element<Fspc>& elm,
00371 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00373 void evaluate(const bem::Constant3d000<Fspc>& elm,
00374 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00376 void evaluate(const bem::Constant3d001<Fspc>& elm,
00377 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00379 void evaluate(const bem::Constant3d002<Fspc>& elm,
00380 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00382 void evaluate(const bem::Linear3d000<Fspc>& elm,
00383 const concepts::Real3d& c, XYColExpPtr* Y[]) const;
00384 };
00385
00386 template <class Fspc>
00387 inline XYColReal* DTaylorY<Fspc>::getCol(uint blksz, uint n) const {
00388 return new XYColReal(blksz, n);
00389 }
00390
00391 template <class Fspc>
00392 inline void DTaylorY<Fspc>::shift(const concepts::Real3d& z,
00393 const concepts::Real src[],
00394 concepts::Real dst[]) const {
00395 Y_.shift(z, src, dst);
00396 }
00397
00398 template <class Fspc>
00399 inline void DTaylorY<Fspc>::shift(const concepts::Real3d& z,
00400 const concepts::Cmplx src[],
00401 concepts::Cmplx dst[]) const {
00402 Y_.shift(z, src, dst);
00403 }
00404
00405 template <class Fspc>
00406 inline void DTaylorY<Fspc>::apply(const XYColExpPtr* Y,
00407 const Fspc src[], Fspc dst[]) const {
00408 const XYColRealPtr* Ytay = dynamic_cast<const XYColRealPtr*>(Y);
00409 if (Ytay) {Y_.apply(Ytay->value(), src, dst); return;}
00410
00411 throw
00412 conceptsException(concepts::MissingFeature("XYColExp not supported"));
00413 }
00414
00415
00416
00420 template <class Fspc = concepts::Real>
00421 class TaylorLaplaceF : public ExpansionF<Fspc> {
00423 uint m_;
00424
00426 concepts::Real* foo_;
00427
00428 public:
00432 TaylorLaplaceF(uint m) {m_ = m; foo_ = new concepts::Real[blksz(m)];}
00433
00434 virtual ~TaylorLaplaceF() {delete[] foo_;}
00435
00439 uint blksz(uint m) const {return (m * (m * (m + 3) + 2)) / 6;}
00440 uint m() const {return m_;}
00443 virtual FColReal* getCol(uint blksz) const {
00444 return new FColReal(blksz);
00445 }
00447 inline void evaluate(uint m, const concepts::Real3d& z,
00448 FColExp* Fexp) const;
00449 void evaluate(uint m, const concepts::Real3d& z, FColReal Fexp[]) const;
00451 inline void apply(uint m, const FColExp* Fexp, const Fspc src[],
00452 Fspc dst[]) const;
00453 void apply(uint m, const FColReal Fexp[], const Fspc src[],
00454 Fspc dst[]) const;
00455 };
00456
00457 template <class Fspc>
00458 void TaylorLaplaceF<Fspc>::evaluate(uint m, const concepts::Real3d& z,
00459 FColExp* Fexp) const {
00460 FColReal* Ftay = dynamic_cast<FColReal*>(Fexp);
00461 if (Ftay) {evaluate(m, z, Ftay); return;}
00462
00463 throw
00464 conceptsException(concepts::MissingFeature("FColExp not supported"));
00465 }
00466
00467 template <class Fspc>
00468 void TaylorLaplaceF<Fspc>::apply(uint m, const FColExp* Fexp,
00469 const Fspc src[], Fspc dst[]) const {
00470 const FColReal* Ftay = dynamic_cast<const FColReal*>(Fexp);
00471 if (Ftay) {apply(m, Ftay, src, dst); return;}
00472
00473 throw
00474 conceptsException(concepts::MissingFeature("FColExp not supported"));
00475 }
00476
00477 }
00478
00479 #endif // taylor_hh