/Users/jack/Code/basso_dev/inc/Tetra4Basis.h

Go to the documentation of this file.

#ifndef _TETRA4_BASIS_BASSO_H_
#define _TETRA4_BASIS_BASSO_H_

#include "basso.h"
#include "Basis.h"
#include "quadrature_rules.h"

namespace basso {

class Tetra4Basis : public Basis {

public:
        
        // constructors
        Tetra4Basis() { }
        
        // destructors
        virtual ~Tetra4Basis() { }
        
        // member functions
        virtual BasisType       Type() const { return kTETRA4; }
        virtual BasisShape Shape() const { return kTETRAHEDRA; }
        virtual int                             NumNodes() const { return 4; }     
        virtual int                             NumEdges() const { return 6; }      
        virtual int                             NumFaces() const { return 4; }      
        virtual int                             Dimension() const { return 3; }
        virtual int                             Order() const { return 1; }
        
        virtual void            ParentCoord( Array< Point > &xi )       const;
        virtual Point           Centroid() const { return Point( 0.1666666666666666667, 0.1666666666666666667, 0.1666666666666666667 ); }
        virtual void            NumNodesOnFaces( iArray &nn_face )      const;
        virtual void            NumNodesOnEdges( iArray &nn_edge )      const;
        virtual void            NodesOnFace ( int f, iArray &face_nodeids )             const;
        virtual void            NodesOnEdge ( int e, iArray &edge_nodeids )                     const;
        virtual void            FaceBasisType( Array<BasisType> &face_basis )   const;
        virtual void            EdgeBasisType( Array< BasisType > &edge_basis ) const;
        
        virtual void            Quadrature( int order, QuadratureRule &qrule ) const;
        
