buildface.cpp File Reference

#include <stdio.h>
#include "face.h"

Include dependency graph for buildface.cpp:

Go to the source code of this file.

Functions
blockLoc	dirToCorner (block *b, const blockLoc &dir)
void	swap (int &a, int &b)
patch *	findPatch (const blockSpan &at, const vector< patch * > &from)
void	findPartner (internalBCpatch *p)
bool	isSmaller (face *a, face *b)
void	buildFaces (vector< block * > &blocks, bool buildTypeTwo)

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:

blockLoc dirToCorner	(	block *	b,
		const blockLoc &	dir
	)

Definition at line 66 of file buildface.cpp.

References block::getDim(), and i.

Referenced by buildFaces().

{
        blockLoc ret(0,0,0);
        for (int i=0;i<3;i++)
                if (dir[i])
                        ret[i] = b->getDim()[i]-1;
        return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void findPartner

(

internalBCpatch *

p

)

Definition at line 100 of file buildface.cpp.

References d, internalBCpatch::dest, internalBCpatch::destSpan, findPatch(), block::getBlockNumber(), block::getFace(), face::getPatches(), block::nFaces, blockSpan::orient(), and internalBCpatch::setPartner().

Referenced by buildFaces().

{
        //First orient the start and end locations:
        blockSpan d=p->destSpan;
        d.orient();
        patch *partner=NULL;
        for (int f=0;partner==NULL && f<block::nFaces;f++)
                partner=findPatch(d,p->dest->getFace(f).getPatches());
        if (partner==NULL) {
                fprintf(stderr,"Couldn't find match for internal patch on block %d!\n",
                        p->dest->getBlockNumber()+1);
                abort();
        }
        p->setPartner((internalBCpatch *)partner);
}

Here is the call graph for this function:

Here is the caller graph for this function:

patch* findPatch	(	const blockSpan &	at,
		const vector< patch * > &	from
	)

Definition at line 90 of file buildface.cpp.

Referenced by findPartner().

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

Here is the caller graph for this function:

bool isSmaller	(	face *	a,
		face *	b
	)

Definition at line 117 of file buildface.cpp.

References face::getDim(), and blockDim::getSize().

Referenced by buildFaces().

                                {
        int a_area=a->getDim().getSize();
        int b_area=b->getDim().getSize();
        return a_area<=b_area;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void swap ( int &  a, int &  b  )

inline

Definition at line 88 of file buildface.cpp.

Referenced by Geo_Metric_Base_3::compute_angles(), FaceOffset_3::compute_eigenvectors(), Rocmop::compute_eigenvectors(), FloGridBlock::DestroyGrid(), RFC_Pane_overlay::determine_counterparts(), MesqPane::elements_get_attached_vertices(), RFC_Window_overlay::evaluate_normals(), if(), PatchData::initialize_data(), Roccom_base::load_module(), main(), Halfedge_data_structure_using_vector< V, H, F >::normalize_border(), Mesh::operator>>(), rational_rotation_approximation(), Rocmop::redistribute_vertices_ridge(), In_place_list_n< T, managed >::sort(), In_place_list_n< T, managed >::swap(), swap_endian(), MesqPane::vertices_get_attached_elements(), MeshImpl::vtk_read_unstructured_grid(), and MeshImpl::write_vtk().

{int tmp=a;a=b;b=tmp;}

Here is the caller graph for this function: