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

Go to the documentation of this file.

#ifndef _DOF_MAP_BASSO_H_
#define _DOF_MAP_BASSO_H_


// std includes

// Basso includes
#include "basso.h"

namespace basso {
        
        
class DofMap {
        
public:
        DofMap( int nn=0, int maxnl=0 );
        
        int GlobalDof( int nid, int localdof ) const { return fDofMap[nid][localdof]; }
        
        int NumNodes() const { return fDofMap.size(); }
        
        int NumDof() const { return fNumDof; }

        void Resize( int nn, int nldof=0 ); 

        const iArray &GlobalDofs( int nid ) const { return fDofMap[nid]; }
        
        void SetScatterVector( const iArray &conn, const Array<Dof> &ldofs, iArray &sctr ) const;

        
        void Gather( const iArray &conn, const Array<Dof> &ldofs, 
                const nArray &d, nArray &de ) const;
        
        void Scatter( const iArray &conn, const Array<Dof> &ldofs, 
                const nMatrix &ke, DynamicCSRMatrix &K ) const;
        
        void Scatter( const iArray &conn, const Dof &ldofs, 
                const nMatrix &ke, DynamicCSRMatrix &K ) const; 
        
        void Scatter( const iArray &conn, const Array<Dof> &ldofs, const nArray &fe, nArray &f ) const;

        bool ActiveDof( int nid, int localdof ) const 
        { 
#ifdef DOFMAP_EXPLICIT_BOUNDS_CHECK
                if ( nid>NumNodes()-1 )
                        return false;
                if ( localdof>fDofMap[nid].size()-1 )
                        return false;
#endif
                if ( fDofMap[nid][localdof]<0 )
                        return false;
                return true;    
        }
        
                
        void AddNodalDof( int nid, int localdof ); 
        
