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

Go to the documentation of this file.

#ifndef _GMSH_INPUT_BASSO_H_
#define _GMSH_INPUT_BASSO_H_

// I/O includes
#include <iostream>
#include <iomanip>
#include <fstream>

// STL includes
#include <vector>
#include <list>
#include <set>
#include <map>

// Basso includes
#include "basso.h"
#include "FEInput.h"

namespace basso {

class GmshInput : public FEInput {
        
public:
        

                GmshInput( ) : FEInput( ) { }
                GmshInput( const String &file ) : FEInput(file) {  }
        virtual ~GmshInput() {}
        
        // MEMEBER FUNCTIONS
        
        virtual void ReadNodes( Array<Node> &nodes );
        
        virtual void AddElements( list<Element> &elem, int pid=-999 ) const;
        
        virtual void AddNodeSet( set<int> &nid, int pid ) const;

protected:
        
        BasisType GetBasisType( int etype ) const;
        
        int NumNodesElement( int etype ) const;
        
protected:

                
};


void GmshInput::ReadNodes( Array<Node> &node )  
{

        // open msh file
        std::ifstream inFile;
        if ( OpenFile(inFile) ) 
                WarningMessage("GmshInput::ReadNodes","could not open file");

        // look for node section 
        GotoSection(inFile,"$Nodes");

        //  get the number of nodes
        int nn;
        inFile >> nn;

        if ( node.size()!=nn )
                resize( node, nn );

        // fill node
        for ( int i=0; i<nn; ++i ) 
        {
                int id;
                Numeric x, y, z;
                inFile >> id >> x >> y >> z;
                node[i]=Node(i,x,y,z);
                mNodeMap[id]=i;
        }
        CloseFile(inFile);
        
}

void GmshInput::AddElements( list<Element> &elem, int pid ) const
{
        // open msh file
        std::ifstream inFile;
        if ( OpenFile(inFile) ) 
                WarningMessage("GmshInput::ReadElements","could not open file");
        

        // look for element section 
        GotoSection(inFile,"$Elements");

        //  get the number of elements
        int ne;
        inFile >> ne;

        // fill element
        map<int,int>::const_iterator mItr;
        for ( int e=0; e<ne; ++e ) 
        {
                int eid, etype, epid, nid, ntag;
                
                inFile >> eid >> etype >> ntag;
                iArray tags(ntag);
                for ( int t=0; t<ntag; ++t )
                        inFile >> tags[t];
                epid=tags[0]; 
                        
                int nne=NumNodesElement(etype);
                iArray econn(nne);
                for ( int n=0; n<nne; ++n )  
                        inFile >> econn[n];
                if ( pid==epid || pid==-999 ) 
                {
                        for ( int n=0; n<nne; ++n ) 
                        {
                                mItr = mNodeMap.find( econn[n] );
                                econn[n] = mItr->second;   // renumber conn
                        }
                                
                        elem.push_back( Element( eid, epid, GetBasisType(etype), econn ) );
                }
        }
        CloseFile(inFile);
         
}

void GmshInput::AddNodeSet( set<int> &nset, int pid ) const
{
        // open msh file
        std::ifstream inFile;
        if ( OpenFile(inFile) ) 
                WarningMessage("GmshInput::AddNodeSet","could not open file");
         

        // look for element section 
        GotoSection(inFile,"$Elements");        

        //  get the number of elements
        int ne;
        inFile >> ne;

        // fill element
        map<int,int>::const_iterator mItr;
        for ( int e=0; e<ne; ++e ) 
        {
                int eid, etype, epid, nid, ntag;
                
                inFile >> eid >> etype >> ntag;
                iArray tags(ntag);
                for ( int t=0; t<ntag; ++t )
                        inFile >> tags[t];
                epid=tags[0]; 
                        
                int nne=NumNodesElement(etype);
                iArray econn(nne);
                for ( int n=0; n<nne; ++n )
                        inFile >> econn[n];
                if ( pid==epid )
                        for ( int n=0; n<nne; ++n )
                        {
                                mItr = mNodeMap.find( econn[n] );
                                nset.insert( mItr->second );
                        }
        }

        CloseFile(inFile);
}

int GmshInput::NumNodesElement( int etype ) const
{
        switch (etype) {
                
                case 1:
                return 2;
                
                case 2:
                return 3;
                
                case 3:
                return 4;
                
                case 4:
                return 4;
                
                case 5:
                return 8;
                
                case 6:
                return 6;
                
                case 7:
                return 5;
                
                case 8:
                return 3;
                
                case 9:
                return 6;
                
                case 10:
                return 9;
                
                case 11:
                return 10;
                
                case 12:
                return 27;
                
                case 13:
                return 18;
                
                case 14:
                return 14;
                
                case 15:
                return 1;
                
                case 16:
                return 8;
                
                case 17:
                return 20;
                
                case 18:
                return 15;
                
                case 19:
                return 13;
                
                default:
                WarningMessage("BasisType GmshInput::NumNodesElement( int etype )","Unknown etype");
                return 1;
        }
}
        

BasisType GmshInput::GetBasisType( int etype ) const
{
        switch (etype) {
                
                case 1:
                return kLINE2;
                
                case 2:
                return kTRIA3;
                
                case 3:
                return kQUAD4;
                
                case 4:
                return kTETRA4;
                
                case 5:
                return kHEXA8;
                
                case 6:
                return kPRISM6;
                
                case 7:
                return kPYRAMID5;
                
                case 8:
                return kLINE3;
                
                case 9:
                return kTRIA6;
                
                case 10:
                return kQUAD9;
                
                case 11:
                return kTETRA10;
                
                case 12:
                return kHEXA27;
                
                case 13:
                return kPRISM18;
                
                case 14:
                return kPYRAMID14;
                
                case 15:
                return kPOINT1;
                
                case 16:
                return kQUAD8;
                
                case 17:
                return kHEXA20;
                
                case 18:
                return kPRISM15;
                
                case 19:
                return kPYRAMID13;
                
                default:
                WarningMessage("BasisType GmshInput::GetBasisType( int etype )","Unknown etype");
                return kNONE;
        }
}





} // end Basso namepsace 
#endif  

---