        virtual void            Na( const Point &p, nArray &shapefunct ) const { shape_tetra4(shapefunct,p.x(),p.y(),p.z()); }
        virtual void            DNa( const Point &p, nMatrix &grad_shape ) const { dshape_tetra4(grad_shape,p.x(),p.y(),p.z()); }
        virtual void            Na( nArray &shapefunct )    const { Na( Centroid(), shapefunct ); }
        virtual void            DNa( nMatrix &grad_shape ) const { DNa( Centroid(), grad_shape ); }

private:
        
};

void Tetra4Basis::ParentCoord( Array< Point > &xi ) const
{
#ifdef ALLOW_DYNAMIC_RESIZE 
        if ( xi.size()!=NumNodes() )
                xi.resize(NumNodes());
#endif
        xi[0]=Point(0.0,0.0,0.0);
        xi[1]=Point(1.0,0.0,0.0);
        xi[2]=Point(0.0,1.0,0.0);
        xi[3]=Point(0.0,0.0,1.0);
}

void    Tetra4Basis::NumNodesOnFaces( iArray &nn_face )         const
{
#ifdef ALLOW_DYNAMIC_RESIZE 
        if ( nn_face.size()!=NumEdges() )
                nn_face.resize( NumEdges() );
#endif
        for ( int i=0; i<NumFaces(); ++i )
                nn_face[i]=3;
}

void    Tetra4Basis::NumNodesOnEdges( iArray &nn_edge )         const
{
#ifdef ALLOW_DYNAMIC_RESIZE 
        if ( nn_edge.size()!=NumEdges() )
                nn_edge.resize( NumEdges() );
#endif
        for ( int i=0; i<NumEdges(); ++i )
                nn_edge[i]=2; 
}

void Tetra4Basis::NodesOnFace ( int f, iArray &face_nodeids ) const
{
#ifdef ALLOW_DYNAMIC_RESIZE 
        if ( face_nodeids.size()!=3 )
                face_nodeids.resize(3);
#endif
        switch (f) {
        
                case 0:
                face_nodeids[0]=1; face_nodeids[1]=2; face_nodeids[2]=3;
                break;
                
                case 1:
                face_nodeids[0]=3; face_nodeids[1]=2; face_nodeids[2]=0;
                break;
                
                case 2:
                face_nodeids[0]=3; face_nodeids[1]=0; face_nodeids[2]=1;
                break;
                
                case 3:
                face_nodeids[0]=2; face_nodeids[1]=1; face_nodeids[2]=0;
                break;
                
                default:
                WarningMessage("Tetra4Basis::NodesOnFace","face id out of range");
                break;
                
        }
}

void Tetra4Basis::NodesOnEdge ( int e, iArray &edge_nodeids ) const
{
#ifdef ALLOW_DYNAMIC_RESIZE 
        if ( edge_nodeids.size()!=2 )
                edge_nodeids.resize(2);
#endif
        
        switch (e) {
        
                case 0:
                edge_nodeids[0]=0; edge_nodeids[1]=1;
                break;
                
                case 1:
                edge_nodeids[0]=1; edge_nodeids[1]=2;
                break;
                
                case 2:
                edge_nodeids[0]=2; edge_nodeids[1]=0;
                break;
                
                case 3:
                edge_nodeids[0]=3; edge_nodeids[1]=0;
                break;
                
                case 4:
                edge_nodeids[0]=3; edge_nodeids[1]=2;
                break;
                
                case 5:
                edge_nodeids[0]=3; edge_nodeids[1]=1;
                break;
                
                default:
                WarningMessage("Tetra4Basis::NodesOnFace","face id out of range");
                break;
                
        }
}

void Tetra4Basis::FaceBasisType( Array< BasisType > &face_basis ) const
{
#ifdef ALLOW_DYNAMIC_RESIZE 
        if ( face_basis.size()!=NumFaces() )
                face_basis.resize(NumFaces());
#endif
        for ( int i=0; i<NumEdges(); ++i )
                face_basis[i]=kTRIA3;
}

void Tetra4Basis::EdgeBasisType( Array< BasisType > &edge_basis ) const
{
#ifdef ALLOW_DYNAMIC_RESIZE 
        if ( edge_basis.size()!=NumEdges() )
                edge_basis.resize(NumEdges());
#endif
        for ( int i=0; i<NumEdges(); ++i )
                edge_basis[i]=kLINE2; 
}

void Tetra4Basis::Quadrature( int order, QuadratureRule &qrule ) const
{
        
        int npts;
        if ( order<=1 )
                npts=1;
        else if ( order<=2 )
                npts=4;
        else if ( order<=3 )
                npts=5;
        else {
                npts=5;
                WarningMessage("Tetra4Basis::Quadrature( int order )","quadrature order >3");
        }

        if ( vect_size(qrule)!=npts )
                resize(qrule,npts);

        quadrature_tetra( qrule );
        
}
/*
 void Tetra4Basis::Na( const Point &p, nArray &shapefunct ) const
{
#ifdef ALLOW_DYNAMIC_RESIZE 
        if ( shapefunct.size()!=NumNodes() )
                shapefunct.resize(NumNodes());  
#endif
        shapefunct[0]=1.0-p.x()-p.y()-p.z();
        shapefunct[1]=p.x();
        shapefunct[2]=p.y();
        shapefunct[3]=p.z();
}

void Tetra4Basis::DNa( const Point &p, nMatrix &grad_shape ) const
{
#ifdef ALLOW_DYNAMIC_RESIZE 
        if ( mat_nrows(grad_shape)!=NumNodes() || mat_ncols(grad_shape)!=Dimension() )
                resize( grad_shape, NumNodes(), Dimension() );  
#endif
        grad_shape(0,0)=-1.0; grad_shape(0,1)=-1.0; grad_shape(0,2)=-1.0; 
        grad_shape(1,0)= 1.0; grad_shape(1,1)= 0.0; grad_shape(1,2)= 0.0;
        grad_shape(2,0)= 0.0; grad_shape(2,1)= 1.0; grad_shape(2,2)= 0.0;
        grad_shape(3,0)= 0.0; grad_shape(3,1)= 0.0; grad_shape(3,2)= 1.0;
}
*/
} // end namespace

#endif

---