        void RenumberGlobalDofs( ); 
        
        
private:
        Array< iArray > fDofMap;
        int fNumDof;
        
};

void DofMap::Resize( int nn, int nldof )
{ 
        int nnOld=vect_size(fDofMap);
        resize( fDofMap, nn );
        if ( nldof>0 )
                for ( int n=nnOld; n<nn; ++n )
                        resize( fDofMap[n], nldof );
}

void DofMap::Gather( const iArray &conn, const Array<Dof> &ldofs, 
        const nArray &d, nArray &de ) const
{
#ifdef DOFMAP_ALLOW_DYNAMIC_RESIZE
        if ( de.size()!=conn.size()*ldofs.size() )
                resize( de, conn.size()*ldofs.size() );
#elif DOFMAP_EXPLICIT_BOUNDS_CHECK
        if ( de.size()!=conn.size()*ldofs.size()  )
                ErrorMessage("DofMap::Gather","incompatible dimension size of de");
#endif  
        iArray::const_iterator nrItr;
        Array<Dof>::const_iterator lrItr;
        int grdof, lrdof=0;
        for ( nrItr=conn.begin(); nrItr!=conn.end(); ++nrItr ) 
                for ( lrItr=ldofs.begin(); lrItr!=ldofs.end(); ++lrItr ) 
                {
                        grdof=fDofMap[*nrItr][*lrItr];
                        de[ lrdof++ ] = d[ grdof ];
                }       
}

void DofMap::Scatter( const iArray &conn, const Array<Dof> &ldofs, 
        const nArray &fe, nArray &f ) const
{
#ifdef DOFMAP_EXPLICIT_BOUNDS_CHECK
        if ( fe.size()!=conn.size()*ldofs.size()  )
                ErrorMessage("DofMap::Scatter","incompatible dimension size of fe");
#endif  
        iArray::const_iterator nrItr;
        Array<Dof>::const_iterator lrItr;
        int grdof, lrdof=0;
        for ( nrItr=conn.begin(); nrItr!=conn.end(); ++nrItr ) 
                for ( lrItr=ldofs.begin(); lrItr!=ldofs.end(); ++lrItr ) 
                {
                        grdof=fDofMap[*nrItr][*lrItr];
                        f[ grdof ] += fe[ lrdof++ ];
                }       
}


void DofMap::Scatter( const iArray &conn, const Array<Dof> &ldofs, 
                const nMatrix &ke, DynamicCSRMatrix &K ) const
{
#ifdef DOFMAP_EXPLICIT_BOUNDS_CHECK
        if ( mat_nrows(ke)!=conn.size()*ldofs.size() || mat_ncols(ke)!=conn.size()*ldofs.size() )
                ErrorMessage("DofMap::Scatter","incompatible dimension size of ke");
#endif  
        iArray::const_iterator nrItr, ncItr;
        Array<Dof>::const_iterator lrItr, lcItr;
        int grdof, gcdof, lrdof=0, lcdof=0;
        for ( nrItr=conn.begin(); nrItr!=conn.end(); ++nrItr ) 
                for ( lrItr=ldofs.begin(); lrItr!=ldofs.end(); ++lrItr ) 
                {
                        grdof=fDofMap[*nrItr][*lrItr];
                        for ( ncItr=conn.begin(); ncItr!=conn.end(); ++ncItr ) 
                                for ( lcItr=ldofs.begin(); lcItr!=ldofs.end(); ++lcItr )
                                {
                                        gcdof=fDofMap[*ncItr][*lcItr];
                                        K( grdof, gcdof ) += ke( lrdof, lcdof++ );
                                }
                        ++lrdof;
                        lcdof=0;
                }
}

void DofMap::Scatter( const iArray &conn, const Dof &ldof, 
                const nMatrix &ke, DynamicCSRMatrix &K ) const
{
#ifdef DOFMAP_EXPLICIT_BOUNDS_CHECK
        if ( mat_nrows(ke)!=conn.size() || mat_ncols(ke)!=conn.size() )
                ErrorMessage("DofMap::Scatter","incompatible dimension size of ke");
#endif  
        iArray::const_iterator nrItr, ncItr;
        int grdof, gcdof, lrdof=0, lcdof=0;
        for ( nrItr=conn.begin(); nrItr!=conn.end(); ++nrItr ) 
        {
                grdof=fDofMap[*nrItr][ldof];
                for ( ncItr=conn.begin(); ncItr!=conn.end(); ++ncItr ) 
                {
                        gcdof=fDofMap[*ncItr][ldof];
                        K( grdof, gcdof ) += ke( lrdof, lcdof++ );
                }
                ++lrdof;
                lcdof=0;
        }
}

void DofMap::SetScatterVector( const iArray &conn, const Array<Dof> &ldofs, iArray &sctr ) const
{
#ifdef DOFMAP_ALLOW_DYNAMIC_RESIZE
        if ( sctr.size()!=conn.size()*ldofs.size() )
                resize( sctr, conn.size()*ldofs.size() );
#elif DOFMAP_EXPLICIT_BOUNDS_CHECK
        if ( sctr.size()!=conn.size()*ldofs.size() )
                ErrorMessage("DofMap::SetScatterVector","incompatible dimension size of sctr");
#endif
        iArray::const_iterator nItr;
        Array<Dof>::const_iterator ldofItr;
        int n=0;
        for ( nItr=conn.begin(); nItr!=conn.end(); ++nItr ) 
                for ( ldofItr=ldofs.begin(); ldofItr!=ldofs.end(); ++ldofItr )
                        sctr[n++]=fDofMap[*nItr][*ldofItr];
}

DofMap::DofMap( int neq, int maxnl ) : fDofMap(neq)
{
        fNumDof=0;
        for ( int i=0; i<NumNodes(); ++i ) {
                resize(fDofMap[i],maxnl);
                for ( int j=0; j<fDofMap[i].size(); ++j )
                        fDofMap[i][j]=-1;
        }
}

void DofMap::RenumberGlobalDofs( )
{
        fNumDof=0;
        for ( int i=0; i<fDofMap.size(); ++i ) 
                for ( int j=0; j<fDofMap[i].size(); ++j ) 
                        if ( ActiveDof(i,j) ) 
                                fDofMap[i][j] = fNumDof++;
}

void DofMap::AddNodalDof( int nid, int localdof ) 
{ 
        if ( fDofMap.size()<nid )
                resize( fDofMap, nid );
        if ( fDofMap[nid].size()<localdof )
                resize( fDofMap[nid], localdof+1 );
        if ( !ActiveDof(nid,localdof) )
                fDofMap[nid][localdof] = fNumDof++;
}

std::ostream &operator << ( std::ostream &out, const DofMap &dmap )
{
        out << "DofMap: " << dmap.NumNodes()  << " nodes " << dmap.NumDof() << " dofs";
 
        for ( int i=0; i<dmap.NumNodes(); ++i ) 
        {
                cout << "\n" << i << " { ";
                for ( int s=0; s<dmap.GlobalDofs(i).size(); ++s )
                        if ( dmap.ActiveDof(i,s) )
                                cout << dmap.GlobalDof(i,s) << " ";
                cout << "}";
        }
        
        return out;
}

} // end of namespace

#endif

---