#include <cstring>
#include <cstdlib>
#include "adj.h"
#include "util.h"

Include dependency graph for makeflo.h:

This graph shows which files directly or indirectly include this file:

Classes
class	makefloParam

Macros
#define	MAKEFLO_VERSION "1.93"

Functions
void	checkQuality (const block &b)

const char *	readBoundaries (vector< block * > &blocks, const char *inMesh)

const char *	splitBlocks (vector< block * > &blocks, int nPieces)

void	buildFaces (vector< block * > &blocks, bool buildTypeTwo)

const char *	writeFlo (vector< block * > &blocks, int nPEs, const char inBcs, const char out)

const char *	writeTop (vector< block * > &blocks, const char inBcs, const char out)

const char *	writeMblock (vector< block * > &blocks, const char *outMblock)

const char *	writeBlocks (vector< block * > &blocks, const char *outMesh)

Variables
makefloParam	parameters

Macro Definition Documentation

#define MAKEFLO_VERSION "1.93"

Definition at line 65 of file makeflo.h.

Referenced by printUsage().

Function Documentation

void buildFaces	(	vector< block * > &	blocks,
		bool	buildTypeTwo
	)

Definition at line 123 of file buildface.cpp.

References buildFaces(), dirToCorner(), block::face2name, findPartner(), block::getBlockNumber(), patch::getFace(), block::getFace(), block::getLoc(), face::getPatches(), i, patch::isExternal(), adjList::isExternal(), isSmaller(), nodeMatcher::loc2node(), n, block::nFaces, internalBCpatch::partner, face::patchForCoord(), and internalBCpatch::type.

