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

Go to the documentation of this file.

#ifndef _ELEMENT_BASSO_H_
#define _ELEMENT_BASSO_H_

// std includes

// Basso includes
#include "basso.h"
#include "Basis.h"
#include "basic_fem_operations.h"

// Basis types
#include "basis_includes.h"

namespace basso {



class Element  {

public:
        
        // PUBLIC DEFS
        typedef iArray::const_iterator  const_iterator;
        typedef iArray::iterator                iterator;
        
        // CONSTRUCTORS 
        
        Element( int id=0, int part=0, BasisType bt=kNONE ) : fConn( basis_type_numnodes(bt) )
                { fBasisLocal=false; SetBasis(bt); eid=id; pid=part; }
        
        Element( int id, int part, BasisType bt, const iArray &nids ) 
                : fConn(nids) { eid=id; pid=part; fBasisLocal=false; SetBasis(bt); }
        
        Element( int id, int part, Basis *bt, const iArray &nids ) : fConn( nids )
                { eid=id; pid=part; fBasis=bt; fBasisLocal=false; }

        Element( const Element &be ) { fBasisLocal=false; CopyElement(be); }
        
        ~Element() { if ( fBasisLocal ) delete fBasis; }
        
        // ACCESSORS
        Element::const_iterator begin() const { return fConn.begin(); }
        Element::iterator begin()  { return fConn.begin(); }
        
        Element::const_iterator end() const { return fConn.end(); }
        Element::iterator end()  { return fConn.end(); }
        
        int operator[] ( int i ) const { return NodeId(i); }
        
        // MEMBER FUNCTIONS
        
        int NodeId( int i ) const
        {
#ifdef EXPLICIT_BOUNDS_CHECK
                if ( i<0 || i>fConn.size()-1 )
                        ErrorMessage("Element::NodeId","index i out of range for element");
#endif          
                return fConn[i];
        }


        BasisType Type() const { return fBasis->Type(); }
                
        BasisShape Shape() const { return fBasis->Shape(); }

        int     NumNodes() const { return fBasis->NumNodes(); }

        int     NumEdges() const { return fBasis->NumEdges(); }

        int     NumFaces() const { return fBasis->NumFaces(); }

        int     Dimension() const { return fBasis->Dimension(); }

        int     Order() const { return fBasis->Order(); }

        void ParentCoord( Array< Point > &pts ) const { fBasis->ParentCoord(pts); }

        Point Centroid() const { return fBasis->Centroid(); }

        void NumNodesOnFaces( iArray &nn_face ) const { fBasis->NumNodesOnFaces(nn_face); }

        void NumNodesOnEdges( iArray &nn_edge ) const { fBasis->NumNodesOnEdges(nn_edge); }

        void NodesOnFace ( int f, iArray &face_nodeids ) const { fBasis->NodesOnFace(f,face_nodeids); }

        void NodesOnEdge ( int e, iArray &edge_nodeids ) const { fBasis->NodesOnEdge(e,edge_nodeids); }

        void FaceBasisType( Array<BasisType> &face_basis ) const { fBasis->FaceBasisType(face_basis); }

        void EdgeBasisType( Array< BasisType > &edge_basis ) const { fBasis->EdgeBasisType(edge_basis); }

        void Quadrature( int p, QuadratureRule &quad ) const { fBasis->Quadrature(p,quad); }
                
        void Na( const Point &p, Array<Numeric> &shapefunct ) const { fBasis->Na(p,shapefunct); }

        void Na( Array<Numeric> &shapefunct ) const { fBasis->Na(shapefunct); }

        void DNa( const Point &p, dense_matrix<Numeric> &shapefunct ) const { fBasis->DNa(p,shapefunct); }

        void DNa( dense_matrix<Numeric> &shapefunct ) const { fBasis->DNa(shapefunct); }
        
        int Id() const { return eid; }
        
        int PartId() const { return pid; }
        
        const iArray &Connectivity() const { return fConn; }
        
        const Basis *BasisPtr() const { return fBasis; }
        
        Element &CopyElement( const Element &elem ) 
        {
                // check element size
                fConn = elem.fConn;
                eid = elem.eid;
                pid = elem.pid;
                if ( elem.fBasisLocal )
                        if ( fBasisLocal )
                                *fBasis = *(elem.fBasis);
                        else
                                SetBasis( elem.fBasis->Type() );
                else
                        fBasis = elem.fBasis; 
                return *this; 
        }
        
        Element &operator = ( const Element &conn1 ) { return CopyElement(conn1); }

protected:
        void SetBasis( BasisType bt );

protected:
        int eid;
        int pid;
        iArray fConn;
        Basis *fBasis;
        bool fBasisLocal;
        
};

void Element::SetBasis( BasisType bt )
{
        if ( fBasisLocal ) delete fBasis;
        
        switch ( bt )  {
                
                case kLINE2:
                fBasis = new Line2Basis();
                break;

                case kLINE3:
                fBasis = new Line3Basis();
                break;
                                                
                case kTRIA3:
                fBasis = new Tria3Basis();
                break;

/*
                case kTRIA4:
                fBasis = new Tria4Basis();
                break;
*/
                
                case kTRIA6:
                fBasis = new Tria6Basis();
                break;
                
                case kQUAD4:
                fBasis = new Quad4Basis();
                break;
                
                case kQUAD8:
                fBasis = new Quad8Basis();
                break;
                
                case kTETRA4:
                fBasis = new Tetra4Basis();
                break;
                
                case kTETRA10:
                fBasis = new Tetra10Basis();
                break;
                
                case kHEXA8:
                fBasis = new Hexa8Basis();
                break;  

/*              
                case kHEXA20:
                fBasis = new Hexa20Basis();
                break;
                
                
*/                                                                                                                      
                default:
                WarningMessage("Element::SetBasis( BasisType )","BasisType not yet implemented in this function");
                return;
                
        } 
        fBasisLocal=true;
        
}

std::ostream &operator << ( std::ostream &out, const Element &elem )
{
        out << "Element " << elem.Id()  << " Part " << elem.PartId() << " " << elem.Type();
        out << " { ";
        if ( elem.NumNodes()>0 ) {
                for ( int i=0; i<elem.NumNodes()-1; ++i ) {     
                        out << elem[i] << ", ";
                }
                out << elem[elem.NumNodes()-1]; 
        }
        out << " }";
        
        return out;
}

} // end namespace

#endif

---