#include <MeshAssembler.h>

Public Types
typedef shared_ptr< Array < double > >	ArrayDblePtr

typedef shared_ptr< Array< int > >	ArrayIntPtr

typedef map< int, ArrayIntPtr >	ArrayIntPtrMap

typedef shared_ptr< StorageSite >	StorageSitePtr

typedef shared_ptr < CRConnectivity >	CRConnectivityPtr

typedef shared_ptr< Array < Mesh::VecD3 > >	ArrayVecD3Ptr

typedef vector< map< int, set < int > > >	VecMap

Public Member Functions
	MeshAssembler (const MeshList &meshList)

	~MeshAssembler ()

const MeshList &	meshList () const

void	debug_print ()

void	debug_sites ()

void	debug_localToGlobal_mappers ()

void	debug_globalCellToMeshID_mappers ()

void	debug_sync_localToGlobal_mappers ()

void	debug_faceCells ()

void	debug_localNodeToGlobal ()

Private Member Functions
	MeshAssembler (const MeshAssembler &)

void	init ()

void	setCellsSite ()

void	setFacesSite ()

void	setInterfaceNodes ()

void	setNodesSite ()

void	setCellsMapper ()

void	setNodesMapper ()

void	setBoundaryFaceGroup ()

void	setCoord ()

void	setSites ()

void	setMeshCellColor ()

void	setFaceCells ()

void	setFaceNodes ()

void	setMesh ()

void	countInterfaceNodes ()

int	getInnerNodesCount ()

int	getInterfaceNodesDuplicatedCount ()

int	getInterfaceNodesCount ()

void	debug_file_open (const string &fname)

void	debug_file_close ()

Private Attributes
const MeshList	_meshList

StorageSitePtr	_cellSite

StorageSitePtr	_faceSite

StorageSitePtr	_nodeSite

VecMap	_interfaceNodesSet

map< int, ArrayIntPtr >	_localCellToGlobal

vector< int >	_globalCellToMeshID

vector< int >	_globalCellToLocal

vector< map< int, int > >	_localInterfaceNodesToGlobalMap

map< int, ArrayIntPtr >	_localNodeToGlobal

set< Mesh::VecD3 >	_interfaceNodeCoord

CRConnectivityPtr	_faceCells

CRConnectivityPtr	_faceNodes

ArrayVecD3Ptr	_coord

ofstream	_debugFile

int	_nInterfaceNodes

int	_interiorFaceSize

MeshList	_mesh

Detailed Description

Definition at line 15 of file MeshAssembler.h.

Member Typedef Documentation

typedef shared_ptr< Array<double> > MeshAssembler::ArrayDblePtr

Definition at line 19 of file MeshAssembler.h.

typedef shared_ptr< Array<int> > MeshAssembler::ArrayIntPtr

Definition at line 20 of file MeshAssembler.h.

typedef map<int,ArrayIntPtr> MeshAssembler::ArrayIntPtrMap

Definition at line 21 of file MeshAssembler.h.

typedef shared_ptr< Array<Mesh::VecD3> > MeshAssembler::ArrayVecD3Ptr

Definition at line 25 of file MeshAssembler.h.

typedef shared_ptr< CRConnectivity > MeshAssembler::CRConnectivityPtr

Definition at line 23 of file MeshAssembler.h.

typedef shared_ptr< StorageSite > MeshAssembler::StorageSitePtr

Definition at line 22 of file MeshAssembler.h.

typedef vector< map<int, set<int> > > MeshAssembler::VecMap

Definition at line 26 of file MeshAssembler.h.

Constructor & Destructor Documentation

MeshAssembler::MeshAssembler ( const MeshList & meshList )

Definition at line 15 of file MeshAssembler.cpp.

References init().

                                                          :_meshList( meshList )
 {
 
     init();
 }

MeshAssembler::~MeshAssembler ( )

Definition at line 21 of file MeshAssembler.cpp.

References _mesh.

 {
    vector< Mesh* >::iterator it_mesh;
    for ( it_mesh = _mesh.begin(); it_mesh != _mesh.end(); it_mesh++)
         delete *it_mesh;
 }

MeshAssembler::MeshAssembler ( const MeshAssembler & )

private

Member Function Documentation

void MeshAssembler::countInterfaceNodes ( )

private

Definition at line 135 of file MeshAssembler.cpp.

