Memosa-FVM: Mesh Class Reference

 {
   _ghostCellSiteGatherMapLevel1.insert( pair<PartIDMeshIDPair, shared_ptr<StorageSite> >( id, site ) );
 
 }

void Mesh::createGhostCellSiteScatter	(	const PartIDMeshIDPair &	id,
		shared_ptr< StorageSite >	site
	)

Definition at line 694 of file Mesh.cpp.

References _ghostCellSiteScatterMap.

 {
   _ghostCellSiteScatterMap.insert( pair<PartIDMeshIDPair, shared_ptr<StorageSite> >( id, site ) );
 
 }

void Mesh::createGhostCellSiteScatterLevel1	(	const PartIDMeshIDPair &	id,
		shared_ptr< StorageSite >	site
	)

Definition at line 708 of file Mesh.cpp.

Referenced by MeshMetricsCalculator< T >::calculateCellCentroids(), MeshMetricsCalculator< T >::calculateCellVolumes(), MeshPartitioner::cellcells_global_extension(), CellMark_Impl(), COMETModel< T >::coarsenInterfaceCells(), GradientModel< Vector< T, 3 > >::compute(), FlowModel< T >::Impl::computeContinuityResidual(), KineticModel< T >::computeIBFaceDsf(), COMETModel< T >::computeIBFaceDsf(), MeshMetricsCalculator< T >::computeIBInterpolationMatrices(), MeshMetricsCalculator< T >::computeIBInterpolationMatricesCells(), NcDataWriter::connectivities(), KineticModel< T >::ConservationofMassCheck(), COMETModel< T >::ConservationofMassCheck(), KineticModel< T >::correctMassDeficit(), COMETModel< T >::correctMassDeficit(), IBManager::createIBFaces(), FluentReader::createMesh(), DriftDiscretization< X, Diag, OffDiag >::discretize(), GenericIBDiscretization< X, Diag, OffDiag >::discretize(), PhononConvectionDiscretization< X, Diag, OffDiag >::discretize(), ConvectionDiscretization< X, Diag, OffDiag >::discretize(), GenericKineticIBDiscretization< X, Diag, OffDiag >::discretize(), ConvectionDiscretization_Kmodel< X, Diag, OffDiag >::discretize(), MomentumPressureGradientDiscretization< X >::discretize(), ElecDiffusionDiscretization< X, Diag, OffDiag >::discretize(), extrude(), MeshDismantler::faceCellsAddBoundaryInterfaces(), MeshDismantler::faceCellsAddInteriorFaces(), MeshDismantler::faceCellsAddMeshInterfaces(), MeshDismantler::faceCellsAddPartitionInterfaces(), MeshDismantler::faceNodesAddBoundaryInterfaces(), MeshDismantler::faceNodesAddInteriorFaces(), MeshDismantler::faceNodesAddMeshInterfaces(), MeshDismantler::faceNodesAddPartitionInterfaces(), MeshDismantler::faceNodesInit(), MeshPartitioner::gatherCellsLevel1_partID_map(), getCellCells(), getCellFaces(), getCellNodes(), getFaceCells(), getFaceCells2(), MeshDismantler::getGatherArrays(), GradientModel< Vector< T, 3 > >::getLeastSquaresGradientMatrix2D(), GradientModel< Vector< T, 3 > >::getLeastSquaresGradientMatrix3D(), MeshDismantler::getScatterArrays(), MeshMetricsCalculator< T >::init(), MeshDismantler::init(), KineticModel< T >::MacroparameterIBCell(), IBManager::markIntersections(), MeshDismantler::set_local_global(), MeshPartitioner::set_local_global(), MeshDismantler::setCellsSite(), MeshAssembler::setFaceCells(), MeshDismantler::setFacesSite(), MeshAssembler::setMeshCellColor(), ElectricModel< T >::Impl::updateConvectionFlux(), and MovingMeshModel< T >::volChange().

 {
   _ghostCellSiteScatterMapLevel1.insert( pair<PartIDMeshIDPair, shared_ptr<StorageSite> >( id, site ) );
 
 }

const StorageSite & Mesh::createInterfaceGroup	(	const int	size,
		const int	offset,
		const int	id
	)

Definition at line 268 of file Mesh.cpp.

References _faceGroups, _faces, and _interfaceGroups.

Referenced by FluentReader::createMesh(), COMETModel< T >::FinishCoarseMesh(), and COMETModel< T >::MakeCoarseMesh2().

 {
   shared_ptr<FaceGroup> fg(new FaceGroup(size,offset,_faces,id,"interface"));
   _faceGroups.push_back(fg);
   _interfaceGroups.push_back(fg);
   return fg->site;
 }

const StorageSite & Mesh::createInteriorFaceGroup ( const int size )

Definition at line 259 of file Mesh.cpp.

References _faceGroups, _faces, and _interiorFaceGroup.

Referenced by FluentReader::createMesh(), extrude(), COMETModel< T >::FinishCoarseMesh(), COMETModel< T >::MakeCoarseMesh2(), and Mesh().

 {
   _interiorFaceGroup = shared_ptr<FaceGroup>(new FaceGroup(size,0,_faces,0,"interior"));
   _faceGroups.push_back(_interiorFaceGroup);
   return _interiorFaceGroup->site;
 }

void Mesh::createLocalGlobalArray ( )

Definition at line 738 of file Mesh.cpp.

References _cells, _localToGlobal, and StorageSite::getCountLevel1().

Referenced by MeshDismantler::set_local_global(), and MeshPartitioner::set_local_global().

 {
    _localToGlobal      = shared_ptr< Array<int> > ( new Array<int>( _cells.getCountLevel1() ) );
    *_localToGlobal  = -1;
 }

void Mesh::createLocalToGlobalNodesArray ( )

Definition at line 745 of file Mesh.cpp.

References _localToGlobalNodes, _nodes, and StorageSite::getCount().

 {
    _localToGlobalNodes = shared_ptr< Array<int> > ( new Array<int>( _nodes.getCount() ) );
    *_localToGlobalNodes  = -1;
 }

void Mesh::createRowColSiteCRConn ( )

private

Definition at line 2239 of file Mesh.cpp.

References _cellCellsGhostExt, _cellSiteGhostExt, _recvCounts, _recvIndices, getCells(), StorageSite::getCount(), StorageSite::getGatherMap(), getGlobalToLocal(), Array< T >::getLength(), getNumBounCells(), and StorageSite::getSelfCount().

Referenced by createCellCellsGhostExt().

 { 
     //counting interface counts
     //counting interfaces
     set<int> interfaceCells;
     //const Array<int>& localToGlobal = this->getLocalToGlobal();
     const map<int,int>& globalToLocal = this->getGlobalToLocal();
     const StorageSite& site = this->getCells();
     const int originalCount = site.getCount();
     const StorageSite::GatherMap& gatherMap = site.getGatherMap();
     int countLevel0 = 0;
     foreach(const StorageSite::GatherMap::value_type& mpos, gatherMap){
        const StorageSite&  oSite = *mpos.first;
        const Array<int>& gatherArray = dynamic_cast< const Array<int>& > (*mpos.second);
        countLevel0 += gatherArray.getLength();
        EntryIndex e(&oSite,&site);
        const Array<int>  & recv_indices = dynamic_cast< const Array<int>& > (*_recvIndices[e]);
        const Array<int>  & recv_counts  = dynamic_cast< const Array<int>& > (*_recvCounts [e]);
        //loop over gatherArray
        int indx = 0;
        for ( int i = 0; i < gatherArray.getLength(); i++ ){
           const int nnb = recv_counts[i]; //give getCount() 
           for ( int nb = 0; nb < nnb; nb++ ){
               const int localID = globalToLocal.find( recv_indices[indx] )->second;
               if ( localID >= originalCount ){
                  interfaceCells.insert( recv_indices[indx] );
               }
               indx++;
            }
         }
      }
      const int selfCount   = site.getSelfCount();
      const int countLevel1 = int(interfaceCells.size());
      //ghost cells = sum of boundary and interfaces
      const int nghost = getNumBounCells() +  countLevel0 + countLevel1;
      _cellSiteGhostExt  = shared_ptr<StorageSite> ( new StorageSite(selfCount, nghost) );
      //constructing new CRConnecitvity;
      _cellCellsGhostExt = shared_ptr< CRConnectivity> ( new CRConnectivity( *_cellSiteGhostExt, *_cellSiteGhostExt) );
 }

void Mesh::createScatterGatherCountsBuffer ( )

Definition at line 2011 of file Mesh.cpp.

References _recvCounts, _sendCounts, getCellCells(), getCells(), CRConnectivity::getCount(), StorageSite::getGatherMap(), Array< T >::getLength(), and StorageSite::getScatterMap().

Referenced by MeshDismantler::setCellCellsGhostExt().

 {
 #ifdef FVM_PARALLEL
     //SENDING allocation and filling
     const StorageSite& site     = this->getCells();
     const CRConnectivity& cellCells = this->getCellCells();
     const StorageSite::ScatterMap& scatterMap = site.getScatterMap();
     foreach(const StorageSite::ScatterMap::value_type& mpos, scatterMap){
         const StorageSite&  oSite = *mpos.first;
         //checking if storage site is only site or ghost site, we only communicate ghost site ( oSite.getCount() == -1 ) 
         const Array<int>& scatterArray = *mpos.second;
         //key site
         EntryIndex e(&site,&oSite);
         //allocate array
         _sendCounts[e] = shared_ptr< Array<int>   > ( new Array<int> (scatterArray.getLength()) ); 
         //fill send array
         Array<int>& sendArray = dynamic_cast< Array<int>& > ( *_sendCounts[e] );
         for( int i = 0; i < scatterArray.getLength(); i++ ){
             const int cellID = scatterArray[i];
             sendArray[i] = cellCells.getCount(cellID);
         }
     }
                              
 
     //RECIEVING allocation (filling will be done by MPI Communication)
     const StorageSite::GatherMap& gatherMap = site.getGatherMap();
     foreach(const StorageSite::GatherMap::value_type& mpos, gatherMap){
     const StorageSite&  oSite = *mpos.first;
     const Array<int>& gatherArray = *mpos.second;
     //checking if storage site is only site or ghost site, we only communicate ghost site ( oSite.getCount() == -1 ) 
     EntryIndex e(&oSite,&site);
     //allocate array
        _recvCounts[e] = shared_ptr< Array<int> > ( new Array<int> (gatherArray.getLength()) ); 
     }
 #endif       
  }

void Mesh::createScatterGatherIndicesBuffer ( )

Definition at line 2124 of file Mesh.cpp.

References _recvCounts, _recvIndices, _sendIndices, getCellCells(), getCells(), CRConnectivity::getCount(), StorageSite::getGatherMap(), Array< T >::getLength(), getLocalToGlobal(), and StorageSite::getScatterMap().

Referenced by MeshDismantler::setCellCellsGhostExt().

 {
 #ifdef FVM_PARALLEL
     //SENDING allocation and filling
     const StorageSite& site     = this->getCells();
     const CRConnectivity& cellCells = this->getCellCells();
     const Array<int>&   localToGlobal = this->getLocalToGlobal();
     const StorageSite::ScatterMap& scatterMap = site.getScatterMap();
     foreach(const StorageSite::ScatterMap::value_type& mpos, scatterMap){
         const StorageSite&  oSite = *mpos.first;
         const Array<int>& scatterArray = *mpos.second;
         //loop over surround indices and itself for sizing
         EntryIndex e(&site,&oSite);
         //allocate array
         int sendSize = 0;
         for ( int i = 0; i < scatterArray.getLength(); i++ ){
            sendSize += cellCells.getCount( scatterArray[i] );
         }
         _sendIndices[e] = shared_ptr< Array<int>   > ( new Array<int> (sendSize) ); 
         //fill send array
         Array<int>& sendArray = dynamic_cast< Array<int>&   > ( *_sendIndices[e] );
         int indx = 0;
         for( int i = 0; i < scatterArray.getLength(); i++ ){
            const int cellID = scatterArray[i];
            for ( int j = 0; j < cellCells.getCount(cellID); j++ ){
               sendArray[indx] = localToGlobal[ cellCells(cellID,j) ];
               indx++;
            }
         }
     }
     //RECIEVING allocation (filling will be done by MPI Communication)
     const StorageSite::GatherMap& gatherMap = site.getGatherMap();
     foreach(const StorageSite::GatherMap::value_type& mpos, gatherMap){
        const StorageSite&  oSite = *mpos.first;
        EntryIndex e(&oSite,&site);
        const Array<int>& recvCounts   =  dynamic_cast< const Array<int>& > (*_recvCounts[e]);
        int recvSize = 0;
        for ( int i = 0; i < recvCounts.getLength(); i++ ){
            recvSize += recvCounts[i];
        }
        //allocate array
        _recvIndices[e] = shared_ptr< Array<int> > ( new Array<int>     (recvSize) ); 
     }
 #endif
 } 

Mesh * Mesh::createShell	(	const int	fgId,
		Mesh &	otherMesh,
		const int	otherFgId
	)

Definition at line 1582 of file Mesh.cpp.

