pzquad.h

Go to the documentation of this file.

#ifndef INTQUADHPP
#define INTQUADHPP

#include <iostream>

#include "pzreal.h"
template<class T>
class TPZVec;
template<class T, int N>
class TPZManVector;

class TPZIntRuleT3D;
class TPZIntRuleP3D;

#include "tpzintrulet.h"
#include "tpzintpoints.h"
#include "tpzprinteg.h"

//*******************************************************************
// Base Class TInt1D -          which handles the integration
//                                                                                                                              for 1D problems
//*******************************************************************
class TPZInt1d : public TPZIntPoints {
                int fOrdKsi;
                TPZGaussRule *fIntP;
public:
                enum {Dim = 1};
                TPZInt1d(int OrdK = 0,int type = 0);
                TPZInt1d(const TPZInt1d &copy ) : TPZIntPoints(copy), fOrdKsi(copy.fOrdKsi), fIntP(copy.fIntP) {
                }
    TPZInt1d &operator=(const TPZInt1d &copy)
    {
        fOrdKsi = copy.fOrdKsi;
        fIntP = copy.fIntP;
        return *this;
    }
                virtual ~TPZInt1d() {
                }
                virtual int NPoints() const;
                virtual void Point(int ip, TPZVec<REAL> &pos, REAL &w) const;

                virtual void SetType(int type,int order) {
                                fIntP->SetType(type,order);
                }
                virtual void SetOrder(TPZVec<int> &ord,int type = 0);
                virtual void GetOrder(TPZVec<int> &ord) const;
                virtual int GetRealMaxOrder() const;
                
                virtual int GetMaxOrder() const{
                                return 36;
                }
                
                virtual int Dimension() const
                {
                                return Dim;
                }

                virtual TPZIntPoints *PrismExtend(int order)
                {
                                return new TPZPrInteg<TPZInt1d>(order);
                }
                virtual TPZIntPoints *Clone() const
                {
                                return new TPZInt1d(*this);
                }
    
                void Print(std::ostream &out = std::cout) const {
                                if(fIntP) fIntP->Print(out);
                }

                void Name(std::string &name) const {
                                name = "TPZInt1D";
                }
};

//*******************************************************************
// Base Class TPZIntTriang - which handles the integration
//                                                                                                                                              for 2D problems, triangle elements
//*******************************************************************
class TPZIntTriang : public TPZIntPoints{
    
protected:
                int fOrdKsi;
                TPZIntRuleT *fIntKsi;

public:
                enum {Dim = 2};
                TPZIntTriang(int OrdK = 2);
                TPZIntTriang(const TPZIntTriang &copy) : TPZIntPoints(copy), fOrdKsi(copy.fOrdKsi), fIntKsi(copy.fIntKsi) {
                }
    TPZIntTriang &operator=(const TPZIntTriang &copy)
    {
        TPZIntPoints::operator=(copy);
        fOrdKsi = copy.fOrdKsi;
        fIntKsi = copy.fIntKsi;
        return *this;
    }
                virtual ~TPZIntTriang() {
                }

                virtual int  NPoints() const;
                virtual void Point(int ip, TPZVec<REAL> &pos, REAL &w) const;

                virtual void SetOrder(TPZVec<int> &ord,int type = 0);
                virtual void GetOrder(TPZVec<int> &ord) const;
                virtual int GetMaxOrder() const;
                virtual int Dimension() const
                {
                                return Dim;
                }

                virtual TPZIntPoints *PrismExtend(int order)
                {
                                return new TPZPrInteg<TPZIntTriang>(order);
                }
                virtual TPZIntPoints *Clone() const
                {
                                return new TPZIntTriang(*this);
                }
                
                void Name(std::string &name) const {
                                name = "TPZIntTriang";
                }
};

//*******************************************************************
// Base Class TPZIntQuad -      which handles the integration
//                                                                                                                                              for 2D problems, quadrilaterals elements
//*******************************************************************
class TPZIntQuad : public TPZIntPoints{
                int fOrdKsi;
                int fOrdEta;
                TPZGaussRule *fIntKsi;
                TPZGaussRule *fIntEta;
public:
                enum {Dim = 2};
                TPZIntQuad(int OrdK,int OrdE);
    
                TPZIntQuad(int OrdK = 1);
    
                TPZIntQuad(const TPZIntQuad &copy) : TPZIntPoints(copy), fOrdKsi(copy.fOrdKsi), fOrdEta(copy.fOrdEta), fIntKsi(copy.fIntKsi),fIntEta(copy.fIntEta) {
                }
    TPZIntQuad &operator=(const TPZIntQuad &copy)
    {
        TPZIntPoints::operator=(copy);
        fOrdKsi = copy.fOrdKsi;
        fOrdEta = copy.fOrdEta;
        fIntKsi = copy.fIntKsi;
        fIntEta = copy.fIntEta;
        return *this;
    }
                virtual ~TPZIntQuad() {
                }
                
                virtual int NPoints() const;
                virtual void Point(int ip, TPZVec<REAL> &pos, REAL &w) const;

