#include <adj.h>

Inheritance diagram for node:

Collaboration diagram for node:

Public Member Functions
void *	operator new (size_t s)

void	operator delete (void *ptr)

	node (const vector3d &l)

const vector3d &	getLoc (void) const

const blockLoc &	getLoc (const face *b) const

Public Member Functions inherited from adjList
	adjList ()

	~adjList ()

int	getLength (void) const

bool	hasFace (const face *test) const

bool	hasLoc (const face *test, const blockLoc &l) const

void	addFace (face *b, const blockLoc &l)

const blockLoc &	getLoc (const face *b) const

bool	isExternal (void) const

void	print (void) const

Static Public Member Functions
static face *	intersect (const node *nodes, const face notHim=NULL, blockLoc loc=NULL, blockLoc oX=NULL, blockLoc *oY=NULL)

Static Public Attributes
static allocPool< node >	pool

Private Attributes
const vector3d &	loc

Additional Inherited Members
Protected Attributes inherited from adjList
adjRec *	next

Detailed Description

Definition at line 150 of file adj.h.

Constructor & Destructor Documentation

node ( const vector3d & l )

inline

Definition at line 157 of file adj.h.

157 :loc(l) { }

node::loc

const vector3d & loc

Definition: adj.h:151

Member Function Documentation

const vector3d& getLoc ( void ) const

inline

Definition at line 160 of file adj.h.

References loc.

160 { return loc; }

node::loc

const vector3d & loc

Definition: adj.h:151

const blockLoc& getLoc ( const face * b ) const

inline

Definition at line 163 of file adj.h.

References adjList::getLoc().

163 { return adjList::getLoc(b); }

adjList::getLoc

const blockLoc & getLoc(const face *b) const

Definition: adj.cpp:111

Here is the call graph for this function:

face * intersect	(	const node **	nodes,
		const face *	notHim = `NULL`,
		blockLoc *	loc = `NULL`,
		blockLoc *	oX = `NULL`,
		blockLoc *	oY = `NULL`
	)

static

Definition at line 136 of file adj.cpp.

References adjRec::getNext(), adjList::next, nHops(), and test().

Referenced by facet::facet(), and facetOrientation::facetOrientation().

 {
 /*Nodes in "n" array should be laid out like:
     [0]  [1]
     [2]  [3]
 */
         const int nNodes=4; 
         const int expectedHops[nNodes]={0,1,1,2};
         int l;
 
         //Check each entry in list 0,
         // and return the first that is present everywhere.
         for (adjRec *test=n[0]->next;test!=NULL;test=test->getNext()) {
                 face *tFace=test->getFace();
                 
                 //Check if it's the "bad" face
                 if (tFace==notHim) continue;
                 
                 //Check if it's in every list at some orientation
                 blockLoc orientX,orientY;
                 const blockLoc &tLoc=test->getLoc();
                 bool isPresent=true;
                 for (l=1;l<nNodes && isPresent;l++)
                 { //Check this list for the location
                         bool inList=false;
                         for (adjRec *c=n[l]->next;c!=NULL;c=c->getNext()) {
                                 if (c->getFace()!=tFace) 
                                         continue;//Keep looking
                                 blockLoc dir=c->getLoc()-tLoc;
                                 //Make sure it's the proper number of hops to this location:
                                 if (nHops(dir)==expectedHops[l]) {
                                         inList=true;
                                         if (l==1) orientX=dir; //X axis
                                         if (l==2) orientY=dir; //Y axis
                                 }
                         }
                         if (!inList) isPresent=false;
                 }
                 
                 //This location is in every list-- return it
                 if (isPresent) {
                         if (retLoc!=NULL) *retLoc=tLoc;
                         if (oX!=NULL) *oX=orientX;
                         if (oY!=NULL) *oY=orientY;
                         return tFace;
                 }
         }
         //If we get here, the intersection is empty--
         // must be a boundary node
         return NULL;
 }