References _connectivityMap, _dimension, _isShell, _parentFaceGroupSite, arrayFromVector(), getCells(), getFaceCells(), getFaceGroup(), StorageSite::getGatherMap(), StorageSite::getScatterMap(), StorageSite::getSelfCount(), Mesh(), StorageSite::setCount(), and FaceGroup::site.

 {
   typedef Array<int> IntArray;
   
   const FaceGroup& fg = getFaceGroup(fgId);
   const StorageSite& fgSite = fg.site;
 
   const FaceGroup& otherfg = otherMesh.getFaceGroup(otherFgId);
   const StorageSite& otherfgSite = otherfg.site;
 
   StorageSite& cells = getCells();
 
 
   StorageSite& otherCells = otherMesh.getCells();
   
   const CRConnectivity& faceCells = getFaceCells(fgSite);
   const CRConnectivity& otherFaceCells = otherMesh.getFaceCells(otherfgSite);
 
   const int count = fgSite.getSelfCount();
 
   Mesh* shellMesh = new Mesh(_dimension);
 
   shellMesh->_isShell = true;
   shellMesh->_parentFaceGroupSite = &fgSite;
   
   StorageSite& sMeshCells = shellMesh->getCells();
 
   // as many cells as there are faces, plus twice the number of ghost cells
   sMeshCells.setCount( count, 2*count);
 
 
   // we will number the cells in the shell mesh in the same order as
   // the faces on the left mesh
   
   // create a mapping from the cells in the left mesh to the smesh
   // cells using the faceCell connectivity
   map<int, int> leftCellsToSCells;
   map<int, int> rightCellsToSCells;
   for(int f=0; f<count; f++)
   {
       const int lc1 = faceCells(f,1);
       const int rc1 = otherFaceCells(f,1);
       leftCellsToSCells[lc1] = f;
       rightCellsToSCells[rc1] = f;
   }
 
   // since there can be more than one face group in common between the
   // two meshes, we need to split up the existing gather scatter index
   // arrays into two sets, one for the cells that are connected
   // through the faces in the current face group and one for the rest.
 
   
   StorageSite::ScatterMap& lScatterMap = cells.getScatterMap();
   StorageSite::ScatterMap& rScatterMap = otherCells.getScatterMap();
 
   shared_ptr<IntArray> L2RScatterOrigPtr = lScatterMap[&otherCells];
   shared_ptr<IntArray> R2LScatterOrigPtr = rScatterMap[&cells];
   
   
   StorageSite::GatherMap& lGatherMap = cells.getGatherMap();
   StorageSite::GatherMap& rGatherMap = otherCells.getGatherMap();
   
   shared_ptr<IntArray> R2LGatherOrigPtr = lGatherMap[&otherCells];
   shared_ptr<IntArray> L2RGatherOrigPtr = rGatherMap[&cells];
 
 
   vector<int> L2SScatterVector;
   vector<int> R2SScatterVector;
   vector<int> S2LScatterVector;
   vector<int> S2RScatterVector;
 
   vector<int> L2SGatherVector;
   vector<int> R2SGatherVector;
   vector<int> S2LGatherVector;
   vector<int> S2RGatherVector;
 
   vector<int> L2RScatterNewVector;
   vector<int> R2LScatterNewVector;
   vector<int> L2RGatherNewVector;
   vector<int> R2LGatherNewVector;
   
   for(int i=0; i<L2RScatterOrigPtr->getLength(); i++)
   {
       const int lcs = (*L2RScatterOrigPtr)[i];
       const int rcg = (*L2RGatherOrigPtr)[i];
       // if the left cell is in the current face groups neighbours it goes into the new1 
       if (rightCellsToSCells.find(rcg) != rightCellsToSCells.end())
       {
           
           const int sCell = rightCellsToSCells[rcg];
 
           L2SScatterVector.push_back(lcs);
           L2SGatherVector.push_back(sCell+count);
 
           S2RScatterVector.push_back(sCell);
           S2RGatherVector.push_back(rcg);
       }
       else
       {
           L2RScatterNewVector.push_back(lcs);
           L2RGatherNewVector.push_back(rcg);
       }
   }        
 
   for(int i=0; i<R2LGatherOrigPtr->getLength(); i++)
   {
       const int lcg = (*R2LGatherOrigPtr)[i];
       const int rcs = (*R2LScatterOrigPtr)[i];
       // if the left cell is in the current face groups neighbours it goes into the new1 
       if (leftCellsToSCells.find(lcg) != leftCellsToSCells.end())
       {
           const int sCell = leftCellsToSCells[lcg];
 
           S2LGatherVector.push_back(lcg);
           S2LScatterVector.push_back(sCell);
 
           R2SGatherVector.push_back(sCell+2*count);
           R2SScatterVector.push_back(rcs);
 
       }
       else
       {
           R2LGatherNewVector.push_back(lcg);
           R2LScatterNewVector.push_back(rcs);
       }
   }        
 
 
   // set the gather scatter arrays in the smesh cells
   sMeshCells.getScatterMap()[&cells] = arrayFromVector(S2LScatterVector);
   sMeshCells.getScatterMap()[&otherCells] = arrayFromVector(S2RScatterVector);
   sMeshCells.getGatherMap()[&cells] = arrayFromVector(L2SGatherVector);
   sMeshCells.getGatherMap()[&otherCells] = arrayFromVector(R2SGatherVector);
 
   // replace the existing arrays in left and right maps and add the
   // new ones
 
   lScatterMap.erase(&otherCells);
   if (L2RScatterNewVector.size() > 0)
     lScatterMap[&otherCells] = arrayFromVector(L2RScatterNewVector);
   lScatterMap[&sMeshCells] = arrayFromVector(L2SScatterVector);
   
   lGatherMap.erase(&otherCells);
   if (R2LGatherNewVector.size() > 0)
     lGatherMap[&otherCells] = arrayFromVector(R2LGatherNewVector);
   lGatherMap[&sMeshCells] = arrayFromVector(S2LGatherVector);
   
   rScatterMap.erase(&cells);
   if (R2LScatterNewVector.size() > 0)
     rScatterMap[&cells] = arrayFromVector(R2LScatterNewVector);
   rScatterMap[&sMeshCells] = arrayFromVector(R2SScatterVector);
   
   rGatherMap.erase(&cells);
   if (L2RGatherNewVector.size() > 0)
     rGatherMap[&cells] = arrayFromVector(L2RGatherNewVector);
   rGatherMap[&sMeshCells] = arrayFromVector(S2RGatherVector);
 
   // create the cell cell connectivity for the shell mesh
   shared_ptr<CRConnectivity> sCellCells(new CRConnectivity(sMeshCells,sMeshCells));
   sCellCells->initCount();
 
   // two neighbours for the first count cells, one for the rest
   for(int i=0; i<count; i++)
   {
       sCellCells->addCount(i,2);
       sCellCells->addCount(i+count,1);
       sCellCells->addCount(i+2*count,1);
   }
   
   sCellCells->finishCount();
 
   for(int i=0; i<count; i++)
   {
       sCellCells->add(i,i+count);
       sCellCells->add(i,i+2*count);
 
       sCellCells->add(i+count,i);
       sCellCells->add(i+2*count,i);
   }
 
   sCellCells->finishAdd();
 
   SSPair key(&sMeshCells,&sMeshCells);
 
   shellMesh->_connectivityMap[key] = sCellCells;
 
   return shellMesh;
 }

Mesh::DEFINE_TYPENAME ( "Mesh" )

void Mesh::eraseConnectivity	(	const StorageSite &	rowSite,
		const StorageSite &	colSite
	)		const

Definition at line 359 of file Mesh.cpp.

References _connectivityMap.

Referenced by MeshMetricsCalculator< T >::eraseIBInterpolationMatrices(), getCellCells2(), and uniqueFaceCells().

 {
   SSPair key(&rowSite,&colSite);
   _connectivityMap.erase(key);
 }

Mesh * Mesh::extractBoundaryMesh ( )

Definition at line 1122 of file Mesh.cpp.

References _connectivityMap, _dimension, _nodes, createBoundaryFaceGroup(), getAllFaceGroups(), StorageSite::getCommonMap(), StorageSite::getCount(), CRConnectivity::getCount(), getFaceNodes(), getFaces(), getNodeCoordinates(), getNodes(), FaceGroup::groupType, Mesh(), setCoordinates(), StorageSite::setCount(), and FaceGroup::site.

 {
   StorageSite& nodes = _nodes;
   const Array<VecD3>& coords = getNodeCoordinates();
 
   const int nodeCount = nodes.getCount();
   Array<int> globalToLocalNodes(nodeCount);
 
   globalToLocalNodes = -1;
   int bMeshNodeCount=0;
   int bMeshFaceCount=0;
   foreach(const FaceGroupPtr fgPtr, getAllFaceGroups())
   {
       const FaceGroup& fg = *fgPtr;
       const StorageSite& faces = fg.site;
       if (fg.groupType!="interior")
       {
           const int nFaces = faces.getCount();
           const CRConnectivity& faceNodes = getFaceNodes(faces);
           for(int f=0; f<nFaces; f++)
           {
               const int nFaceNodes = faceNodes.getCount(f);
               for(int nn=0; nn<nFaceNodes; nn++)
               {
                   const int n=faceNodes(f,nn);
                   if (globalToLocalNodes[n] == -1)
                   {
                       globalToLocalNodes[n] = bMeshNodeCount++;
                   }
               }
           }
           bMeshFaceCount += nFaces;
       }
   }
 
 
   Mesh *bMesh = new Mesh(_dimension);
 
 
   StorageSite& bMeshFaces = bMesh->getFaces();
   StorageSite& bMeshNodes = bMesh->getNodes();
   bMeshFaces.setCount( bMeshFaceCount );
   bMeshNodes.setCount( bMeshNodeCount );
   
   bMesh->createBoundaryFaceGroup(bMeshFaceCount,0,0,"wall");
   
   //setting coordinates
   shared_ptr< Array<VecD3> > bMeshCoordPtr( new Array< VecD3 > ( bMeshNodeCount ) );
 
   shared_ptr<IntArray> myCommonNodes(new IntArray(bMeshNodeCount));
   shared_ptr<IntArray> otherCommonNodes(new IntArray(bMeshNodeCount));
 
   for(int n=0; n<nodeCount; n++)
   {
       const int nLocal = globalToLocalNodes[n];
       if (nLocal >=0)
       {
           (*bMeshCoordPtr)[nLocal] = coords[n];
           (*myCommonNodes)[nLocal] = nLocal;
           (*otherCommonNodes)[nLocal] = n;
       }
   }
   nodes.getCommonMap()[&bMeshNodes] = myCommonNodes;
   bMeshNodes.getCommonMap()[&nodes] = otherCommonNodes;
          
   bMesh->setCoordinates( bMeshCoordPtr );
   
   //faceNodes constructor
   shared_ptr<CRConnectivity> bFaceNodes( new CRConnectivity(bMeshFaces,
                                                             bMeshNodes) );
   
   bFaceNodes->initCount();
 
   bMeshFaceCount=0;
   
   foreach(FaceGroupPtr fgPtr, getAllFaceGroups())
   {
       FaceGroup& fg = *fgPtr;
       StorageSite& faces = const_cast<StorageSite&>(fg.site);
       if (fg.groupType!="interior")
       {
           const int nFaces = faces.getCount();
           const CRConnectivity& faceNodes = getFaceNodes(faces);
 
           shared_ptr<IntArray> myCommonFaces(new IntArray(nFaces));
           shared_ptr<IntArray> otherCommonFaces(new IntArray(nFaces));
 
           for(int f=0; f<nFaces; f++)
           {
               const int nFaceNodes = faceNodes.getCount(f);
               bFaceNodes->addCount(bMeshFaceCount,nFaceNodes);
               (*myCommonFaces)[f] = bMeshFaceCount;
               (*otherCommonFaces)[f] = f;
               bMeshFaceCount++;
           }
 
           faces.getCommonMap()[&bMeshFaces] = myCommonFaces;
           bMeshFaces.getCommonMap()[&faces] = otherCommonFaces;
       }
   }
 
   bFaceNodes->finishCount();
   bMeshFaceCount=0;
 
   foreach(const FaceGroupPtr fgPtr, getAllFaceGroups())
   {
       const FaceGroup& fg = *fgPtr;
       const StorageSite& faces = fg.site;
       if (fg.groupType!="interior")
       {
           const int nFaces = faces.getCount();
           const CRConnectivity& faceNodes = getFaceNodes(faces);
           for(int f=0; f<nFaces; f++)
           {
               const int nFaceNodes = faceNodes.getCount(f);
               for(int nn=0; nn<nFaceNodes; nn++)
               {
                   const int n=faceNodes(f,nn);
                   const int nLocal = globalToLocalNodes[n];
                   bFaceNodes->add(bMeshFaceCount,nLocal);
               }
               bMeshFaceCount++;
           }
       }
   }
   
   bFaceNodes->finishAdd();
   //setting faceNodes
   SSPair key(&bMeshFaces,&bMeshNodes);
   bMesh->_connectivityMap[key] = bFaceNodes;
 
   return bMesh;
 
 }

Mesh * Mesh::extrude	(	int	nz,
		double	zmax,
		bool	boundaryOnly = `false`
	)

Definition at line 1258 of file Mesh.cpp.

