Documentation for Concepts 2.0

Go to the documentation of this file.
00001 /* Base class for functions on space with hp elements in 2D
00002  */
00003 
00004 #ifndef hpFunctionBase2d_hh
00005 #define hpFunctionBase2d_hh
00006 
00007 #include "space/function.hh"
00008 #include "toolbox/stiffArray.hh"
00009 #include "quad.hh"
00010 
00011 namespace hp2D {
00012 
00013   using concepts::Real;
00014   using concepts::Real2d;
00015 
00016   // ******************************************************* ElementFunction **
00017 
00033   template<uint dim, typename F = Real, typename Q = Quad<Real> >
00034   class ElementFunction : 
00035     public concepts::ElementFunction<F, typename Q::type> 
00036   {
00037   public:
00038     typedef concepts::Element<typename Q::type> Element;
00039 
00041     virtual uint n() const { return dim; }
00042 
00043     virtual void operator() (const Element& elm,
00044            const concepts::Array<F>& coeff,
00045            concepts::Array<F>& val, const uint *i) const;
00046     virtual void operator() (const Element& elm,
00047            const uint* j,
00048            concepts::Array<F>& val, const uint* i) const;
00049     virtual void operator() (const Element& elm,
00050            const concepts::Array<F>& coeff,
00051            concepts::Array<F>& val, const Real p, 
00052            const Real t = 0.0) const;
00053     virtual void operator() (const Element& elm,
00054            const concepts::Array<F>& coeff,
00055            concepts::Array<F>& val, const Real2d& p,
00056            const Real t = 0.0) const;
00057     virtual void operator() (const Element& elm,
00058            const concepts::Array<F>& coeff,
00059            concepts::Array<F>& val,
00060            const concepts::Real3d& p,
00061            const Real t = 0.0) const;
00062   private:
00063     virtual void compute_(const Q& elm, const concepts::Array<F>& coeff,
00064         concepts::Array<F>& val,
00065         const uint i[2]) const = 0;
00066 
00067     virtual void compute_(const Q& elm, const uint j[3], 
00068         concepts::Array<F>& val,
00069         const uint i[2]) const = 0;
00070 
00071     virtual void compute_(const Q& elm, const concepts::Array<F>& coeff,
00072         concepts::Array<F>& val,
00073         const Real2d& p, const Real t = 0.0) const = 0;
00074   };
00075 
00076   template<uint dim, typename F, typename Q>
00077   void ElementFunction<dim,F,Q>::operator()
00078     (const Element& elm, const concepts::Array<F>& coeff,
00079      concepts::Array<F>& val, const uint *i) const {
00080     // Quadrilaterial
00081     const Q* quad = dynamic_cast<const Q*>(&elm);
00082     if (quad) return compute_(*quad, coeff, val, i);
00083      
00084     throw conceptsException(concepts::MissingFeature("element not supported"));
00085   }
00086 
00087   template<uint dim, typename F, typename Q>
00088   void ElementFunction<dim,F,Q>::operator()
00089     (const Element& elm, const uint* j,
00090      concepts::Array<F>& val, const uint *i) const {
00091     // Quadrilaterial
00092     const Q* quad = dynamic_cast<const Q*>(&elm);
00093     if (quad) return compute_(*quad, j, val, i);
00094 
00095     throw conceptsException(concepts::MissingFeature("element not supported"));
00096   }
00097 
00098   template<uint dim, typename F, typename Q>
00099   void ElementFunction<dim,F,Q>::operator()
00100   (const Element& elm, const concepts::Array<F>& coeff,
00101    concepts::Array<F>& val, const Real p, const Real t) const {
00102     const Real2d p2(p);
00103 
00104     // Quadrilaterial
00105     const Q* quad = dynamic_cast<const Q*>(&elm);
00106     if (quad) return compute_(*quad, coeff, val, p2, t);
00107 
00108     throw conceptsException(concepts::MissingFeature("element not supported"));
00109   }
00110 
00111   template<uint dim, typename F, typename Q>
00112   void ElementFunction<dim,F,Q>::operator()
00113   (const Element& elm, const concepts::Array<F>& coeff,
00114    concepts::Array<F>& val, const Real2d& p, const Real t) const {
00115     // Quadrilaterial
00116     const Q* quad = dynamic_cast<const Q*>(&elm);
00117     if (quad) return compute_(*quad, coeff, val, p, t);
00118 
00119     throw conceptsException(concepts::MissingFeature("element not supported"));
00120   }
00121 
00122   template<uint dim, typename F, typename Q>
00123   void ElementFunction<dim,F,Q>::operator()
00124   (const Element& elm, const concepts::Array<F>& coeff,
00125    concepts::Array<F>& val, const concepts::Real3d& p, const Real t) const {
00126     const Real2d p2(p);
00127 
00128     // Quadrilaterial
00129     const Q* quad = dynamic_cast<const Q*>(&elm);
00130     if (quad) return compute_(*quad, coeff, val, p2, t);
00131 
00132     throw conceptsException(concepts::MissingFeature("element not supported"));
00133   }
00134 
00135   // **************************************************** ElementFunction<1> **
00136 
00137   template<typename F, typename Q>
00138   class ElementFunction<1,F,Q> :
00139     public concepts::ElementFunction<F, typename Q::type> {
00140   public:
00141     typedef concepts::Element<typename Q::type> Element;
00142 
00144     virtual uint n() const { return 1; }
00145     virtual void operator() (const Element& elm,
00146            const concepts::Array<F>& coeff,
00147            concepts::Array<F>& val, const uint *i) const;
00148     virtual void operator() (const Element& elm,
00149            const uint* j,
00150            concepts::Array<F>& val, const uint* i) const;
00151     virtual void operator() (const Element& elm,
00152            const concepts::Array<F>& coeff,
00153            concepts::Array<F>& val, const Real p, 
00154            const Real t = 0.0) const;
00155     virtual void operator() (const Element& elm,
00156            const concepts::Array<F>& coeff,
00157            concepts::Array<F>& val, const Real2d& p,
00158            const Real t = 0.0) const;
00159     virtual void operator() (const Element& elm,
00160            const concepts::Array<F>& coeff,
00161            concepts::Array<F>& val,
00162            const concepts::Real3d& p,
00163            const Real t = 0.0) const;
00164 
00165     virtual void operator() (const Element& elm,
00166            const concepts::Array<F>& coeff,
00167            F& val, const uint *i) const;
00168     virtual void operator() (const Element& elm,
00169            const uint* j,
00170            F& val, const uint* i) const;
00171     virtual void operator() (const Element& elm,
00172            const concepts::Array<F>& coeff,
00173            F& val, const Real p,
00174            const Real t = 0.0) const;
00175     virtual void operator() (const Element& elm,
00176            const concepts::Array<F>& coeff,
00177            F& val, const Real2d& p,
00178            const Real t = 0.0) const;
00179     virtual void operator() (const Element& elm,
00180            const concepts::Array<F>& coeff,
00181            F& val, const concepts::Real3d& p,
00182            const Real t = 0.0) const;
00183   private:
00184     virtual void compute_(const Q& elm, const concepts::Array<F>& coeff,
00185         F& val, const uint i[2]) const = 0;
00186     virtual void compute_(const Q& elm, const uint j[3], 
00187         F& val, const uint i[2]) const = 0;
00188     virtual void compute_(const Q& elm, const concepts::Array<F>& coeff,
00189         F& val, const Real2d& p, const Real t) const = 0;
00190   };
00191 
00192   template<typename F, typename Q>
00193   void ElementFunction<1,F,Q>::operator()
00194     (const Element& elm, const concepts::Array<F>& coeff,
00195      concepts::Array<F>& val, const uint *i) const {
00196     val.resize(1);
00197     (*this)(elm, coeff, val[0], i);
00198   }
00199 
00200   template<typename F, typename Q>
00201   void ElementFunction<1,F,Q>::operator()
00202     (const Element& elm, const uint* j,
00203      concepts::Array<F>& val, const uint *i) const {
00204     val.resize(1);
00205     (*this)(elm, j, val[0], i);
00206   }
00207 
00208   template<typename F, typename Q>
00209   void ElementFunction<1,F,Q>::operator()
00210     (const Element& elm, const concepts::Array<F>& coeff,
00211      concepts::Array<F>& val, const Real p, const Real t) const {
00212     const Real2d p2(p);
00213     val.resize(1);
00214     (*this)(elm, coeff, val[0], p2, t);
00215   }
00216 
00217   template<typename F, typename Q>
00218   void ElementFunction<1,F,Q>::operator()
00219     (const Element& elm, const concepts::Array<F>& coeff,
00220      concepts::Array<F>& val, const Real2d& p, const Real t) const {
00221     val.resize(1);
00222     (*this)(elm, coeff, val[0], p, t);
00223   }
00224 
00225   template<typename F, typename Q>
00226   void ElementFunction<1,F,Q>::operator()
00227     (const Element& elm, const concepts::Array<F>& coeff,
00228      concepts::Array<F>& val, const concepts::Real3d& p, const Real t) const {
00229     const Real2d p2(p);
00230     val.resize(1);
00231     (*this)(elm, coeff, val[0], p2, t);
00232   }
00233 
00234   //                         *************
00235 
00236   template<typename F, typename Q>
00237   void ElementFunction<1,F,Q>::operator()
00238     (const Element& elm, const concepts::Array<F>& coeff,
00239      F& val, const uint *i) const {
00240     // Quadrilaterial
00241     const Q* quad = dynamic_cast<const Q*>(&elm);
00242     if (quad)
00243       return compute_(*quad, coeff, val, i);
00244 
00245     throw conceptsException(concepts::MissingFeature("element not supported"));
00246   }
00247 
00248   template<typename F, typename Q>
00249   void ElementFunction<1,F,Q>::operator()
00250     (const Element& elm, const uint* j,
00251      F& val, const uint *i) const {
00252     // Quadrilaterial
00253     const Q* quad = dynamic_cast<const Q*>(&elm);
00254     if (quad) return compute_(*quad, j, val, i);
00255 
00256     throw conceptsException(concepts::MissingFeature("element not supported"));
00257   }
00258 
00259   template<typename F, typename Q>
00260   void ElementFunction<1,F,Q>::operator()
00261     (const Element& elm, const concepts::Array<F>& coeff,
00262      F& val, const Real p, const Real t) const {
00263     const Real2d p2(p);
00264     (*this)(elm, coeff, val, p2, t);
00265   }
00266 
00267   template<typename F, typename Q>
00268   void ElementFunction<1,F,Q>::operator()
00269     (const Element& elm, const concepts::Array<F>& coeff,
00270      F& val, const Real2d& p, const Real t) const {
00271     // Quadrilaterial
00272     const Q* quad = dynamic_cast<const Q*>(&elm);
00273     if (quad) return compute_(*quad, coeff, val, p, t);
00274 
00275     throw conceptsException(concepts::MissingFeature("element not supported"));
00276   }
00277 
00278   template<typename F, typename Q>
00279   void ElementFunction<1,F,Q>::operator()
00280     (const Element& elm, const concepts::Array<F>& coeff,
00281      F& val, const concepts::Real3d& p, const Real t) const {
00282     const Real2d p2(p);
00283     (*this)(elm, coeff, val, p2, t);
00284   }
00285 
00286 } // namespace hp2D
00287 
00288 
00289 #endif // hpFunctionBase2d_hh