#include <PaneConnectivity.hpp>

Collaboration diagram for PaneConnectivity:

Public Member Functions
	PaneConnectivity ()
	Default Constructor. More...

	PaneConnectivity (const int *pconnarray, const int size)
	Custom constructor. More...

	~PaneConnectivity ()
	Destructor. More...

void	getPointConnectionPairs (const int localPointId, std::vector< std::pair< int, int > > &connections)
	This method returns the point connection pairs for the given local point. More...

void	constructPaneConnectivityFromArray (const int *pconnarray, const int size)
	Constructs a PaneConnectivity object from the pcon array returned from Rocmap. More...

int	getNumberOfConnections () const
	Returns the number of connections for this instance. More...

bool	hasPane (const int paneId) const
	Checks if the pane exists in this instance. More...

int	getNumberOfNodesSharedWithRemotePane (const int remotePane)
	Returns the number of nodes shared with a particular remote pane. More...

bool	hasLocalPoint (const int localPointId) const
	This method checks if the local point exists in this instance. More...

void	getRemotePaneIdsSharedWithPoint (const int localPointId, std::vector< int > &rmtpaneIds)
	This method returns the list of remote panes that share the point associated with the provided localPointId. More...

void	getRemotePaneIds (std::vector< int > &rmtpanes)
	Returns the remote pane ids that are connected to this instance. More...

int	getSharedPointIdAt (const int paneId, const int nodeIndex)
	This method returns the local shared point Id of the given pane at the given index. More...

std::vector< int > &	getNodesSharedWithRemotePane (const int remotePane)
	Returns a reference to the list of nodes shared with the remotePane. More...

Private Member Functions
int	getSharedNodeIndex (const int remotePane, const int localPoint)
	Returns the index to the shared node list of the local point that is shared with the given remote pane. More...

int	accesspcon (int &index, const int *p, const int size)
	A convenience method which provides safe access to the pconn array by doing bounds checking and memory corruption checking. More...

void	buildPaneConnectivity (const int *pconnarray, const int size)
	Builds the pane connectivity data-structured from a flat integer array returned from RocMap. More...

Private Attributes
std::map< int, std::vector< int > >	pconn
	Holds a mapping of remote pane to a list of local ids that are shared. More...

std::map< int, std::vector< int > >	point2remotePaneList
	Holds a mapping of localpoint ids to remote pane ids. More...

std::map< std::pair< int, int > , int >	rmtpanePointPair2Index
	Holds a mapping of a (remotePane,localPoint) pair to the index in the shared node list. More...

Detailed Description

Definition at line 19 of file PaneConnectivity.hpp.

Constructor & Destructor Documentation

PaneConnectivity ( )

inline

Default Constructor.

Postcondition: this ->getNumberOfConnection( ) == 0.

Definition at line 129 of file PaneConnectivity.hpp.

129 { }

PaneConnectivity	(	const int *	pconnarray,
		const int	size
	)

inline

Custom constructor.

Builds a PaneConnectivity data-structured from the pconnarray returned from Roccom.

Parameters

pconnarray	the pcon connectivity array.
size	the size of the pconnarray.

Precondition: pconnarray != NULL

Postcondition: this ->getNumberOfConnections( ) == pconnarray[ 0 ].

Definition at line 139 of file PaneConnectivity.hpp.

                         {
                                 this ->buildPaneConnectivity( pconnarray, size );
                         }

~PaneConnectivity ( )

inline

Destructor.

Definition at line 147 of file PaneConnectivity.hpp.

147 { }

Member Function Documentation

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

inlineprivate

A convenience method which provides safe access to the pconn array by doing bounds checking and memory corruption checking.

After, the access transaction is complete, the index is also automatically incremented.

Parameters

index	the index to access.
p	the pcon array.
size	the size of the pcon array.

Returns: p[ index ] the datum at the given index

Precondition: index >= 0 && index < size.; p != NULL.

Postcondition: index == index+1.

Definition at line 70 of file PaneConnectivity.hpp.

                         {
 
                                 #ifdef ASSERT_ON
                                         assert( index >= 0 && index < size );
                                         assert( p != NULL );
                                 #endif
 
                                 int datum = p[ index ]; ++index;
                                 return datum;
                         }

void buildPaneConnectivity	(	const int *	pconnarray,
		const int	size
	)

inlineprivate

Builds the pane connectivity data-structured from a flat integer array returned from RocMap.

Parameters

pconnarray	the pconn array returned from Rocmap.
size	the size of the pconn array.

Definition at line 87 of file PaneConnectivity.hpp.

References PaneConnectivity::pconn.

                         {
                                 #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
 
                         }

void constructPaneConnectivityFromArray	(	const int *	pconnarray,
		const int	size
	)

inline

Constructs a PaneConnectivity object from the pcon array returned from Rocmap.

Parameters

pconnarray	the pcon connectivity array.
size	the size of the pconnarray.

Precondition: pconnarray != NULL

Postcondition: this ->getNumberOfConnections( ) == pconnarray[ 0 ].

Definition at line 181 of file PaneConnectivity.hpp.

                          {
                                 this ->buildPaneConnectivity( pconnarray, size );
                          }

std::vector< int >& getNodesSharedWithRemotePane ( const int remotePane )

inline

Returns a reference to the list of nodes shared with the remotePane.

Parameters

remotePane the id of the remote pane that has shared nodes with this instance.