    // type 0 : Gauss Legendre
    // type 1 : Gauss Lobatto
    // type 2 : Jacobi
    // type 3 : Chebyshev
                virtual void SetType(int type,int order) {
                                fIntKsi->SetType(type,order);
                                fIntEta->SetType(type,order);
                }
    
    // type 0 : Gauss Legendre
    // type 1 : Gauss Lobatto
    // type 2 : Jacobi
    // type 3 : Chebyshev
                virtual void SetOrder(TPZVec<int> &ord,int type = 0);
    
                virtual void GetOrder(TPZVec<int> &ord) const;
                virtual int GetRealMaxOrder() const;  
                
                virtual int GetMaxOrder() const{
                                return 36;
                }
                
                virtual int Dimension() const
                {
                                return Dim;
                }

                virtual TPZIntPoints *PrismExtend(int order)
                {
                                return new TPZPrInteg<TPZIntQuad>(order);
                }
                virtual TPZIntPoints* Clone() const
                {
                                return new TPZIntQuad(*this);
                }

                void Name(std::string &name) const {
                                name = "TPZIntQuad";
                }
};


class TPZIntCube3D : public TPZIntPoints{
                int fOrdKsi;
                int fOrdEta;
                int fOrdZeta;
                TPZGaussRule *fIntKsi;
                TPZGaussRule *fIntEta;
                TPZGaussRule *fIntZeta;
public:
                enum {Dim = 3};
                TPZIntCube3D(int OrdK = 2,int OrdE = 2,int OrdZ = 2);
                TPZIntCube3D(const TPZIntCube3D &copy) : TPZIntPoints(copy), fOrdKsi(copy.fOrdKsi), fOrdEta(copy.fOrdEta), fOrdZeta(copy.fOrdZeta),
                                fIntKsi(copy.fIntKsi), fIntEta(copy.fIntEta), fIntZeta(copy.fIntZeta) {
                }
    
    TPZIntCube3D &operator=(const TPZIntCube3D &copy)
    {
        TPZIntPoints::operator=(copy);
        fOrdKsi = copy.fOrdKsi;
        fOrdEta = copy.fOrdEta;
        fOrdZeta = copy.fOrdZeta;
        fIntKsi = copy.fIntKsi;
        fIntEta = copy.fIntEta;
        fIntZeta = copy.fIntZeta;
        return *this;
    }

                virtual ~TPZIntCube3D() {
                }
                
                virtual int NPoints() const;
                virtual void Point(int ip, TPZVec<REAL> &pos, REAL &w) const;

                virtual void SetType(int type,int order) {
                                fIntKsi->SetType(type,order);
                                fIntEta->SetType(type,order);
                                fIntZeta->SetType(type,order);
                }
                virtual void SetOrder(TPZVec<int> &ord,int type = 0);
                virtual void GetOrder(TPZVec<int> &ord) const;
                virtual int GetRealMaxOrder() const;
                virtual int GetMaxOrder() const{
                                return 20;    // With this order the number of integration points are 8000
                }
                
                virtual int Dimension() const
                {
                                return Dim;
                }

                virtual TPZIntPoints *PrismExtend(int order)
                {
                                return new TPZPrInteg<TPZIntCube3D>(order);
                }
                virtual TPZIntPoints *Clone() const
                {
                                return new TPZIntCube3D(*this);
                }

                void Name(std::string &name) const {
                                name = "TPZIntCube3D";
                }
};


class TPZIntTetra3D : public TPZIntPoints {
                int fOrdKsi;
                TPZIntRuleT3D *fIntKsi;
public:
                enum {Dim = 3};
                TPZIntTetra3D(int OrdK = 2);
                TPZIntTetra3D(const TPZIntTetra3D &copy) : TPZIntPoints(copy), fOrdKsi(copy.fOrdKsi), fIntKsi(copy.fIntKsi) {
                }

    TPZIntTetra3D &operator=(const TPZIntTetra3D &copy)
    {
        TPZIntPoints::operator=(copy);
        fOrdKsi = copy.fOrdKsi;
        fIntKsi = copy.fIntKsi;
        return *this;
    }
    
                virtual int NPoints() const;
                virtual void Point(int ip, TPZVec<REAL> &pos, REAL &w) const;

                virtual void SetOrder(TPZVec<int> &ord,int type = 0);
                virtual void GetOrder(TPZVec<int> &ord) const;
                virtual int GetMaxOrder() const;  
                virtual int Dimension() const
                {
                                return Dim;
                }

                virtual TPZIntPoints *PrismExtend(int order)
                {
                                return new TPZPrInteg<TPZIntTetra3D>(order);
                }
                virtual TPZIntPoints* Clone() const
                {
                                return new TPZIntTetra3D(*this);
                }

                void Name(std::string &name) const {
                                name = "TPZIntTetra3D";
                }
};