References _cells, _connectivityMap, _dimension, _faces, _interiorFaceGroup, _nodes, createBoundaryFaceGroup(), createInteriorFaceGroup(), getAllFaceCells(), getAllFaceGroups(), getAllFaceNodes(), getCellNodes(), getCells(), StorageSite::getCount(), CRConnectivity::getCount(), getFaceCells(), getFaceNodes(), getFaces(), getNodeCoordinates(), getNodes(), StorageSite::getSelfCount(), FaceGroup::groupType, FaceGroup::id, Mesh(), setCoordinates(), StorageSite::setCount(), and FaceGroup::site.

 {
   if (boundaryOnly)
     nz = 1;
   
   if (_dimension != 2)
     throw CException("can only extrude two dimensional mesh");
 
   const int myNCells = _cells.getSelfCount();
   const int myNFaces = _faces.getSelfCount();
   const int myNInteriorFaces = _interiorFaceGroup->site.getCount();
   const int myNBoundaryFaces = myNFaces - myNInteriorFaces;
   const int myNNodes = _nodes.getSelfCount();
   const CRConnectivity& myCellNodes = getCellNodes();
  
   const int eNInteriorFaces_rib = boundaryOnly ? 0 : nz*myNInteriorFaces;
   const int eNInteriorFaces_cap = (nz-1)*myNCells;
   
   const int eNInteriorFaces = eNInteriorFaces_rib + eNInteriorFaces_cap;
   const int eNBoundaryFaces = nz*myNBoundaryFaces + 2*myNCells;
   const int eNFaces = eNInteriorFaces + eNBoundaryFaces;
   const int eNInteriorCells = boundaryOnly ? 0 : nz*myNCells;
   const int eNBoundaryCells = boundaryOnly ? 0 : eNBoundaryFaces;
   
   const int eNNodes = (nz+1)*myNNodes;
   
   Mesh *eMesh = new Mesh(3);
 
   // set nodes
   StorageSite& eMeshNodes = eMesh->getNodes();
   eMeshNodes.setCount( eNNodes );
 
   const Array<VecD3>& myCoords = getNodeCoordinates();
   shared_ptr< Array<VecD3> > eMeshCoordPtr( new Array< VecD3 > ( eNNodes ) );
   Array<VecD3>& eCoords = *eMeshCoordPtr;
   const double dz = zmax/nz;
 
   const double z0 = -zmax/2.0;
   for(int k=0, en=0; k<=nz; k++)
   {
       const double z = z0 + dz*k;
       for(int n=0; n<myNNodes; n++)
       {
           eCoords[en][0] = myCoords[n][0];
           eCoords[en][1] = myCoords[n][1];
           eCoords[en][2] = z;
           en++;
       }
   }
 
   eMesh->setCoordinates( eMeshCoordPtr );
   
           
   // set cells
   
   StorageSite& eMeshCells = eMesh->getCells();
   eMeshCells.setCount( eNInteriorCells, eNBoundaryCells);
   
 
   // set faces
   
   StorageSite& eMeshFaces = eMesh->getFaces();
   eMeshFaces.setCount(eNFaces);
 
 
   shared_ptr<CRConnectivity> eFaceNodes( new CRConnectivity(eMeshFaces,
                                                             eMeshNodes) );
 
   shared_ptr<CRConnectivity> eFaceCells( new CRConnectivity(eMeshFaces,
                                                             eMeshCells) );
 
   // set counts for face cells and face nodes
 
   
   eFaceNodes->initCount();
   eFaceCells->initCount();
 
   int f = 0;
 
   if (!boundaryOnly)
   {
       // rib faces first
       for(; f<eNInteriorFaces_rib; f++)
       {
           eFaceNodes->addCount(f,4);
           eFaceCells->addCount(f,2);
       }
       
       // interior cap faces
       for(int k=1; k<nz; k++)
       {
           for(int c=0; c<myNCells; c++)
           {
               eFaceNodes->addCount(f, myCellNodes.getCount(c));
               eFaceCells->addCount(f, 2);
               f++;
           }
       }
       
       eMesh->createInteriorFaceGroup(eNInteriorFaces);
   }
   
 
   // z = 0 faces
   eMesh->createBoundaryFaceGroup(myNCells,  f, 10000, "wall");
   for(int c=0; c<myNCells; c++)
   {
       eFaceNodes->addCount(f, myCellNodes.getCount(c));
       eFaceCells->addCount(f, 2);
       f++;
   }
   
   // z = zmax faces
   eMesh->createBoundaryFaceGroup(myNCells,  f, 10001, "wall");
   for(int c=0; c<myNCells; c++)
   {
       eFaceNodes->addCount(f, myCellNodes.getCount(c));
       eFaceCells->addCount(f, 2);
       f++;
   }
   
   foreach(const FaceGroupPtr fgPtr, getAllFaceGroups())
   {
       const FaceGroup& fg = *fgPtr;
       const StorageSite& faces = fg.site;
       if (fg.groupType!="interior")
       {
           const int nBFaces = faces.getCount();
 
           eMesh->createBoundaryFaceGroup(nBFaces*nz,  f, fg.id, fg.groupType);
 
           for(int k=0;  k<nz; k++)
             for(int bf=0; bf<nBFaces; bf++)
             {
                 eFaceNodes->addCount(f,4);
                 eFaceCells->addCount(f,2);
                 f++;
             }
       }
   }
   
   eFaceNodes->finishCount();
   eFaceCells->finishCount();
 
 
   // now set the indices of face cells and nodes
 
   
   f = 0;
 
   
   // rib faces first
 
   const CRConnectivity& myFaceNodes = getAllFaceNodes();
   const CRConnectivity& myFaceCells = getAllFaceCells();
 
   if (!boundaryOnly)
   {
       for(int k=0; k<nz; k++)
       {
           const int eCellOffset = k*myNCells;
           const int eNodeOffset = k*myNNodes;
           
           for(int myf=0; myf<myNInteriorFaces; myf++)
           {
               const int myNode0 = myFaceNodes(myf,0);
               const int myNode1 = myFaceNodes(myf,1);
               
               const int myCell0 = myFaceCells(myf,0);
               const int myCell1 = myFaceCells(myf,1);
               
               
               eFaceNodes->add(f, myNode0 + eNodeOffset);
               eFaceNodes->add(f, myNode1 + eNodeOffset );
               eFaceNodes->add(f, myNode1 + eNodeOffset + myNNodes);
               eFaceNodes->add(f, myNode0 + eNodeOffset + myNNodes);
               
               eFaceCells->add(f, myCell0 + eCellOffset);
               eFaceCells->add(f, myCell1 + eCellOffset);
               
               f++;
           }
       }
       
       // interior cap faces
       for(int k=1; k<nz; k++)
       {
           const int eCellOffset = k*myNCells;
           const int eNodeOffset = k*myNNodes;
           
           for(int c=0; c<myNCells; c++)
           {
               const int nCellNodes = myCellNodes.getCount(c);
               for(int nnc=0; nnc<nCellNodes; nnc++)
               {
                   eFaceNodes->add(f, myCellNodes(c,nnc) + eNodeOffset);
               }
               
               eFaceCells->add(f, c + eCellOffset - myNCells);
               eFaceCells->add(f, c + eCellOffset);
               f++;
           }
       }
   }
 
   // counter for boundary faces 
   int ebf = 0;
 
 
   // z = 0 faces
   {  
       const int eCellOffset = 0;
       const int eNodeOffset = 0;
 
       for(int c=0; c<myNCells; c++)
       {
           const int nCellNodes = myCellNodes.getCount(c);
           
           // reverse order of face nodes
           for(int nnc=nCellNodes-1; nnc>=0; nnc--)
           {
               eFaceNodes->add(f, myCellNodes(c,nnc) + eNodeOffset);
           }
           
           eFaceCells->add(f, c + eCellOffset);
           eFaceCells->add(f, ebf + eNInteriorCells);
           f++;
           ebf++;
       }
       
   }
   
   // z = zmax faces
   {  
       const int eCellOffset = (nz-1)*myNCells;
       const int eNodeOffset = nz*myNNodes;
 
       for(int c=0; c<myNCells; c++)
       {
           const int nCellNodes = myCellNodes.getCount(c);
           
           // reverse order of face nodes
           for(int nnc=0; nnc<nCellNodes; nnc++)
           {
               eFaceNodes->add(f, myCellNodes(c,nnc) + eNodeOffset);
           }
           
           eFaceCells->add(f, c + eCellOffset);
           eFaceCells->add(f, ebf + eNInteriorCells);
           f++;
           ebf++;
       }
   }
   
 
   // rib boundary faces
   foreach(const FaceGroupPtr fgPtr, getAllFaceGroups())
   {
       const FaceGroup& fg = *fgPtr;
       const StorageSite& faces = fg.site;
       if (fg.groupType!="interior")
       {
           const int nBFaces = faces.getCount();
 
           const CRConnectivity& bFaceNodes = getFaceNodes(faces);
           const CRConnectivity& bFaceCells = getFaceCells(faces);
           
           for(int k=0;  k<nz; k++)
           {
               const int eCellOffset = k*myNCells;
               const int eNodeOffset = k*myNNodes;
               for(int bf=0; bf<nBFaces; bf++)
               {
                   const int myNode0 = bFaceNodes(bf,0);
                   const int myNode1 = bFaceNodes(bf,1);
                   
                   const int myCell0 = bFaceCells(bf,0);
           
                   
                   eFaceNodes->add(f, myNode0 + eNodeOffset);
                   eFaceNodes->add(f, myNode1 + eNodeOffset);
                   eFaceNodes->add(f, myNode1 + eNodeOffset + myNNodes);
                   eFaceNodes->add(f, myNode0 + eNodeOffset + myNNodes);
                   
                   eFaceCells->add(f, myCell0 + eCellOffset);
                   eFaceCells->add(f, ebf + eNInteriorCells);
                   
                   f++;
                   ebf++;
               }
           }
       }
       
   }
 
   eFaceNodes->finishAdd();
   eFaceCells->finishAdd();
 
  //setting faceNodes
   SSPair key1(&eMeshFaces,&eMeshNodes);
   eMesh->_connectivityMap[key1] = eFaceNodes;
 
   if (!boundaryOnly)
   {
       SSPair key2(&eMeshFaces,&eMeshCells);
       eMesh->_connectivityMap[key2] = eFaceCells;
   }
   
   return eMesh;
 }

void Mesh::findCommonFaces	(	StorageSite &	faces,
		StorageSite &	otherFaces,
		const GeomFields &	geomFields
	)

Definition at line 996 of file Mesh.cpp.

References GeomFields::area, GeomFields::coordinate, cross(), epsilon, StorageSite::getCommonMap(), StorageSite::getCount(), mag(), and mag2().

 {
   const int count(faces.getCount());
   if (count != otherFaces.getCount())
     throw CException("face groups are not of the same length");
 
   const Array<VecD3>& coords =
     dynamic_cast<const Array<VecD3>& >(geomFields.coordinate[faces]);
   
   const Array<VecD3>& otherCoords =
     dynamic_cast<const Array<VecD3>& >(geomFields.coordinate[otherFaces]);
 
   const Array<VecD3>& area =
     dynamic_cast<const Array<VecD3>& >(geomFields.area[faces]);
   
   const Array<VecD3>& otherArea =
     dynamic_cast<const Array<VecD3>& >(geomFields.area[otherFaces]);
 
   KSearchTree thisFacesTree(coords);
   
   Array<int> closest(2);
 
   shared_ptr<IntArray> myCommonFaces(new IntArray(count));
   shared_ptr<IntArray> otherCommonFaces(new IntArray(count));
   
   for(int f=0; f<count; f++)
   {
       thisFacesTree.findNeighbors(otherCoords[f],2,closest);
       
       const int closestFace = closest[0];
       double dist0 = mag(otherCoords[f] - coords[closestFace]);
       
       // distance between the two closest point used as scale
       
       double distScale = mag(coords[closest[0]] - coords[closest[1]]);
       
       if (dist0 < distScale*epsilon)
       {
           double crossProductMag(mag2(cross(otherArea[f],area[closestFace])));
           if (crossProductMag > mag2(otherArea[f])*epsilon)
             throw CException("cross product is not small");
           
           (*otherCommonFaces)[f] = closestFace;
           (*myCommonFaces)[closestFace] = f;
       }
       else
         throw CException("Not a match");
       
   }
   
   faces.getCommonMap()[&otherFaces] = myCommonFaces;
   otherFaces.getCommonMap()[&faces] = otherCommonFaces;
   
 }

void Mesh::findCommonNodes ( Mesh & other )

Definition at line 877 of file Mesh.cpp.

