Changeset 900


Ignore:
Timestamp:
07/13/16 17:56:22 (5 years ago)
Author:
oabramkina
Message:

Sequential version of new functionalities for mesh connectivity:

edge_faces
face_edges
face_face.

Location:
XIOS/trunk/src/node
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/node/mesh.cpp

    r883 r900  
    144144///---------------------------------------------------------------- 
    145145/*! 
    146  * \fn void CMesh::hashDblDbl (double lon, double lat) 
     146 * \fn CArray<size_t,1>& CMesh::createHashes (double lon, double lat) 
    147147 * Creates two hash values for each dimension, longitude and latitude. 
    148148 * \param [in] lon Node longitude in degrees. 
     
    150150 */ 
    151151 
    152   void hashDblDbl (double lon, double lat) 
     152  vector<size_t> CMesh::createHashes (double lon, double lat) 
    153153  { 
    154154    double minBoundLon = 0. ; 
     
    169169    size_t iMaxLat=(maxBoundLat-minBoundLat)/precLat ; 
    170170 
    171     size_t hash0,hash1,hash2,hash3 ; 
     171    vector<size_t> hash(4); 
    172172    size_t lon0,lon1,lat0,lat1 ; 
    173173 
     
    196196    } 
    197197 
    198     hash0=hashPair(lon0,lat0) ; 
    199     hash1=hashPair(lon0,lat1) ; 
    200     hash2=hashPair(lon1,lat0) ; 
    201     hash3=hashPair(lon1,lat1) ; 
    202  
    203   } // hashDblDbl 
     198    hash[0] = hashPair(lon0,lat0) ; 
     199    hash[1] = hashPair(lon0,lat1) ; 
     200    hash[2] = hashPair(lon1,lat0) ; 
     201    hash[3] = hashPair(lon1,lat1) ; 
     202 
     203    return hash; 
     204 
     205  } // createHashes 
    204206 
    205207///---------------------------------------------------------------- 
     
    211213      return std::pair<int,int>(b,a); 
    212214  } 
     215 
     216///---------------------------------------------------------------- 
     217//#include <random> 
     218//  size_t randNum() 
     219//  { 
     220//    typedef mt19937 rng; 
     221//    size_t max = numeric_limits<size_t>::max(); 
     222//    uniform_int_distribution<> distr(0, max); 
     223//    return distr(rng); 
     224//  } 
    213225 
    214226///---------------------------------------------------------------- 
     
    320332      edge_lat.resizeAndPreserve(nbFaces*nvertex); 
    321333      edge_nodes.resizeAndPreserve(2, nbFaces*nvertex); 
     334      edge_faces.resize(2, nbFaces*nvertex); 
     335      face_edges.resize(nvertex, nbFaces); 
     336      face_faces.resize(nvertex, nbFaces); 
     337 
     338      vector<int> countEdges(nbFaces*nvertex);   // needed in case if edges have been already generated 
     339      vector<int> countFaces(nbFaces); 
     340      countEdges.assign(nbFaces*nvertex, 0); 
     341      countFaces.assign(nbFaces, 0); 
     342      int edge; 
    322343      for (int nf = 0; nf < nbFaces; ++nf) 
    323344      { 
    324345        for (int nv1 = 0; nv1 < nvertex; ++nv1) 
    325346        { 
     347          int nv = 0; 
    326348          int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation 
    327349          if (map_edges.find(make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))) == map_edges.end()) 
    328350          { 
    329351            map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))] = nbEdges ; 
     352            face_edges(nv1,nf) = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))]; 
     353            edge_faces(0,nbEdges) = nf; 
     354            edge_faces(1,nbEdges) = -999; 
     355            face_faces(nv1,nf) = -1; 
    330356            edge_nodes(Range::all(),nbEdges) = face_nodes(nv1,nf), face_nodes(nv2,nf); 
    331357            edge_lon(nbEdges) = ( abs( node_lon(face_nodes(nv1,nf)) - node_lon(face_nodes(nv2,nf))) < 180.) ? 
     
    335361            ++nbEdges; 
    336362          } 
     363          else 
     364          { 
     365            edge = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))]; 
     366            face_edges(nv1,nf) = edge; 
     367            if (edgesAreWritten) 
     368            { 
     369              edge_faces(countEdges[edge], edge) = nf; 
     370              if (countEdges[edge]==0) 
     371              { 
     372                face_faces(nv1,nf) = -1; 
     373              } 
     374              else 
     375              { 
     376                int face1 = nf; // = edge_faces(1,edge) 
     377                int face2 = edge_faces(0,edge); 
     378                face_faces(countFaces[face1], face1) =  face2; 
     379                face_faces(countFaces[face2], face2) =  face1; 
     380                ++(countFaces[face1]); 
     381                ++(countFaces[face2]); 
     382              } 
     383            } 
     384            else 
     385            { 
     386              edge_faces(1,edge) = nf; 
     387              int face1 = nf; // = edge_faces(1,edge) 
     388              int face2 = edge_faces(0,edge); 
     389              face_faces(countFaces[face1], face1) =  face2; 
     390              face_faces(countFaces[face2], face2) =  face1; 
     391              ++(countFaces[face1]); 
     392              ++(countFaces[face2]); 
     393            } 
     394            ++(countEdges[edge]); 
     395          } 
    337396        } 
    338397      } 
    339398      edge_nodes.resizeAndPreserve(2, nbEdges); 
     399      edge_faces.resizeAndPreserve(2, nbEdges); 
    340400      edge_lon.resizeAndPreserve(nbEdges); 
    341401      edge_lat.resizeAndPreserve(nbEdges); 
    342    
     402 
    343403      // Create faces 
    344404      face_lon.resize(nbFaces); 
     
    347407      face_lat = latvalue; 
    348408      facesAreWritten = true; 
     409 
    349410    } // nvertex > 2 
    350411     
     
    362423 * \param [in] bounds_lat Array of boundary latitudes. Its size depends on the element type. 
    363424 */ 
    364   void CMesh::createMeshEpsilon(const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue, 
     425  void CMesh::createMeshEpsilon(const MPI_Comm& comm, const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue, 
    365426            const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat) 
    366427  { 
     428 
    367429    nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows(); 
    368430 
     
    370432    { 
    371433      nbNodes = lonvalue.numElements(); 
    372       node_lon.resizeAndPreserve(nbNodes); 
    373       node_lat.resizeAndPreserve(nbNodes); 
    374       for (int nn = 0; nn < nbNodes; ++nn) 
    375       { 
    376         if ( nodeIndex(lonvalue(nn), latvalue(nn)) == -1 ) 
    377         { 
    378           node_lon(nn) = lonvalue(nn); 
    379           node_lat(nn) = latvalue(nn); 
    380         } 
    381       } 
    382     nodesAreWritten = true; 
    383     } 
     434 
     435      CClientClientDHTSizet::Index2VectorInfoTypeMap hash2Idx;      // map <hash, idx> 
     436      vector<size_t> hashValues(4);                                 // temporary vector for storing hashes for each node 
     437      vector<size_t> globalIndexes(nbNodes);                        // Probably a map ? 
     438      CArray<size_t,1> hashList(nbNodes*4);                         // Do I need it? 
     439      CArray<size_t,1> idxList(nbNodes); 
     440 
     441      // Assign a unique index for each node represented by four hashes 
     442      // The first hash will serve as the unique index 
     443      size_t randomIdx; 
     444      int rank, size; 
     445      MPI_Comm_rank(comm, &rank); 
     446      MPI_Comm_size(comm, &size); 
     447      srand((unsigned)time(NULL)+rank*size); 
     448 
     449      for (size_t nn = 0; nn < nbNodes; ++nn) 
     450      { 
     451        hashValues = CMesh::createHashes(lonvalue(nn), latvalue(nn)); 
     452        idxList(nn) = hashValues[nn]; 
     453//        randomIdx = rand() % numeric_limits<size_t>::max(); 
     454//        idxList(nn) = randomIdx; 
     455//        for (size_t nh = 0; nh < 4; ++nh) 
     456//        { 
     457//          hash2Idx[hashValues[nh]].push_back(randomIdx); 
     458//          hashList(nn*4 + nh) = hashValues[nh]; 
     459//        } 
     460      } 
     461 
     462 
     463//      CClientClientDHTSizet dhtSizet(hash2Idx, comm); 
     464//      dhtSizet.computeIndexInfoMapping(hashList); 
     465 //     CClientClientDHTSizet::Index2VectorInfoTypeMap& hashIdxList = dhtSizet.getInfoIndexMap(); 
     466 
     467//      // (2.1) Create a list of indexes for each hush 
     468//      CClientClientDHTSizet dhtSizet(hash2Idx, comm); 
     469//      dhtSizet.computeIndexInfoMapping(hashList); 
     470//      CClientClientDHTSizet::Index2VectorInfoTypeMap& hashIdxList = dhtSizet.getInfoIndexMap(); 
     471// 
     472//      // (2.2) If more than one index assigned to a hush, set the larger value to be equal to the smaller 
     473//      int iidx = 0; 
     474//      for (CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = hashIdxList.begin(); it != hashIdxList.end(); ++it, ++iidx) 
     475//      { 
     476//        vector<size_t> tmp = it->second; 
     477//        size_t idxMinValue = it->second[0]; 
     478//        for (int i = 1; i < it->second.size(); ++i) 
     479//        { 
     480//          if (it->second[i] < idxMinValue ) 
     481//              idxMinValue = it->second[i]; 
     482//        } 
     483//        if ( (iidx % 4) == 0 ) 
     484//          idxList(iidx/4) = idxMinValue; 
     485//      } 
     486 
     487      // Unique global indexing 
     488      CDHTAutoIndexing dhtSizetIdx = CDHTAutoIndexing(idxList, comm); 
     489      CClientClientDHTSizet* pDhtSizet = &dhtSizetIdx; 
     490      pDhtSizet->computeIndexInfoMapping(idxList); 
     491 
     492      //globalIndexes = dhtSizetIdx.getGlobalIndex(); 
     493 
     494      node_lon.resize(nbNodes); 
     495      node_lat.resize(nbNodes); 
     496      node_lon = lonvalue; 
     497      node_lat = latvalue; 
     498 
     499      nodesAreWritten = true; 
     500 
     501    } 
     502 
    384503    else if (nvertex == 2) 
    385504    { 
    386505      nbEdges = bounds_lon.shape()[1]; 
    387506 
     507      vector<size_t> hashValues(4); 
     508      for (int ne = 0; ne < nbEdges; ++ne) 
     509      { 
     510        for (int nv = 0; nv < nvertex; ++nv) 
     511        { 
     512          hashValues = CMesh::createHashes(bounds_lon(nv, ne), bounds_lat(nv, ne)); 
     513//          for (size_t nh = 0; nh < 4; ++nh) 
     514//          { 
     515//            hash2Idx[hashValues[nh]].push_back(randomIdx); 
     516//            hashList(nn*4 + nh) = hashValues[nh]; 
     517//          } 
     518 
     519 
     520        } 
     521      } 
    388522      // Create nodes and edge_node connectivity 
     523 
    389524      node_lon.resizeAndPreserve(nbEdges*nvertex); // Max possible number of nodes 
    390525      node_lat.resizeAndPreserve(nbEdges*nvertex); 
    391526      edge_nodes.resizeAndPreserve(nvertex, nbEdges); 
    392527 
    393       for (int ne = 0; ne < nbEdges; ++ne) 
    394       { 
    395         for (int nv = 0; nv < nvertex; ++nv) 
    396         { 
    397           if ( nodeIndex(bounds_lon(nv, ne), bounds_lat(nv ,ne)) == -1) 
    398           { 
    399             edge_nodes(nv,ne) = nbNodes ; 
    400             node_lon(nbNodes) = bounds_lon(nv, ne); 
    401             node_lat(nbNodes) = bounds_lat(nv, ne); 
    402             ++nbNodes ; 
    403           } 
    404           else 
    405             edge_nodes(nv,ne) = nodeIndex(bounds_lon(nv, ne), bounds_lat(nv ,ne)); 
    406         } 
    407       } 
    408       node_lon.resizeAndPreserve(nbNodes); 
    409       node_lat.resizeAndPreserve(nbNodes); 
     528//      for (int ne = 0; ne < nbEdges; ++ne) 
     529//      { 
     530//        for (int nv = 0; nv < nvertex; ++nv) 
     531//        { 
     532//          if ( nodeIndex(bounds_lon(nv, ne), bounds_lat(nv ,ne)) == -1) 
     533//          { 
     534//            edge_nodes(nv,ne) = nbNodes ; 
     535//            node_lon(nbNodes) = bounds_lon(nv, ne); 
     536//            node_lat(nbNodes) = bounds_lat(nv, ne); 
     537//            ++nbNodes ; 
     538//          } 
     539//          else 
     540//            edge_nodes(nv,ne) = nodeIndex(bounds_lon(nv, ne), bounds_lat(nv ,ne)); 
     541//        } 
     542//      } 
     543//      node_lon.resizeAndPreserve(nbNodes); 
     544//      node_lat.resizeAndPreserve(nbNodes); 
    410545 
    411546      // Create edges 
     
    433568      face_nodes.resize(nvertex, nbFaces); 
    434569 
    435       for (int nf = 0; nf < nbFaces; ++nf) 
     570      /*for (int nf = 0; nf < nbFaces; ++nf) 
    436571      { 
    437572        for (int nv = 0; nv < nvertex; ++nv) 
     
    451586      } 
    452587      node_lon.resizeAndPreserve(nbNodes); 
    453       node_lat.resizeAndPreserve(nbNodes); 
     588      node_lat.resizeAndPreserve(nbNodes);*/ 
     589 
    454590 
    455591      // Create edges and edge_nodes connectivity 
    456       edge_lon.resizeAndPreserve(nbFaces*nvertex); // Max possible number of edges 
    457       edge_lat.resizeAndPreserve(nbFaces*nvertex); 
    458       edge_nodes.resizeAndPreserve(2, nbFaces*nvertex); 
    459       for (int nf = 0; nf < nbFaces; ++nf) 
    460       { 
    461         for (int nv1 = 0; nv1 < nvertex; ++nv1) 
    462         { 
    463           int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation 
    464           if (map_edges.find(make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))) == map_edges.end()) 
    465           { 
    466             map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))] = nbEdges ; 
    467             edge_nodes(Range::all(),nbEdges) = face_nodes(nv1,nf), face_nodes(nv2,nf); 
    468             edge_lon(nbEdges) = ( abs( node_lon(face_nodes(nv1,nf)) - node_lon(face_nodes(nv2,nf))) < 180.) ? 
    469                         (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5) : 
    470                         (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5 -180.);; 
    471             edge_lat(nbEdges) = ( node_lat(face_nodes(nv1,nf)) + node_lat(face_nodes(nv2,nf)) ) * 0.5; 
    472             ++nbEdges; 
    473           } 
    474         } 
    475       } 
    476       edge_nodes.resizeAndPreserve(2, nbEdges); 
    477       edge_lon.resizeAndPreserve(nbEdges); 
    478       edge_lat.resizeAndPreserve(nbEdges); 
     592//      edge_lon.resizeAndPreserve(nbFaces*nvertex); // Max possible number of edges 
     593//      edge_lat.resizeAndPreserve(nbFaces*nvertex); 
     594//      edge_nodes.resizeAndPreserve(2, nbFaces*nvertex); 
     595//      for (int nf = 0; nf < nbFaces; ++nf) 
     596//      { 
     597//        for (int nv1 = 0; nv1 < nvertex; ++nv1) 
     598//        { 
     599//          int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation 
     600//          if (map_edges.find(make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))) == map_edges.end()) 
     601//          { 
     602//            map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))] = nbEdges ; 
     603//            edge_nodes(Range::all(),nbEdges) = face_nodes(nv1,nf), face_nodes(nv2,nf); 
     604//            edge_lon(nbEdges) = ( abs( node_lon(face_nodes(nv1,nf)) - node_lon(face_nodes(nv2,nf))) < 180.) ? 
     605//                        (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5) : 
     606//                        (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5 -180.);; 
     607//            edge_lat(nbEdges) = ( node_lat(face_nodes(nv1,nf)) + node_lat(face_nodes(nv2,nf)) ) * 0.5; 
     608//            ++nbEdges; 
     609//          } 
     610//        } 
     611//      } 
     612//      edge_nodes.resizeAndPreserve(2, nbEdges); 
     613//      edge_lon.resizeAndPreserve(nbEdges); 
     614//      edge_lat.resizeAndPreserve(nbEdges); 
    479615 
    480616      // Create faces 
    481       face_lon.resize(nbFaces); 
    482       face_lat.resize(nbFaces); 
    483       face_lon = lonvalue; 
    484       face_lat = latvalue; 
    485       facesAreWritten = true; 
     617//      face_lon.resize(nbFaces); 
     618//      face_lat.resize(nbFaces); 
     619//      face_lon = lonvalue; 
     620//      face_lat = latvalue; 
     621//      facesAreWritten = true; 
     622 
    486623    } // nvertex >= 3 
    487624 
     
    489626 
    490627} // namespace xios 
     628 
     629//  void CMesh::createMeshEpsilon(const MPI_Comm& comm, const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue, 
     630//            const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat) 
     631//  { 
     632// 
     633//    nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows(); 
     634// 
     635//    if (nvertex == 1) 
     636//    { 
     637//      nbNodes = lonvalue.numElements(); 
     638//      node_lon.resizeAndPreserve(nbNodes); 
     639//      node_lat.resizeAndPreserve(nbNodes); 
     640//      for (int nn = 0; nn < nbNodes; ++nn) 
     641//      { 
     642//        if ( nodeIndex(lonvalue(nn), latvalue(nn)) == -1 ) 
     643//        { 
     644//          node_lon(nn) = lonvalue(nn); 
     645//          node_lat(nn) = latvalue(nn); 
     646//        } 
     647//      } 
     648// 
     649//      nodesAreWritten = true; 
     650//    } 
     651//    else if (nvertex == 2) 
     652//    { 
     653//      nbEdges = bounds_lon.shape()[1]; 
     654// 
     655//      // Create nodes and edge_node connectivity 
     656//      node_lon.resizeAndPreserve(nbEdges*nvertex); // Max possible number of nodes 
     657//      node_lat.resizeAndPreserve(nbEdges*nvertex); 
     658//      edge_nodes.resizeAndPreserve(nvertex, nbEdges); 
     659// 
     660//      for (int ne = 0; ne < nbEdges; ++ne) 
     661//      { 
     662//        for (int nv = 0; nv < nvertex; ++nv) 
     663//        { 
     664//          if ( nodeIndex(bounds_lon(nv, ne), bounds_lat(nv ,ne)) == -1) 
     665//          { 
     666//            edge_nodes(nv,ne) = nbNodes ; 
     667//            node_lon(nbNodes) = bounds_lon(nv, ne); 
     668//            node_lat(nbNodes) = bounds_lat(nv, ne); 
     669//            ++nbNodes ; 
     670//          } 
     671//          else 
     672//            edge_nodes(nv,ne) = nodeIndex(bounds_lon(nv, ne), bounds_lat(nv ,ne)); 
     673//        } 
     674//      } 
     675//      node_lon.resizeAndPreserve(nbNodes); 
     676//      node_lat.resizeAndPreserve(nbNodes); 
     677// 
     678//      // Create edges 
     679//      edge_lon.resizeAndPreserve(nbEdges); 
     680//      edge_lat.resizeAndPreserve(nbEdges); 
     681// 
     682//      for (int ne = 0; ne < nbEdges; ++ne) 
     683//      { 
     684//        if (map_edges.find(make_ordered_pair (edge_nodes(0,ne), edge_nodes(1,ne))) == map_edges.end()) 
     685//        { 
     686//          map_edges[make_ordered_pair ( edge_nodes(0,ne), edge_nodes(1,ne) )] = ne ; 
     687//          edge_lon(ne) = lonvalue(ne); 
     688//          edge_lat(ne) = latvalue(ne); 
     689//        } 
     690//      } 
     691//      edgesAreWritten = true; 
     692//    } // nvertex = 2 
     693//    else 
     694//    { 
     695//      nbFaces = bounds_lon.shape()[1]; 
     696// 
     697//      // Create nodes and face_node connectivity 
     698//      node_lon.resizeAndPreserve(nbFaces*nvertex);  // Max possible number of nodes 
     699//      node_lat.resizeAndPreserve(nbFaces*nvertex); 
     700//      face_nodes.resize(nvertex, nbFaces); 
     701// 
     702//      for (int nf = 0; nf < nbFaces; ++nf) 
     703//      { 
     704//        for (int nv = 0; nv < nvertex; ++nv) 
     705//        { 
     706//          if ( nodeIndex(bounds_lon(nv, nf), bounds_lat(nv ,nf)) == -1) 
     707//          { 
     708//            face_nodes(nv,nf) = nbNodes ; 
     709//            node_lon(nbNodes) = bounds_lon(nv, nf); 
     710//            node_lat(nbNodes) = bounds_lat(nv ,nf); 
     711//            ++nbNodes ; 
     712//          } 
     713//          else 
     714//          { 
     715//            face_nodes(nv,nf) = nodeIndex(bounds_lon(nv, nf), bounds_lat(nv ,nf)); 
     716//          } 
     717//        } 
     718//      } 
     719//      node_lon.resizeAndPreserve(nbNodes); 
     720//      node_lat.resizeAndPreserve(nbNodes); 
     721// 
     722//      // Create edges and edge_nodes connectivity 
     723//      edge_lon.resizeAndPreserve(nbFaces*nvertex); // Max possible number of edges 
     724//      edge_lat.resizeAndPreserve(nbFaces*nvertex); 
     725//      edge_nodes.resizeAndPreserve(2, nbFaces*nvertex); 
     726//      for (int nf = 0; nf < nbFaces; ++nf) 
     727//      { 
     728//        for (int nv1 = 0; nv1 < nvertex; ++nv1) 
     729//        { 
     730//          int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation 
     731//          if (map_edges.find(make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))) == map_edges.end()) 
     732//          { 
     733//            map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))] = nbEdges ; 
     734//            edge_nodes(Range::all(),nbEdges) = face_nodes(nv1,nf), face_nodes(nv2,nf); 
     735//            edge_lon(nbEdges) = ( abs( node_lon(face_nodes(nv1,nf)) - node_lon(face_nodes(nv2,nf))) < 180.) ? 
     736//                        (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5) : 
     737//                        (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5 -180.);; 
     738//            edge_lat(nbEdges) = ( node_lat(face_nodes(nv1,nf)) + node_lat(face_nodes(nv2,nf)) ) * 0.5; 
     739//            ++nbEdges; 
     740//          } 
     741//        } 
     742//      } 
     743//      edge_nodes.resizeAndPreserve(2, nbEdges); 
     744//      edge_lon.resizeAndPreserve(nbEdges); 
     745//      edge_lat.resizeAndPreserve(nbEdges); 
     746// 
     747//      // Create faces 
     748//      face_lon.resize(nbFaces); 
     749//      face_lat.resize(nbFaces); 
     750//      face_lon = lonvalue; 
     751//      face_lat = latvalue; 
     752//      facesAreWritten = true; 
     753//    } // nvertex >= 3 
     754// 
     755//  } // createMeshEpsilon 
  • XIOS/trunk/src/node/mesh.hpp

    r881 r900  
    99  
    1010#include "array_new.hpp" 
    11 #include "client_client_dht_template.hpp" 
     11#include "client_client_dht_template_impl.hpp" 
     12#include "dht_auto_indexing.hpp" 
    1213 
    1314namespace xios { 
     
    3536      int nbFaces; 
    3637      int nvertex;   
    37        
     38 
    3839      bool nodesAreWritten; 
    3940      bool edgesAreWritten; 
     
    5051      CArray<double, 1> face_lat; 
    5152      CArray<int, 2> face_nodes; 
     53      CArray<int, 2> face_edges; 
     54      CArray<int, 2> edge_faces; 
     55      CArray<int, 2> face_faces; 
    5256 
    5357      void createMesh(const CArray<double, 1>&, const CArray<double, 1>&,  
    5458            const CArray<double, 2>&, const CArray<double, 2>& ); 
    5559                         
    56       void createMeshEpsilon(const CArray<double, 1>&, const CArray<double, 1>&, 
     60      void createMeshEpsilon(const MPI_Comm&, const CArray<double, 1>&, const CArray<double, 1>&, 
    5761            const CArray<double, 2>&, const CArray<double, 2>& ); 
    5862             
     
    6266 
    6367      static std::map <StdString, CMesh> meshList; 
     68      vector<size_t> createHashes (double, double); 
    6469 
    65       size_t nodeIndex (double, double);       
    66       boost::unordered_map <size_t, size_t> hashed_map_nodes; 
    67       boost::unordered_map <pair<double,double>, int> map_nodes; 
    68       boost::unordered_map <pair<int,int>, int> map_edges; 
     70      size_t nodeIndex (double, double);                           // redundant in parallel version with epsilon precision 
     71      boost::unordered_map <size_t, size_t> hashed_map_nodes;      // redundant in parallel version with epsilon precision 
     72      boost::unordered_map <pair<double,double>, int> map_nodes;   // redundant in parallel version with epsilon precision 
     73      boost::unordered_map <pair<int,int>, int> map_edges;         // redundant in parallel version with epsilon precision 
    6974 
    7075  };  
Note: See TracChangeset for help on using the changeset viewer.