Returns: NodeList a reference to list of shared nodes.

Note: NodeList cannot be changed by the client of this method.

Precondition: this ->hasPane( remotePane ) == true.

Postcondition: NodeList.size( ) == this ->getNumberOfNodesSharedWithRemotePane( remotePane ).

Definition at line 293 of file PaneConnectivity.hpp.

References PaneConnectivity::hasPane(), and PaneConnectivity::pconn.

Referenced by maskPoints().

                          {
                                 #ifdef ASSERT_ON
                                          assert( this ->hasPane( remotePane ) );
                                 #endif
                                 return( this ->pconn[ remotePane ] );
                          }

Here is the call graph for this function:

Here is the caller graph for this function:

int getNumberOfConnections ( ) const

inline

Returns the number of connections for this instance.

Returns: N the number of inter-zone connections.

Postcondition: N >= 0.

Definition at line 191 of file PaneConnectivity.hpp.

191 { return this ->pconn.size( ); }

int getNumberOfNodesSharedWithRemotePane ( const int remotePane )

inline

Returns the number of nodes shared with a particular remote pane.

Parameters

remotePane the remote pane in query.

Returns: N the number of nodes share with the remote pane.

Precondition: this ->hasPane( remotePane ) == true.

Postcondition: N >= 0.

Definition at line 207 of file PaneConnectivity.hpp.

References PaneConnectivity::hasPane(), and PaneConnectivity::pconn.

Referenced by maskPoints().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

This method returns the point connection pairs for the given local point.

Parameters

localPointId	the point id in query.
connections	the list of connection pairs.

Note: A connection pair consists of the remotePaneId and sharedNodeIndex to the

Definition at line 155 of file PaneConnectivity.hpp.

References PaneConnectivity::getSharedNodeIndex(), and i.

                          {
 
                                 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 );
                                 }
 
                          }

Here is the call graph for this function:

void getRemotePaneIds ( std::vector< int > & rmtpanes )

inline

Returns the remote pane ids that are connected to this instance.

Parameters

rmtpanes vector where the remote pane ids will be stored.

Postcondition: rmtpanes.size( ) == this ->getNumberOfConnections( );; this ->hasPane( rmtpanes[ i ] ) == true, for 0 <= i <= rmtpances.size( ).

Definition at line 257 of file PaneConnectivity.hpp.

Referenced by maskPoints().

                          {
                                  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;
                          }

Here is the caller graph for this function:

void getRemotePaneIdsSharedWithPoint	(	const int	localPointId,
		std::vector< int > &	rmtpaneIds
	)

inline

This method returns the list of remote panes that share the point associated with the provided localPointId.

Parameters

localPointId	the local point id.
rmtpaneIds	the list of remote pane ids.

Precondition: this ->hasLocalPoint( locaPointId ) == true.

Definition at line 239 of file PaneConnectivity.hpp.

References copy, PaneConnectivity::hasLocalPoint(), and PaneConnectivity::point2remotePaneList.

                          {
                                         #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( ) );
                          }

Here is the call graph for this function:

int getSharedNodeIndex	(	const int	remotePane,
		const int	localPoint
	)

inlineprivate

Returns the index to the shared node list of the local point that is shared with the given remote pane.

Parameters

remotePane	the remote pane id.
localPoint	the local point id.

Returns: idx the index to the shared node list.

Precondition: this ->hasPane( remotePane ) == true.; this ->hasLocalPoint( localPoint ) == true.

Postcondition: this ->pconn[ remotePane ][ idx ] == localPoint.

Definition at line 35 of file PaneConnectivity.hpp.

References PaneConnectivity::hasLocalPoint(), PaneConnectivity::hasPane(), PaneConnectivity::pconn, and PaneConnectivity::rmtpanePointPair2Index.

Referenced by PaneConnectivity::getPointConnectionPairs().

                         {
 
                           #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;
                         }

Here is the call graph for this function:

Here is the caller graph for this function:

int getSharedPointIdAt	(	const int	paneId,
		const int	nodeIndex
	)

inline

This method returns the local shared point Id of the given pane at the given index.

Parameters

paneId	the pane id in query.
nodeIndex	the index of the point in query.

Returns: localID the local mesh point id of given pane.

Precondition: this ->hasPane( paneId ) == true.; nodeIndex >= 0 && nodeIndex < this ->pconn[ paneId ].size( ).

Postcondition: localID >= 0 && localID < N where N is the number of nodes in the mesh at the given pane.

Definition at line 276 of file PaneConnectivity.hpp.

References PaneConnectivity::hasPane(), and PaneConnectivity::pconn.

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

Here is the call graph for this function:

bool hasLocalPoint ( const int localPointId ) const

inline

This method checks if the local point exists in this instance.

Parameters

localPointId the local point id.

Returns: Status true if the local point exists, else false.

Precondition: localPointId >= 0.

Definition at line 221 of file PaneConnectivity.hpp.

References PaneConnectivity::point2remotePaneList.

Referenced by PaneConnectivity::getRemotePaneIdsSharedWithPoint(), and PaneConnectivity::getSharedNodeIndex().

                          {
                                         #ifdef ASSERT_ON
                                          assert( localPointId >= 0 );
                                         #endif
 
                                         if( this ->point2remotePaneList.find( localPointId ) != this ->point2remotePaneList.end( ) )
                                                 return true;
                                         else
                                                 return false;
                          }