References _nodes, epsilon, KSearchTree::findNeighbors(), getAllFaceGroups(), StorageSite::getCommonMap(), StorageSite::getCount(), CRConnectivity::getCount(), getFaceNodes(), getNodeCoordinates(), FaceGroup::groupType, KSearchTree::insert(), mag(), and FaceGroup::site.

 {
   StorageSite& nodes = _nodes;
   StorageSite& otherNodes = other._nodes;
   const int nNodes = nodes.getCount();
   const int nOtherNodes = otherNodes.getCount();
 
   const Array<VecD3>& coords = getNodeCoordinates();
   const Array<VecD3>& otherCoords = other.getNodeCoordinates();
 
 
   KSearchTree bNodeTree;
 
   // add all boundary nodes of this mesh to the tree
   {
       Array<bool> nodeMark(nNodes);
       nodeMark = false;
       foreach(const FaceGroupPtr fgPtr, getAllFaceGroups())
       {
           const FaceGroup& fg = *fgPtr;
           const StorageSite& faces = fg.site;
           if (fg.groupType!="interior")
           {
               const int nFaces = faces.getCount();
               const CRConnectivity& faceNodes = getFaceNodes(faces);
               for(int f=0; f<nFaces; f++)
               {
                   const int nFaceNodes = faceNodes.getCount(f);
                   for(int nn=0; nn<nFaceNodes; nn++)
                   {
                       const int n=faceNodes(f,nn);
                       if (!nodeMark[n])
                       {
                           nodeMark[n] = true;
                           bNodeTree.insert(coords[n],n);
                       }
                   }
               }
           }
       }
   }
   
 
   // loop over all the boundary nodes of the other mesh to find possible common ones
   Array<bool> nodeMark(nOtherNodes);
 
   typedef map<int,int> CommonNodesMap;
   CommonNodesMap commonNodesMap;
 
   Array<int> closest(2);
   
   nodeMark = false;
 
   
   foreach(const FaceGroupPtr fgPtr, other.getAllFaceGroups())
   {
       const FaceGroup& fg = *fgPtr;
       const StorageSite& faces = fg.site;
       if (fg.groupType!="interior")
       {
           const int nFaces = faces.getCount();
           const CRConnectivity& faceNodes = other.getFaceNodes(faces);
 
           for(int f=0; f<nFaces; f++)
           {
               const int nFaceNodes = faceNodes.getCount(f);
               for(int nn=0; nn<nFaceNodes; nn++)
               {
                   const int n=faceNodes(f,nn);
                   if (!nodeMark[n])
                   {
                       bNodeTree.findNeighbors(otherCoords[n],2,closest);
                       
                       double dist0 = mag(otherCoords[n] - coords[closest[0]]);
                       
                       // distance between the two closest point used as scale
                       
                       double distScale = mag(coords[closest[0]] - coords[closest[1]]);
                       
                       if (dist0 < distScale*epsilon)
                       {
                           // if another node has already been found as the
                           // closest for this one we have something wrong
                           if (commonNodesMap.find(closest[0]) != commonNodesMap.end())
                           {
                               throw CException("duplicate nodes on the mesh ?");
                           }
                           commonNodesMap.insert(make_pair(closest[0], n));
                       }
                       nodeMark[n] = true;
                   }
               }
           }
       }
   }
 
   const int nCommon = commonNodesMap.size();
 
   if (nCommon == 0)
     return;
   cout << "found " << nCommon << " common nodes " << endl;
   
   shared_ptr<IntArray> myCommonNodes(new IntArray(nCommon));
   shared_ptr<IntArray> otherCommonNodes(new IntArray(nCommon));
 
   int nc=0;
   foreach(CommonNodesMap::value_type& pos, commonNodesMap)
   {
       (*myCommonNodes)[nc] = pos.first;
       (*otherCommonNodes)[nc] = pos.second;
       nc++;
   }
   
   nodes.getCommonMap()[&otherNodes] = myCommonNodes;
   otherNodes.getCommonMap()[&nodes] = otherCommonNodes;
   
 }

int Mesh::get_request_size ( )

private

Definition at line 2363 of file Mesh.cpp.

References getCells(), StorageSite::getGatherProcID(), and StorageSite::getScatterMap().

Referenced by syncCounts(), and syncIndices().

 {
     int indx =  0;
     const StorageSite& site = this->getCells();
     const StorageSite::ScatterMap& scatterMap = site.getScatterMap();
     foreach(const StorageSite::ScatterMap::value_type& mpos, scatterMap){
         const StorageSite&  oSite = *mpos.first;
         //checking if storage site is only site or ghost site, we only communicate ghost site ( oSite.getCount() == -1 ) 
         if ( oSite.getGatherProcID() != -1 )
            indx++;
     }
     return indx;
 }

const CRConnectivity & Mesh::getAllFaceCells ( ) const

Definition at line 378 of file Mesh.cpp.

References _cells, _connectivityMap, and _faces.

 {
   SSPair key(&_faces,&_cells);
   ConnectivityMap::const_iterator pos = _connectivityMap.find(key);
   if (pos != _connectivityMap.end())
     return *pos->second;
   throw CException("face cells not defined");
 }

CRConnectivity & Mesh::getAllFaceCells ( )

Definition at line 469 of file Mesh.cpp.

References _cells, _connectivityMap, and _faces.

 {
   SSPair key(&_faces,&_cells);
   ConnectivityMap::const_iterator pos = _connectivityMap.find(key);
   if (pos != _connectivityMap.end())
     return *pos->second;
   throw CException("face cells not defined");
 }

const FaceGroupList& Mesh::getAllFaceGroups ( ) const

inline

Definition at line 193 of file Mesh.h.

References _faceGroups.

194 {return _faceGroups;}

Mesh::_faceGroups

FaceGroupList _faceGroups

Definition: Mesh.h:362

const CRConnectivity & Mesh::getAllFaceNodes ( ) const

Definition at line 368 of file Mesh.cpp.

References _connectivityMap, _faces, and _nodes.

Referenced by MeshMetricsCalculator< T >::calculateFaceAreas(), MeshMetricsCalculator< T >::calculateFaceCentroids(), NcDataWriter::connectivities(), extrude(), MeshDismantler::faceNodesAddBoundaryInterfaces(), MeshDismantler::faceNodesAddInteriorFaces(), MeshDismantler::faceNodesAddMeshInterfaces(), MeshDismantler::faceNodesAddPartitionInterfaces(), MeshDismantler::faceNodesInit(), getCellNodes(), getFaceNodes(), MeshAssembler::getInnerNodesCount(), IBManager::markIntersections(), AABB::meshIntersections(), setCommonFacesMap(), MeshAssembler::setFaceNodes(), MeshAssembler::setInterfaceNodes(), and MovingMeshModel< T >::volChange().

 {
   SSPair key(&_faces,&_nodes);
   ConnectivityMap::const_iterator pos = _connectivityMap.find(key);
   if (pos != _connectivityMap.end())
     return *pos->second;
   throw CException("face nodes not defined");
 }

const ArrayBase & Mesh::getBNglobalToLocal ( ) const

Definition at line 346 of file Mesh.cpp.

References createAndGetBNglobalToLocal().

 {
   return *(createAndGetBNglobalToLocal());
 }

const FaceGroupList& Mesh::getBoundaryFaceGroups ( ) const

inline

Definition at line 187 of file Mesh.h.

References _boundaryGroups.

188 {return _boundaryGroups;}

Mesh::_boundaryGroups

FaceGroupList _boundaryGroups

Definition: Mesh.h:363

int Mesh::getBoundaryGroupCount ( ) const

inline

Definition at line 184 of file Mesh.h.

References _boundaryGroups.

Referenced by debug_mesh(), MeshDismantler::faceCellsAddBoundaryInterfaces(), MeshDismantler::faceNodesAddBoundaryInterfaces(), MeshDismantler::faceNodesInit(), MeshDismantler::global_offset(), MeshPartitioner::global_offset(), MeshPartitioner::globalCellID_procID_map(), MeshDismantler::set_local_global(), MeshPartitioner::set_local_global(), MeshAssembler::setBoundaryFaceGroup(), MeshAssembler::setFaceCells(), MeshAssembler::setFaceNodes(), and MeshAssembler::setMeshCellColor().

184 {return _boundaryGroups.size();}

Mesh::_boundaryGroups

FaceGroupList _boundaryGroups

Definition: Mesh.h:363

const StorageSite & Mesh::getBoundaryNodes ( ) const

Definition at line 325 of file Mesh.cpp.

References _boundaryNodes, _nodes, createAndGetBNglobalToLocal(), and StorageSite::getCount().

Referenced by MovingMeshModel< T >::advance(), and MeshMetricsCalculator< T >::calculateBoundaryNodeNormal().

 {
   if(!_boundaryNodes)
   {
       const int nNodes = _nodes.getCount();
       shared_ptr<Array<int> > GlobalToLocalPtr = createAndGetBNglobalToLocal();
       Array<int>& GlobalToLocal = *GlobalToLocalPtr;
       int BoundaryNodeCount = 0;
       int nLocal = 0;
       for(int i=0;i<nNodes;i++)
       {
           if(GlobalToLocal[i] != -1)
             nLocal++;
       }
       BoundaryNodeCount = nLocal;
       _boundaryNodes = new StorageSite(BoundaryNodeCount,0,0,0);
   }
   return *_boundaryNodes;
 }

const set<int>& Mesh::getBoundaryNodesSet ( ) const

inline

Definition at line 253 of file Mesh.h.

References _boundaryNodesSet.

253 { return _boundaryNodesSet;}

Mesh::_boundaryNodesSet

set< int > _boundaryNodesSet

Definition: Mesh.h:394

set<int>& Mesh::getBoundaryNodesSet ( )

inline

Definition at line 254 of file Mesh.h.

References _boundaryNodesSet.

254 { return _boundaryNodesSet;}

Mesh::_boundaryNodesSet

set< int > _boundaryNodesSet

Definition: Mesh.h:394

const CRConnectivity & Mesh::getCellCells ( ) const

Definition at line 480 of file Mesh.cpp.

References _cells, _connectivityMap, getAllFaceCells(), getCellFaces(), and CRConnectivity::multiply().

 {
   SSPair key(&_cells,&_cells);
   ConnectivityMap::const_iterator pos = _connectivityMap.find(key);
   if (pos != _connectivityMap.end())
     return *pos->second;
 
   const CRConnectivity& faceCells = getAllFaceCells();
   const CRConnectivity& cellFaces = getCellFaces();
   shared_ptr<CRConnectivity> cellCells = cellFaces.multiply(faceCells,true);
   _connectivityMap[key] = cellCells;
   return *cellCells;
 }

const CRConnectivity & Mesh::getCellCells2 ( ) const

Definition at line 495 of file Mesh.cpp.

References _cellCells2, _cellCellsGlobal, _globalToLocal, CRConnectivity::CELLCELL2, eraseConnectivity(), getCellCells(), getCells(), CRConnectivity::getCol(), StorageSite::getCount(), CRConnectivity::getCount(), StorageSite::getCountLevel1(), Array< T >::getLength(), CRConnectivity::getRow(), CRConnectivity::getRowSite(), StorageSite::getSelfCount(), and CRConnectivity::multiply().

Referenced by IBManager::createIBInterpolationStencil(), IBManager::createSolidInterpolationStencil(), PlateModel< T >::Impl::initDeformationLinearization(), and StructureModel< T >::Impl::initDeformationLinearization().

 {
   if (!_cellCells2)
   { 
 #ifdef FVM_PARALLEL
     if ( MPI::COMM_WORLD.Get_size() > 1 ) {
       //CRConnectivity constructor
       _cellCells2 = shared_ptr<CRConnectivity> ( new CRConnectivity(this->getCells(), this->getCells()) );
       //initCount
       _cellCells2->initCount();
 
       const int ncells = this->getCells().getCountLevel1();
       const int selfCount = this->getCells().getSelfCount();
 
       const CRConnectivity& cellCells = this->getCellCells();
       multimap<int,int>::const_iterator it0;
       multimap<int,int>::const_iterator it1;
        //loop over  cells
       for ( int n = 0; n < ncells; n++ ){ 
          set<int> setCells;
          for ( int k = 0; k < cellCells.getCount(n); k++ ){
              const int cellID1 = cellCells(n,k);
              setCells.insert( cellID1 );
              if ( cellID1 < selfCount ){ //it means inner cells use cellCells 
                 for ( int i = 0; i < cellCells.getCount(cellID1); i++ ){
                     const int cellID2 = cellCells(cellID1,i);
                     setCells.insert(cellID2);
                 }
              } else {
                 for (  it1 = _cellCellsGlobal.equal_range(cellID1).first; it1 != _cellCellsGlobal.equal_range(cellID1).second; it1++ ){
                    const int globalCellID2 = it1->second;
                    const int localID2 = _globalToLocal.find(globalCellID2)->second;
                    if ( _globalToLocal.count(globalCellID2) > 0 )
                       setCells.insert(localID2);
                 }
              }
          }
          //erase itself
          setCells.erase(n);
          _cellCells2->addCount(n,setCells.size());
       }
       //finish count
       _cellCells2->finishCount();
       //add cellcells2
       //loop over  cells
       for ( int n = 0; n < ncells; n++ ){ 
          set<int> setCells;
          for ( int k = 0; k < cellCells.getCount(n); k++ ){
              const int cellID1 = cellCells(n,k);
              setCells.insert( cellID1 );
              if ( cellID1 < selfCount ){ //it means inner cells use cellCells 
                 for ( int i = 0; i < cellCells.getCount(cellID1); i++ ){
                     const int cellID2 = cellCells(cellID1,i);
                     setCells.insert(cellID2);
                 }
              } else {
                 for (  it1 = _cellCellsGlobal.equal_range(cellID1).first; it1 != _cellCellsGlobal.equal_range(cellID1).second; it1++ ){
                    const int globalCellID2 = it1->second;
                    const int localID2 = _globalToLocal.find(globalCellID2)->second;
                    if ( _globalToLocal.count(globalCellID2) > 0 )
                       setCells.insert(localID2);
                 }
              }
          }
          //erase itself
          setCells.erase(n);
          foreach ( const set<int>::value_type cellID, setCells ){
              _cellCells2->add(n, cellID);
          }
       }
       //finish add
       _cellCells2->finishAdd();
 
      //unique numbering for cells to
     {
        const int ncount = _cellCells2->getRowSite().getCountLevel1();
        const Array<int>& row = _cellCells2->getRow();
        Array<int>& col = _cellCells2->getCol();
        for( int i = 0; i < ncount; i++ ){
           for ( int j = row[i]; j < row[i+1]; j++ ){
              const int globalID = (*_localToGlobal)[ col[j] ];
              col[j] = _globalToLocal[globalID];
           }
        }
      }
      //uniqing numberinf for face cells
      {
         CRConnectivity& faceCells = (const_cast<Mesh *>(this))->getAllFaceCells();
         const int nfaces = faceCells.getRowSite().getCount();
         const Array<int>& row = faceCells.getRow();
         Array<int>& col = faceCells.getCol();
         for( int i = 0; i < nfaces; i++ ){
            for ( int j = row[i]; j < row[i+1]; j++ ){
               const int globalID = (*_localToGlobal)[ col[j] ];
               col[j] = _globalToLocal[globalID];
            }
         }
         const StorageSite& cellSite = this->getCells();
         this->eraseConnectivity(cellSite,cellSite);
      }
 
 
       //get mappers to update cellCell2 localToGlobalMap and globalToLocalMapper
       map<int,int>& globalToLocalMapper = _cellCells2->getGlobalToLocalMapper();
       foreach( const  mapInt::value_type& mpos, _globalToLocal ){
          globalToLocalMapper[mpos.first] = mpos.second;
       }
 
       //localToGlobal need to be first created
       _cellCells2->resizeLocalToGlobalMap( this->getCells().getCountLevel1() );
       Array<int>& localToGlobal = *(_cellCells2->getLocalToGlobalMapPtr());
       for ( int i = 0; i < localToGlobal.getLength(); i++ ){
          localToGlobal[i] = (*_localToGlobal)[i];
       }
 
   } else {  //if it is a one processor, we want to call this version, otherwise, couplingplate has trouble
        const CRConnectivity& cellCells = getCellCells();
        _cellCells2 = cellCells.multiply(cellCells, true);
   }
 
    //set enum as CELLCELL2
   _cellCells2->setConnType(CRConnectivity::CELLCELL2);
 
 #endif
 
 #ifndef FVM_PARALLEL
        const CRConnectivity& cellCells = getCellCells();
        _cellCells2 = cellCells.multiply(cellCells, true);
 #endif
 
 
 
   }
 
   return *_cellCells2;
 }

