#include <face.h>

Collaboration diagram for face:

Public Member Functions
	face (block *source_, nodeMatcher &map, vector< externalBCpatch > &extBCs_, int dir_x_, int dir_y_, const blockSpan &span_)

void	buildPatches (void)

node *	nodeForCoord (const blockLoc &at)

patch *	patchForCoord (const blockLoc &at)

	~face ()

block *	getBlock (void) const

blockDim	getDim (void) const

const vector< patch * > &	getPatches (void) const

Private Member Functions
void	fillNeighbors (int x, int y, const node **nbor) const

bool	nodesMatch (int x, int y, const face *dest, const facetOrientation &o) const

int	loc2nodeX (const blockLoc &l) const

int	loc2nodeY (const blockLoc &l) const

int	loc2node (const blockLoc &l) const

blockLoc	getSourceLoc (int x, int y) const

int	markPatched (facet *b, const blockSpan &span)

Private Attributes
block *	source

vector< externalBCpatch >	extBCs

vector< patch * >	patches

int	dir_x

int	dir_y

blockSpan	span

node **	nodes

int	nx

int	ny

Detailed Description

Definition at line 90 of file face.h.

Constructor & Destructor Documentation

face	(	block *	source_,
		nodeMatcher &	map,
		vector< externalBCpatch > &	extBCs_,
		int	dir_x_,
		int	dir_y_,
		const blockSpan &	span_
	)

Definition at line 131 of file face.cpp.

References adjList::addFace(), BLOCKSPAN_FOR, dir_x, dir_y, blockSpan::end, findOther(), adjList::getLength(), block::getLoc(), block::getOriginalNumber(), i, loc2node(), nodeMatcher::loc2node(), nodes, nx, ny, parameters, adjList::print(), makefloParam::skipAxis, source, span, and blockSpan::start.

         :source(source_), extBCs(extBCs_), dir_x(dir_x_), dir_y(dir_y_), 
         span(span_)
 {
         nx=span.end[dir_x]-span.start[dir_x];
         ny=span.end[dir_y]-span.start[dir_y];
         if (findOther(dir_x,dir_y)==parameters.skipAxis) 
         { //Don't bother about this face-- it's the Z face of a 2D problem
                 nodes=NULL;
                 return;
         }
         nodes=new node*[nx*ny];
         blockLoc i;
         BLOCKSPAN_FOR(i,span) {
                 vector3d nodeLoc=source->getLoc(i);
                 node *nu=map.loc2node(nodeLoc);
                 nu->addFace(this,i);
 
                 if (nu->getLength()>(3*8)) {
                         fprintf(stderr,"WARNING: multiply shared node %p: (%d,%d,%d) for block %d:",
                                 nu,i[0],i[1],i[2],source->getOriginalNumber()+1);
                         nu->print();
                 }
                 nodes[loc2node(i)]=nu;
         }
 }

Here is the call graph for this function:

~face ( )

Definition at line 160 of file face.cpp.

References i, nodes, and patches.

             {
         delete[] nodes;
         for (unsigned int i=0;i<patches.size();i++)
                 delete patches[i];
 }

Member Function Documentation

void buildPatches ( void )

Definition at line 227 of file face.cpp.

