Documentation for Concepts 2.0

Go to the documentation of this file.
00001 /* Functions on space with hp elements in 2D
00002  */
00003 
00004 #ifndef hpFunction2d_hh
00005 #define hpFunction2d_hh
00006 
00007 #include "toolbox/sequence.hh"
00008 #include "functionBase.hh"
00009 #include "edge.hh"
00010 #include "traces.hh"
00011 
00012 namespace hp2D {
00013 
00014   // forward declaration
00015   class InfiniteQuad;
00016 
00017   using concepts::Real;
00018   using concepts::Real2d;
00019 
00020   // ***************************************************************** Value **
00021 
00026   template<typename F = Real, typename G= typename concepts::Realtype<F>::type>
00027   class Value : public concepts::ElementFunction<F, G> {
00028   public:
00029     virtual Value<F,G>* clone() const { return new Value(); }
00030 
00032     virtual uint n() const { return 1; }
00033 
00034     virtual void operator() (const concepts::Element<G>& elm,
00035                              const concepts::Array<F>& coeff,
00036                              concepts::Array<F>& val, const uint *i) const;
00037     virtual void operator() (const concepts::Element<G>& elm,
00038                              const uint* j,
00039                              concepts::Array<F>& val, const uint* i) const;
00040     virtual void operator() (const concepts::Element<G>& elm,
00041                              const concepts::Array<F>& coeff,
00042                              concepts::Array<F>& val, const Real p, 
00043                              const Real t = 0.0) const;
00044     virtual void operator() (const concepts::Element<G>& elm,
00045                              const concepts::Array<F>& coeff,
00046                              concepts::Array<F>& val, const Real2d& p,
00047                              const Real t = 0.0) const;
00048     virtual void operator() (const concepts::Element<G>& elm,
00049                              const concepts::Array<F>& coeff,
00050                              concepts::Array<F>& val,
00051                              const concepts::Real3d& p,
00052                              const Real t = 0.0) const;
00053 
00054     void operator() (const concepts::Element<G>& elm,
00055                      const concepts::Array<F>& coeff,
00056                      F& val, const uint *i) const;
00057     void operator() (const concepts::Element<G>& elm,
00058                      const uint* j, F& val, const uint* i) const;
00059     void operator() (const concepts::Element<G>& elm,
00060                      const concepts::Array<F>& coeff, F& val, const Real2d& p,
00061                      const Real t = 0.0) const;
00062   protected:
00063     virtual std::ostream& info(std::ostream& os) const;
00064   private:
00065     template<class H>
00066     bool compute_(H elm, const concepts::Array<F>& coeff,
00067                   F& val, const uint i[2]) const;
00068 
00069     template<class H>
00070     bool compute_(H elm, const uint j[2], F& val, const uint i[2]) const;
00071     
00072     bool compute_(const Quad<Real>* elm, const concepts::Array<F>& coeff,
00073                   F& val, const Real2d& p, const Real t) const;
00074 
00075     bool compute_(const InfiniteQuad* elm, const concepts::Array<F>& coeff,
00076                   F& val, const Real2d& p, const Real t) const;
00077 
00078     void compute_(const concepts::Array<F>& coeff, F& val, 
00079                   const Real* xValues, uint nsx,
00080                   const Real* yValues, uint nsy) const;
00081   };  
00082 
00083   // ****************************************************************** Grad **
00084 
00089   template<typename F = Real>
00090   class Grad : public ElementFunction<2,F> {
00091   public:
00092     virtual Grad<F>* clone() const { return new Grad(); }
00093   protected:
00094     virtual std::ostream& info(std::ostream& os) const;
00095   private:
00096     virtual void compute_(const Quad<Real>& elm,
00097                           const concepts::Array<F>& coeff,
00098                           concepts::Array<F>& val,
00099                           const uint i[2]) const;
00100     virtual void compute_(const Quad<Real>& elm, const uint j[2],
00101                           concepts::Array<F>& val,
00102                           const uint i[2]) const;
00103     virtual void compute_(const Quad<Real>& elm,
00104                           const concepts::Array<F>& coeff,
00105                           concepts::Array<F>& val,
00106                           const Real2d& p, const Real t = 0.0) const;
00107   };
00108 
00109   // **************************************************************** Plcurl **
00110 
00115   template<typename F = Real>
00116   class PlCurl : public ElementFunction<2,F> {
00117   public:
00118     virtual PlCurl<F>* clone() const { return new PlCurl(); }
00119   protected:
00120     virtual std::ostream& info(std::ostream& os) const;
00121   private:
00122     virtual void compute_(const Quad<Real>& elm,
00123                           const concepts::Array<F>& coeff,
00124                           concepts::Array<F>& val,
00125                           const uint i[2]) const;
00126     virtual void compute_(const Quad<Real>& elm, const uint j[2],
00127                           concepts::Array<F>& val,
00128                           const uint i[2]) const;
00129     virtual void compute_(const Quad<Real>& elm,
00130                           const concepts::Array<F>& coeff,
00131                           concepts::Array<F>& val,
00132                           const Real2d& p, const Real t = 0.0) const;
00133   };
00134 
00135   // ***************************************************************** Trace **
00136 
00143   template<typename F = Real,
00144            typename G = typename concepts::Realtype<F>::type>
00145   class Trace : public ElementFunction<1,F,hp1D::Element<G> > {
00146   public:
00148     Trace() : attrib_(concepts::Attribute(0)) {}
00150     Trace(const concepts::Attribute attrib) : attrib_(attrib) {}
00151 
00153     concepts::Set<concepts::Attribute>& attrib() { return attrib_; }
00154 
00155     virtual Trace<F,G>* clone() const { 
00156       Trace<F,G>* tmp = new Trace();
00157       tmp->attrib() = attrib_;
00158       return tmp;
00159     }
00160   protected:
00161     virtual std::ostream& info(std::ostream& os) const;
00162   private:
00163     concepts::Set<concepts::Attribute> attrib_;
00164 
00165     virtual void compute_(const hp1D::Element<G>& elm,
00166                           const concepts::Array<F>& coeff,
00167                           F& val, const uint i[2]) const;
00168     virtual void compute_(const hp1D::Element<G>& elm, const uint j[2],
00169                           F& val, const uint i[2]) const;
00170     virtual void compute_(const hp1D::Element<G>& elm,
00171                           const concepts::Array<F>& coeff,
00172                           F& val, const Real2d& p, const Real t = 0.0) const;
00173   };
00174 
00175   // ************************************************************ TraceDeriv **
00176 
00184   template<typename F = Real,
00185            typename G = typename concepts::Realtype<F>::type>
00186   class TraceDeriv : public ElementFunction<1,F,hp1D::Element<G> > {
00187   public:
00189     TraceDeriv() : attrib_(concepts::Attribute(0)) {}
00191     TraceDeriv(const concepts::Attribute attrib) : attrib_(attrib) {}
00192 
00194     concepts::Set<concepts::Attribute>& attrib() { return attrib_; }
00195 
00196     virtual TraceDeriv<F,G>* clone() const { 
00197       TraceDeriv<F,G>* tmp = new TraceDeriv();
00198       tmp->attrib() = attrib_;
00199       return tmp;
00200     }
00201   protected:
00202     virtual std::ostream& info(std::ostream& os) const;
00203   private:
00204     concepts::Set<concepts::Attribute> attrib_;
00205 
00206     virtual void compute_(const hp1D::Element<G>& elm,
00207                           const concepts::Array<F>& coeff,
00208                           F& val, const uint i[2]) const;
00209     virtual void compute_(const hp1D::Element<G>& elm, const uint j[2],
00210                           F& val, const uint i[2]) const;
00211     virtual void compute_(const hp1D::Element<G>& elm,
00212                           const concepts::Array<F>& coeff,
00213                           F& val, const Real2d& p, const Real t = 0.0) const;
00214   };
00215 
00216 
00217   // ********************************************************** NeumannTrace **
00218 
00227   template<typename F = Real,
00228            typename G = typename concepts::Realtype<F>::type>
00229   class NeumannTrace : public ElementFunction<1,F,Quad<G> > {
00230   public:
00233     NeumannTrace() {}
00234 
00235     virtual NeumannTrace<F,G>* clone() const { 
00236       return new NeumannTrace();
00237     }
00238   protected:
00239     virtual std::ostream& info(std::ostream& os) const;
00240   private:
00241 
00242     virtual void compute_(const Quad<G>& elm,
00243                           const concepts::Array<F>& coeff,
00244                           F& val, const uint i[2]) const;
00245     virtual void compute_(const Quad<G>& elm, const uint j[2],
00246                           F& val, const uint i[2]) const;
00247     virtual void compute_(const Quad<G>& elm,
00248                           const concepts::Array<F>& coeff,
00249                           F& val, const Real2d& p, const Real t = 0.0) const;
00250   };
00251 
00252 
00253 } // namespace hp2D
00254 
00255 #endif // hpFunction2d_hh