const CRConnectivity& Mesh::getCellCellsGhostExt ( ) const

inline

Definition at line 267 of file Mesh.h.

References _cellCellsGhostExt, and getCellCells().

                                                      { 
 #ifdef FVM_PARALLEL
       int numProcs = MPI::COMM_WORLD.Get_size();
       if ( numProcs > 1 )
           return *_cellCellsGhostExt;
       else
 #endif      
         return this->getCellCells();
   }

multiMap& Mesh::getCellCellsGlobal ( )

inline

Definition at line 247 of file Mesh.h.

References _cellCellsGlobal.

Referenced by MeshPartitioner::cellcells_global_extension(), MeshPartitioner::DEBUG_cellcells_global(), MeshPartitioner::gatherCellsLevel1_partID_map(), MeshPartitioner::set_cellcells_global(), and MeshDismantler::setCellsSite().

247 { return _cellCellsGlobal;}

Mesh::_cellCellsGlobal

multiMap _cellCellsGlobal

Definition: Mesh.h:400

const multiMap& Mesh::getCellCellsGlobal ( ) const

inline

Definition at line 248 of file Mesh.h.

References _cellCellsGlobal.

248 { return _cellCellsGlobal;}

Mesh::_cellCellsGlobal

multiMap _cellCellsGlobal

Definition: Mesh.h:400

Array<int>& Mesh::getCellColors ( )

inline

Definition at line 228 of file Mesh.h.

References _cellColor.

Referenced by MeshDismantler::getGatherArrays(), MeshDismantler::getScatterArrays(), MeshDismantler::setCellsMapper(), MeshDismantler::setCellsSite(), MeshDismantler::setFacesSite(), MeshDismantler::setNodesMapper(), and MeshDismantler::setNodesSite().

228 { return *_cellColor;}

Mesh::_cellColor

shared_ptr< Array< int > > _cellColor

Definition: Mesh.h:371

const Array<int>& Mesh::getCellColors ( ) const

inline

Definition at line 229 of file Mesh.h.

References _cellColor.

229 { return *_cellColor;}

Mesh::_cellColor

shared_ptr< Array< int > > _cellColor

Definition: Mesh.h:371

Array<int>& Mesh::getCellColorsOther ( )

inline

Definition at line 231 of file Mesh.h.

References _cellColorOther.

Referenced by MeshDismantler::getGatherArrays(), and MeshDismantler::getScatterArrays().

231 { return *_cellColorOther;}

Mesh::_cellColorOther

shared_ptr< Array< int > > _cellColorOther

Definition: Mesh.h:372

const Array<int>& Mesh::getCellColorsOther ( ) const

inline

Definition at line 232 of file Mesh.h.

References _cellColorOther.

232 { return *_cellColorOther;}

Mesh::_cellColorOther

shared_ptr< Array< int > > _cellColorOther

Definition: Mesh.h:372

const CRConnectivity & Mesh::getCellFaces ( ) const

Definition at line 454 of file Mesh.cpp.

References _cells, _connectivityMap, _faces, getAllFaceCells(), and CRConnectivity::getTranspose().

Referenced by COMETBoundary< T >::applyTemperatureWallFine(), CellMark_Impl(), COMETModel< T >::coarsenInterfaceCells(), COMETModel< T >::coarsenInterior(), COMETModel< T >::correctSolution(), MeshAssembler::countInterfaceNodes(), getCellCells(), COMETModel< T >::MakeCoarseMesh1(), COMETModel< T >::MakeCoarseMesh2(), and COMETInterface< T >::makeDMMcoeffs().

 {
   SSPair key(&_cells,&_faces);
   ConnectivityMap::const_iterator pos = _connectivityMap.find(key);
   if (pos != _connectivityMap.end())
     return *pos->second;
 
   const CRConnectivity& faceCells = getAllFaceCells();
   shared_ptr<CRConnectivity> cellFaces = faceCells.getTranspose();
 
   _connectivityMap[key] = cellFaces;
   return *cellFaces;
 }

const CRConnectivity & Mesh::getCellNodes ( ) const

Definition at line 426 of file Mesh.cpp.

References _cells, _connectivityMap, _coordinates, _faces, _nodes, getAllFaceCells(), getAllFaceNodes(), and orderCellFacesAndNodes().

Referenced by MovingMeshModel< T >::advance(), StructureDeformationModel< T >::calculateNodeDisplacement(), PlateDeformationModel< T >::calculateNodeDisplacement(), debug_mesh(), extrude(), MeshPartitioner::get_local_nodes(), PartMesh::local_nodes(), IBManager::markIntersections(), AABB::meshIntersections(), PartMesh::set_eptr_eind(), MeshPartitioner::set_eptr_eind(), MeshDismantler::setNodesMapper(), MeshDismantler::setNodesSite(), PlateDeformationModel< T >::updateBoundaryMesh(), and VTKWriter< T >::VTKWriter().

 {
   SSPair key(&_cells,&_nodes);
  
 
 
   ConnectivityMap::const_iterator pos = _connectivityMap.find(key);
 
   if (pos != _connectivityMap.end())
     return *pos->second;
 
 
   const CRConnectivity& faceCells = getAllFaceCells();
   const CRConnectivity& faceNodes = getAllFaceNodes();
   
   SSPair keycf(&_cells,&_faces);
   shared_ptr<CRConnectivity> cellFaces = faceCells.getTranspose();
   shared_ptr<CRConnectivity> cellNodes = cellFaces->multiply(faceNodes,false);
 
   _connectivityMap[keycf] = cellFaces;
   _connectivityMap[key] = cellNodes;
   
   orderCellFacesAndNodes(*cellFaces, *cellNodes, faceNodes,
                          faceCells, *_coordinates);
   return *cellNodes;
 }

const StorageSite& Mesh::getCells ( ) const

inline

Definition at line 109 of file Mesh.h.

References _cells.

109 {return _cells;}

Mesh::_cells

StorageSite _cells

Definition: Mesh.h:354

StorageSite& Mesh::getCells ( )

inline

Definition at line 157 of file Mesh.h.

References _cells.

157 {return _cells;}

Mesh::_cells

StorageSite _cells

Definition: Mesh.h:354

int Mesh::getCellZoneID ( ) const

inline

Definition at line 319 of file Mesh.h.

References _cellZoneID.

319 { return _cellZoneID;}

Mesh::_cellZoneID

int _cellZoneID

Definition: Mesh.h:352

const map<int,int>& Mesh::getCommonFacesMap ( ) const

inline

Definition at line 255 of file Mesh.h.

References _commonFacesMap.

255 { return _commonFacesMap;}

Mesh::_commonFacesMap

map< int, int > _commonFacesMap

Definition: Mesh.h:392

const map<int,int>& Mesh::getCommonFacesMapOther ( ) const

inline

Definition at line 256 of file Mesh.h.

References _commonFacesMapOther.

256 { return _commonFacesMapOther;}

Mesh::_commonFacesMapOther

map< int, int > _commonFacesMapOther

Definition: Mesh.h:393

const CRConnectivity & Mesh::getConnectivity	(	const StorageSite &	from,
		const StorageSite &	to
	)		const

Definition at line 416 of file Mesh.cpp.

References _connectivityMap.

Referenced by CellMark_Impl(), MeshMetricsCalculator< T >::computeGridInterpolationMatrices(), MeshMetricsCalculator< T >::computeIBandSolidInterpolationMatrices(), KineticModel< T >::computeIBFaceDsf(), COMETModel< T >::computeIBFaceDsf(), MeshMetricsCalculator< T >::computeIBInterpolationMatrices(), MeshMetricsCalculator< T >::computeIBInterpolationMatricesCells(), KineticModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), MeshMetricsCalculator< T >::computeSolidInterpolationMatrices(), ElectricModel< T >::Impl::computeSolidSurfaceForce(), FlowModel< T >::Impl::computeSolidSurfaceForce(), KineticModel< T >::computeSurfaceForce(), COMETModel< T >::computeSurfaceForce(), COMETModel< T >::correctSolution(), COMETModel< T >::injectResid(), COMETModel< T >::makeFinestToCoarseConn(), and COMETModel< T >::makePlotColors().

 {
   SSPair key(&from,&to);
   ConnectivityMap::const_iterator pos = _connectivityMap.find(key);
   if (pos != _connectivityMap.end())
     return *pos->second;
   throw CException("connectivity not defined");
 }

ConnectivityMap& Mesh::getConnectivityMap ( )

inline

Definition at line 335 of file Mesh.h.

References _connectivityMap.

Referenced by MeshPartitioner::extractBoundaryMesh().

335 {return _connectivityMap;}

Mesh::_connectivityMap

ConnectivityMap _connectivityMap

Definition: Mesh.h:365

int Mesh::getDimension ( ) const

inline

Definition at line 105 of file Mesh.h.

References _dimension.

Referenced by AABB::AABB(), MeshMetricsCalculator< T >::calculateCellVolumes(), MeshPartitioner::cellcells_global_extension(), MeshMetricsCalculator< T >::computeIBInterpolationMatrices(), MeshMetricsCalculator< T >::computeIBInterpolationMatricesCells(), MeshMetricsCalculator< T >::computeSolidInterpolationMatrices(), StructureModel< T >::Impl::computeVMStress(), StructureModel< T >::Impl::creepInit(), debug_mesh(), BatteryPCDiffusionDiscretization< X, Diag, OffDiag >::discretize(), StructureSourceDiscretization< T, Diag, OffDiag >::discretizeFaces(), StructurePlasticDiscretization< T, Diag, OffDiag >::discretizeFaces(), MeshPartitioner::extractBoundaryMesh(), GradientModel< Vector< T, 3 > >::getGradientMatrix(), StructureModel< T >::Impl::getTraction(), MeshDismantler::init(), COMETModel< T >::MakeCoarseMesh1(), COMETModel< T >::MakeCoarseMesh2(), COMETModel< T >::MakeInteriorCoarseMesh(), IBManager::markIntersections(), COMETModel< T >::syncGhostCoarsening(), MovingMeshModel< T >::volChange(), and VTKWriter< T >::VTKWriter().

105 {return _dimension;}

Mesh::_dimension

const int _dimension

Definition: Mesh.h:346

const CRConnectivity & Mesh::getFaceCells ( const StorageSite & site ) const

Definition at line 388 of file Mesh.cpp.

References _cells, _connectivityMap, CRConnectivity::createOffset(), getAllFaceCells(), StorageSite::getCount(), and StorageSite::getOffset().

 {
   SSPair key(&faces,&_cells);
   ConnectivityMap::const_iterator pos = _connectivityMap.find(key);
   if (pos != _connectivityMap.end())
     return *pos->second;
 
   shared_ptr<CRConnectivity> thisFaceCells =
     getAllFaceCells().createOffset(faces,faces.getOffset(),faces.getCount());
   _connectivityMap[key] = thisFaceCells;
   return *thisFaceCells;
 }

const CRConnectivity & Mesh::getFaceCells2 ( ) const

Definition at line 633 of file Mesh.cpp.

References _faceCells2, getAllFaceCells(), getCellCells(), and CRConnectivity::multiply().

 {
   if (!_faceCells2)
   {
       const CRConnectivity& cellCells = getCellCells();
       const CRConnectivity& faceCells = getAllFaceCells();
       _faceCells2 = faceCells.multiply(cellCells, false);
   }
   return *_faceCells2;
 }

const FaceGroup & Mesh::getFaceGroup ( const int fgId ) const

Definition at line 1570 of file Mesh.cpp.

References getAllFaceGroups(), and FaceGroup::id.

Referenced by COMETModel< T >::coarsenInterfaceCells(), COMETDiscretizer< T >::correctInterface(), createDoubleShell(), FluentReader::createMesh(), createShell(), COMETModel< T >::initCoarse(), COMETInterface< T >::makeCoarseCoeffs(), COMETInterface< T >::makeDMMcoeffs(), COMETModel< T >::MakeInteriorCoarseMesh(), COMETInterface< T >::makeNoInterfaceCoeffs(), BatteryModel< T >::Impl::printMatrixElementsOnFace(), COMETInterface< T >::updateOtherGhost(), and COMETInterface< T >::updateResid().

 {
   foreach(const FaceGroupPtr fgPtr, getAllFaceGroups())
   {
       const FaceGroup& fg = *fgPtr;
       if (fg.id == fgId)
         return fg;
   }
   throw CException("no face group with given id");
 }

int Mesh::getFaceGroupCount ( ) const

inline

Definition at line 183 of file Mesh.h.

References _faceGroups.

Referenced by debug_mesh().

183 {return _faceGroups.size();}

Mesh::_faceGroups

FaceGroupList _faceGroups

Definition: Mesh.h:362

const CRConnectivity & Mesh::getFaceNodes ( const StorageSite & site ) const

Definition at line 402 of file Mesh.cpp.

References _connectivityMap, _nodes, CRConnectivity::createOffset(), getAllFaceNodes(), StorageSite::getCount(), and StorageSite::getOffset().

Referenced by AABB::AABB(), MeshMetricsCalculator< T >::calculateBoundaryNodeNormal(), createAndGetBNglobalToLocal(), MeshPartitioner::extractBoundaryMesh(), extractBoundaryMesh(), extrude(), findCommonNodes(), StructureDeformationModel< T >::updateBoundaryMesh(), and VTKWriter< T >::VTKWriter().

 {
   SSPair key(&faces,&_nodes);
   ConnectivityMap::const_iterator pos = _connectivityMap.find(key);
   if (pos != _connectivityMap.end())
     return *pos->second;
 
   shared_ptr<CRConnectivity> thisFaceNodes =
     getAllFaceNodes().createOffset(faces,faces.getOffset(),faces.getCount());
   _connectivityMap[key] = thisFaceNodes;
   return *thisFaceNodes;
 }

const StorageSite& Mesh::getFaces ( ) const

inline

Definition at line 108 of file Mesh.h.

References _faces.

Referenced by COMETBoundary< T >::applyTemperatureWallFine(), MeshMetricsCalculator< T >::calculateCellCentroids(), MeshMetricsCalculator< T >::calculateCellVolumes(), MeshMetricsCalculator< T >::calculateFaceAreaMag(), MeshMetricsCalculator< T >::calculateFaceAreas(), MeshMetricsCalculator< T >::calculateFaceCentroids(), CellMark_Impl(), COMETModel< T >::coarsenInterfaceCells(), COMETModel< T >::coarsenInterior(), COMETModel< T >::COMETModel(), FlowModel< T >::Impl::computeContinuityResidual(), KineticModel< T >::computeIBFaceDsf(), COMETModel< T >::computeIBFaceDsf(), FlowModel< T >::Impl::computeIBFaceVelocity(), MeshMetricsCalculator< T >::computeIBInterpolationMatrices(), MeshMetricsCalculator< T >::computeIBInterpolationMatricesCells(), KineticModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), KineticModel< T >::ConservationofMassCheck(), COMETModel< T >::ConservationofMassCheck(), KineticModel< T >::correctMassDeficit(), COMETModel< T >::correctMassDeficit(), COMETModel< T >::correctSingleNeighbor(), MeshAssembler::countInterfaceNodes(), IBManager::createIBFaces(), IBManager::createIBInterpolationStencil(), FluentReader::createMesh(), IBManager::createSolidInterpolationStencil(), debug_mesh(), DriftDiscretization< X, Diag, OffDiag >::discretize(), GenericIBDiscretization< X, Diag, OffDiag >::discretize(), PhononConvectionDiscretization< X, Diag, OffDiag >::discretize(), ConvectionDiscretization< X, Diag, OffDiag >::discretize(), GenericKineticIBDiscretization< X, Diag, OffDiag >::discretize(), ConvectionDiscretization_Kmodel< X, Diag, OffDiag >::discretize(), MomentumPressureGradientDiscretization< X >::discretize(), ElecDiffusionDiscretization< X, Diag, OffDiag >::discretize(), MeshPartitioner::extractBoundaryMesh(), extractBoundaryMesh(), extrude(), IBManager::findNearestCellForSolidFaces(), COMETModel< T >::FinishCoarseMesh(), MeshAssembler::getInnerNodesCount(), GradientModel< Vector< T, 3 > >::getLeastSquaresGradientMatrix2D(), GradientModel< Vector< T, 3 > >::getLeastSquaresGradientMatrix3D(), FlowModel< T >::Impl::getMomentumFluxIntegralonIBFaces(), FlowModel< T >::Impl::getPressureIntegralonIBFaces(), MeshMetricsCalculator< T >::init(), ThermalModel< T >::Impl::init(), VacancyModel< T >::Impl::init(), SpeciesModel< T >::Impl::init(), ElectricModel< T >::Impl::init(), FlowModel< T >::Impl::init(), BatteryModel< T >::Impl::init(), COMETModel< T >::init(), MovingMeshModel< T >::init(), KineticModel< T >::MacroparameterIBCell(), COMETModel< T >::MakeCoarseMesh1(), COMETModel< T >::MakeCoarseMesh2(), COMETModel< T >::MakeInteriorCoarseMesh(), IBManager::markIntersections(), Mesh(), AABB::meshIntersections(), PhononModel< T >::PhononModel(), MeshDismantler::setFacesSite(), IBManager::update(), StructureDeformationModel< T >::updateBoundaryMesh(), PlateDeformationModel< T >::updateBoundaryMesh(), ElectricModel< T >::Impl::updateConvectionFlux(), MovingMeshModel< T >::updateTime(), MovingMeshModel< T >::volChange(), FluentDataExporter< T >::writeScalarField(), VTKWriter< T >::writeScalarField(), and VTKWriter< T >::writeVectorField().

108 {return _faces;}

Mesh::_faces

StorageSite _faces

Definition: Mesh.h:355

StorageSite& Mesh::getFaces ( )

inline

Definition at line 156 of file Mesh.h.

References _faces.

156 {return _faces;}

Mesh::_faces

StorageSite _faces

Definition: Mesh.h:355

const StorageSite* Mesh::getGhostCellSiteGather ( const PartIDMeshIDPair & id ) const

inline

Definition at line 122 of file Mesh.h.

References _ghostCellSiteGatherMap.

Referenced by NcDataReader::createMappers().

123 { return _ghostCellSiteGatherMap.find(id)->second.get(); }

Mesh::_ghostCellSiteGatherMap

GhostCellSiteMap _ghostCellSiteGatherMap

Definition: Mesh.h:378

const StorageSite* Mesh::getGhostCellSiteGatherLevel1 ( const PartIDMeshIDPair & id ) const

inline

Definition at line 145 of file Mesh.h.

Mesh::_ghostCellSiteGatherMapLevel1

146 { return _ghostCellSiteGatherMapLevel1.find(id)->second.get(); }

GhostCellSiteMap _ghostCellSiteGatherMapLevel1

Definition: Mesh.h:381

GhostCellSiteMap& Mesh::getGhostCellSiteGatherMap ( )

inline

Definition at line 125 of file Mesh.h.

References _ghostCellSiteGatherMap.

126 { return _ghostCellSiteGatherMap; }

Mesh::_ghostCellSiteGatherMap

GhostCellSiteMap _ghostCellSiteGatherMap

Definition: Mesh.h:378

const GhostCellSiteMap& Mesh::getGhostCellSiteGatherMap ( ) const

inline

Definition at line 128 of file Mesh.h.

References _ghostCellSiteGatherMap.

129 { return _ghostCellSiteGatherMap; }

Mesh::_ghostCellSiteGatherMap

GhostCellSiteMap _ghostCellSiteGatherMap

Definition: Mesh.h:378

GhostCellSiteMap& Mesh::getGhostCellSiteGatherMapLevel1 ( )

inline

Definition at line 148 of file Mesh.h.

Mesh::_ghostCellSiteGatherMapLevel1

Referenced by MeshPartitioner::DEBUG_level1_scatter_gather_cells().

149 { return _ghostCellSiteGatherMapLevel1; }

GhostCellSiteMap _ghostCellSiteGatherMapLevel1

Definition: Mesh.h:381

const GhostCellSiteMap& Mesh::getGhostCellSiteGatherMapLevel1 ( ) const

inline

Definition at line 151 of file Mesh.h.

Mesh::_ghostCellSiteGatherMapLevel1

152 { return _ghostCellSiteGatherMapLevel1; }

GhostCellSiteMap _ghostCellSiteGatherMapLevel1

Definition: Mesh.h:381

const StorageSite* Mesh::getGhostCellSiteScatter ( const PartIDMeshIDPair & id ) const

inline

Definition at line 113 of file Mesh.h.

References _ghostCellSiteScatterMap.

Referenced by NcDataReader::createMappers(), and MeshDismantler::partitionInterfaceMappers().

114 { return _ghostCellSiteScatterMap.find(id)->second.get(); }

Mesh::_ghostCellSiteScatterMap

GhostCellSiteMap _ghostCellSiteScatterMap

Definition: Mesh.h:377

const StorageSite* Mesh::getGhostCellSiteScatterLevel1 ( const PartIDMeshIDPair & id ) const

inline

Definition at line 136 of file Mesh.h.

Mesh::_ghostCellSiteScatterMapLevel1

137 { return _ghostCellSiteScatterMapLevel1.find(id)->second.get(); }

GhostCellSiteMap _ghostCellSiteScatterMapLevel1

Definition: Mesh.h:380

const GhostCellSiteMap& Mesh::getGhostCellSiteScatterMap ( ) const

inline

Definition at line 116 of file Mesh.h.

References _ghostCellSiteScatterMap.

Referenced by MeshPartitioner::globalCellID_procID_map().

117 { return _ghostCellSiteScatterMap; }

Mesh::_ghostCellSiteScatterMap

GhostCellSiteMap _ghostCellSiteScatterMap

Definition: Mesh.h:377

GhostCellSiteMap& Mesh::getGhostCellSiteScatterMap ( )

inline

Definition at line 119 of file Mesh.h.

References _ghostCellSiteScatterMap.

120 { return _ghostCellSiteScatterMap; }

Mesh::_ghostCellSiteScatterMap

GhostCellSiteMap _ghostCellSiteScatterMap

Definition: Mesh.h:377

const GhostCellSiteMap& Mesh::getGhostCellSiteScatterMapLevel1 ( ) const

inline

Definition at line 139 of file Mesh.h.

Mesh::_ghostCellSiteScatterMapLevel1

Referenced by MeshPartitioner::DEBUG_level1_scatter_gather_cells().

140 { return _ghostCellSiteScatterMapLevel1; }

GhostCellSiteMap _ghostCellSiteScatterMapLevel1

Definition: Mesh.h:380

GhostCellSiteMap& Mesh::getGhostCellSiteScatterMapLevel1 ( )

inline

Definition at line 142 of file Mesh.h.

Mesh::_ghostCellSiteScatterMapLevel1

143 { return _ghostCellSiteScatterMapLevel1; }

GhostCellSiteMap _ghostCellSiteScatterMapLevel1

Definition: Mesh.h:380

map<int,int>& Mesh::getGlobalToLocal ( )

inline

Definition at line 243 of file Mesh.h.

References _globalToLocal.

Referenced by addCRConn(), createRowColSiteCRConn(), MeshPartitioner::DEBUG_local_global(), MeshDismantler::set_local_global(), MeshPartitioner::set_local_global(), MeshDismantler::setCellsSite(), FlowModel< T >::Impl::setDirichlet(), FlowModel< T >::Impl::setReferencePP(), and GradientMatrix< T_Scalar >::syncValues().

243 { return _globalToLocal;}

Mesh::_globalToLocal

map< int, int > _globalToLocal

Definition: Mesh.h:398

const map<int,int>& Mesh::getGlobalToLocal ( ) const

inline

Definition at line 244 of file Mesh.h.

References _globalToLocal.

244 { return _globalToLocal;}

Mesh::_globalToLocal

map< int, int > _globalToLocal

Definition: Mesh.h:398

const map<int,int> Mesh::getGlobalToLocalNodes ( ) const

inline

Definition at line 235 of file Mesh.h.

References _globalToLocalNodes.

235 { return _globalToLocalNodes;}

Mesh::_globalToLocalNodes

map< int, int > _globalToLocalNodes

Definition: Mesh.h:399

map<int,int> Mesh::getGlobalToLocalNodes ( )

inline

Definition at line 236 of file Mesh.h.

References _globalToLocalNodes.

236 { return _globalToLocalNodes;}

Mesh::_globalToLocalNodes

map< int, int > _globalToLocalNodes

Definition: Mesh.h:399

const Array< int > & Mesh::getIBFaceList ( ) const

Definition at line 686 of file Mesh.cpp.

References _ibFaceList.

Referenced by CellMark_Impl(), GradientModel< Vector< T, 3 > >::compute(), KineticModel< T >::computeIBFaceDsf(), COMETModel< T >::computeIBFaceDsf(), FlowModel< T >::Impl::computeIBFaceVelocity(), MeshMetricsCalculator< T >::computeIBInterpolationMatrices(), MeshMetricsCalculator< T >::computeIBInterpolationMatricesCells(), KineticModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), IBManager::createIBInterpolationStencil(), IBManager::createSolidInterpolationStencil(), FlowModel< T >::Impl::getMomentumFluxIntegralonIBFaces(), FlowModel< T >::Impl::getPressureIntegralonIBFaces(), and IBManager::update().

 {
   if (_ibFaceList)  return (*_ibFaceList);
   throw CException("ib face list not defined");
 }

const StorageSite& Mesh::getIBFaces ( ) const

inline

Definition at line 111 of file Mesh.h.

References _ibFaces.

Referenced by CellMark_Impl(), COMETESBGKDiscretizer< T >::COMETConvection(), COMETESBGKDiscretizer< T >::COMETConvectionFine(), GradientModel< Vector< T, 3 > >::compute(), VacancyModel< T >::Impl::computeIBFaceConcentration(), KineticModel< T >::computeIBFaceDsf(), COMETModel< T >::computeIBFaceDsf(), ElectricModel< T >::Impl::computeIBFacePotential(), ThermalModel< T >::Impl::computeIBFaceTemperature(), FlowModel< T >::Impl::computeIBFaceVelocity(), MeshMetricsCalculator< T >::computeIBInterpolationMatrices(), MeshMetricsCalculator< T >::computeIBInterpolationMatricesCells(), KineticModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), KineticModel< T >::computeSolidFacePressure(), COMETModel< T >::computeSolidFacePressure(), KineticModel< T >::correctMassDeficit(), COMETModel< T >::correctMassDeficit(), IBManager::createIBFaces(), IBManager::createIBInterpolationStencil(), IBManager::createSolidInterpolationStencil(), GenericIBDiscretization< X, Diag, OffDiag >::discretize(), GenericKineticIBDiscretization< X, Diag, OffDiag >::discretize(), discretizeMassFluxInterior(), MeshMetricsCalculator< T >::eraseIBInterpolationMatrices(), FlowModel< T >::Impl::getMomentumFluxIntegralonIBFaces(), FlowModel< T >::Impl::getPressureIntegralonIBFaces(), KineticModel< T >::MacroparameterIBCell(), COMETModel< T >::MakeCoarseMesh2(), COMETModel< T >::MakeIBCoarseModel(), markIBFaces(), COMETESBGKDiscretizer< T >::setBoundaryValFine(), and IBManager::update().

111 {return _ibFaces;}

Mesh::_ibFaces

StorageSite _ibFaces

Definition: Mesh.h:358

StorageSite& Mesh::getIBFaces ( )

inline

Definition at line 159 of file Mesh.h.

References _ibFaces.

159 {return _ibFaces;}

Mesh::_ibFaces

StorageSite _ibFaces

Definition: Mesh.h:358

int Mesh::getID ( ) const

inline

Definition at line 106 of file Mesh.h.

References _id.

106 {return _id;}

Mesh::_id

int _id

Definition: Mesh.h:349

int Mesh::getInterfaceGroupCount ( ) const

inline

Definition at line 185 of file Mesh.h.

References _interfaceGroups.

Referenced by MeshPartitioner::cellcells_global_extension(), debug_mesh(), MeshDismantler::faceCellsAddPartitionInterfaces(), MeshDismantler::faceNodesAddPartitionInterfaces(), MeshDismantler::faceNodesInit(), MeshPartitioner::gatherCellsLevel1_partID_map(), MeshAssembler::getInnerNodesCount(), MeshAssembler::getInterfaceNodesCount(), MeshAssembler::getInterfaceNodesDuplicatedCount(), MeshDismantler::partitionInterfaceMappers(), MeshAssembler::setFaceCells(), MeshAssembler::setFaceNodes(), and MeshAssembler::setInterfaceNodes().

185 {return _interfaceGroups.size();}

Mesh::_interfaceGroups

FaceGroupList _interfaceGroups

Definition: Mesh.h:364

const FaceGroupList& Mesh::getInterfaceGroups ( ) const

inline

Definition at line 190 of file Mesh.h.

References _interfaceGroups.

191 {return _interfaceGroups;}

Mesh::_interfaceGroups

FaceGroupList _interfaceGroups

Definition: Mesh.h:364

const FaceGroup& Mesh::getInteriorFaceGroup ( ) const

inline

Definition at line 181 of file Mesh.h.

References _interiorFaceGroup.

Referenced by debug_mesh(), StructureSourceDiscretization< T, Diag, OffDiag >::discretize(), StructurePlasticDiscretization< T, Diag, OffDiag >::discretize(), PlateSourceDiscretization< T, Diag, OffDiag >::discretize(), MeshDismantler::faceCellsAddInteriorFaces(), MeshDismantler::faceCellsAddMeshInterfaces(), MeshDismantler::faceNodesAddInteriorFaces(), MeshDismantler::faceNodesAddMeshInterfaces(), MeshDismantler::faceNodesInit(), COMETModel< T >::HeatFluxIntegralFace(), FlowModel< T >::Impl::linearizeContinuity(), FlowModel< T >::Impl::postContinuitySolve(), MeshDismantler::setCellsSite(), MeshAssembler::setFaceCells(), MeshAssembler::setFaceNodes(), and MeshAssembler::setMeshCellColor().

181 {return *_interiorFaceGroup;}

Mesh::_interiorFaceGroup

shared_ptr< FaceGroup > _interiorFaceGroup

Definition: Mesh.h:361

Array<int>& Mesh::getLocalToGlobal ( )

inline

Definition at line 240 of file Mesh.h.

References _localToGlobal.

Referenced by MeshPartitioner::cellcells_global_extension(), MeshMetricsCalculator< T >::computeIBInterpolationMatrices(), MeshMetricsCalculator< T >::computeIBInterpolationMatricesCells(), createScatterGatherIndicesBuffer(), MeshPartitioner::DEBUG_local_global(), MeshPartitioner::gatherCellsLevel1_partID_map(), MeshPartitioner::globalCellID_procID_map(), IBManager::markIBTypePlus(), MeshPartitioner::set_cellcells_global(), MeshDismantler::set_local_global(), MeshPartitioner::set_local_global(), and FlowModel< T >::Impl::setDirichlet().

240 { return *_localToGlobal;}

Mesh::_localToGlobal

shared_ptr< Array< int > > _localToGlobal

Definition: Mesh.h:397

const Array<int>& Mesh::getLocalToGlobal ( ) const

inline

Definition at line 241 of file Mesh.h.

References _localToGlobal.

241 { return *_localToGlobal;}

Mesh::_localToGlobal

shared_ptr< Array< int > > _localToGlobal

Definition: Mesh.h:397

shared_ptr< Array<int> > Mesh::getLocalToGlobalNodesPtr ( )

inline

Definition at line 234 of file Mesh.h.

References _localToGlobalNodes.

234 { return _localToGlobalNodes;}

Mesh::_localToGlobalNodes

shared_ptr< Array< int > > _localToGlobalNodes

Definition: Mesh.h:396

shared_ptr< ArrayBase > Mesh::getLocalToGlobalPtr ( )

inline

Definition at line 239 of file Mesh.h.

References _localToGlobal.

239 { return _localToGlobal;}

Mesh::_localToGlobal

shared_ptr< Array< int > > _localToGlobal

Definition: Mesh.h:397

const Array<VecD3>& Mesh::getNodeCoordinates ( ) const

inline

Definition at line 218 of file Mesh.h.

References _coordinates.

Referenced by AABB::AABB(), MeshMetricsCalculator< T >::calculateNodeCoordinates(), PartMesh::coordinates(), MeshPartitioner::coordinates(), PartMesh::dumpTecplot(), MeshPartitioner::extractBoundaryMesh(), extractBoundaryMesh(), extrude(), findCommonNodes(), NcDataWriter::get_coords(), MeshAssembler::getInterfaceNodesCount(), IBManager::markIntersections(), AABB::meshIntersections(), MeshAssembler::setCoord(), MeshDismantler::setCoord(), StructureDeformationModel< T >::updateBoundaryMesh(), and PlateDeformationModel< T >::updateBoundaryMesh().

218 {return *_coordinates;}

shared_ptr< Array< VecD3 > > _coordinates

Definition: Mesh.h:366

Array<VecD3>& Mesh::getNodeCoordinates ( )

inline

Definition at line 219 of file Mesh.h.

References _coordinates.

219 {return *_coordinates;}

shared_ptr< Array< VecD3 > > _coordinates

Definition: Mesh.h:366

shared_ptr<ArrayBase> Mesh::getNodeCoordinatesPtr ( )

inline

Definition at line 220 of file Mesh.h.

References _coordinates.

220 {return _coordinates;}

Referenced by LinearizeInterfaceJump< X, Diag, OffDiag >::discretize(), LinearizeInterfaceJumpUnconnected< X, Diag, OffDiag >::discretize(), BatteryLinearizeThermalInterface< X, Diag, OffDiag >::discretize(), BatteryLinearizePotentialInterface< X, Diag, OffDiag >::discretize(), LinearizePotentialInterface< X, Diag, OffDiag >::discretize(), BatteryPCLinearizeInterface_BV< X, Diag, OffDiag, otherMeshDiag >::discretize(), BatteryLinearizeSpeciesInterface< X, Diag, OffDiag >::discretize(), LinearizeSpeciesInterface< X, Diag, OffDiag >::discretize(), BatteryFixInterfaceGhost< X, Diag, OffDiag >::fixInterfaces(), and BatteryModel< T >::Impl::updateShellGhosts().

shared_ptr< Array< VecD3 > > _coordinates

Definition: Mesh.h:366

const StorageSite& Mesh::getNodes ( ) const

inline

Definition at line 110 of file Mesh.h.

References _nodes.

110 {return _nodes;}

Mesh::_nodes

StorageSite _nodes

Definition: Mesh.h:356

StorageSite& Mesh::getNodes ( )

inline

Definition at line 158 of file Mesh.h.

References _nodes.

158 {return _nodes;}

Mesh::_nodes

StorageSite _nodes

Definition: Mesh.h:356

int Mesh::getNumBounCells ( )

private

Definition at line 2350 of file Mesh.cpp.

References getBoundaryFaceGroups().

Referenced by addCRConn(), countCRConn(), and createRowColSiteCRConn().

 {
     //boundary information has been stored
     const FaceGroupList&  boundaryFaceGroups = this->getBoundaryFaceGroups();
     int nBounElm = 0;
     for ( int bounID = 0; bounID < int(boundaryFaceGroups.size()); bounID++){
         nBounElm += boundaryFaceGroups.at(bounID)->site.getCount();
     }
     return nBounElm; 
 }

int Mesh::getNumOfAssembleMesh ( ) const

inline

Definition at line 251 of file Mesh.h.

References _numOfAssembleMesh.

Referenced by MeshDismantler::init().

251 { return _numOfAssembleMesh;}

Mesh::_numOfAssembleMesh

int _numOfAssembleMesh

Definition: Mesh.h:373

const StorageSite& Mesh::getOtherFaceGroupSite ( ) const

inline

Definition at line 332 of file Mesh.h.

References _otherFaceGroupSite.

333 {return *_otherFaceGroupSite;}

Mesh::_otherFaceGroupSite

const StorageSite * _otherFaceGroupSite

Definition: Mesh.h:417

int Mesh::getOtherMeshID ( ) const

inline

Definition at line 327 of file Mesh.h.

References _otherMeshID.

Referenced by BatteryFixInterfaceGhost< X, Diag, OffDiag >::fixInterfaces(), SpeciesModel< T >::Impl::init(), BatteryModel< T >::Impl::init(), SpeciesModel< T >::Impl::linearize(), ElectricModel< T >::Impl::linearizeElectroStatics(), BatteryModel< T >::Impl::linearizePC(), BatteryModel< T >::Impl::linearizePC_Thermal(), BatteryModel< T >::Impl::linearizePotential(), BatteryModel< T >::Impl::linearizeSpecies(), BatteryModel< T >::Impl::linearizeThermal(), and BatteryModel< T >::Impl::updateShellGhosts().

327 {return _otherMeshID;}

Mesh::_otherMeshID

int _otherMeshID

Definition: Mesh.h:419

const StorageSite& Mesh::getParentFaceGroupSite ( ) const

inline

Definition at line 329 of file Mesh.h.

References _parentFaceGroupSite.

330 {return *_parentFaceGroupSite;}

Mesh::_parentFaceGroupSite

const StorageSite * _parentFaceGroupSite

Definition: Mesh.h:416

int Mesh::getParentMeshID ( ) const

inline

Definition at line 326 of file Mesh.h.

References _parentMeshID.

Referenced by BatteryFixInterfaceGhost< X, Diag, OffDiag >::fixInterfaces(), SpeciesModel< T >::Impl::init(), BatteryModel< T >::Impl::init(), SpeciesModel< T >::Impl::linearize(), ElectricModel< T >::Impl::linearizeElectroStatics(), BatteryModel< T >::Impl::linearizePC(), BatteryModel< T >::Impl::linearizePC_Thermal(), BatteryModel< T >::Impl::linearizePotential(), BatteryModel< T >::Impl::linearizeSpecies(), BatteryModel< T >::Impl::linearizeThermal(), and BatteryModel< T >::Impl::updateShellGhosts().

326 {return _parentMeshID;}

Mesh::_parentMeshID