class TPZIntPyram3D : public TPZIntPoints {
                int fOrdKsi;
                TPZIntRuleP3D *fIntKsi;
public:
                enum {Dim =3};
                TPZIntPyram3D(int OrdK = 2);
                TPZIntPyram3D(const TPZIntPyram3D &copy) : TPZIntPoints(copy), fOrdKsi(copy.fOrdKsi), 
                                                fIntKsi(copy.fIntKsi) {
                }
                
    TPZIntPyram3D &operator=(const TPZIntPyram3D &copy)
    {
        TPZIntPoints::operator=(copy);
        fOrdKsi = copy.fOrdKsi;
        fIntKsi = copy.fIntKsi;
        return *this;
    }
    
                virtual int NPoints() const;
                virtual void Point(int ip, TPZVec<REAL> &pos, REAL &w) const;
                
                virtual void SetOrder(TPZVec<int> &ord,int type = 0);
                virtual void GetOrder(TPZVec<int> &ord) const;
                virtual int GetMaxOrder() const;  
                virtual int Dimension() const
                {
                                return Dim;
                }

                virtual TPZIntPoints *PrismExtend(int order)
                {
                                return new TPZPrInteg<TPZIntPyram3D>(order);
                }
                TPZIntPoints *Clone() const
                {
                                return new TPZIntPyram3D(*this);
                }

                void Name(std::string &name) const {
                                name = "TPZIntPyram3D";
                }
};

class TPZIntPrism3D  : public TPZIntPoints {
                int fOrdKsi,fOrdKti;
                TPZInt1d fIntRule1D;
                TPZIntTriang fIntTriang;
public:
                
                enum {Dim = 3};
                TPZIntPrism3D(int OrdK = 2,int OrdL = 2);
                TPZIntPrism3D(const TPZIntPrism3D &copy) : TPZIntPoints(copy), fOrdKsi(copy.fOrdKsi), fOrdKti(copy.fOrdKti), 
                                                fIntRule1D(copy.fIntRule1D), fIntTriang(copy.fIntTriang) {
                }
    TPZIntPrism3D &operator=(const TPZIntPrism3D &copy)
    {
        TPZIntPoints::operator=(copy);
        fOrdKsi = copy.fOrdKsi;
        fOrdKti = copy.fOrdKti;
        fIntRule1D = copy.fIntRule1D;
        fIntTriang = copy.fIntTriang;
        return *this;
    }
                virtual ~TPZIntPrism3D();
                
                int NPoints() const;
                void Point(int ip, TPZVec<REAL> &pos, REAL &w) const;

                virtual void SetType(int type,int order) {
                                fIntRule1D.SetType(type,order);
                }
                void SetOrder(TPZVec<int> &ord,int type = 0);
                void GetOrder(TPZVec<int> &ord) const;
                virtual int GetMaxOrder() const;  
                virtual int Dimension() const
                {
                                return Dim;
                }

                virtual TPZIntPoints *PrismExtend(int order)
                {
                                return new TPZPrInteg<TPZIntPrism3D>(order);
                }
                TPZIntPoints *Clone() const
                {
                                return new TPZIntPrism3D(*this);
                }

                void Name(std::string &name) const {
                                name = "TPZIntPrism3D";
                }
};

class TPZInt1Point : public TPZIntPoints {
                
public:
                
    enum {Dim = 0};
    TPZInt1Point(int order = 0);

                TPZInt1Point(const TPZInt1Point &copy ) : TPZIntPoints(copy) {
                }
    TPZInt1Point & operator=(const TPZInt1Point &copy )
    {
        TPZIntPoints::operator=(copy);
        return *this;
    }
    virtual ~TPZInt1Point();
                
    int NPoints() const;
    void Point(int ip, TPZVec<REAL> &pos, REAL &w) const;

    void SetOrder(TPZVec<int> &ord,int type = 0);
    void GetOrder(TPZVec<int> &ord) const;
    int GetMaxOrder() const;  
    int Dimension() const {
                                return Dim;
    }

    TPZIntPoints *PrismExtend(int order);
                TPZIntPoints *Clone() const {
                                return new TPZInt1Point(*this);
                }

                virtual void Name(std::string &name) const {
                                name = "TPZInt1Point";
                }
};

inline TPZInt1Point::TPZInt1Point(int order) : TPZIntPoints()
{
}

inline TPZInt1Point::~TPZInt1Point() {
}

inline int TPZInt1Point::NPoints() const{
                return 1;
}

inline void TPZInt1Point::Point(int ip, TPZVec<REAL> &pos, REAL &w) const {
#ifndef NODEBUG
                if(ip!=0) {
                                std::cout << "TPZInt1Point:: Bad number point " << ip << std::endl;
                                return;
                }
#endif
                w = 1.;
}

inline void  TPZInt1Point::SetOrder(TPZVec<int> &ord,int type) {
}

inline void TPZInt1Point::GetOrder(TPZVec<int> &/* ord */) const {
}

inline int TPZInt1Point::GetMaxOrder() const {
                return 1;
}

inline TPZIntPoints *TPZInt1Point::PrismExtend(int order) {
                return new TPZPrInteg<TPZInt1Point> (order);
}

#endif