PaneConnectivity.hpp

Go to the documentation of this file.

#ifndef PANECONNECTIVITY_HPP_
#define PANECONNECTIVITY_HPP_

#include <map>
#include <utility>
#include <vector>
#include <algorithm>
#include <cassert>

namespace Rocstar { namespace Rocin { namespace Utilities {

        class PaneConnectivity
        {
                private:
                        std::map< int, std::vector< int > >             pconn;                                                                  
                        std::map< int, std::vector< int > >                     point2remotePaneList;           
                        std::map< std::pair< int, int >, int >  rmtpanePointPair2Index; 
                        inline int getSharedNodeIndex( const int remotePane, const int localPoint )
                        {

                          #ifdef ASSERT_ON
                                  assert( this ->hasPane( remotePane ) );
                                  assert( this ->hasLocalPoint( localPoint ) );
                                #endif

                                std::pair< int, int > keyPair = std::make_pair( remotePane, localPoint );

                                #ifdef ASSERT_ON
                                        assert( this ->rmtpanePointPair2Index.find( keyPair ) != this ->rmtpanePointPair2Index.end( )  );
                                #endif

                                int idx = this ->rmtpanePointPair2Index[ keyPair ];

                                #ifdef ASSERT_ON
                                        assert( this ->pconn[ remotePane ][ idx ] == localPoint );
                                #endif

                                return idx;
                        }

                        inline int accesspcon( int &index, const int *p, const int size )
                        {

                                #ifdef ASSERT_ON
                                        assert( index >= 0 && index < size );
                                        assert( p != NULL );
                                #endif

                                int datum = p[ index ]; ++index;
                                return datum;
                        }

                        inline void buildPaneConnectivity( const int *pconnarray, const int size )
                        {
                                #ifdef ASSERT_ON
                                        assert( pconnarray != NULL );
                                        assert( size >= 0 );
                                #endif

                                int idx                                                                 = 0;
                                int numberOfConnections = this ->accesspcon( idx, pconnarray, size );

                                for( int connection=0; connection < numberOfConnections; ++connection )
                                {
                                        int rmtpane  = this ->accesspcon( idx, pconnarray, size );
                                        int numnodes = this ->accesspcon( idx, pconnarray, size );

                                        std::vector< int > sharedNodeList;
                                        sharedNodeList.resize( numnodes         );

                                        for( int node = 0; node < numnodes; ++node )
                                        {
                                                sharedNodeList[ node ]                                                           = this ->accesspcon( idx, pconnarray, size )-1; /* Note, pconn is 1-based, not 0-based so 1 is subtracted */
                                                std::pair< int, int > keyPair                                    = std::make_pair(rmtpane, sharedNodeList[ node ] );
                                                this ->rmtpanePointPair2Index[ keyPair ] = node;
                                                this ->point2remotePaneList[ sharedNodeList[ node ] ].push_back( rmtpane );
                                        }

                                        this ->pconn[ rmtpane ] = sharedNodeList;

                                }

                                #ifdef ASSERT_ON
                                        assert( this ->pconn.size( ) == pconnarray[ 0 ] );
                                #endif

                        }

                public:

                        PaneConnectivity( ){ }

                        PaneConnectivity( const int *pconnarray, const int size )
                        {
                                this ->buildPaneConnectivity( pconnarray, size );
                        }

                        ~PaneConnectivity( ) { }

                         void getPointConnectionPairs( const int localPointId, std::vector< std::pair< int, int > > &connections )
                         {

                                std::vector< int > rmtpanes;
                                this ->getRemotePaneIdsSharedWithPoint( localPointId, rmtpanes );


                                for( int i=0; i < rmtpanes.size( ); ++i )
                                {
//                                      std::cout << rmtpanes[ i ] << " " << localPointId << std::endl;

                                        std::pair< int, int > valuePair = std::make_pair( rmtpanes[ i ], this ->getSharedNodeIndex( rmtpanes[ i ], localPointId ) );

//                                      std::cout << valuePair.first << " " << valuePair.second << std::endl;
                                        connections.push_back( valuePair );
                                }

                         }

                         void constructPaneConnectivityFromArray( const int *pconnarray, const int size )
                         {
                                this ->buildPaneConnectivity( pconnarray, size );
                         }

                         inline int getNumberOfConnections( ) const { return this ->pconn.size( ); }

                         inline bool hasPane( const int paneId ) const { return( this ->pconn.find( paneId ) != this ->pconn.end( ) ); }

                         int getNumberOfNodesSharedWithRemotePane( const int remotePane )
                         {
                                        #ifdef ASSERT_ON
                                         assert( this ->hasPane( remotePane ) );
                                        #endif
                                        return( this ->pconn[ remotePane ].size( ) );
                         }

                         inline bool hasLocalPoint( const int localPointId ) const
                         {
                                        #ifdef ASSERT_ON
                                         assert( localPointId >= 0 );
                                        #endif

                                        if( this ->point2remotePaneList.find( localPointId ) != this ->point2remotePaneList.end( ) )
                                                return true;
                                        else
                                                return false;
                         }

                         void getRemotePaneIdsSharedWithPoint( const int localPointId, std::vector< int > &rmtpaneIds )
                         {
                                        #ifdef ASSERT_ON
                                         assert( this ->hasLocalPoint( localPointId ) );
                                        #endif

                                         rmtpaneIds.resize( this ->point2remotePaneList[ localPointId ].size( ) );
                                         std::copy( this ->point2remotePaneList[ localPointId ].begin( ),
                                                                                        this ->point2remotePaneList[ localPointId ].end( ),
                                                                                        rmtpaneIds.begin( ) );
                         }

                         void getRemotePaneIds( std::vector< int > &rmtpanes )
                         {
                                 if( rmtpanes.size( ) != this ->getNumberOfConnections( )  )
                                         rmtpanes.resize( this ->getNumberOfConnections( ) );

                                 std::map< int, std::vector< int > >::iterator iter = this ->pconn.begin( );
                                 for( int idx=0; iter != this ->pconn.end( ); ++iter, ++idx )
                                         rmtpanes[ idx ] = iter ->first;
                         }

                         int getSharedPointIdAt( const int paneId, const int nodeIndex )
                         {
                                        #ifdef ASSERT_ON
                                         assert( this ->hasPane( paneId ) );
                                         assert( nodeIndex >= 0 && nodeIndex < this ->pconn[ paneId ].size( )  );
                                        #endif
                                        return this ->pconn[ paneId ][ nodeIndex ];
                         }

                         std::vector< int >& getNodesSharedWithRemotePane( const int remotePane )
                         {
                                #ifdef ASSERT_ON
                                         assert( this ->hasPane( remotePane ) );
                                #endif
                                return( this ->pconn[ remotePane ] );
                         }

        }; /* End class Pane Connectivity */

} } }
#endif /* PANECONNECTIVITY_HPP_ */