References _meshList, Mesh::getCellFaces(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getFaces(), StorageSite::getGatherMap(), Array< T >::getLength(), and StorageSite::getScatterMap().

 {
    
   for ( unsigned int n = 0; n < _meshList.size(); n++ ){
      const Mesh& mesh = *(_meshList.at(n));
      const StorageSite& faceSite = mesh.getFaces();
      const CRConnectivity& cellFaces = mesh.getCellFaces();
      for ( int i = 0; i < faceSite.getCount(); i++ ){
          cout << " cellFaces[" << i << " ] = ";
          for ( int j = 0; j < cellFaces.getCount(i); j++ )
              cout << "  " << cellFaces(i,j);
          cout << endl;
      }
   }
   //writing mapping
   for ( unsigned int i = 0; i < _meshList.size(); i++ ){
        const StorageSite& thisSite = _meshList[i]->getCells();
        const StorageSite::ScatterMap& scatterMap = thisSite.getScatterMap();
        foreach(const StorageSite::ScatterMap::value_type& mpos, scatterMap){
           const StorageSite& oSite    = *(mpos.first);
           const Array<int>& fromIndices = *(mpos.second);
           const Array<int>& toIndices   = *(oSite.getGatherMap().find(&thisSite)->second);
           cout << " fromIndices.getLength() = " << fromIndices.getLength() << endl;
           cout << " scatterArray " << endl;
           for ( int n  = 0; n < fromIndices.getLength(); n++){
              cout << "      fromIndices[" << n << "] = " << fromIndices[n] << "      toIndices[" << n << "] = " << toIndices[n] << endl;
           }
        }
    }
 
 }

void MeshAssembler::debug_faceCells ( )

Definition at line 772 of file MeshAssembler.cpp.

References _debugFile, _faceCells, _faceSite, debug_file_close(), and debug_file_open().

Referenced by debug_print().

 {
   debug_file_open("faceCells");
   //faceCells
   _debugFile << " faceCells Connectivity " << endl;
   for ( int i = 0; i < _faceSite->getCount(); i++ ) { 
       int ncells = _faceCells->getCount(i);
       for ( int j = 0; j < ncells; j++ ){
          _debugFile << " faceCells(" << i << "," << j << ") = " << (*_faceCells)(i,j);
       }
       _debugFile << endl;
   }
   debug_file_close();
 }

void MeshAssembler::debug_file_close ( )

private

Definition at line 824 of file MeshAssembler.cpp.

References _debugFile.

Referenced by debug_faceCells(), debug_globalCellToMeshID_mappers(), debug_localNodeToGlobal(), debug_localToGlobal_mappers(), debug_sites(), and debug_sync_localToGlobal_mappers().

 {
     _debugFile.close();
 }

void MeshAssembler::debug_file_open ( const string & fname )

private

Definition at line 817 of file MeshAssembler.cpp.

References _debugFile.

Referenced by debug_faceCells(), debug_globalCellToMeshID_mappers(), debug_localNodeToGlobal(), debug_localToGlobal_mappers(), debug_sites(), and debug_sync_localToGlobal_mappers().

 {  
      string  fname = "MESHASSEMBLER_"+fname_+".dat";
     _debugFile.open( fname.c_str() );
 }

void MeshAssembler::debug_globalCellToMeshID_mappers ( )

Definition at line 738 of file MeshAssembler.cpp.

References _debugFile, _globalCellToLocal, _globalCellToMeshID, debug_file_close(), and debug_file_open().

Referenced by debug_print().

 {
    debug_file_open("globalCellToMeshID");
    //globalCellToMeshID
    for (  unsigned int i = 0; i < _globalCellToMeshID.size(); i++ )
       _debugFile  << " globalCellToMeshID[" << i << "] = " << _globalCellToMeshID[i] << endl;
   
    _debugFile << endl;
    //globalCellToLocal
    for ( unsigned int i = 0; i < _globalCellToLocal.size(); i++ )
       _debugFile  << " globalCellToLocal[" << i << "] = " << _globalCellToLocal[i] << endl;
     
    debug_file_close();
 }

void MeshAssembler::debug_localNodeToGlobal ( )

Definition at line 788 of file MeshAssembler.cpp.

References _debugFile, _localNodeToGlobal, _meshList, debug_file_close(), debug_file_open(), and Array< T >::getLength().

Referenced by debug_print().

 {
   debug_file_open("localNodeToGlobal");
   //localNodeToGlobal
   _debugFile << " localNodeToGlobal " << endl;
   for ( unsigned int n = 0; n < _meshList.size(); n++ ){
       const Array<int>&  localToGlobal = *_localNodeToGlobal[n];
       for ( int i = 0; i < localToGlobal.getLength(); i++ )
          _debugFile << " localToGlobal[" << i << "] = " << localToGlobal[i] << endl;
       _debugFile << endl;
   }
   debug_file_close();
 }

void MeshAssembler::debug_localToGlobal_mappers ( )

Definition at line 723 of file MeshAssembler.cpp.

References _debugFile, _localCellToGlobal, _meshList, debug_file_close(), debug_file_open(), and Array< T >::getLength().

Referenced by debug_print().

 {
    debug_file_open("localToGlobal");
   //mapLocalToGlobal
    for ( unsigned int n = 0; n < _meshList.size(); n++ ){
       _debugFile << " mesh = " << n << endl;
       const Array<int>& localToGlobal = *_localCellToGlobal[n];
       for ( int i = 0; i < localToGlobal.getLength(); i++ )
           _debugFile  << " localCellToGlobal[" << i << "] = " << localToGlobal[i] << endl;
       _debugFile << endl;
    }
    debug_file_close();
 }

void MeshAssembler::debug_print ( )

Definition at line 803 of file MeshAssembler.cpp.

References debug_faceCells(), debug_globalCellToMeshID_mappers(), debug_localNodeToGlobal(), debug_localToGlobal_mappers(), debug_sites(), and debug_sync_localToGlobal_mappers().

 {
     debug_sites();
     debug_localToGlobal_mappers();
     debug_globalCellToMeshID_mappers();
     debug_sync_localToGlobal_mappers();
     debug_faceCells();
     debug_localNodeToGlobal();
 
 }

void MeshAssembler::debug_sites ( )

Definition at line 712 of file MeshAssembler.cpp.

References _cellSite, _debugFile, _faceSite, _nodeSite, debug_file_close(), and debug_file_open().

Referenced by debug_print().

 {
   debug_file_open("sites");
   _debugFile << " cells.getSelfCount() = " << _cellSite->getSelfCount() << " cells.selfCount() = " << _cellSite->getCount() << endl;
   _debugFile << " faces.getSelfCount() = " << _faceSite->getSelfCount() << " faces.selfCount() = " << _faceSite->getCount() << endl;
   _debugFile << " nodes.getSelfCount() = " << _nodeSite->getSelfCount() << " nodes.selfCount() = " << _nodeSite->getCount() << endl;
   debug_file_close();
 }

void MeshAssembler::debug_sync_localToGlobal_mappers ( )

Definition at line 755 of file MeshAssembler.cpp.

References _debugFile, _localCellToGlobal, _meshList, debug_file_close(), debug_file_open(), and Array< T >::getLength().

Referenced by debug_print().

 {
   debug_file_open("syncLocalToGlobal");
   //printing things
   _debugFile << " localCellToGlobal after sync() opeartion " << endl;
   for ( unsigned int n = 0; n < _meshList.size(); n++ ){
      const Array<int>&  localToGlobal = *_localCellToGlobal[n];
      _debugFile << " mesh = " << n << endl;
      for ( int i = 0; i < localToGlobal.getLength(); i++ )
          _debugFile << " localToGlobal[" << i << "] = " << localToGlobal[i] << endl;
      _debugFile << endl;
   }
   debug_file_close();
 }

int MeshAssembler::getInnerNodesCount ( )

private

Definition at line 436 of file MeshAssembler.cpp.

References _interfaceNodesSet, _meshList, Mesh::getAllFaceNodes(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getFaces(), Mesh::getInterfaceGroupCount(), Mesh::getInterfaceGroups(), and Array< T >::getLength().

Referenced by setNodesSite().

                                  {  
    int nodeCount = 0;
    for ( unsigned int n = 0; n < _meshList.size(); n++ ){
       const Mesh& mesh = *(_meshList.at(n));
       const CRConnectivity& faceNodes = mesh.getAllFaceNodes();
       const StorageSite& site = _meshList[n]->getNodes();
       Array<int>  nodeArray( site.getCount() );
       nodeArray = -1;
       //looop over  interior faces
       int nface = mesh.getFaces().getCount();
       for ( int i = 0; i < nface; i++ )
           //loop over face surronding nodes
            for ( int node = 0; node < faceNodes.getCount(i); node++ )
                nodeArray[ faceNodes(i,node) ] = 1;
 
     //loop over interface faces to reset 
      const FaceGroupList& faceGroupList = mesh.getInterfaceGroups();  
      for ( int i = 0; i < mesh.getInterfaceGroupCount(); i++ ){
            int id = faceGroupList[i]->id;
            set<int>&  nodes   = _interfaceNodesSet[n][id];
            foreach ( const set<int>::value_type node, nodes )
                nodeArray[ node] = -1;  //reseting again, we want to seperate inner/boundary nodes than interface nodes
      }
      //node count
      for ( int i = 0; i < nodeArray.getLength(); i++ )
          if ( nodeArray[i] != -1 ) nodeCount++;
    }
 
   return nodeCount;
 }

int MeshAssembler::getInterfaceNodesCount ( )

private

Definition at line 488 of file MeshAssembler.cpp.

References _interfaceNodesSet, _localInterfaceNodesToGlobalMap, _meshList, _nInterfaceNodes, Mesh::getInterfaceGroupCount(), Mesh::getInterfaceGroups(), getInterfaceNodesDuplicatedCount(), and Mesh::getNodeCoordinates().

Referenced by setNodesSite().

 {
   //count nodes on shared interfaces (duplicated)
   int nInterfaceNodes = getInterfaceNodesDuplicatedCount();
 
    Array< Mesh::VecD3 > interfaceNodeValues ( nInterfaceNodes );
    Array< int > globalIndx  ( nInterfaceNodes );
    globalIndx   = -1;
 
    //filing interfaceNodeValues
    int indx = 0;
    for ( unsigned int n = 0; n < _meshList.size(); n++ ){
       const Mesh& mesh = *(_meshList.at(n));
       const FaceGroupList& faceGroupList = mesh.getInterfaceGroups();  
       const Array<Mesh::VecD3>& coord = mesh.getNodeCoordinates();
       //looop over  interfaces
       for ( int i = 0; i < mesh.getInterfaceGroupCount(); i++ ){
            int id = faceGroupList[i]->id;
            const set<int>&  nodes   = _interfaceNodesSet[n][id];
            foreach ( const set<int>::value_type node, nodes ){
               interfaceNodeValues[indx] = coord[node];
               indx++;
            }
       }
    }
 
    //greedy algorithm to fill interfaceNodeCount
   indx =0;
   for ( int i = 0; i < nInterfaceNodes; i++ ){
      if ( globalIndx[i] == -1 ){
         globalIndx[i] = indx;
         double x = interfaceNodeValues[i][0];
         double y = interfaceNodeValues[i][1];
         double z = interfaceNodeValues[i][2];
         for ( int j = i+1; j < nInterfaceNodes; j++ ){
            if ( globalIndx[j] == -1 ){
               double xOther = interfaceNodeValues[j][0];
               double yOther = interfaceNodeValues[j][1];
               double zOther = interfaceNodeValues[j][2];
               if ( x == xOther && y == yOther && z == zOther )
                  globalIndx[j] = indx;
            }
         }
         indx++;
      }
   }
 
 
   _nInterfaceNodes = indx;
   //filling localInterfaceNodes to GlobalNodes data structure
    indx = 0;
    for ( unsigned int n = 0; n < _meshList.size(); n++ ){
       const Mesh& mesh = *(_meshList.at(n));
       const FaceGroupList& faceGroupList = mesh.getInterfaceGroups();
       //looop over  interfaces
       for ( int i = 0; i < mesh.getInterfaceGroupCount(); i++ ){
           int id = faceGroupList[i]->id;
           const set<int>&  nodes   = _interfaceNodesSet[n][id];
           foreach ( const set<int>::value_type node, nodes ){
              _localInterfaceNodesToGlobalMap[n][node] = globalIndx[indx];
              indx++;
           }
       }
    }
 
    return _nInterfaceNodes;
 }

int MeshAssembler::getInterfaceNodesDuplicatedCount ( )

private

Definition at line 469 of file MeshAssembler.cpp.

References _interfaceNodesSet, _meshList, Mesh::getInterfaceGroupCount(), and Mesh::getInterfaceGroups().

Referenced by getInterfaceNodesCount().

 {
    //loop over meshes
    int nInterfaceNodes = 0;
    for ( unsigned int n = 0; n < _meshList.size(); n++ ){
       const Mesh& mesh = *(_meshList.at(n));
       const FaceGroupList& faceGroupList = mesh.getInterfaceGroups();
       //looop over  interfaces
       for ( int i = 0; i < mesh.getInterfaceGroupCount(); i++ ){
            int id = faceGroupList[i]->id;
            const set<int>&  nodes   = _interfaceNodesSet[n][id];
            nInterfaceNodes += nodes.size();
       }
    }
    return nInterfaceNodes;
 }

void MeshAssembler::init ( )

private

Definition at line 30 of file MeshAssembler.cpp.

References _interfaceNodesSet, _localInterfaceNodesToGlobalMap, _mesh, _meshList, setCellsMapper(), setCellsSite(), setCoord(), setFaceCells(), setFaceNodes(), setFacesSite(), setInterfaceNodes(), setMesh(), setMeshCellColor(), setNodesMapper(), and setNodesSite().

Referenced by MeshAssembler().

 {
   int dim = _meshList.at(0)->getDimension();
    //construct merged Linearsystem
   _mesh.push_back( new Mesh( dim) );
 
 
   _interfaceNodesSet.resize( _meshList.size() );
   _localInterfaceNodesToGlobalMap.resize( _meshList.size() );
 
    setCellsSite();
    setFacesSite();
    setInterfaceNodes();
    //countInterfaceNodes();
    setNodesSite();
    setCellsMapper();
    setFaceCells();
    setNodesMapper();
    setFaceNodes();
    setCoord();
    setMesh();
    setMeshCellColor();
 
 }

const MeshList& MeshAssembler::meshList ( ) const

inline

Definition at line 34 of file MeshAssembler.h.

References _mesh.

34 { return _mesh;}

MeshAssembler::_mesh

MeshList _mesh

Definition: MeshAssembler.h:101

void MeshAssembler::setBoundaryFaceGroup ( )

private

Definition at line 595 of file MeshAssembler.cpp.

References _interiorFaceSize, _mesh, _meshList, Mesh::getBoundaryFaceGroups(), and Mesh::getBoundaryGroupCount().

Referenced by setMesh().

 {
      //interior face size stored
      int face =   _interiorFaceSize;
      //now add boundary faces
      for ( unsigned int n = 0; n < _meshList.size(); n++ ){
           const Mesh& mesh = *(_meshList[n]);
           const FaceGroupList&  bounGroupList = mesh.getBoundaryFaceGroups();
           //loop over interfaces 
           for ( int i = 0; i <mesh.getBoundaryGroupCount(); i++ ){
               //sweep interfaces for add up operation
               int size   = bounGroupList[i]->site.getCount();
               int offset = face;
               int id     = bounGroupList[i]->id;
               string  boundaryType = bounGroupList[i]->groupType;
               //update face for offset
               face += size;
               _mesh.at(0)->createBoundaryFaceGroup( size, offset, id, boundaryType );
           }
      }
 
 }

void MeshAssembler::setCellsMapper ( )

private

Definition at line 180 of file MeshAssembler.cpp.

References _globalCellToLocal, _globalCellToMeshID, _localCellToGlobal, _meshList, StorageSite::getCount(), and StorageSite::getSelfCount().

Referenced by init().

 {
     //count cells
     int selfCount = 0;
     for ( unsigned int id = 0; id < _meshList.size(); id++ ){
        const StorageSite& cellSite = _meshList[id]->getCells();
        selfCount += cellSite.getSelfCount();
     }
     _globalCellToMeshID.resize( selfCount );
     _globalCellToLocal.resize ( selfCount );
     //loop over meshes
     int glblIndx = 0;
     for ( unsigned int id = 0; id < _meshList.size(); id++ ){
        const StorageSite& cellSite = _meshList[id]->getCells();
        _localCellToGlobal[id]   = ArrayIntPtr( new Array<int>( cellSite.getCount() ) ); 
         Array<int>&  localToGlobal = *_localCellToGlobal[id];
         localToGlobal = -1; //initializer 
        //loop over inner cells
        for ( int n = 0; n < cellSite.getSelfCount(); n++ ){
             localToGlobal[n] = glblIndx;
            _globalCellToMeshID[glblIndx] = id;  //belongs to which mesh from global Cell ID
            _globalCellToLocal [glblIndx] = n;   //gives local Cell ID from Global ID but which mesh comes from mapGlobalCellToMeshID
             glblIndx++;
        }
     }
 
   //creating cellID MultiField to use sync() operation
   shared_ptr<MultiField>  cellMultiField = shared_ptr<MultiField>( new MultiField()    );
   shared_ptr<Field>       cellField      = shared_ptr<Field>     ( new Field("cellID") );
  
   for ( unsigned int n = 0; n < _meshList.size(); n++ ){
      const StorageSite* site = &_meshList[n]->getCells();
      MultiField::ArrayIndex ai( cellField.get(), site );
      shared_ptr<Array<int> > cIndex(new Array<int>(site->getCount()));
       *cIndex = -1;
      cellMultiField->addArray(ai,cIndex);
   }
 
   //fill  local mesh with global Indx
   for ( unsigned int n = 0; n < _meshList.size(); n++ ){
      const StorageSite* site = &_meshList[n]->getCells();
      MultiField::ArrayIndex ai( cellField.get(), site );
      Array<int>&  localCell = dynamic_cast< Array<int>& >( (*cellMultiField)[ai] ); 
      const Array<int>&  localToGlobal = *_localCellToGlobal[n];
      for ( int i = 0; i < site->getSelfCount(); i++ )
           localCell[i] =localToGlobal[i];
   }
   //sync opeartion
   cellMultiField->sync();
 
   //fill  local mesh with global Indx after sync
   for ( unsigned int n = 0; n < _meshList.size(); n++ ){
      const StorageSite* site = &_meshList[n]->getCells();
      MultiField::ArrayIndex ai( cellField.get(), site );
      const Array<int>&  localCell = dynamic_cast< const Array<int>& >( (*cellMultiField)[ai] ); 
      Array<int>&  localToGlobal = *_localCellToGlobal[n];
      for ( int i = 0; i < site->getCount(); i++ )
           localToGlobal[i] = localCell[i];
   }
 
 
 //    //above algorithm fill localCellToGlobal for only inner cells but we will do ghost cells for interfaces
 //    for ( unsigned int i = 0; i < _meshList.size(); i++ ){
 //        const StorageSite& thisSite = _meshList[i]->getCells();
 //        const StorageSite::ScatterMap& scatterMap = thisSite.getScatterMap();
 //        foreach(const StorageSite::ScatterMap::value_type& mpos, scatterMap){
 //           const StorageSite& oSite    = *(mpos.first);
 //           const Array<int>& fromIndices = *(mpos.second);
 //           const Array<int>& toIndices   = *(oSite.getGatherMap().find(&thisSite)->second);
 //           cout << " fromIndices.getLength() = " << fromIndices.getLength() << endl;
 //           cout << " scatterArray " << endl;
 //           for ( int n  = 0; n < fromIndices.getLength(); n++){
 //              cout << "      fromIndices[" << n << "] = " << fromIndices[n] << "      toIndices[" << n << "] = " << toIndices[n] << endl;
 //           }
 //        }
 //    }
 
 }

void MeshAssembler::setCellsSite ( )

private

Definition at line 57 of file MeshAssembler.cpp.

References _cellSite, _meshList, StorageSite::getCount(), Array< T >::getLength(), StorageSite::getScatterMap(), and StorageSite::getSelfCount().

Referenced by init().

 {
    int siteCount     = 0;
    int siteSelfCount = 0;
    for ( unsigned int id = 0; id < _meshList.size(); id++ ){
       const StorageSite& site = _meshList[id]->getCells();
       const StorageSite::ScatterMap& scatterMap = site.getScatterMap();
       int nghost = 0;
       foreach(const StorageSite::ScatterMap::value_type& mpos, scatterMap){
          const Array<int>& fromIndices = *(mpos.second);
          nghost += fromIndices.getLength();
       }
       siteCount += site.getCount() - nghost;
       siteSelfCount += site.getSelfCount();
    }
 
    _cellSite = StorageSitePtr( new StorageSite(siteSelfCount, siteCount-siteSelfCount) );
 
 }

void MeshAssembler::setCoord ( )

private

Definition at line 620 of file MeshAssembler.cpp.

References _coord, _localNodeToGlobal, _meshList, _nodeSite, StorageSite::getCount(), Mesh::getNodeCoordinates(), and Mesh::getNodes().

Referenced by init().

 {
    _coord = ArrayVecD3Ptr(new Array<Mesh::VecD3>(_nodeSite->getCount()));
     for ( unsigned n = 0; n < _meshList.size(); n++ ){
          const Mesh& mesh = *(_meshList[n]);
          const StorageSite& nodeSite = mesh.getNodes();
          const Array<int>& localToGlobal = *_localNodeToGlobal[n];
          const Array<Mesh::VecD3>&   coordLocal = mesh.getNodeCoordinates();
          //loop over local mesh nodes
          for ( int i = 0; i < nodeSite.getCount(); i++ ){
                if ( localToGlobal[i] != -1 ) //so mapping is well defined
                  (*_coord)[ localToGlobal[i] ] = coordLocal[i];
          }
     }
 }

void MeshAssembler::setFaceCells ( )

private

Definition at line 261 of file MeshAssembler.cpp.

References _cellSite, _faceCells, _faceSite, _localCellToGlobal, _meshList, Mesh::getAllFaceCells(), Mesh::getBoundaryFaceGroups(), Mesh::getBoundaryGroupCount(), Mesh::getCells(), StorageSite::getCount(), Mesh::getInterfaceGroupCount(), Mesh::getInterfaceGroups(), Mesh::getInteriorFaceGroup(), StorageSite::getSelfCount(), and FaceGroup::site.

Referenced by init().

 {
     _faceCells = CRConnectivityPtr( new CRConnectivity( *_faceSite, *_cellSite) );
     _faceCells->initCount();
     
      //addCount
      const int cellCount = 2;
      for ( int i = 0; i < _faceSite->getCount(); i++ )
         _faceCells->addCount(i, cellCount); // face has always two cells
      //finish count
      _faceCells->finishCount();
 
      //first interior faces 
      int face = 0;
      for ( unsigned int n = 0; n < _meshList.size(); n++ ){
         const Mesh& mesh = *(_meshList[n]);
         const CRConnectivity& faceCells = mesh.getAllFaceCells();
         const FaceGroup& faceGroup = mesh.getInteriorFaceGroup();
         const Array<int>& localToGlobal = *_localCellToGlobal[n];
         for ( int i = 0; i < faceGroup.site.getCount(); i++ ){
             int cell1 = faceCells(i,0);
             int cell2 = faceCells(i,1);
             _faceCells->add( face, localToGlobal[ cell1 ] );
             _faceCells->add( face, localToGlobal[ cell2 ] );
             face++;
         }
      }
 
      //now add interfaces
      set<int> faceGroupSet; // this set make sure that no duplication in sweep
      for ( unsigned int n = 0; n < _meshList.size(); n++ ){
           const Mesh& mesh = *(_meshList[n]);
           const CRConnectivity& faceCells = mesh.getAllFaceCells();
           const FaceGroupList&  faceGroupList = mesh.getInterfaceGroups();
           const Array<int>& localToGlobal = *_localCellToGlobal[n];
           //loop over interfaces 
           for ( int i = 0; i < mesh.getInterfaceGroupCount(); i++ ){
                int faceGroupID = faceGroupList[i]->id;
                //pass only if it is not in faceGroupSet
                if ( faceGroupSet.count( faceGroupID) == 0 ){
                    faceGroupSet.insert( faceGroupID );
                    //sweep interfaces for add up operation
                    int ibeg = faceGroupList[i]->site.getOffset();
                    int iend = ibeg + faceGroupList[i]->site.getCount();
                    for ( int i = ibeg; i < iend; i++ ){
                       int cell1 = faceCells(i,0);
                       int cell2 = faceCells(i,1);
                       _faceCells->add( face, localToGlobal[ cell1 ] );
                       _faceCells->add( face, localToGlobal[ cell2 ] );
                       face++;
                    }
                }
            }
       }
      //now add boundary faces
      int indx = _cellSite->getSelfCount();
      for ( unsigned int n = 0; n < _meshList.size(); n++ ){
           const Mesh& mesh = *(_meshList[n]);
           const StorageSite& cellSite = mesh.getCells();
           const CRConnectivity& faceCells = mesh.getAllFaceCells();
           const FaceGroupList&  bounGroupList = mesh.getBoundaryFaceGroups();
           const Array<int>& localToGlobal = *_localCellToGlobal[n];
           //loop over interfaces 
           for ( int i = 0; i <mesh.getBoundaryGroupCount(); i++ ){
               //sweep interfaces for add up operation
               int ibeg = bounGroupList[i]->site.getOffset();
               int iend = ibeg + bounGroupList[i]->site.getCount();
               for ( int i = ibeg; i < iend; i++ ){
                   int cell1 = faceCells(i,0);
                   int cell2 = faceCells(i,1);
                   //cell1
                   if ( cell1 < cellSite.getSelfCount() )
                       _faceCells->add( face, localToGlobal[ cell1 ] ); 
                   else 
                       _faceCells->add( face, localToGlobal[ cell2 ] ); 
                   //adding boundary cells       
                   _faceCells->add( face, indx  ); 
                   indx++;
                   face++;
               }
           }
        }
 
       //finishAdd
       _faceCells->finishAdd();
 
 
 }

void MeshAssembler::setFaceNodes ( )

private

Definition at line 352 of file MeshAssembler.cpp.

References _faceNodes, _faceSite, _interiorFaceSize, _localNodeToGlobal, _meshList, _nodeSite, Mesh::getAllFaceNodes(), Mesh::getBoundaryFaceGroups(), Mesh::getBoundaryGroupCount(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getInterfaceGroupCount(), Mesh::getInterfaceGroups(), Mesh::getInteriorFaceGroup(), CRConnectivity::getRow(), and FaceGroup::site.

Referenced by init().

 {
     _faceNodes = CRConnectivityPtr( new CRConnectivity( *_faceSite, *_nodeSite) );
     _faceNodes->initCount();
      //addCount
      const Mesh& mesh0 = *_meshList[0];
      const int nodeCount = mesh0.getAllFaceNodes().getRow()[1] -  mesh0.getAllFaceNodes().getRow()[0];
      for ( int i = 0; i < _faceSite->getCount(); i++ )
         _faceNodes->addCount(i, nodeCount); 
      //finish count
      _faceNodes->finishCount();
      //first interior faces 
      int face = 0;
      for ( unsigned int n = 0; n < _meshList.size(); n++ ){
         const Mesh& mesh = *(_meshList[n]);
         const CRConnectivity& faceNodes = mesh.getAllFaceNodes();
         const FaceGroup& faceGroup = mesh.getInteriorFaceGroup();
         const StorageSite& faceGroupSite = faceGroup.site;
         const Array<int>& localToGlobal = *_localNodeToGlobal[n];
         for ( int i = 0; i < faceGroupSite.getCount(); i++ ){
            for ( int j = 0; j < faceNodes.getCount(i); j++ ){
                int nodeID = faceNodes(i,j);
               _faceNodes->add( face, localToGlobal[nodeID] );
            }
            face++;
         }
      }
 
      //interfaces (mesh)
      set<int> faceGroupSet;
      for ( unsigned int n = 0; n < _meshList.size(); n++ ){
          const Mesh& mesh = *(_meshList[n]);
          const CRConnectivity& faceNodes = mesh.getAllFaceNodes();
          const FaceGroupList& faceGroupList = mesh.getInterfaceGroups();
          const Array<int>& localToGlobal = *_localNodeToGlobal[n];
          for ( int i = 0; i < mesh.getInterfaceGroupCount(); i++ ){
                int faceGroupID = faceGroupList[i]->id;
                //pass only if it is not in faceGroupSet
                if ( faceGroupSet.count( faceGroupID) == 0 ){
                    faceGroupSet.insert( faceGroupID );
                    //sweep interfaces for add up operation
                    int ibeg = faceGroupList[i]->site.getOffset();
                    int iend = ibeg + faceGroupList[i]->site.getCount();
                    for ( int i = ibeg; i < iend; i++ ){
                        for ( int j = 0; j < faceNodes.getCount(i); j++ ){
                            int nodeID = faceNodes(i,j);
                            _faceNodes->add( face, localToGlobal[nodeID] );
                        }
                        face++;
                    }
                 }
          }
      }
      //interior face size stored
      _interiorFaceSize = face;
 
 
      //now add boundary faces
      for ( unsigned int n = 0; n < _meshList.size(); n++ ){
           const Mesh& mesh = *(_meshList[n]);
           const CRConnectivity& faceNodes = mesh.getAllFaceNodes();
           const FaceGroupList&  bounGroupList = mesh.getBoundaryFaceGroups();
           const Array<int>& localToGlobal = *_localNodeToGlobal[n];
           //loop over interfaces 
           for ( int i = 0; i <mesh.getBoundaryGroupCount(); i++ ){
               //sweep interfaces for add up operation
               int ibeg = bounGroupList[i]->site.getOffset();
               int iend = ibeg + bounGroupList[i]->site.getCount();
               for ( int i = ibeg; i < iend; i++ ){
                   for ( int j = 0; j < faceNodes.getCount(i); j++ ){
                       int nodeID = faceNodes(i,j);
                       _faceNodes->add( face, localToGlobal[nodeID] );
                    }
                   face++;
               }
           }
        }
 
     //finishAdd
     _faceNodes->finishAdd();
 }

void MeshAssembler::setFacesSite ( )

private

Definition at line 79 of file MeshAssembler.cpp.

References _faceSite, _meshList, and StorageSite::getCount().

Referenced by init().

 {
    int faceCount = 0;
    for ( unsigned int id = 0; id < _meshList.size(); id++ ){
       const StorageSite& site = _meshList[id]->getFaces();
       faceCount += site.getCount();
    }
 
    int sharedFaceCount = 0;
    for ( unsigned int id = 0; id < _meshList.size(); id++ ){
         const FaceGroupList &  faceGroupList = _meshList[id]->getInterfaceGroups();
        for ( int n = 0; n < _meshList[id]->getInterfaceGroupCount(); n++ ){
           const StorageSite& site = faceGroupList[n]->site;
           sharedFaceCount += site.getCount();
        }
    }
    _faceSite = StorageSitePtr( new StorageSite(faceCount - sharedFaceCount / 2 ) );
     assert( sharedFaceCount%2  == 0 );
 
 }

void MeshAssembler::setInterfaceNodes ( )

private

Definition at line 102 of file MeshAssembler.cpp.

References _interfaceNodesSet, _meshList, Mesh::getAllFaceNodes(), StorageSite::getCount(), CRConnectivity::getCount(), Mesh::getInterfaceGroupCount(), Mesh::getInterfaceGroups(), and StorageSite::getOffset().

Referenced by init().

 {
    //loop over meshes
    for ( unsigned int n = 0; n < _meshList.size(); n++ ){
       const Mesh& mesh = *(_meshList.at(n));
       const CRConnectivity& faceNodes = mesh.getAllFaceNodes();
       //const CRConnectivity& faceCells = mesh.getAllFaceCells();       
       const FaceGroupList& faceGroupList = mesh.getInterfaceGroups();
       //looop over  interfaces
       for ( int i = 0; i < mesh.getInterfaceGroupCount(); i++ ){
            int id = faceGroupList[i]->id;
            set<int>&  nodes   = _interfaceNodesSet[n][id];
            //loop over faces to fill nodes
            const StorageSite& site = faceGroupList[i]->site;
            int jstart =   site.getOffset(); 
            int jend   = jstart + site.getCount();
            for ( int face = jstart; face < jend; face++ ){
                //loop over face surronding nodes
                for ( int node = 0; node < faceNodes.getCount(face); node++ ){
                    nodes.insert( faceNodes(face,node) );
 /*                   cout << " nemsh = " << n << "faceNodes(" << face << "," << node << ") = "  << faceNodes(face,node) << 
                            " faceCells(" << face << "," << "0) = " << faceCells(face,0) << 
                            " faceCells(" << face << "," << "1) = " << faceCells(face,1) << endl;*/
                }
            }
       }
    }
 
 }

void MeshAssembler::setMesh ( )

private

Definition at line 649 of file MeshAssembler.cpp.

References _coord, _faceCells, _faceNodes, _interiorFaceSize, _mesh, setBoundaryFaceGroup(), and setSites().

Referenced by init().

 {
     //set sites
     setSites();
     //interior face group
     _mesh.at(0)->createInteriorFaceGroup( _interiorFaceSize );
     //boundary face group
     setBoundaryFaceGroup();
     //setting coordinates
     _mesh.at(0)->setCoordinates( _coord     );
     //setting faceNodes CRConnecitivty
     _mesh.at(0)->setFaceNodes  ( _faceNodes );
     //setting faceCells CRConnectivity
     _mesh.at(0)->setFaceCells  ( _faceCells );
 
 }

void MeshAssembler::setMeshCellColor ( )

private

Definition at line 668 of file MeshAssembler.cpp.

References _cellSite, _localCellToGlobal, _mesh, _meshList, Mesh::getAllFaceCells(), Mesh::getBoundaryFaceGroups(), Mesh::getBoundaryGroupCount(), StorageSite::getCount(), Mesh::getInteriorFaceGroup(), and FaceGroup::site.

Referenced by init().

 {
      //allocate Mesh::_cellColor
     _mesh.at(0)->createCellColor();
 
     Array<int>& cellColor = _mesh.at(0)->getCellColors();
     //first interior faces of local meshes
     for ( unsigned int n = 0; n < _meshList.size(); n++ ){
        const Mesh& mesh = *(_meshList[n]);
        const CRConnectivity& faceCells = mesh.getAllFaceCells();
        const FaceGroup& faceGroup = mesh.getInteriorFaceGroup();
        const Array<int>& localToGlobal = *_localCellToGlobal[n];
        for ( int i = 0; i < faceGroup.site.getCount(); i++ ){
            int cell1 = faceCells(i,0);
            int cell2 = faceCells(i,1);
            cellColor[ localToGlobal[ cell1 ] ] = n;
            cellColor[ localToGlobal[ cell2 ] ] = n;
        }
     }
 
   //now color only boundary cells
      int indx = _cellSite->getSelfCount();
      for ( unsigned int n = 0; n < _meshList.size(); n++ ){
           const Mesh& mesh = *(_meshList[n]);
           const FaceGroupList&  bounGroupList = mesh.getBoundaryFaceGroups();
           //loop over interfaces 
           for ( int i = 0; i <mesh.getBoundaryGroupCount(); i++ ){
               //sweep interfaces for add up operation
               int ibeg = bounGroupList[i]->site.getOffset();
               int iend = ibeg + bounGroupList[i]->site.getCount();
               for ( int i = ibeg; i < iend; i++ ){
                   cellColor[indx] = n;
                   //adding boundary cells       
                   indx++;
               }
           }
        }
       //assigning Mesh::numOfAssembleMesh
      _mesh[0]->setNumOfAssembleMesh( int(_meshList.size()) );
 
 }

void MeshAssembler::setNodesMapper ( )

private

Definition at line 558 of file MeshAssembler.cpp.

References _localInterfaceNodesToGlobalMap, _localNodeToGlobal, _meshList, _nInterfaceNodes, StorageSite::getCount(), and CRConnectivity::getCount().

Referenced by init().

 {
 
     int glblIndx = _nInterfaceNodes; // node numbering first from interfaces
     cout << " glbIndx = " << glblIndx << endl;
     for ( unsigned int id = 0; id < _meshList.size(); id++ ){
        const StorageSite& nodeSite = _meshList[id]->getNodes();
        const StorageSite& faceSite = _meshList[id]->getFaces();
        const CRConnectivity& faceNodes = _meshList[id]->getAllFaceNodes();
        _localNodeToGlobal[id]   = ArrayIntPtr( new Array<int>( nodeSite.getCount() ) ); 
        Array<bool> isVisitedNodes( nodeSite.getCount() );
        isVisitedNodes = false;
         Array<int>&  localToGlobal = *_localNodeToGlobal[id];
         localToGlobal = -1; //initializer 
         const  map<int,int>&  localInterfaceNodesToGlobalMap = _localInterfaceNodesToGlobalMap[id];
         //loop over faces then connecting nodes
         for ( int face = 0; face < faceSite.getCount(); face++ ){
            for ( int n = 0; n < faceNodes.getCount(face); n++ ){
                int nodeID = faceNodes(face,n); 
                //cout << " nodeID = " << nodeID << " isVisitedNodes = " << isVisitedNodes[nodeID] << endl;
                if ( !isVisitedNodes[nodeID]){ //if it is not visited, we renumber it
                    if ( localInterfaceNodesToGlobalMap.count( nodeID ) == 0 ) 
                       localToGlobal[nodeID] = glblIndx++;
                    else 
                       localToGlobal[nodeID] = localInterfaceNodesToGlobalMap.find(nodeID)->second;
                    isVisitedNodes[nodeID] = true;
                }
            }
         }
     }
 
 
 
 }

void MeshAssembler::setNodesSite ( )

private

Definition at line 169 of file MeshAssembler.cpp.

References _nodeSite, getInnerNodesCount(), and getInterfaceNodesCount().

Referenced by init().

 {
   //count inner nodes for assembly
   int nodeCount       = getInnerNodesCount();
   int nInterfaceNodes = getInterfaceNodesCount();
   _nodeSite = StorageSitePtr( new StorageSite(nodeCount + nInterfaceNodes) );
 
 }

void MeshAssembler::setSites ( )

private

Definition at line 638 of file MeshAssembler.cpp.

References _cellSite, _faceSite, _mesh, _nodeSite, and StorageSite::setCount().

Referenced by setMesh().

 {
    StorageSite& faceSite = _mesh.at(0)->getFaces();
    StorageSite& cellSite = _mesh.at(0)->getCells();
    StorageSite& nodeSite = _mesh.at(0)->getNodes();
    faceSite.setCount( _faceSite->getCount() );
    cellSite.setCount( _cellSite->getSelfCount(), _cellSite->getCount()-_cellSite->getSelfCount() );
    nodeSite.setCount( _nodeSite->getCount() );
 }