References by, blockSpan::end, extBCs, block::face2name, fillNeighbors(), getBlock(), block::getBlockNumber(), facetOrientation::getDestLoc(), block::getDim(), facet::getFace(), block::getFaceNo(), block::getOriginalNumber(), getSourceLoc(), orient_t::inverse(), isDisjoint(), markPatched(), matchOrientations(), nodes, nodesMatch(), nx, ny, orient_t::orient, patches, patch::setFace(), source, patch::srcSpan, blockSpan::start, x, and y.

 {
 #if 0
         //Doublecheck that our nodes agree with our location
         for (int y=0;y<ny;y++)
         for (int x=0;x<nx;x++) {
                 if (!nodes[(x  )+nx*(y  )]->hasLoc(this,getSourceLoc(x,y)))
                 {
                         fprintf(stderr,"ERROR! Face/node location disagreement!\n");
                         abort();
                 }
         }
 #endif  
         if (nodes==NULL) return; //Disabled face
 
         //Build an array showing the connected face
         // for each *element's* face-- or "facet"
         int x,y; //Loop indices
         int bx=nx-1,by=ny-1; //Size of facet array
         facet *b=new facet[bx*by];//2D facet array (bx x by)
         for (y=0;y<by;y++)
         for (x=0;x<bx;x++) {
                 const node *nbor[4];
                 fillNeighbors(x,y,nbor);
                 b[x+bx*y]=facet(nbor,this);
         }
 
         //Keep track of the number of facets patched so far
         int nFacets=bx*by;
         int nPatched=0;
 
         //Apply the existant internal boundary conditions
         for (unsigned int ep=0;ep<patches.size();ep++) {
                 nPatched+=markPatched(b,patches[ep]->srcSpan);
         }
 
         //Apply the external boundary conditions
         for (unsigned int ec=0;ec<extBCs.size();ec++) {
                 const externalBCpatch &ep=extBCs[ec];
                 patch *p=new externalBCpatch(ep);
                 p->setFace(this);
                 patches.push_back(p);
                 nPatched+=markPatched(b,ep.srcSpan);
         }
         
         //Extract each patch from the facet array
         int itCount=0;//Runaway loop leash
         while (nPatched<nFacets) {
                 int startX=-1, startY=-1;
                 //Find the first facet not yet patched
                 for (y=0;y<by && startY==-1;y++)
                 for (x=0;x<bx && startX==-1;x++)
                   if (!b[x+bx*y].isPatched()) { 
                     startX=x;
                     startY=y;
                   }
                 //This facet touches the face "dest"
                 const facet &destFacet=b[startX+bx*startY];
                 face *dest=destFacet.getFace();
                 const node *nbor[4];
                 fillNeighbors(startX,startY,nbor);
                 facetOrientation o(nbor,this,startX,startY);
                 
                 //Extend the patch as far right as it will go
                 x=startX;
                 y=startY;
                 while (x<bx && b[x+bx*y].matches(destFacet) &&
                         nodesMatch(x,y,dest,o))
                                 x++;
                 int endX=x;
                 if (startX==endX) {
                         blockLoc badLoc=getSourceLoc(startX,startY);
                         blockLoc sz=source->getDim();
                         fprintf(stderr,"ERROR! Face of block %d is non-conformal at node (%d,%d,%d) of (%d,%d,%d)\n",1+source->getOriginalNumber(),badLoc[0],badLoc[1],badLoc[2],sz[0],sz[1],sz[2]);
                         abort();
                 }
                 //Extend the patch as far down as it will go,
                 // marking those facets as patched (face=NULL)
                 for (y=startY;y<by;y++) {
                         bool rowValid=true;
                         for (x=startX;x<endX;x++)
                                 if (!(b[x+bx*y].matches(destFacet) &&
                                       nodesMatch(x,y,dest,o)))
                                         rowValid=false;
                         if (!rowValid) 
                                 break;//Another block encountered
                         //If we get this far, the row is valid-- mark it
                         for (x=startX;x<endX;x++)
                                 b[x+bx*y].markPatched();
                         nPatched+=endX-startX;
                 }
                 int endY=y;
                 
 
                 //Build and return a patch structure
                 patch *p=NULL;
                 blockSpan srcSpan(getSourceLoc(startX,startY),
                                   getSourceLoc(endX,endY)+blockLoc(1,1,1)
                                 );
 
 #if 1           //Make sure new patch is disjoint from all old patches
                 for (unsigned int otherP=0;otherP<patches.size();otherP++)
                         if (!isDisjoint(srcSpan,patches[otherP]->srcSpan)) {
                                 fprintf(stderr,"ERROR! Patches not disjoint!\n");
                                 abort();
                         }
 #endif
 
                 if (dest==NULL)
                 {  //An (unexpected) external boundary condition
                         int bcNo=0;//Default boundary condition number
                         p=new externalBCpatch(this,source,srcSpan,bcNo);
                         /* Warn user that we've fabricated a BC */
                         printf("Makeflo WARNING: Missing boundary condition (using zero) for original block %d,\n"
                                "    split block %d, %s face, cells (%d,%d,%d) - (%d,%d,%d)\n",
                                1+source->getOriginalNumber(),
                                1+source->getBlockNumber(),block::face2name[source->getFaceNo(this)],
                                1+srcSpan.start[0],1+srcSpan.start[1],1+srcSpan.start[2], 
                                srcSpan.end[0],srcSpan.end[1],srcSpan.end[2]);
                 }
                 else 
                 { //An internal boundary-- find other block's location
                         //Match up the orientations
                         orient_t src2dest;
                         matchOrientations(src2dest,
                                 getSourceLoc(1,0)-getSourceLoc(0,0),
                                 getSourceLoc(0,1)-getSourceLoc(0,0),
                                 o.getDestLoc(1,0)-o.getDestLoc(0,0),
                                 o.getDestLoc(0,1)-o.getDestLoc(0,0)
                         );
                         blockSpan destSpan(
                                   o.getDestLoc(startX,startY),
                                   o.getDestLoc(endX,endY)+blockLoc(1,1,1)
                                 );
                         p=new internalBCpatch(
                                 this,source,dest->getBlock(),
                                 srcSpan,destSpan,
                                 src2dest);
                         orient_t dest2src=src2dest.inverse();
                         destSpan.orient(srcSpan,dest2src);
                         dest->patches.push_back(new internalBCpatch(
                                 dest,dest->getBlock(),source,
                                 destSpan,srcSpan,
                                 dest2src
                         ));
                 }
                 //Return the new patch
                 patches.push_back(p);
 
                 if (itCount++>2000) 
                 { //There can't be 2000 actual patches-- must be an error
                         fprintf(stderr,"ERROR! Runaway patching loop (%s:%d)!\n",
                                 __FILE__,__LINE__);
                         abort();
                 }
         }
         
         //Free the temporary block array
         delete[] b;
 }

