Changeset 1542 for XIOS/trunk/src/node


Ignore:
Timestamp:
06/13/18 16:48:53 (6 years ago)
Author:
oabramkina
Message:

Replacing Boost's unordered_map and shared_pointer by its STL counterparts.

Two notes for Curie:

  • one can see the content of unordered_map with ddt only if XIOS has been compiled with gnu
  • XIOS will not compile any more with pgi (all available versions use old STL which are not up to the c++11 norms)
Location:
XIOS/trunk/src/node
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/node/axis.cpp

    r1421 r1542  
    202202     { 
    203203       // size estimation for sendDistributedValue 
    204        boost::unordered_map<int, vector<size_t> >::const_iterator it, ite = indSrv_[client->serverSize].end(); 
     204       std::unordered_map<int, vector<size_t> >::const_iterator it, ite = indSrv_[client->serverSize].end(); 
    205205       for (it = indSrv_[client->serverSize].begin(); it != ite; ++it) 
    206206       { 
    … …  
    623623       
    624624        std::vector<int> serverZeroIndex; 
    625         serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);       
     625        serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 0); 
    626626 
    627627        std::list<int> serverZeroIndexLeader; 
    … …  
    689689    // we need to compute the local index on the server from its corresponding global index 
    690690    size_t nbWritten = 0, indGlo;       
    691     boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
     691    std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
    692692                                                        ite = globalLocalIndexMap_.end(), it;           
    693693    CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(), 
    … …  
    721721    { 
    722722      nbWritten = 0; 
    723       boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
     723      std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
    724724                                                          ite = globalLocalIndexMap_.end(), it; 
    725725      for (int i = 0; i < zoom_index.numElements(); ++i) 
    … …  
    745745    // { 
    746746    //   nbWritten = 0; 
    747     //   boost::unordered_map<size_t,size_t> localGlobalIndexMap; 
     747    //   std::unordered_map<size_t,size_t> localGlobalIndexMap; 
    748748    //   for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
    749749    //   { 
    … …  
    810810      CDistributionServer srvDist(server->intraCommSize, nBegin, nSize, nBeginGlobal, nGlob);  
    811811      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex(); 
    812       boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
     812      std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
    813813                                                          ite = globalLocalIndexMap_.end(), it;    
    814814 
    815815      CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(), 
    816816                                       itSrve = writtenGlobalIndex.end(), itSrv; 
    817       boost::unordered_map<size_t,size_t> localGlobalIndexMap; 
     817      std::unordered_map<size_t,size_t> localGlobalIndexMap; 
    818818      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
    819819      { 
    … …  
    11371137      } 
    11381138 
    1139       boost::unordered_map<int, std::vector<size_t> >::const_iterator it, iteMap; 
     1139      std::unordered_map<int, std::vector<size_t> >::const_iterator it, iteMap; 
    11401140      iteMap = indSrv_[nbServer].end(); 
    11411141      for (int k = 0; k < connectedServerRank_[nbServer].size(); ++k) 

  • XIOS/trunk/src/node/axis.hpp

    r1371 r1542  
    166166         bool isCompressible_; 
    167167         std::map<int, map<int,int> > nbSenders; // Mapping of number of communicating client to a server 
    168          std::map<int, boost::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server 
     168         std::map<int, std::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server 
    169169         // std::map<int, vector<int> > indWrittenSrv_; // Global written index of each client sent to server 
    170          boost::unordered_map<size_t,size_t> globalLocalIndexMap_; 
     170         std::unordered_map<size_t,size_t> globalLocalIndexMap_; 
    171171         std::vector<int> indexesToWrite; 
    172172         std::map<int,int> numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_; 

  • XIOS/trunk/src/node/calendar_wrapper.cpp

    r1201 r1542  
    3232  \return the calendar 
    3333  */ 
    34   boost::shared_ptr<CCalendar> CCalendarWrapper::getCalendar(bool checkValid /*= false*/) const 
     34  std::shared_ptr<CCalendar> CCalendarWrapper::getCalendar(bool checkValid /*= false*/) const 
    3535  { 
    3636    if (checkValid && !this->calendar) 
    … …  
    9292#define DECLARE_CALENDAR(MType, eType)                                     \ 
    9393      if (type.getValue() == type_attr::eType)                             \ 
    94         calendar = boost::shared_ptr<CCalendar>(new C##MType##Calendar()); 
     94        calendar = std::shared_ptr<CCalendar>(new C##MType##Calendar()); 
    9595#include "calendar_type.conf" 
    9696#undef DECLARE_CALENDAR 
    … …  
    111111                << "Both leap_year_drift and leap_year_month attributes are mandatory if you wish to use leap_year_drift_offset attribute."); 
    112112 
    113         boost::shared_ptr<CUserDefinedCalendar> userDefinedCalendar; 
     113        std::shared_ptr<CUserDefinedCalendar> userDefinedCalendar; 
    114114        if (year_length.isEmpty()) 
    115115          userDefinedCalendar.reset(new CUserDefinedCalendar(day_length.getValue(), month_lengths.getValue())); 

  • XIOS/trunk/src/node/calendar_wrapper.hpp

    r591 r1542  
    6767    public : 
    6868      /// Accesseurs /// 
    69       boost::shared_ptr<CCalendar> getCalendar(bool checkValid = false) const; 
     69      std::shared_ptr<CCalendar> getCalendar(bool checkValid = false) const; 
    7070 
    7171      const CDate& getInitDate() const; 
    … …  
    7878    private: 
    7979      // Calendar of context 
    80       boost::shared_ptr<CCalendar> calendar; 
     80      std::shared_ptr<CCalendar> calendar; 
    8181 
    8282  }; // class CCalendarWrapper 

  • XIOS/trunk/src/node/context.cpp

    r1489 r1542  
    2323namespace xios { 
    2424 
    25   shared_ptr<CContextGroup> CContext::root; 
     25  std::shared_ptr<CContextGroup> CContext::root; 
    2626 
    2727   /// ////////////////////// Définitions ////////////////////// /// 
    … …  
    6666   CContextGroup* CContext::getRoot(void) 
    6767   { 
    68       if (root.get()==NULL) root=shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName())); 
     68      if (root.get()==NULL) root=std::shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName())); 
    6969      return root.get(); 
    7070   } 
    … …  
    7676   \return Calendar 
    7777   */ 
    78    boost::shared_ptr<CCalendar> CContext::getCalendar(void) const 
     78   std::shared_ptr<CCalendar> CContext::getCalendar(void) const 
    7979   { 
    8080      return (this->calendar); 
    … …  
    8787   \param[in] newCalendar new calendar 
    8888   */ 
    89    void CContext::setCalendar(boost::shared_ptr<CCalendar> newCalendar) 
     89   void CContext::setCalendar(std::shared_ptr<CCalendar> newCalendar) 
    9090   { 
    9191      this->calendar = newCalendar; 
    … …  
    14141414     idServer_ = this->getId(); 
    14151415     idServer_ += "_server_"; 
    1416      idServer_ += boost::lexical_cast<string>(i); 
     1416     idServer_ += std::to_string(static_cast<unsigned long long>(i)); 
    14171417     return idServer_; 
    14181418   } 

  • XIOS/trunk/src/node/context.hpp

    r1378 r1542  
    88 
    99#include "declare_group.hpp" 
    10 //#include "context_client.hpp" 
    11 //#include "context_server.hpp" 
    1210#include "data_output.hpp" 
    1311#include "garbage_collector.hpp" 
    … …  
    8381 
    8482         /// Mutateurs /// 
    85          void setCalendar(boost::shared_ptr<CCalendar> newCalendar); 
     83         void setCalendar(std::shared_ptr<CCalendar> newCalendar); 
    8684 
    8785         /// Accesseurs /// 
    88          boost::shared_ptr<CCalendar>      getCalendar(void) const; 
     86         std::shared_ptr<CCalendar>      getCalendar(void) const; 
    8987 
    9088      public : 
    … …  
    227225      public : 
    228226         // Calendar of context 
    229          boost::shared_ptr<CCalendar>   calendar; 
     227         std::shared_ptr<CCalendar>   calendar; 
    230228 
    231229         // List of all enabled files (files on which fields are written or read) 
    … …  
    241239 
    242240         // Context root 
    243          static shared_ptr<CContextGroup> root; 
     241         static std::shared_ptr<CContextGroup> root; 
    244242 
    245243         // Determine context on client or not 

  • XIOS/trunk/src/node/domain.cpp

    r1509 r1542  
    150150     } 
    151151 
    152      boost::unordered_map<int, vector<size_t> >::const_iterator itIndexEnd = indSrv_[client->serverSize].end(); 
     152     std::unordered_map<int, vector<size_t> >::const_iterator itIndexEnd = indSrv_[client->serverSize].end(); 
    153153     // std::map<int, std::vector<int> >::const_iterator itWrittenIndexEnd = indWrittenSrv_.end(); 
    154154     for (size_t k = 0; k < connectedServerRank_[client->serverSize].size(); ++k) 
    155155     { 
    156156       int rank = connectedServerRank_[client->serverSize][k]; 
    157        boost::unordered_map<int, std::vector<size_t> >::const_iterator it = indSrv_[client->serverSize].find(rank); 
     157       std::unordered_map<int, std::vector<size_t> >::const_iterator it = indSrv_[client->serverSize].find(rank); 
    158158       size_t idxCount = (it != itIndexEnd) ? it->second.size() : 0; 
    159159 
    … …  
    18381838           CServerDistributionDescription serverDescription(nGlobDomain, nbServer); 
    18391839           std::vector<int> serverZeroIndex; 
    1840            if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0); 
    1841            else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1); 
     1840           if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 0); 
     1841           else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 1); 
    18421842 
    18431843           std::list<int> serverZeroIndexLeader; 
    … …  
    18961896 
    18971897      size_t nbWritten = 0, indGlo;       
    1898       boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
     1898      std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
    18991899                                                          ite = globalLocalIndexMap_.end(), it;           
    19001900      CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(), 
    … …  
    19321932      // { 
    19331933      //   nbWritten = 0; 
    1934       //   boost::unordered_map<size_t,size_t> localGlobalIndexMap; 
     1934      //   std::unordered_map<size_t,size_t> localGlobalIndexMap; 
    19351935      //   for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
    19361936      //   { 
    … …  
    19961996      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex(); 
    19971997 
    1998       boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
     1998      std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
    19991999                                                          ite = globalLocalIndexMap_.end(), it;    
    20002000      CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(), 
    20012001                                       itSrve = writtenGlobalIndex.end(), itSrv; 
    2002       boost::unordered_map<size_t,size_t> localGlobalIndexMap; 
     2002      std::unordered_map<size_t,size_t> localGlobalIndexMap; 
    20032003      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
    20042004      { 
    … …  
    20762076      list<CArray<int,1> > list_indZoom, list_writtenInd, list_indGlob; 
    20772077 
    2078       boost::unordered_map<int, vector<size_t> >::const_iterator itIndex, iteIndex; 
     2078      std::unordered_map<int, vector<size_t> >::const_iterator itIndex, iteIndex; 
    20792079      iteIndex = indSrv_[serverSize].end(); 
    20802080      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 
    … …  
    21772177      list<CArray<bool,1> > list_mask; 
    21782178 
    2179       boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
     2179      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
    21802180      iteMap = indSrv_[serverSize].end(); 
    21812181      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 
    … …  
    22242224      list<CArray<double,1> > list_area; 
    22252225 
    2226       boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
     2226      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
    22272227      iteMap = indSrv_[serverSize].end(); 
    22282228      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 
    … …  
    22752275      list<CArray<double,2> > list_boundslon, list_boundslat; 
    22762276 
    2277       boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
     2277      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
    22782278      iteMap = indSrv_[serverSize].end(); 
    22792279      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 
    … …  
    23922392      } 
    23932393 
    2394       boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
     2394      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
    23952395      iteMap = indSrv_[serverSize].end(); 
    23962396      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 

  • XIOS/trunk/src/node/domain.hpp

    r1353 r1542  
    215215 
    216216/** Global index of each client sent to server: map<serverSize, map<serverRank, indexes>> */ 
    217          std::map<int, boost::unordered_map<int, vector<size_t> > > indSrv_; 
     217         std::map<int, std::unordered_map<int, vector<size_t> > > indSrv_; 
    218218         // std::map<CContextClient*, std::map<int, vector<int> > > indWrittenSrv_; // Global written index of each client sent to server 
    219219         std::vector<int> indexesToWrite; 
    … …  
    229229         TransMapTypes transformationMap_;          
    230230         bool isUnstructed_; 
    231          boost::unordered_map<size_t,size_t> globalLocalIndexMap_; 
     231         std::unordered_map<size_t,size_t> globalLocalIndexMap_; 
    232232        
    233233       private: 

  • XIOS/trunk/src/node/field.cpp

    r1524 r1542  
    219219      // Gather all data from different clients       
    220220      recvDataSrv.resize(storeClient.numElements()); 
    221       recvFoperationSrv = boost::shared_ptr<func::CFunctor>(new func::CInstant(recvDataSrv)); 
     221      recvFoperationSrv = std::shared_ptr<func::CFunctor>(new func::CInstant(recvDataSrv)); 
    222222    } 
    223223 
    … …  
    716716   //---------------------------------------------------------------- 
    717717 
    718    boost::shared_ptr<COutputPin> CField::getInstantDataFilter() 
     718   std::shared_ptr<COutputPin> CField::getInstantDataFilter() 
    719719   { 
    720720     return instantDataFilter; 
    … …  
    984984              << "An operation must be defined for field \"" << getId() << "\"."); 
    985985 
    986       boost::shared_ptr<func::CFunctor> functor; 
     986      std::shared_ptr<func::CFunctor> functor; 
    987987      CArray<double, 1> dummyData; 
    988988 
    … …  
    10271027     { 
    10281028        if (!instantDataFilter) 
    1029           instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid,true)); 
     1029          instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid,true)); 
    10301030 
    10311031 
    … …  
    10351035         if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write)) 
    10361036         { 
    1037            fileServerWriterFilter = boost::shared_ptr<CFileServerWriterFilter>(new CFileServerWriterFilter(gc, this)); 
     1037           fileServerWriterFilter = std::shared_ptr<CFileServerWriterFilter>(new CFileServerWriterFilter(gc, this)); 
    10381038           instantDataFilter->connectOutput(fileServerWriterFilter, 0); 
    10391039         } 
    … …  
    10431043     { 
    10441044       if (!instantDataFilter) 
    1045          instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true)); 
     1045         instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true)); 
    10461046 
    10471047             // If the field data is to be read by the client or/and written to a file 
    … …  
    10501050         if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write)) 
    10511051         { 
    1052            fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this)); 
     1052           fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this)); 
    10531053           instantDataFilter->connectOutput(fileWriterFilter, 0); 
    10541054         } 
    … …  
    10641064         { 
    10651065           boost::scoped_ptr<IFilterExprNode> expr(parseExpr(getExpression() + '\0')); 
    1066            boost::shared_ptr<COutputPin> filter = expr->reduce(gc, *this); 
     1066           std::shared_ptr<COutputPin> filter = expr->reduce(gc, *this); 
    10671067 
    10681068           // Check if a spatial transformation is needed 
    … …  
    10731073             if (grid && grid != gridRef && grid->hasTransform()) 
    10741074             { 
    1075                  std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, detectMissingValues, defaultValue);  
     1075                 std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, detectMissingValues, defaultValue);  
    10761076 
    10771077               filter->connectOutput(filters.first, 0); 
    … …  
    10891089         { 
    10901090           checkTimeAttributes(); 
    1091            instantDataFilter = serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, freq_offset, true, 
     1091           instantDataFilter = serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, freq_offset, true, 
    10921092                                                                                                       detectMissingValues, defaultValue)); 
    10931093         } 
    … …  
    10951095         { 
    10961096            if (check_if_active.isEmpty()) check_if_active = false;  
    1097             instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, NoneDu, false, 
     1097            instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, NoneDu, false, 
    10981098                                                                                                        detectMissingValues, defaultValue)); 
    10991099         } 
    … …  
    11051105         if (!read_access.isEmpty() && read_access) 
    11061106         { 
    1107            storeFilter = boost::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid, 
     1107           storeFilter = std::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid, 
    11081108                                                                          detectMissingValues, defaultValue)); 
    11091109           instantDataFilter->connectOutput(storeFilter, 0); 
    … …  
    11121112         if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write)) 
    11131113         { 
    1114            fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this)); 
     1114           fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this)); 
    11151115           getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0); 
    11161116         } 
    … …  
    11261126    * \return the output pin corresponding to the field reference 
    11271127    */ 
    1128    boost::shared_ptr<COutputPin> CField::getFieldReference(CGarbageCollector& gc) 
     1128   std::shared_ptr<COutputPin> CField::getFieldReference(CGarbageCollector& gc) 
    11291129   { 
    11301130     if (instantDataFilter || field_ref.isEmpty()) 
    … …  
    11351135     fieldRef->buildFilterGraph(gc, false); 
    11361136 
    1137      std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters; 
     1137     std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters; 
    11381138     // Check if a spatial transformation is needed 
    11391139     if (grid && grid != fieldRef->grid && grid->hasTransform()) 
    … …  
    11441144     } 
    11451145     else 
    1146        filters.first = filters.second = boost::shared_ptr<CFilter>(new CPassThroughFilter(gc)); 
     1146       filters.first = filters.second = std::shared_ptr<CFilter>(new CPassThroughFilter(gc)); 
    11471147 
    11481148     fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0); 
    … …  
    11601160    * \return the output pin corresponding to a self reference 
    11611161    */ 
    1162    boost::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc) 
     1162   std::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc) 
    11631163   { 
    11641164     if (instantDataFilter || !hasExpression()) 
    … …  
    11761176         { 
    11771177           checkTimeAttributes(); 
    1178            serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, freq_offset, true, 
     1178           serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, freq_offset, true, 
    11791179                                                                                   detectMissingValues, defaultValue)); 
    11801180         } 
    … …  
    11931193         { 
    11941194           if (check_if_active.isEmpty()) check_if_active = false; 
    1195            clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, NoneDu, false, 
     1195           clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, NoneDu, false, 
    11961196                                                                                   detectMissingValues, defaultValue)); 
    11971197         } 
    … …  
    12131213    * \return the output pin corresponding to the requested temporal filter 
    12141214    */ 
    1215    boost::shared_ptr<COutputPin> CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq) 
    1216    { 
    1217      std::map<CDuration, boost::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq); 
     1215   std::shared_ptr<COutputPin> CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq) 
     1216   { 
     1217     std::map<CDuration, std::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq); 
    12181218 
    12191219     if (it == temporalDataFilters.end()) 
    … …  
    12261226 
    12271227       const bool detectMissingValues = (!detect_missing_value.isEmpty()  && detect_missing_value == true); 
    1228        boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
     1228       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
    12291229                                                                             CContext::getCurrent()->getCalendar()->getInitDate(), 
    12301230                                                                             freq_op, freq_offset, outFreq, detectMissingValues)); 
    … …  
    12471247    */ 
    12481248    
    1249    boost::shared_ptr<COutputPin> CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq) 
     1249   std::shared_ptr<COutputPin> CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq) 
    12501250   { 
    12511251     if (instantDataFilter || !hasExpression()) 
    … …  
    12641264 
    12651265       const bool detectMissingValues = (!detect_missing_value.isEmpty() && detect_missing_value == true); 
    1266        boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
     1266       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
    12671267                                                                             CContext::getCurrent()->getCalendar()->getInitDate(), 
    12681268                                                                             freq_op, freq_offset, outFreq, detectMissingValues)); 

  • XIOS/trunk/src/node/field.hpp

    r1524 r1542  
    9292         template <int N> void getData(CArray<double, N>& _data) const; 
    9393 
    94          boost::shared_ptr<COutputPin> getInstantDataFilter(); 
     94         std::shared_ptr<COutputPin> getInstantDataFilter(); 
    9595 
    9696         /// Mutateur /// 
    … …  
    143143          
    144144          
    145          boost::shared_ptr<COutputPin> getFieldReference(CGarbageCollector& gc); 
    146          boost::shared_ptr<COutputPin> getSelfReference(CGarbageCollector& gc); 
    147          boost::shared_ptr<COutputPin> getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq); 
    148          boost::shared_ptr<COutputPin> getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq); 
     145         std::shared_ptr<COutputPin> getFieldReference(CGarbageCollector& gc); 
     146         std::shared_ptr<COutputPin> getSelfReference(CGarbageCollector& gc); 
     147         std::shared_ptr<COutputPin> getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq); 
     148         std::shared_ptr<COutputPin> getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq); 
    149149 
    150150//         virtual void fromBinary(StdIStream& is); 
    … …  
    226226         bool mustAutoTrigger; 
    227227 
    228          map<int,boost::shared_ptr<func::CFunctor> > foperation_srv; 
     228         map<int,std::shared_ptr<func::CFunctor> > foperation_srv; 
    229229 
    230230         // map<int, CArray<double,1> > data_srv; 
    231231         CArray<double,1> recvDataSrv; 
    232232          
    233          boost::shared_ptr<func::CFunctor> recvFoperationSrv; 
     233         std::shared_ptr<func::CFunctor> recvFoperationSrv; 
    234234         string content; 
    235235 
    … …  
    258258 
    259259         //! The output pin of the filter providing the instant data for the field 
    260          boost::shared_ptr<COutputPin> instantDataFilter; 
     260         std::shared_ptr<COutputPin> instantDataFilter; 
    261261         //! The output pin of the filters providing the result of the field's temporal operation 
    262          std::map<CDuration, boost::shared_ptr<COutputPin>, DurationFakeLessComparator> temporalDataFilters; 
     262         std::map<CDuration, std::shared_ptr<COutputPin>, DurationFakeLessComparator> temporalDataFilters; 
    263263         //! The output pin of the filter providing the instant data for self references 
    264          boost::shared_ptr<COutputPin> selfReferenceFilter; 
     264         std::shared_ptr<COutputPin> selfReferenceFilter; 
    265265         //! The source filter for data provided by the client 
    266          boost::shared_ptr<CSourceFilter> clientSourceFilter; 
     266         std::shared_ptr<CSourceFilter> clientSourceFilter; 
    267267         //! The source filter for data provided by the server 
    268          boost::shared_ptr<CSourceFilter> serverSourceFilter; 
     268         std::shared_ptr<CSourceFilter> serverSourceFilter; 
    269269         //! The terminal filter which stores the instant data 
    270          boost::shared_ptr<CStoreFilter> storeFilter; 
     270         std::shared_ptr<CStoreFilter> storeFilter; 
    271271         //! The terminal filter which writes the data to file 
    272          boost::shared_ptr<CFileWriterFilter> fileWriterFilter; 
     272         std::shared_ptr<CFileWriterFilter> fileWriterFilter; 
    273273         //! The terminal filter which writes data to file 
    274          boost::shared_ptr<CFileServerWriterFilter> fileServerWriterFilter; 
     274         std::shared_ptr<CFileServerWriterFilter> fileServerWriterFilter; 
    275275   }; // class CField 
    276276 

  • XIOS/trunk/src/node/file.cpp

    r1516 r1542  
    6464   \return data writer object. 
    6565   */ 
    66    boost::shared_ptr<CDataOutput> CFile::getDataOutput(void) const 
     66   std::shared_ptr<CDataOutput> CFile::getDataOutput(void) const 
    6767   { 
    6868      return data_out; 
    … …  
    7575   \return data reader object. 
    7676   */ 
    77    boost::shared_ptr<CDataInput> CFile::getDataInput(void) const 
     77   std::shared_ptr<CDataInput> CFile::getDataInput(void) const 
    7878   { 
    7979      return data_in; 
    … …  
    545545         if (isOpen) data_out->closeFile(); 
    546546 
    547         data_out = shared_ptr<CDataOutput>(new CNc4DataOutput(this, oss.str(), append, useClassicFormat, useCFConvention, 
     547        data_out = std::shared_ptr<CDataOutput>(new CNc4DataOutput(this, oss.str(), append, useClassicFormat, useCFConvention, 
    548548                                                              fileComm, multifile, isCollective, time_counter_name)); 
    549549        isOpen = true; 
    … …  
    669669      bool ugridConvention = !convention.isEmpty() ? (convention == convention_attr::UGRID) : false; 
    670670      if (time_counter_name.isEmpty()) 
    671         data_in = shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), readComm, multifile, isCollective, readMetaDataPar, ugridConvention)); 
     671        data_in = std::shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), readComm, multifile, isCollective, readMetaDataPar, ugridConvention)); 
    672672      else 
    673         data_in = shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), readComm, multifile, isCollective, readMetaDataPar, ugridConvention, time_counter_name)); 
     673        data_in = std::shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), readComm, multifile, isCollective, readMetaDataPar, ugridConvention, time_counter_name)); 
    674674      isOpen = true; 
    675675    } 

  • XIOS/trunk/src/node/file.hpp

    r1494 r1542  
    7171         /// Accesseurs /// 
    7272         const StdString getFileOutputName(void) const; 
    73          boost::shared_ptr<CDataOutput> getDataOutput(void) const; 
    74          boost::shared_ptr<CDataInput> getDataInput(void) const; 
     73         std::shared_ptr<CDataOutput> getDataOutput(void) const; 
     74         std::shared_ptr<CDataInput> getDataInput(void) const; 
    7575         CFieldGroup* getVirtualFieldGroup(void) const; 
    7676         CVariableGroup* getVirtualVariableGroup(void) const; 
    … …  
    186186         CFieldGroup* vFieldGroup; 
    187187         CVariableGroup* vVariableGroup; 
    188          boost::shared_ptr<CDataOutput> data_out; 
    189          boost::shared_ptr<CDataInput> data_in; 
     188         std::shared_ptr<CDataOutput> data_out; 
     189         std::shared_ptr<CDataInput> data_in; 
    190190         std::vector<CField*> enabledFields; 
    191191 

  • XIOS/trunk/src/node/grid.cpp

    r1397 r1542  
    783783 
    784784         // Compute mapping between client and server 
    785          std::vector<boost::unordered_map<size_t,std::vector<int> > > indexServerOnElement; 
     785         std::vector<std::unordered_map<size_t,std::vector<int> > > indexServerOnElement; 
    786786         CServerDistributionDescription serverDistributionDescription(getGlobalDimension(), client->serverSize); 
    787787         std::vector<int> serverZeroIndex = serverDistributionDescription.computeServerGlobalByElement(indexServerOnElement, 
    … …  
    889889      \param [out] globalIndexOnServer global index of grid and its corresponding rank of server. 
    890890   */ 
    891    void CGrid::computeIndexByElement(const std::vector<boost::unordered_map<size_t,std::vector<int> > >& indexServerOnElement, 
     891   void CGrid::computeIndexByElement(const std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement, 
    892892                                     const CContextClient* client, 
    893893                                     CClientServerMapping::GlobalIndexMap& globalIndexOnServer) 
    … …  
    942942 
    943943     std::vector<std::vector<bool> > elementOnServer(nbElement, std::vector<bool>(serverSize, false)); 
    944      std::vector<boost::unordered_map<int,std::vector<size_t> > > globalElementIndexOnServer(nbElement); 
     944     std::vector<std::unordered_map<int,std::vector<size_t> > > globalElementIndexOnServer(nbElement); 
    945945     CArray<int,1> nbIndexOnServer(serverSize); // Number of distributed global index held by each client for each server 
    946946     // Number of temporary distributed global index held by each client for each server 
    … …  
    950950     { 
    951951       nbIndexOnServer = 0; 
    952        const boost::unordered_map<size_t,std::vector<int> >& indexServerElement = indexServerOnElement[idx]; 
     952       const std::unordered_map<size_t,std::vector<int> >& indexServerElement = indexServerOnElement[idx]; 
    953953       const CArray<size_t,1>& globalIndexElementOnClient = globalIndexElement[idx]; 
    954954       CClientClientDHTInt clientClientDHT(indexServerElement, client->intraComm); 

  • XIOS/trunk/src/node/grid.hpp

    r1422 r1542  
    288288        void checkAttributesAfterTransformation(); 
    289289        void setTransformationAlgorithms(); 
    290         void computeIndexByElement(const std::vector<boost::unordered_map<size_t,std::vector<int> > >& indexServerOnElement, 
     290        void computeIndexByElement(const std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement, 
    291291                                   const CContextClient* client, 
    292292                                   CClientServerMapping::GlobalIndexMap& globalIndexOnServer); 

  • XIOS/trunk/src/node/mesh.cpp

    r1507 r1542  
    66 
    77#include "mesh.hpp" 
     8#include <boost/functional/hash.hpp> 
     9//#include <unordered_map> 
    810 
    911namespace xios { 
    … …  
    136138    } 
    137139 
    138  
    139 ///---------------------------------------------------------------- 
    140 /*! 
    141  * \fn size_t CMesh::nodeIndex (double lon, double lat) 
    142  * Returns its index if a node exists; otherwise adds the node and returns -1. 
    143  * Precision check is implemented with two hash values for each dimension, longitude and latitude. 
    144  * \param [in] lon Node longitude in degrees. 
    145  * \param [in] lat Node latitude in degrees ranged from 0 to 360. 
    146  * \return node index if a node exists; -1 otherwise 
    147  */ 
    148   size_t CMesh::nodeIndex (double lon, double lat) 
    149   { 
    150     double minBoundLon = 0. ; 
    151     double maxBoundLon = 360. ; 
    152     double minBoundLat = -90 ; 
    153     double maxBoundLat = 90 ; 
    154     double prec=1e-11 ; 
    155     double precLon=prec ; 
    156     double precLat=prec ; 
    157  
    158     size_t maxsize_t=numeric_limits<size_t>::max() ; 
    159     if ( (maxBoundLon-minBoundLon)/maxsize_t > precLon) precLon=(maxBoundLon-minBoundLon)/maxsize_t ; 
    160     if ( (maxBoundLat-minBoundLat)/maxsize_t > precLat) precLat=(maxBoundLat-minBoundLat)/maxsize_t ; 
    161  
    162     size_t iMinLon=0 ; 
    163     size_t iMaxLon=(maxBoundLon-minBoundLon)/precLon ; 
    164     size_t iMinLat=0 ; 
    165     size_t iMaxLat=(maxBoundLat-minBoundLat)/precLat ; 
    166  
    167     size_t hash0,hash1,hash2,hash3 ; 
    168     size_t lon0,lon1,lat0,lat1 ; 
    169  
    170     lon0=(lon-minBoundLon)/precLon ; 
    171     if ( ((lon0+1)*precLon + lon0*precLon)/2 > lon-minBoundLon) 
    172     { 
    173       if (lon0==iMinLon) lon1=iMaxLon ; 
    174       else lon1=lon0-1 ; 
    175     } 
    176     else 
    177     { 
    178       if (lon0==iMaxLon) lon1=iMinLon ; 
    179       else lon1=lon0+1 ; 
    180     } 
    181  
    182     lat0=(lat-minBoundLat)/precLat ; 
    183     if ( ((lat0+1)*precLat + lat0*precLat)/2 > lat-minBoundLat) 
    184     { 
    185       if (lat0==iMinLat) lat1=lat0 ; 
    186       else lat1=lat0-1 ; 
    187     } 
    188     else 
    189     { 
    190       if (lat0==iMaxLat) lat1=lat0 ; 
    191       else lat1=lat0+1 ; 
    192     } 
    193  
    194     hash0=hashPair(lon0,lat0) ; 
    195     hash1=hashPair(lon0,lat1) ; 
    196     hash2=hashPair(lon1,lat0) ; 
    197     hash3=hashPair(lon1,lat1) ; 
    198  
    199     boost::unordered_map<size_t, size_t>::iterator end = hashed_map_nodes.end() ; 
    200     size_t mapSize = hashed_map_nodes.size(); 
    201     if (hashed_map_nodes.find(hash0)==end && hashed_map_nodes.find(hash1)==end && hashed_map_nodes.find(hash2)==end && hashed_map_nodes.find(hash3)==end) 
    202     { 
    203       hashed_map_nodes[hash0] = mapSize ; 
    204       hashed_map_nodes[hash1] = mapSize + 1; 
    205       hashed_map_nodes[hash2] = mapSize + 2; 
    206       hashed_map_nodes[hash3] = mapSize + 3; 
    207       return -1; 
    208     } 
    209     else 
    210       return ( (hashed_map_nodes[hash0]+1) / 4 ); 
    211  
    212   } // nodeIndex() 
    213  
    214140///---------------------------------------------------------------- 
    215141/*! 
    … …  
    298224 * \param [in] bounds_lat Array of boundary latitudes. Its size depends on the element type. 
    299225 */ 
    300   void CMesh::createMesh(const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue, 
    301             const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat) 
    302   { 
    303     int nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows(); 
    304  
    305     if (nvertex == 1) 
    306     { 
    307       nbNodes_ = lonvalue.numElements(); 
    308       node_lon.resizeAndPreserve(nbNodes_); 
    309       node_lat.resizeAndPreserve(nbNodes_); 
    310       for (int nn = 0; nn < nbNodes_; ++nn) 
    311       { 
    312         if (map_nodes.find(make_pair (lonvalue(nn), latvalue(nn))) == map_nodes.end()) 
    313         { 
    314           map_nodes[make_pair (lonvalue(nn), latvalue(nn))] = nn ; 
    315           node_lon(nn) = lonvalue(nn); 
    316           node_lat(nn) = latvalue(nn); 
    317         } 
    318       } 
    319     } 
    320     else if (nvertex == 2) 
    321     { 
    322       nbEdges_ = bounds_lon.shape()[1]; 
    323  
    324       // Create nodes and edge_node connectivity 
    325       node_lon.resizeAndPreserve(nbEdges_*nvertex); // Max possible number of nodes 
    326       node_lat.resizeAndPreserve(nbEdges_*nvertex); 
    327       edge_nodes.resizeAndPreserve(nvertex, nbEdges_); 
    328  
    329       for (int ne = 0; ne < nbEdges_; ++ne) 
    330       { 
    331         for (int nv = 0; nv < nvertex; ++nv) 
    332         { 
    333           if (map_nodes.find(make_pair (bounds_lon(nv, ne), bounds_lat(nv ,ne))) == map_nodes.end()) 
    334           { 
    335             map_nodes[make_pair (bounds_lon(nv, ne), bounds_lat(nv, ne))] = nbNodes_ ; 
    336             edge_nodes(nv,ne) = nbNodes_ ; 
    337             node_lon(nbNodes_) = bounds_lon(nv, ne); 
    338             node_lat(nbNodes_) = bounds_lat(nv, ne); 
    339             ++nbNodes_ ; 
    340           } 
    341           else 
    342             edge_nodes(nv,ne) = map_nodes[make_pair (bounds_lon(nv, ne), bounds_lat(nv ,ne))]; 
    343         } 
    344       } 
    345       node_lon.resizeAndPreserve(nbNodes_); 
    346       node_lat.resizeAndPreserve(nbNodes_); 
    347  
    348       // Create edges 
    349       edge_lon.resizeAndPreserve(nbEdges_); 
    350       edge_lat.resizeAndPreserve(nbEdges_); 
    351  
    352       for (int ne = 0; ne < nbEdges_; ++ne) 
    353       { 
    354         if (map_edges.find(make_ordered_pair (edge_nodes(0,ne), edge_nodes(1,ne))) == map_edges.end()) 
    355         { 
    356           map_edges[make_ordered_pair ( edge_nodes(0,ne), edge_nodes(1,ne) )] = ne ; 
    357           edge_lon(ne) = lonvalue(ne); 
    358           edge_lat(ne) = latvalue(ne); 
    359         } 
    360  
    361       } 
    362       edgesAreWritten = true; 
    363     } 
    364     else 
    365     { 
    366       nbFaces_ = bounds_lon.shape()[1]; 
    367    
    368       // Create nodes and face_node connectivity 
    369       node_lon.resizeAndPreserve(nbFaces_*nvertex);  // Max possible number of nodes 
    370       node_lat.resizeAndPreserve(nbFaces_*nvertex); 
    371       face_nodes.resize(nvertex, nbFaces_); 
    372    
    373       for (int nf = 0; nf < nbFaces_; ++nf) 
    374       { 
    375         for (int nv = 0; nv < nvertex; ++nv) 
    376         { 
    377           if (map_nodes.find(make_pair (bounds_lon(nv, nf), bounds_lat(nv ,nf))) == map_nodes.end()) 
    378           { 
    379             map_nodes[make_pair (bounds_lon(nv, nf), bounds_lat(nv, nf))] = nbNodes_ ; 
    380             face_nodes(nv,nf) = nbNodes_ ; 
    381             node_lon(nbNodes_) = bounds_lon(nv, nf); 
    382             node_lat(nbNodes_) = bounds_lat(nv ,nf); 
    383             ++nbNodes_ ; 
    384           } 
    385           else 
    386           { 
    387             face_nodes(nv,nf) = map_nodes[make_pair (bounds_lon(nv, nf), bounds_lat(nv ,nf))]; 
    388           } 
    389         } 
    390       } 
    391       node_lon.resizeAndPreserve(nbNodes_); 
    392       node_lat.resizeAndPreserve(nbNodes_); 
    393    
    394       // Create edges and edge_nodes connectivity 
    395       edge_lon.resizeAndPreserve(nbFaces_*nvertex); // Max possible number of edges 
    396       edge_lat.resizeAndPreserve(nbFaces_*nvertex); 
    397       edge_nodes.resizeAndPreserve(2, nbFaces_*nvertex); 
    398       edge_faces.resize(2, nbFaces_*nvertex); 
    399       face_edges.resize(nvertex, nbFaces_); 
    400       face_faces.resize(nvertex, nbFaces_); 
    401  
    402       vector<int> countEdges(nbFaces_*nvertex);   // needed in case if edges have been already generated 
    403       vector<int> countFaces(nbFaces_); 
    404       countEdges.assign(nbFaces_*nvertex, 0); 
    405       countFaces.assign(nbFaces_, 0); 
    406       int edge; 
    407       for (int nf = 0; nf < nbFaces_; ++nf) 
    408       { 
    409         for (int nv1 = 0; nv1 < nvertex; ++nv1) 
    410         { 
    411           int nv = 0; 
    412           int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation 
    413           if (map_edges.find(make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))) == map_edges.end()) 
    414           { 
    415             map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))] = nbEdges_ ; 
    416             face_edges(nv1,nf) = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))]; 
    417             edge_faces(0,nbEdges_) = nf; 
    418             edge_faces(1,nbEdges_) = -999; 
    419             face_faces(nv1,nf) = 999999; 
    420             edge_nodes(Range::all(),nbEdges_) = face_nodes(nv1,nf), face_nodes(nv2,nf); 
    421             edge_lon(nbEdges_) = ( abs( node_lon(face_nodes(nv1,nf)) - node_lon(face_nodes(nv2,nf))) < 180.) ? 
    422                         (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5) : 
    423                         (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5 -180.); 
    424             edge_lat(nbEdges_) = ( node_lat(face_nodes(nv1,nf)) + node_lat(face_nodes(nv2,nf)) ) * 0.5; 
    425             ++nbEdges_; 
    426           } 
    427           else 
    428           { 
    429             edge = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))]; 
    430             face_edges(nv1,nf) = edge; 
    431             if (edgesAreWritten) 
    432             { 
    433               edge_faces(countEdges[edge], edge) = nf; 
    434               if (countEdges[edge]==0) 
    435               { 
    436                 face_faces(nv1,nf) = 999999; 
    437               } 
    438               else 
    439               { 
    440                 int face1 = nf; // = edge_faces(1,edge) 
    441                 int face2 = edge_faces(0,edge); 
    442                 face_faces(countFaces[face1], face1) =  face2; 
    443                 face_faces(countFaces[face2], face2) =  face1; 
    444                 ++(countFaces[face1]); 
    445                 ++(countFaces[face2]); 
    446               } 
    447             } 
    448             else 
    449             { 
    450               edge_faces(1,edge) = nf; 
    451               int face1 = nf; // = edge_faces(1,edge) 
    452               int face2 = edge_faces(0,edge); 
    453               face_faces(countFaces[face1], face1) =  face2; 
    454               face_faces(countFaces[face2], face2) =  face1; 
    455               ++(countFaces[face1]); 
    456               ++(countFaces[face2]); 
    457             } 
    458             ++(countEdges[edge]); 
    459           } 
    460         } 
    461       } 
    462       edge_nodes.resizeAndPreserve(2, nbEdges_); 
    463       edge_faces.resizeAndPreserve(2, nbEdges_); 
    464       edge_lon.resizeAndPreserve(nbEdges_); 
    465       edge_lat.resizeAndPreserve(nbEdges_); 
    466  
    467       // Create faces 
    468       face_lon.resize(nbFaces_); 
    469       face_lat.resize(nbFaces_); 
    470       face_lon = lonvalue; 
    471       face_lat = latvalue; 
    472       facesAreWritten = true; 
    473  
    474     } // nvertex > 2 
    475      
    476   } // createMesh() 
     226//  void CMesh::createMesh(const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue, 
     227//            const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat) 
     228//  { 
     229//    int nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows(); 
     230// 
     231//    if (nvertex == 1) 
     232//    { 
     233//      nbNodes_ = lonvalue.numElements(); 
     234//      node_lon.resizeAndPreserve(nbNodes_); 
     235//      node_lat.resizeAndPreserve(nbNodes_); 
     236//      for (int nn = 0; nn < nbNodes_; ++nn) 
     237//      { 
     238//        if (map_nodes.find(make_pair (lonvalue(nn), latvalue(nn))) == map_nodes.end()) 
     239//        { 
     240//          map_nodes[make_pair (lonvalue(nn), latvalue(nn))] = nn ; 
     241//          node_lon(nn) = lonvalue(nn); 
     242//          node_lat(nn) = latvalue(nn); 
     243//        } 
     244//      } 
     245//    } 
     246//    else if (nvertex == 2) 
     247//    { 
     248//      nbEdges_ = bounds_lon.shape()[1]; 
     249// 
     250//      // Create nodes and edge_node connectivity 
     251//      node_lon.resizeAndPreserve(nbEdges_*nvertex); // Max possible number of nodes 
     252//      node_lat.resizeAndPreserve(nbEdges_*nvertex); 
     253//      edge_nodes.resizeAndPreserve(nvertex, nbEdges_); 
     254// 
     255//      for (int ne = 0; ne < nbEdges_; ++ne) 
     256//      { 
     257//        for (int nv = 0; nv < nvertex; ++nv) 
     258//        { 
     259//          if (map_nodes.find(make_pair (bounds_lon(nv, ne), bounds_lat(nv ,ne))) == map_nodes.end()) 
     260//          { 
     261//            map_nodes[make_pair (bounds_lon(nv, ne), bounds_lat(nv, ne))] = nbNodes_ ; 
     262//            edge_nodes(nv,ne) = nbNodes_ ; 
     263//            node_lon(nbNodes_) = bounds_lon(nv, ne); 
     264//            node_lat(nbNodes_) = bounds_lat(nv, ne); 
     265//            ++nbNodes_ ; 
     266//          } 
     267//          else 
     268//            edge_nodes(nv,ne) = map_nodes[make_pair (bounds_lon(nv, ne), bounds_lat(nv ,ne))]; 
     269//        } 
     270//      } 
     271//      node_lon.resizeAndPreserve(nbNodes_); 
     272//      node_lat.resizeAndPreserve(nbNodes_); 
     273// 
     274//      // Create edges 
     275//      edge_lon.resizeAndPreserve(nbEdges_); 
     276//      edge_lat.resizeAndPreserve(nbEdges_); 
     277// 
     278//      for (int ne = 0; ne < nbEdges_; ++ne) 
     279//      { 
     280//        if (map_edges.find(make_ordered_pair (edge_nodes(0,ne), edge_nodes(1,ne))) == map_edges.end()) 
     281//        { 
     282//          map_edges[make_ordered_pair ( edge_nodes(0,ne), edge_nodes(1,ne) )] = ne ; 
     283//          edge_lon(ne) = lonvalue(ne); 
     284//          edge_lat(ne) = latvalue(ne); 
     285//        } 
     286// 
     287//      } 
     288//      edgesAreWritten = true; 
     289//    } 
     290//    else 
     291//    { 
     292//      nbFaces_ = bounds_lon.shape()[1]; 
     293// 
     294//      // Create nodes and face_node connectivity 
     295//      node_lon.resizeAndPreserve(nbFaces_*nvertex);  // Max possible number of nodes 
     296//      node_lat.resizeAndPreserve(nbFaces_*nvertex); 
     297//      face_nodes.resize(nvertex, nbFaces_); 
     298// 
     299//      for (int nf = 0; nf < nbFaces_; ++nf) 
     300//      { 
     301//        for (int nv = 0; nv < nvertex; ++nv) 
     302//        { 
     303//          if (map_nodes.find(make_pair (bounds_lon(nv, nf), bounds_lat(nv ,nf))) == map_nodes.end()) 
     304//          { 
     305//            map_nodes[make_pair (bounds_lon(nv, nf), bounds_lat(nv, nf))] = nbNodes_ ; 
     306//            face_nodes(nv,nf) = nbNodes_ ; 
     307//            node_lon(nbNodes_) = bounds_lon(nv, nf); 
     308//            node_lat(nbNodes_) = bounds_lat(nv ,nf); 
     309//            ++nbNodes_ ; 
     310//          } 
     311//          else 
     312//          { 
     313//            face_nodes(nv,nf) = map_nodes[make_pair (bounds_lon(nv, nf), bounds_lat(nv ,nf))]; 
     314//          } 
     315//        } 
     316//      } 
     317//      node_lon.resizeAndPreserve(nbNodes_); 
     318//      node_lat.resizeAndPreserve(nbNodes_); 
     319// 
     320//      // Create edges and edge_nodes connectivity 
     321//      edge_lon.resizeAndPreserve(nbFaces_*nvertex); // Max possible number of edges 
     322//      edge_lat.resizeAndPreserve(nbFaces_*nvertex); 
     323//      edge_nodes.resizeAndPreserve(2, nbFaces_*nvertex); 
     324//      edge_faces.resize(2, nbFaces_*nvertex); 
     325//      face_edges.resize(nvertex, nbFaces_); 
     326//      face_faces.resize(nvertex, nbFaces_); 
     327// 
     328//      vector<int> countEdges(nbFaces_*nvertex);   // needed in case if edges have been already generated 
     329//      vector<int> countFaces(nbFaces_); 
     330//      countEdges.assign(nbFaces_*nvertex, 0); 
     331//      countFaces.assign(nbFaces_, 0); 
     332//      int edge; 
     333//      for (int nf = 0; nf < nbFaces_; ++nf) 
     334//      { 
     335//        for (int nv1 = 0; nv1 < nvertex; ++nv1) 
     336//        { 
     337//          int nv = 0; 
     338//          int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation 
     339//          if (map_edges.find(make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))) == map_edges.end()) 
     340//          { 
     341//            map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))] = nbEdges_ ; 
     342//            face_edges(nv1,nf) = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))]; 
     343//            edge_faces(0,nbEdges_) = nf; 
     344//            edge_faces(1,nbEdges_) = -999; 
     345//            face_faces(nv1,nf) = 999999; 
     346//            edge_nodes(Range::all(),nbEdges_) = face_nodes(nv1,nf), face_nodes(nv2,nf); 
     347//            edge_lon(nbEdges_) = ( abs( node_lon(face_nodes(nv1,nf)) - node_lon(face_nodes(nv2,nf))) < 180.) ? 
     348//                        (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5) : 
     349//                        (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5 -180.); 
     350//            edge_lat(nbEdges_) = ( node_lat(face_nodes(nv1,nf)) + node_lat(face_nodes(nv2,nf)) ) * 0.5; 
     351//            ++nbEdges_; 
     352//          } 
     353//          else 
     354//          { 
     355//            edge = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))]; 
     356//            face_edges(nv1,nf) = edge; 
     357//            if (edgesAreWritten) 
     358//            { 
     359//              edge_faces(countEdges[edge], edge) = nf; 
     360//              if (countEdges[edge]==0) 
     361//              { 
     362//                face_faces(nv1,nf) = 999999; 
     363//              } 
     364//              else 
     365//              { 
     366//                int face1 = nf; // = edge_faces(1,edge) 
     367//                int face2 = edge_faces(0,edge); 
     368//                face_faces(countFaces[face1], face1) =  face2; 
     369//                face_faces(countFaces[face2], face2) =  face1; 
     370//                ++(countFaces[face1]); 
     371//                ++(countFaces[face2]); 
     372//              } 
     373//            } 
     374//            else 
     375//            { 
     376//              edge_faces(1,edge) = nf; 
     377//              int face1 = nf; // = edge_faces(1,edge) 
     378//              int face2 = edge_faces(0,edge); 
     379//              face_faces(countFaces[face1], face1) =  face2; 
     380//              face_faces(countFaces[face2], face2) =  face1; 
     381//              ++(countFaces[face1]); 
     382//              ++(countFaces[face2]); 
     383//            } 
     384//            ++(countEdges[edge]); 
     385//          } 
     386//        } 
     387//      } 
     388//      edge_nodes.resizeAndPreserve(2, nbEdges_); 
     389//      edge_faces.resizeAndPreserve(2, nbEdges_); 
     390//      edge_lon.resizeAndPreserve(nbEdges_); 
     391//      edge_lat.resizeAndPreserve(nbEdges_); 
     392// 
     393//      // Create faces 
     394//      face_lon.resize(nbFaces_); 
     395//      face_lat.resize(nbFaces_); 
     396//      face_lon = lonvalue; 
     397//      face_lat = latvalue; 
     398//      facesAreWritten = true; 
     399// 
     400//    } // nvertex > 2 
     401// 
     402//  } // createMesh() 
    477403 
    478404///---------------------------------------------------------------- 
    … …  
    20882014 
    20892015    // faceToFaces connectivity 
    2090     boost::unordered_map <int, int> mapFaces;  // mapFaces = < hash(face1, face2), hash> (the mapped value is irrelevant) 
     2016    std::unordered_map <int, int> mapFaces;  // mapFaces = < hash(face1, face2), hash> (the mapped value is irrelevant) 
    20912017    int maxNb = 20;                            // some assumption on the max possible number of neighboring cells 
    20922018    faceToFaces.resize(maxNb, nbFaces); 
    … …  
    21452071    CArray<double, 2> faceToNodes (nvertex, nbFaces); 
    21462072 
    2147     boost::unordered_map <pair<double,double>, int> mapNodes; 
     2073    std::unordered_map <pairDouble, int, boost::hash<pairDouble> > mapNodes; 
    21482074 
    21492075    for (int nf = 0; nf < nbFaces; ++nf) 
    … …  
    21612087 
    21622088    // faceToFaces connectivity 
    2163     boost::unordered_map <pair<int,int>, int> mapEdges; 
     2089    std::unordered_map <pairInt, int, boost::hash<pairInt> > mapEdges; 
    21642090    faceToFaces.resize(nvertex, nbFaces); 
    21652091    CArray<int, 2> edgeToFaces(2, nbFaces*nvertex); // max possible 

  • XIOS/trunk/src/node/mesh.hpp

    r931 r1542  
    7676    private: 
    7777 
     78      typedef std::pair<double, double> pairDouble; 
     79      typedef std::pair<int, int> pairInt; 
     80 
    7881      int nbNodes_; 
    7982      int nbEdges_; 
    … …  
    9194      vector<size_t> createHashes (const double, const double); 
    9295 
    93       size_t nodeIndex (double, double);                           // redundant in parallel version with epsilon precision 
    94       boost::unordered_map <size_t, size_t> hashed_map_nodes;      // redundant in parallel version with epsilon precision 
    95       boost::unordered_map <pair<double,double>, int> map_nodes;   // redundant in parallel version with epsilon precision 
    96       boost::unordered_map <pair<int,int>, int> map_edges;         // redundant in parallel version with epsilon precision 
    97  
    9896  };  
    9997 
Note: See TracChangeset for help on using the changeset viewer.