int _parentMeshID

Definition: Mesh.h:418

PeriodicFacePairs& Mesh::getPeriodicFacePairs ( )

inline

Definition at line 337 of file Mesh.h.

References _periodicFacePairs.

Referenced by FluentReader::createMesh(), and MeshMetricsCalculator< T >::init().

337 { return _periodicFacePairs;}

Mesh::_periodicFacePairs

PeriodicFacePairs _periodicFacePairs

Definition: Mesh.h:423

const PeriodicFacePairs& Mesh::getPeriodicFacePairs ( ) const

inline

Definition at line 338 of file Mesh.h.

References _periodicFacePairs.

338 { return _periodicFacePairs;}

Mesh::_periodicFacePairs

PeriodicFacePairs _periodicFacePairs

Definition: Mesh.h:423

const ArrayBase& Mesh::getRecvCounts ( const EntryIndex & e ) const

inline

Definition at line 280 of file Mesh.h.

References _recvCounts.

Referenced by GradientMatrix< T_Scalar >::createScatterGatherValuesBuffer(), and GradientMatrix< T_Scalar >::syncValues().

280 { return *_recvCounts[e];}

Mesh::_recvCounts

GhostArrayMap _recvCounts

Definition: Mesh.h:384

const ArrayBase& Mesh::getRecvIndices ( const EntryIndex & e ) const

inline

Definition at line 281 of file Mesh.h.

References _recvIndices.

Referenced by GradientMatrix< T_Scalar >::syncValues().

281 { return *_recvIndices[e];}

Mesh::_recvIndices

GhostArrayMap _recvIndices

Definition: Mesh.h:386

const ArrayBase& Mesh::getSendCounts ( const EntryIndex & e ) const

inline

Definition at line 277 of file Mesh.h.

References _sendCounts.

Referenced by recvScatterGatherCountsBufferLocal().

277 { return *_sendCounts[e];}

Mesh::_sendCounts

GhostArrayMap _sendCounts

Definition: Mesh.h:383

const ArrayBase& Mesh::getSendIndices ( const EntryIndex & e ) const

inline

Definition at line 278 of file Mesh.h.

References _sendIndices.

Referenced by recvScatterGatherIndicesBufferLocal().

278 { return *_sendIndices[e];}

Mesh::_sendIndices

GhostArrayMap _sendIndices

Definition: Mesh.h:385

shared_ptr< ArrayBase > Mesh::getUpdatedNodesCoordCoupling	(	const GeomFields &	geomField,
		const Mesh &	bMesh
	)

Definition at line 784 of file Mesh.cpp.

References _boundaryNodesSet, _repeatNodes, GeomFields::coordinate, StorageSite::getCount(), getNodes(), StorageSite::getScatterIndex(), and Array< T >::zero().

 {
     const StorageSite& nodes = this->getNodes();
     const StorageSite& boundaryNodes = bMesh.getNodes();
     const map<int,int>&  globalToLocal = nodes.getScatterIndex().find(&boundaryNodes)->second;
     const Array<VecD3>& fieldCoord = dynamic_cast< const Array<VecD3>& > (geomField.coordinate[nodes]);
     shared_ptr< ArrayBase> returnCoord = geomField.coordinate[nodes].newSizedClone( boundaryNodes.getCount() );
     Array<VecD3>& coord = dynamic_cast< Array<VecD3>& > ( *returnCoord );
     coord.zero();
 
     foreach( const set<int>::value_type node, _boundaryNodesSet ){
        const int globalNodeID = (*_localToGlobalNodes)[node];
        const int localNodeID  = globalToLocal.find(globalNodeID)->second;       
        coord[localNodeID]   = fieldCoord[node] / double( (*_repeatNodes)[localNodeID] );  //this fill local partitionin mesh 
     }
    //global reduction to find repeating nodes 
 // #ifdef FVM_PARALLEL
 //    const int count = coord.getLength() * 3;
 //    MPI::COMM_WORLD.Allreduce(MPI::IN_PLACE, coord.getData(), count, MPI::DOUBLE, MPI::SUM);
 // #endif
     return returnCoord;
 }       

void Mesh::InterfaceToBoundary ( )

Definition at line 2424 of file Mesh.cpp.

References _boundaryGroups, and _interfaceGroups.

 {
   foreach(FaceGroupPtr fgPtr, _interfaceGroups)
     {
       _boundaryGroups.push_back(fgPtr);
     }
   _interfaceGroups.clear();
 }

bool Mesh::isConnectedShell ( ) const

inline

Definition at line 325 of file Mesh.h.

References _isConnectedShell.

Referenced by BatteryFixInterfaceGhost< X, Diag, OffDiag >::fixInterfaces(), BatteryModel< T >::Impl::initSpeciesLinearization(), BatteryModel< T >::Impl::linearizeSpecies(), and BatteryModel< T >::Impl::updateShellGhosts().

325 {return _isConnectedShell;}

Mesh::_isConnectedShell

bool _isConnectedShell

Definition: Mesh.h:410

bool Mesh::isDoubleShell ( ) const

inline

bool Mesh::isMergedMesh ( ) const

inline

Definition at line 250 of file Mesh.h.

References _isAssembleMesh.

250 { return _isAssembleMesh;}

Mesh::_isAssembleMesh

bool _isAssembleMesh

Definition: Mesh.h:374

bool Mesh::isShell ( ) const

inline

Definition at line 323 of file Mesh.h.

References _isShell.

Referenced by MeshMetricsCalculator< T >::calculateCellCentroids(), MeshMetricsCalculator< T >::calculateCellVolumes(), GradientModel< Vector< T, 3 > >::compute(), VacancyModel< T >::Impl::computeIBFaceConcentration(), KineticModel< T >::computeIBFaceDsf(), COMETModel< T >::computeIBFaceDsf(), ElectricModel< T >::Impl::computeIBFacePotential(), ThermalModel< T >::Impl::computeIBFaceTemperature(), FlowModel< T >::Impl::computeIBFaceVelocity(), MeshMetricsCalculator< T >::computeIBInterpolationMatrices(), MeshMetricsCalculator< T >::computeIBInterpolationMatricesCells(), KineticModel< T >::computeSolidFaceDsf(), COMETModel< T >::computeSolidFaceDsf(), KineticModel< T >::computeSolidFacePressure(), COMETModel< T >::computeSolidFacePressure(), MeshMetricsCalculator< T >::computeSolidInterpolationMatrices(), ElectricModel< T >::Impl::computeSolidSurfaceForce(), IBManager::createIBFaces(), MeshMetricsCalculator< T >::init(), Linearizer::linearize(), IBManager::markIntersections(), MeshMetricsCalculator< T >::recalculate(), MeshMetricsCalculator< T >::recalculate_deform(), and IBManager::update().

323 {return _isShell;}

Mesh::_isShell

bool _isShell

Definition: Mesh.h:408

void Mesh::recvScatterGatherCountsBufferLocal ( )

Definition at line 2050 of file Mesh.cpp.

References _recvCounts, getCells(), StorageSite::getGatherMap(), StorageSite::getGatherProcID(), StorageSite::getMesh(), and getSendCounts().

Referenced by MeshDismantler::setCellCellsGhostExt().

 {
 #ifdef FVM_PARALLEL
    const StorageSite& site     = this->getCells();
    const StorageSite::GatherMap& gatherMap = site.getGatherMap();
    foreach(const StorageSite::GatherMap::value_type& mpos, gatherMap){
       const StorageSite&  oSite = *mpos.first;
       //checking if storage site is only site or ghost site, we only communicate ghost site ( oSite.getCount() == -1 ) 
       EntryIndex e(&oSite,&site);
       //allocate array
       //mesh interface can be done know
       if ( oSite.getGatherProcID() == - 1) {
            const Mesh& otherMesh = oSite.getMesh();
           *_recvCounts[e] = otherMesh.getSendCounts(e);
       } 
    }
 #endif   
 }

void Mesh::recvScatterGatherIndicesBufferLocal ( )

Definition at line 2172 of file Mesh.cpp.

References _recvIndices, getCells(), StorageSite::getGatherMap(), StorageSite::getGatherProcID(), StorageSite::getMesh(), and getSendIndices().

Referenced by MeshDismantler::setCellCellsGhostExt().

 {
 #ifdef FVM_PARALLEL
     //RECIEVING allocation (filling will be done by MPI Communication)
     const StorageSite& site     = this->getCells();
     const StorageSite::GatherMap& gatherMap = site.getGatherMap();
     foreach(const StorageSite::GatherMap::value_type& mpos, gatherMap){
        const StorageSite&  oSite = *mpos.first;
        EntryIndex e(&oSite,&site);
        //mesh interface can be done know
        if ( oSite.getGatherProcID() == - 1) {
           const Mesh& otherMesh = oSite.getMesh();
           *_recvIndices[e] = otherMesh.getSendIndices(e);
        } 
     }
 #endif    
 }

void Mesh::setCellZoneID ( const int id )

inline

Definition at line 320 of file Mesh.h.

References _cellZoneID.

Referenced by MeshPartitioner::construct_mesh(), and FluentReader::createMesh().

320 {_cellZoneID = id;}

Mesh::_cellZoneID

int _cellZoneID

Definition: Mesh.h:352

void Mesh::setCommonFacesMap ( const Mesh & bMesh )

Definition at line 810 of file Mesh.cpp.

References _commonFacesMap, _commonFacesMapOther, getAllFaceNodes(), getBoundaryFaceGroups(), StorageSite::getCount(), CRConnectivity::getCount(), getNodes(), StorageSite::getOffset(), StorageSite::getScatterIndex(), CRConnectivity::getTranspose(), and FaceGroup::site.

 {
   //loop over local faces 
   const StorageSite& nodes = this->getNodes();
   const StorageSite& boundaryNodes = bMesh.getNodes();
   const map<int,int>&  globalToLocal = nodes.getScatterIndex().find(&boundaryNodes)->second;
 
    const CRConnectivity& faceNodes = this->getAllFaceNodes();
    const CRConnectivity& faceNodesBMesh = bMesh.getAllFaceNodes();
    shared_ptr<CRConnectivity> nodeFacesBMeshPtr = faceNodesBMesh.getTranspose();
    const CRConnectivity& nodeFacesBMesh = *nodeFacesBMeshPtr;
 
    foreach(const FaceGroupPtr fgPtr, this->getBoundaryFaceGroups()){
       const FaceGroup& fg = *fgPtr;
       const StorageSite& faces = fg.site;
       const int nFaces = faces.getCount();
      
       for(int f=0; f<nFaces; f++){
          const int faceID = f + faces.getOffset();
          const int nFaceNodes = faceNodes.getCount(faceID);
          set<int> comp; //vector to store localIds of bMesh 
          vector<int> nodeList(nFaceNodes,0);
          for(int nn=0; nn<nFaceNodes; nn++){
             //get local node number
             const int n=faceNodes(faceID,nn);
             const int globalNodeID = (*_localToGlobalNodes)[n];
             const int localNodeID  = globalToLocal.find(globalNodeID)->second;   //localID boundary mesh
             comp.insert(localNodeID);
             nodeList[nn] = localNodeID;
          }
          //now get corresponding faceID to boundaryMeshFaceID
          //loop over nodeFaces on boundaryMesh
          for( int i = 0; i < nFaceNodes; i++ ){
             bool breakUpperLoop = false;
             const int nfaces = nodeFacesBMesh.getCount(nodeList[i]);
             //loop over faces around nodes of boundary mesh
             for ( int j = 0; j < nfaces; j++ ){
                const int localFaceID  = nodeFacesBMesh(nodeList[i],j); //localFaceID boundary mesh
                //check if this face is connected to our comp vector
                const int nnodes = faceNodesBMesh.getCount(localFaceID);
                vector<bool> matchingNodes(nFaceNodes,false);
                for ( int k = 0; k < nnodes; k++ ){
                   const int nodeID = faceNodesBMesh(localFaceID,j);
                   if ( comp.count(nodeID) == 1 ){ //this means if this node is in search sets
                      matchingNodes[k] = true;
                   }
                }
                //checking if matchinNodes bools are all true
                if ( find(matchingNodes.begin(), matchingNodes.end(), false) == matchingNodes.end() ){
                   _commonFacesMap[faceID] = localFaceID;
                   _commonFacesMapOther[localFaceID] = faceID;
                   breakUpperLoop = true;
                   break;
                }
             }
             if ( breakUpperLoop ){
                break;
             }
          }
       }
    }
   
   
 }

void Mesh::setConnectivity	(	const StorageSite &	rowSite,
		const StorageSite &	colSite,
		shared_ptr< CRConnectivity >	conn
	)

Definition at line 352 of file Mesh.cpp.

References _connectivityMap.

Referenced by CellMark_Impl(), IBManager::createIBInterpolationStencil(), IBManager::createSolidInterpolationStencil(), COMETModel< T >::FinishCoarseMesh(), COMETModel< T >::MakeCoarseMesh2(), COMETModel< T >::makeFinestToCoarseConn(), and Grid::setConnFaceToGrid().

 {
   SSPair key(&rowSite,&colSite);
   _connectivityMap[key] = conn;
 }

void Mesh::setCoordinates ( shared_ptr< Array< VecD3 > > x )

inline

Definition at line 204 of file Mesh.h.

References _coordinates.

Referenced by FluentReader::createMesh(), MeshPartitioner::extractBoundaryMesh(), extractBoundaryMesh(), extrude(), and Mesh().

204 {_coordinates = x;}