Here is the call graph for this function:

void fillNeighbors	(	int	x,
		int	y,
		const node **	nbor
	)		const

inlineprivate

Definition at line 100 of file face.h.

References nodes, nx, and x.

Referenced by buildPatches().

                                                                 {
           nbor[0]=nodes[(x  )+nx*(y  )];
           nbor[1]=nodes[(x+1)+nx*(y  )];
           nbor[2]=nodes[(x  )+nx*(y+1)];
           nbor[3]=nodes[(x+1)+nx*(y+1)];
         }

Here is the caller graph for this function:

block* getBlock ( void ) const

inline

Definition at line 140 of file face.h.

References source.

Referenced by buildPatches(), and adjRec::print().

140 {return source;}

face::source

block * source

Definition: face.h:91

Here is the caller graph for this function:

blockDim getDim ( void ) const

inline

Definition at line 141 of file face.h.

References blockSpan::end, span, and blockSpan::start.

Referenced by isSmaller().

141 {return span.end-span.start;}

blockSpan::start

blockLoc start

Definition: gridutil.h:155

blockSpan::end

blockLoc end

Definition: gridutil.h:156

face::span

blockSpan span

Definition: face.h:96

Here is the caller graph for this function:

const vector<patch *>& getPatches ( void ) const

inline

Definition at line 145 of file face.h.

References patches.

Referenced by buildFaces(), findPartner(), mblockData::blockPatches::init(), and writeBlock().

145 {return patches;}

face::patches

vector< patch * > patches

Definition: face.h:93

Here is the caller graph for this function:

blockLoc getSourceLoc	(	int	x,
		int	y
	)		const

inlineprivate

Definition at line 121 of file face.h.

References dir_x, dir_y, span, blockSpan::start, x, and y.

Referenced by buildPatches().

         {
           blockLoc ret=span.start;
           ret[dir_x]+=x;
           ret[dir_y]+=y;
           return ret;
         }

Here is the caller graph for this function:

int loc2node ( const blockLoc & l ) const

inlineprivate

Definition at line 117 of file face.h.

References loc2nodeX(), loc2nodeY(), and nx.

Referenced by face(), and nodeForCoord().

118 {return loc2nodeX(l)+nx*loc2nodeY(l);}

face::loc2nodeX

int loc2nodeX(const blockLoc &l) const

Definition: face.h:113

face::nx

int nx

Definition: face.h:98

face::loc2nodeY

int loc2nodeY(const blockLoc &l) const

Definition: face.h:115

Here is the call graph for this function:

Here is the caller graph for this function:

int loc2nodeX ( const blockLoc & l ) const

inlineprivate

Definition at line 113 of file face.h.

References dir_x, span, and blockSpan::start.

Referenced by loc2node().

114 {return l[dir_x]-span.start[dir_x];}

blockSpan::start

blockLoc start

Definition: gridutil.h:155

face::dir_x

int dir_x

Definition: face.h:95

face::span

blockSpan span

Definition: face.h:96

Here is the caller graph for this function:

int loc2nodeY ( const blockLoc & l ) const

inlineprivate

Definition at line 115 of file face.h.

References dir_y, span, and blockSpan::start.

Referenced by loc2node().

116 {return l[dir_y]-span.start[dir_y];}

blockSpan::start

blockLoc start

Definition: gridutil.h:155

face::span

blockSpan span

Definition: face.h:96

face::dir_y

int dir_y

Definition: face.h:95

Here is the caller graph for this function:

int markPatched	(	facet *	b,
		const blockSpan &	span
	)

private

Definition at line 197 of file face.cpp.

References dir_x, dir_y, blockSpan::end, block::getBlockNumber(), facet::markPatched(), nx, s, source, blockSpan::start, x, and y.

Referenced by buildPatches().

 {
         int ret=0;
         int bx=nx-1; /* ,by=ny-1; */ //Size of facet array
         const blockLoc &s=span.start, &e=span.end;
         //Mark all those facets as patched
         for (int y=s[dir_y];y<e[dir_y]-1;y++)
         for (int x=s[dir_x];x<e[dir_x]-1;x++) {
                 if (b[x+bx*y].isPatched()) {
                         fprintf(stderr,"FATAL ERROR patching block %d> external boundary conditions overlap!\n",
                                 source->getBlockNumber()+1);
                         exit(1);
                 }
                 b[x+bx*y].markPatched();
                 ret++;
         }
         return ret;     
 }

Here is the call graph for this function:

Here is the caller graph for this function:

node * nodeForCoord ( const blockLoc & at )

Definition at line 113 of file face.cpp.

References dir_x, dir_y, findOther(), loc2node(), nodes, span, and blockSpan::start.

 {
         int dir_z=findOther(dir_x,dir_y);
         if (at[dir_z]!=span.start[dir_z]) return NULL; //Wrong z-plane
         else return nodes[loc2node(at)];        
 }

Here is the call graph for this function:

bool nodesMatch	(	int	x,
		int	y,
		const face *	dest,
		const facetOrientation &	o
	)		const

private

Definition at line 217 of file face.cpp.

References facetOrientation::getDestLoc(), adjList::hasLoc(), nodes, nx, and x.

Referenced by buildPatches().

 {
         if (dest==NULL) return true;
         return nodes[(x  )+nx*(y  )]->hasLoc(dest,o.getDestLoc(x  ,y  ))
             && nodes[(x+1)+nx*(y+1)]->hasLoc(dest,o.getDestLoc(x+1,y+1));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

patch * patchForCoord ( const blockLoc & at )

Definition at line 120 of file face.cpp.

References i, and patches.

Referenced by buildFaces(), and adjList::isExternal().

 {
         int i,len=patches.size();
         for (i=0;i<len;i++)
                 if (patches[i]->srcSpan.contains(at))
                         return patches[i];
         return NULL;
 }