Referenced by buildFaces(), and main().

 {
         int f; unsigned int bNo;
         /* Build each block's faces, which matches up the nodes*/
         nodeMatcher map;
         for (bNo=0;bNo<blocks.size();bNo++)
                 blocks[bNo]->buildFaces(map);
 
         /* Build each face's patches, which aggregates matched nodes
            into rectangular patches.*/
         for (bNo=0;bNo<blocks.size();bNo++)
                 for (f=0;f<block::nFaces;f++)
                         blocks[bNo]->getFace(f).buildPatches();
 
         /*Match up facing internal patches*/
         for (bNo=0;bNo<blocks.size();bNo++)
                 for (f=0;f<block::nFaces;f++) {
                         const vector<patch *> &patches=
                             blocks[bNo]->getFace(f).getPatches();
                         for (unsigned int pNo=0;pNo<patches.size();pNo++) {
                                 patch *p=patches[pNo];
                                 if (p->isExternal()) continue;
                                 findPartner((internalBCpatch *)p);
                         }
                 }
 
         if (!buildTypeTwo) return;
         /*
         Determine which patches should be "type two"--
         patches whose neighbors get pulled around by 
         mesh motion, but don't move themselves.
         Such patches touch a corner node that faces the
         exterior; but none of them are exterior themselves.
         */
         const int nCorners=8;
         blockLoc cornDirs[nCorners]={
                 blockLoc(0,0,0),
                 blockLoc(0,0,1),
                 blockLoc(0,1,0),
                 blockLoc(0,1,1),
                 blockLoc(1,0,0),
                 blockLoc(1,0,1),
                 blockLoc(1,1,0),
                 blockLoc(1,1,1)
         };
         /*Loop over blocks*/
         for (bNo=0;bNo<blocks.size();bNo++) {
                 block *b=blocks[bNo];
                 /*Loop over corners*/
                 for (int cNo=0;cNo<nCorners;cNo++) {
                         blockLoc c=dirToCorner(b,cornDirs[cNo]);
                         /*Determine if this corner faces external world*/
                         node *n=map.loc2node(b->getLoc(c));
                         if (!n->isExternal())
                                 continue; /*Nothing to do*/
                         /*Corner faces outside-- check if any of our patches do:*/
                         bool hasExternalFace=false;
                         for (f=0;f<block::nFaces;f++) {
                                 patch *p=b->getFace(f).patchForCoord(c);
                                 if (p!=NULL && p->isExternal())
                                         hasExternalFace=true;
                         }
                         if (hasExternalFace)
                                 continue; /*Nothing to do*/
                         /*Corner is outside, but none of our faces are:
                         mark all patches as type 2.
                         */
                         printf("Corner %d of block %d is external> patches on ",
                                 cNo,b->getBlockNumber()+1);
                         for (f=0;f<block::nFaces;f++) {
                                 patch *p=b->getFace(f).patchForCoord(c);
                                 if (p!=NULL) {
                                         printf("%s ",block::face2name[f]);
                                         ((internalBCpatch *)p)->setType(2);
                                 }
                         }
                         printf("are all type 2\n");
                 }
         }
         /*Loop over patches, eliminating facing pairs of type 2 boundaries*/
         for (bNo=0;bNo<blocks.size();bNo++) {
                 block *b=blocks[bNo];
                 for (f=0;f<block::nFaces;f++) {
                         const vector<patch *> &patches=b->getFace(f).getPatches();
                         for (unsigned int pNo=0;pNo<patches.size();pNo++) {
                                 patch *p=patches[pNo];
                                 if (!p->isExternal()) {
                                         internalBCpatch *i=(internalBCpatch *)p;
                                         if (i->type==2 && i->partner->type==2)
                                         /*A facing pair of type 2's!*/ 
                                                 i->type=i->partner->type=1;
                                 }
                         }
                 }
         }
 
         /*Loop over patches one final time, adding type 2's to the 
           smaller face of each pair.*/
         for (bNo=0;bNo<blocks.size();bNo++) {
                 block *b=blocks[bNo];
                 for (f=0;f<block::nFaces;f++) {
                         const vector<patch *> &patches=b->getFace(f).getPatches();
                         for (unsigned int pNo=0;pNo<patches.size();pNo++) {
                                 patch *p=patches[pNo];
                                 if (!p->isExternal()) {
                                         internalBCpatch *i=(internalBCpatch *)p;
                                         if (i->type==1 && i->partner->type==1
                                                 && isSmaller(i->getFace(),i->partner->getFace()))
                                                 i->type=2;
                                 }
                         }
                 }
         }
           
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void checkQuality ( const block & b )

Definition at line 74 of file volume.cpp.

References CkSampleT< real, ret >::add(), BLOCKSPAN_FOR, vector3d::cross(), vector3d::dist(), block::getDim(), block::getLoc(), block::getOriginalNumber(), i, j, k, vector3d::max(), CkSampleT< real, ret >::printMinAveMax(), and volume().

Referenced by main().

 {
         int nBadVol=0, nBadFace=0;
         double minVolRatio=1.0;
         blockLoc aBadVol, aBadFace;
         CkSample edgeStats, volumeStats, volRatioStats, faceRatioStats;
         /* loop over all cells in the block */
         blockLoc cellCoor;
         blockSpan cells(blockLoc(0,0,0),b.getDim()-blockLoc(1,1,1));
 
         enum {nCorners=8,nEdges=12,nFaces=6};
         vector3d c[nCorners];
         int i,j,k,f,e;
 
         /* Check the quality of each cell */
         BLOCKSPAN_FOR(cellCoor,cells) {
 
                 // Copy out the locations of the cell corners
                 for (k=0;k<2;k++) for (j=0;j<2;j++) for (i=0;i<2;i++)
                         c[i+2*j+4*k]=b.getLoc(cellCoor+blockLoc(i,j,k));
 
         /* Find the minimum edge length for this cell.
                 FIXME: Rocflo's criterion depends on the minimum edge 
            length for *any* cell in the (partitioned) block.  This means
            our per-cell criterion is actually more stringent than Rocflo's.
          */
                 double minEdge=1.0e30;
                 
                 // Compute the length of the shortest edge
                 const static int edges[nEdges][2]={
                         {0,1}, {1,3}, {3,2}, {2,0},
                         {4,5}, {5,7}, {7,6}, {6,4},
                         {0,4}, {1,5}, {3,7}, {2,6}
                 };
                 for (e=0;e<nEdges;e++) {
                         double l=c[edges[e][0]].dist(c[edges[e][1]]);
                         if (l<minEdge) minEdge=l;
                         edgeStats.add(l);
                 }
 
                 // Compute the outward-pointing normals of the faces
                 const static int faces[nFaces][4]={
                         {0,4,6,2}, {1,3,7,5}, /* imin, imax */
                         {0,1,5,4}, {2,6,7,3}, /* jmin, jmax */
                         {0,2,3,1}, {4,5,7,6}  /* kmin, kmax */
                 };
                 vector3d normals[nFaces]; // area-scaled normal vector
                 vector3d center[nFaces]; // position of centroid
                 for (f=0;f<nFaces;f++) 
                 { // Area and normal come from face diagonals:
                         vector3d diagA=c[faces[f][2]]-c[faces[f][0]];
                         vector3d diagB=c[faces[f][3]]-c[faces[f][1]];
                         normals[f]=0.5*diagA.cross(diagB);
                         center[f]=0.25*(c[faces[f][0]]+c[faces[f][1]]+
                                         c[faces[f][2]]+c[faces[f][3]]);
                 }
                 
                 // Check face vector sum (closedness, smaller is better)
                 vector3d faceVecSum=
                          normals[0]+normals[1]+
                          normals[2]+normals[3]+
                          normals[4]+normals[5];
                 double faceRatio=faceVecSum.max()/(minEdge*minEdge);
                 if (faceRatio>0.1) { /* non-closed face */
                         nBadFace++;
                         aBadFace=cellCoor;
                 }
                 
                 // Compute volume of cell relative to smallest edge (fullness, bigger is better)
                 double volume=0.0;
                 for (f=0;f<nFaces;f++) 
                         volume+=(1.0/3.0)*normals[f].dot(center[f]);
                 
                 double volRatio=volume/(minEdge*minEdge*minEdge);
                 if (volRatio<0.1) { /* bad skinny cell */
                         nBadVol++;
                         if (volRatio<minVolRatio) {
                                 minVolRatio=volRatio;
                                 aBadVol=cellCoor;
                         }
                 }
                 
                 // Update statistics
                 faceRatioStats.add(faceRatio);
                 volumeStats.add(volume);
                 volRatioStats.add(volRatio);
         }
         
         printf("Original block %d mesh quality:\n",1+b.getOriginalNumber());
         printf("    cell volumes: "); volumeStats.printMinAveMax(stdout);
         printf("    edge lengths: "); edgeStats.printMinAveMax(stdout);
         printf("    volume ratio (fullness): "); volRatioStats.printMinAveMax(stdout);
         printf("    face ratio (skewness): "); faceRatioStats.printMinAveMax(stdout);
         
         if (nBadVol>0) {
                 printf("WARNING: detected %d bad-volume cells in original block %d: \n"
                         "     the worst of which is cell (%d,%d,%d), with ratio %.3f\n",
                    nBadVol, b.getOriginalNumber(),
                    1+aBadVol[0],1+aBadVol[1],1+aBadVol[2], minVolRatio);
         }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* readBoundaries	(	vector< block * > &	blocks,
		const char *	inMesh
	)

Definition at line 135 of file readinp.cpp.

References block::addBC(), checkSpan(), ERR, cimg_library::cimg::fopen(), block::getDim(), bcReader::read(), and bcReader::skipLine().

Referenced by main().

 {
         FILE *in=fopen(inMesh,"r");
         if (in==NULL) {
                 fprintf(stderr,"Cannot open boundary condition file '%s'.\n",inMesh);
                 fprintf(stderr,"Continuing without external boundary conditions\n");
                 return NULL;//Ignore missing BC file
         }
         bcReader r(in);
 
         //Check the file header:
         int solver;
         if (!r.read(&solver)) return ERR "Bad file header (line 1)";
         if (solver!=1) return ERR "Must use Gridgen generic solver";
         int nBlocks;
         if (!r.read(&nBlocks)) return ERR "Bad file header (line 2)";
         if (nBlocks!=(int)blocks.size()) return ERR "mesh's block count does not match";
         
         //Read each block
         for (int bn=0;bn<nBlocks;bn++) {
                 block *b=blocks[bn];
                 //Check the block size
                 blockDim dim;
                 if (!r.read(dim)) return ERR "Cannot read block size";
                 if (dim!=b->getDim()) return ERR "mesh's block size does not match";
                 //Skip over the block name line
                 r.skipLine();
                 r.skipLine();
 
                 //Get the patch count and loop over patches
                 int nPatch;
                 if (!r.read(&nPatch)) return ERR "Cannot read patch count";
                 for (int p=0;p<nPatch;p++) {
 
                         //Get the patch dimensions
                         blockSpan span;
                         if (!r.read(span)) return ERR "Cannot read patch dimensions";
                         //Get the patch type and handle patch
                         int type;
                         if (!r.read(&type)) return ERR "Cannot read patch type";
                         if (type>=0) 
                         {//External boundary condition--add to block
                                 b->addBC(span,type);
                                 char errBuf[200];
                                 sprintf(errBuf,"Bad boundary condition for block %d\n",1+bn);
                                 checkSpan(span,errBuf);
                         }
                         else
                         {//Internal boundary condition-- read and ignore
                                 blockSpan dest;
                                 if (!r.read(dest)) return ERR "Cannot read internal patch dimensions";
                                 int destBlock;
                                 if (!r.read(&destBlock)) return ERR "Cannot read destination block";
                                 destBlock--; //Make zero-based
                         }
                 }
         }
         return NULL;//Everything worked
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* splitBlocks	(	vector< block * > &	blocks,
		int	nPieces
	)

Definition at line 205 of file split.cpp.

References bRec::less(), parameters, makefloParam::splithalf, and volume().

Referenced by main().

 {
         if ((int)blocks.size()>=nPieces)
                 return NULL;//Already have enough blocks
 
 
 //We try to split so that the resulting blocks
 // have about the same volume-- distribute pieces
 // to blocks by volume
         unsigned int b,nBlocks=blocks.size();
         
         int *nSplit=new int[nBlocks];   
 
         if (parameters.splithalf == 1) {
                 // split every block in half
           for (b=0;b<nBlocks;b++) {
                 nSplit[b]=2;
           }
         }
         else {   // regular split
         //Create max-heap of blocks, ordered by output volume
         vector<bRec> heap(nBlocks);
         for (b=0;b<nBlocks;b++) {
                 heap[b]=bRec(b,volume(blocks[b]));
                 nSplit[b]=1;
         }
 
         std::make_heap(heap.begin(),heap.end(),bRec::less);
         
         //Allocate remaining output blocks to the most needy
         int nRemaining=nPieces-nBlocks;
         while (nRemaining-->0) {
                 std::pop_heap(heap.begin(),heap.end(),bRec::less);
                 bRec &r=heap[nBlocks-1];
                 r.n=++(nSplit[r.b]);
                 std::push_heap(heap.begin(),heap.end(),bRec::less);
         }
         }   // end of parameters.splithalf
         
         //Split the blocks
         vector<block *> split;//Accumulates split blocks
         for (b=0;b<nBlocks;b++) {
                 printf("Input block %d splits into %d pieces (%d-%d)\n",
                         b+1,nSplit[b],(int)(1+split.size()),(int)(1+split.size()+nSplit[b]-1));
                 blocks[b]->split(nSplit[b],split);
         }
         delete[] nSplit;
 
 //Check the load balance
         double maxVol=-1e100,minVol=1e100,sumVol=0;
         for (b=0;b<split.size();b++) {
                 double vol=volume(split[b]);
                 sumVol+=vol;
                 if (maxVol<vol) maxVol=vol;
                 if (minVol>vol) minVol=vol;
         }
         double avgVol=sumVol/split.size();
         printf("Static load balance results:\n"
                 "  %.2f blocks per processor, %.0f nodes per block\n"
                 "  Heaviest block is %.02f times the average\n"
                 "  Lightest block is %.02f times the average\n",
                 ((double)split.size())/nPieces,avgVol,
                 maxVol/avgVol,minVol/avgVol);
         
 //Return split blocks to caller
         blocks=split;
         return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* writeBlocks	(	vector< block * > &	blocks,
		const char *	outMesh
	)

Definition at line 147 of file write.cpp.

References endsWith(), FC_GLOBAL, i, incrementAscii(), write_fortran(), write_grda(), write_grdb(), write_hdf(), and write_msh().

Referenced by main().

 {
         char oName[1024];
         bool isFortran=false, isHDF=false;
         bool incrementFilenames=true;
         fn_fortran_write writeFn=NULL;
         strcpy(oName,outMesh);
         if (endsWith(outMesh,".msh"))
         { //Write .msh files:
                 isFortran=true;
                 writeFn=FC_GLOBAL(write_msh,WRITE_MSH);
         }
         else if (endsWith(outMesh,"1")||
                  endsWith(outMesh,".grda")||
                  endsWith(outMesh,".grdb")) 
         { //Probably a grda or grdb file:
                 isFortran=true;
                 incrementFilenames=false; //Same filename every time
                 char tmp[1024];
                 strcpy(tmp,outMesh);
                 //Clip off any trailing numbers:
                 int endIdx=strlen(tmp)-1;
                 while (endIdx>0&&(isdigit(tmp[endIdx])||(tmp[endIdx]=='_')))
                         tmp[endIdx--]=0;
                 if (endsWith(tmp,".grda"))
                   writeFn=FC_GLOBAL(write_grda,WRITE_GRDA);
                 else if (endsWith(tmp,".grdb")) 
                   writeFn=FC_GLOBAL(write_grdb,WRITE_GRDB);
                 else return "Unrecognized output mesh extension! (2)";
         }
 #ifdef USE_HDF
         else if (endsWith(outMesh,".hdf"))
         {
                 isHDF=true;
         }
 #endif
         else if (endsWith(outMesh,".null"))
                 {/*Just skip output*/}
         else
                 return "Unrecognized output mesh file extension! (1)";
                 
         
         for (unsigned int i=0;i<blocks.size();i++) {
                 const blockDim &dim=blocks[i]->getDim();
                 const vector3d *locs=&blocks[i]->getLoc(blockLoc(0,0,0));
 
                 if (isFortran)
                   if (i+1==blocks.size())
                   { /* Last time around, pass a negative block number
                        so fortran code can close its file. */
                     write_fortran(-(i+1),dim,locs,oName,writeFn);
                   } else {
                     write_fortran(  i+1 ,dim,locs,oName,writeFn);
                   }
                
 #ifdef USE_HDF
                 else if (isHDF)
                         write_hdf(dim,locs,oName);
 #endif
                 
                 printf("."); fflush(stdout);
                 if (incrementFilenames) {
                   if (!incrementAscii(oName)) 
                         return "Cannot increment output filename!  Use something like 'foo_0001.msh'\n";
                 }
         }
         printf("\n");
 
         return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* writeFlo	(	vector< block * > &	blocks,
		int	nPEs,
		const char *	inBcs,
		const char *	out
	)

Definition at line 230 of file writeflo.cpp.

References cimg_library::cimg::fclose(), cimg_library::cimg::fopen(), writeBlock(), and writeHeader().

Referenced by main().

 {
         FILE *bcs=fopen(inBcs,"r");
         if (bcs==NULL) {
                 char *ret=(char *)malloc(sizeof(char)*1000);
                 sprintf(ret,"Couldn't open input .bc file '%s'!\n",inBcs);
                 return ret;
         }
         bcList bc(bcs);
         fclose(bcs);
 
         FILE *flo=fopen(outFlo,"w");
         if (flo==NULL) return "Couldn't open output .flo file!\n";
 
         //Print the .flo file header
         int nBlocks=blocks.size();
         writeHeader(flo,nBlocks,nPEs);
   
         //Print out each block
         for (int bn=0;bn<nBlocks;bn++)
                 writeBlock(flo,bc,blocks[bn]);
         fclose(flo);
         return NULL; //Everything worked!
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* writeMblock	(	vector< block * > &	blocks,
		const char *	outMblock
	)

Definition at line 134 of file writemblock.cpp.

References d, cimg_library::cimg::fclose(), fName, cimg_library::cimg::fopen(), cimg_library::cimg::fwrite(), parameters, makefloParam::topologyOnly, and mblockData::write().

Referenced by main(), and mblockData::blockPatches::write().

 {
         mblockData d(blocks);
         for (unsigned int b=0;b<blocks.size();b++) {
                 char fName[1024];
 
                 //Write the boundary descriptions
                 sprintf(fName,"%s%05d.bblk",outMblock,b);
                 FILE *fb=fopen(fName,"w");
                 if (fb==NULL) return "Couldn't create .bblk file";
                 d.write(blocks[b],fb);
                 fclose(fb);
                 
                 //Write the mesh locations themselves
                 if (!parameters.topologyOnly) {
                         sprintf(fName,"%s%05d.mblk",outMblock,b);
                         FILE *fm=fopen(fName,"wb");
                         if (fm==NULL) return "Couldn't create .bblk file";
                         fwrite(&blocks[b]->getLoc(blockLoc(0,0,0)),sizeof(vector3d),
                                 blocks[b]->getDim().getSize(),fm);
                         fclose(fm);
                 }
         }
         return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* writeTop	(	vector< block * > &	blocks,
		const char *	inBcs,
		const char *	out
	)

Definition at line 252 of file writetop.cpp.

References cimg_library::cimg::fclose(), cimg_library::cimg::fopen(), and writeBlock().

Referenced by main().

 {
         FILE *bcs=fopen(inBcs,"r");
         if (bcs==NULL) {
                 char *ret=(char *)malloc(sizeof(char)*1000);
                 sprintf(ret,"Couldn't open input .bcmp file '%s'!\n",inBcs);
                 return ret;
         }
         bcListTop bc(bcs);
         fclose(bcs);
 
         FILE *top=fopen(outTop,"w");
         if (top==NULL) return "Couldn't open output .top file!\n";
 
         //Print the .top file header
         int nBlocks=blocks.size();
         fprintf(top,"# RocfloMP topology file, generated by makeflo\n"
                     "# \n"
                     "%d  ! Total number of blocks in this file\n",
                     nBlocks);
         
         //Print out each block
         for (int bn=0;bn<nBlocks;bn++)
                 writeBlock(top,bc,blocks[bn]);
         fclose(top);
         return NULL; //Everything worked!
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

makefloParam parameters

Definition at line 101 of file makeflo.cpp.

Referenced by checkSpan(), blockReader::consume(), face::face(), block::split(), splitBlocks(), writeBlock(), and writeMblock().

Classes

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation