#include <patch.h>

Inheritance diagram for internalBCpatch:

Collaboration diagram for internalBCpatch:

Public Member Functions
void	setPartner (internalBCpatch *p)

void	setType (int to)

virtual void	writeFlo (FILE *out, const bcList &bc)

virtual void	writeMblock (FILE *out, mblockData &d)

virtual void	writeTop (FILE *out, const bcListTop &d)

	internalBCpatch (face f_, block src_, block *dest_, const blockSpan &srcSpan_, const blockSpan &destSpan_, const orient_t &orient_)

Public Member Functions inherited from patch
void	setFace (face *f_)

face *	getFace (void) const

virtual bool	isExternal (void) const

	patch ()

virtual	~patch ()

Public Attributes
block *	dest

blockSpan	destSpan

internalBCpatch *	partner

int	type

orient_t	orient

Public Attributes inherited from patch
block *	src

blockSpan	srcSpan

Additional Inherited Members
Protected Member Functions inherited from patch
	patch (face f_, block src_, const blockSpan &srcSpan_)

Detailed Description

Definition at line 119 of file patch.h.

Constructor & Destructor Documentation

internalBCpatch	(	face *	f_,
		block *	src_,
		block *	dest_,
		const blockSpan &	srcSpan_,
		const blockSpan &	destSpan_,
		const orient_t &	orient_
	)

inline

Definition at line 134 of file patch.h.

           : patch(f_,src_,srcSpan_), 
             dest(dest_),destSpan(destSpan_),
             partner(0),type(1),orient(orient_) { }

Member Function Documentation

void setPartner ( internalBCpatch * p )

inline

Definition at line 125 of file patch.h.

References partner.

Referenced by findPartner().

125 {partner=p;}

internalBCpatch::partner

internalBCpatch * partner

Definition: patch.h:124

Here is the caller graph for this function:

void setType ( int to )

inline

Definition at line 127 of file patch.h.

References type.

127 {type=to;}

internalBCpatch::type

int type

Definition: patch.h:126

void writeFlo	(	FILE *	out,
		const bcList &	bc
	)

virtual

Implements patch.

Definition at line 178 of file writeflo.cpp.

References dest, destSpan, block::getBlockNumber(), getSpan(), orient, patch::src, patch::srcSpan, and type.

 {
         string srcS=getSpan(srcSpan);
         string destS=getSpan(destSpan);
         int destBlockNo=dest->getBlockNumber()+1;
         const char *selfFlag="";
         if (destBlockNo==src->getBlockNumber()+1) {
                 destBlockNo=0;//Self-connecting block
                 selfFlag="(self-connecting)";
         }
         fprintf(out,"%d      %s    ! Internal boundary %s%s\n",
                 type,srcS.c_str(),(type==2)?"(TYPE TWO)":"",selfFlag);
         fprintf(out,"%-5d  %s\n",
                 destBlockNo,destS.c_str());
         fprintf(out,"%d %d %d           ! Orientation\n",
                 1+orient[0],1+orient[1],1+orient[2]);
 }

Here is the call graph for this function:

void writeMblock	(	FILE *	out,
		mblockData &	d
	)

virtual

Implements patch.

Definition at line 200 of file writemblock.cpp.

References mblockData::getPatchNumber(), and printSpan().

 { 
         fprintf(out,"-1 ");
         printSpan(out,srcSpan);
         fprintf(out,"           %d  %d   ",dest->getBlockNumber(),
                 d.getPatchNumber(dest,partner));
         //Figure out the orientation of each axis
         for (int srcAxis=0;srcAxis<3;srcAxis++) {
                 int destAxis=orient[srcAxis];
                 int isFlipped=0; //Is this axis orientation-reversed?
                 if (destSpan.end[destAxis]<destSpan.start[destAxis])
                         isFlipped=1;
                 fprintf(out,"%c%d ",isFlipped?'-':'+',destAxis+1);
         }
         fprintf(out,"\n");
 }

Here is the call graph for this function:

void writeTop	(	FILE *	out,
		const bcListTop &	d
	)

virtual

Implements patch.

Definition at line 204 of file writetop.cpp.

References dest, destSpan, block::getBlockNumber(), blockSpan::getFace(), orient, patch::srcSpan, writePatchEnd(), writePatchMiddle(), writePatchStart(), and writeSpan().

 {
         //Compute where the orientation-indicating minus signs should go:
         int flatAxis=(srcSpan.getFace()%3);
         int l1Axis=(flatAxis+1)%3;
         blockLoc srcSign(1,1,1), destSign(1,1,1);
         srcSign[flatAxis]=0; //Shouldn't ever print flat axis
         destSign[orient[flatAxis]]=0; 
         srcSign[l1Axis]=-1; //Flip sign on l1 axis
         destSign[orient[l1Axis]]=-1;
 
         const int internalBcType=30;
         writePatchStart(out,internalBcType);
         writeSpan(out,srcSpan,srcSign);
         writePatchMiddle(out,1+dest->getBlockNumber());
         writeSpan(out,destSpan,destSign);
         writePatchEnd(out,0); //Internal patches are never coupled
 }