Changeset 967


Ignore:
Timestamp:
10/12/16 11:17:49 (5 years ago)
Author:
mhnguyen
Message:

Ticket 106: Reading a scalar from file

+) Add method to read scalar value
+) Modify the way to send/receive scalar (and non-distributed) data

Test
+) On Curie
+) OK

Location:
XIOS/trunk/src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/io/nc4_data_input.cpp

    r963 r967  
    66#include "domain.hpp" 
    77#include "axis.hpp" 
     8#include "scalar.hpp" 
    89 
    910namespace xios 
     
    1718    , readMetaDataDomains_(), readValueDomains_() 
    1819    , readMetaDataAxis_(), readValueAxis_() 
     20    , readMetaDataScalar_(), readValueScalar_() 
    1921  { 
    2022    SuperClass::type = multifile ? MULTI_FILE : ONE_FILE; 
     
    113115            count.push_back(nZoomSizeServer[idx]); 
    114116            --idx; 
    115            } 
     117          } 
     118          else 
     119          { 
     120            if (1 == axisDomainOrder.numElements()) 
     121            { 
     122              start.push_back(0); 
     123              count.push_back(1); 
     124            } 
     125            --idx; 
     126          } 
    116127        } 
    117128 
     
    140151    std::vector<CDomain*> domainP = grid->getDomains(); 
    141152    std::vector<CAxis*> axisP = grid->getAxis(); 
     153    std::vector<CScalar*> scalarP = grid->getScalars(); 
    142154    int gridDim = domainP.size() * 2 + axisP.size(); 
     155 
     156    // Nothing to do with scalar without timestep 
     157    if ((0 == gridDim) && (!SuperClassWriter::isTemporal(fieldId)))  
     158      return; 
    143159 
    144160    // Verify the compatibility of dimension of declared grid and real grid in file 
     
    163179    } 
    164180 
    165     int mapSize = dimSizeMap.size() - 1; 
    166181    std::list<std::pair<StdString, StdSize> > listDimSize; 
    167182/* 
     
    174189    // Now process domain and axis 
    175190    CArray<int,1> axisDomainOrder = grid->axis_domain_order; 
    176     int numElement = domainP.size() + axisP.size(); 
     191    int numElement = domainP.size() + axisP.size() + scalarP.size(); 
    177192    int elementPosition = 0; 
    178     int idxDomain = 0, idxAxis = 0; 
     193    int idxDomain = 0, idxAxis = 0, idxScalar = 0; 
    179194 
    180195    std::pair<std::set<StdString>::iterator,bool> it; 
     
    210225        } 
    211226        ++idxAxis; 
     227        ++elementPosition; 
     228      } 
     229      else 
     230      { 
     231        if (readAttributeValues) 
     232        { 
     233          it = readValueScalar_.insert(scalarP[idxScalar]->getId()); 
     234          if (it.second) readScalarAttributeValueFromFile(scalarP[idxScalar], listDimSize, elementPosition, fieldId); 
     235        } 
     236        else 
     237        { 
     238          it = readMetaDataScalar_.insert(scalarP[idxScalar]->getId()); 
     239          if (it.second) readScalarAttributesFromFile(scalarP[idxScalar], listDimSize, elementPosition, fieldId); 
     240        } 
     241        ++idxScalar; 
    212242        ++elementPosition; 
    213243      } 
     
    443473  } 
    444474 
     475  /*! 
     476    Read attributes of a scalar from a file 
     477    \param [in] scalar scalar whose attributes are read from the file 
     478    \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file 
     479    \param [in] emelentPosition position of scalar in grid 
     480    \param [in] fieldId id (or name) associated with the grid 
     481  */ 
     482  void CNc4DataInput::readScalarAttributesFromFile(CScalar* scalar, std::list<std::pair<StdString, StdSize> >& dimSizeMap, 
     483                                                  int elementPosition, const StdString& fieldId) 
     484  { 
     485//    std::list<std::pair<StdString, StdSize> >::const_iterator itMapN = dimSizeMap.begin(), 
     486//                                                              iteMap = dimSizeMap.end(); 
     487//    for (int i = 0; i < elementPosition; ++i, ++itMapN) {} 
     488//    axis->n_glo.setValue(itMapN->second); 
     489  } 
     490 
     491  /*! 
     492    Read attribute value of an axis from a file 
     493    \param [in] axis axis whose attributes are read from the file 
     494    \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file 
     495    \param [in] emelentPosition position of axis in grid 
     496    \param [in] fieldId id (or name) associated with the grid 
     497  */ 
     498  void CNc4DataInput::readScalarAttributeValueFromFile(CScalar* scalar, std::list<std::pair<StdString, StdSize> >& dimSizeMap, 
     499                                                      int elementPosition, const StdString& fieldId) 
     500  { 
     501//    std::list<std::pair<StdString, StdSize> >::const_iterator itMapN = dimSizeMap.begin(), 
     502//                                                              iteMap = dimSizeMap.end(); 
     503//    for (int i = 0; i < elementPosition; ++i, ++itMapN) {} 
     504// 
     505//    { // Read axis value 
     506//      std::vector<StdSize> nBegin(1, 0), nSize(1, itMapN->second); 
     507//      CArray<double,1> readAxisValue(itMapN->second); 
     508//      readFieldVariableValue(readAxisValue, itMapN->first, nBegin, nSize, true); 
     509//      int begin = 0, n = itMapN->second; 
     510//      if (!axis->begin.isEmpty()) begin = axis->begin.getValue(); 
     511//      if (!axis->n.isEmpty()) n = axis->n.getValue(); 
     512//      axis->value.resize(n); 
     513//      for (int i = 0; i < n; ++i) axis->value(i) = readAxisValue(begin + i); 
     514//    } 
     515  } 
     516 
    445517  void CNc4DataInput::closeFile_(void) 
    446518  { 
  • XIOS/trunk/src/io/nc4_data_input.hpp

    r802 r967  
    1111  class CDomain; 
    1212  class CAxis; 
     13  class CScalar; 
    1314 
    1415  class CNc4DataInput 
     
    5152                                        int elementPosition, const StdString& fieldId); 
    5253 
     54    void readScalarAttributesFromFile(CScalar* scalar, std::list<std::pair<StdString, StdSize> >& dimSizeMap, 
     55                                      int elementPosition, const StdString& fieldId); 
     56    void readScalarAttributeValueFromFile(CScalar* scalar, std::list<std::pair<StdString, StdSize> >& dimSizeMap, 
     57                                          int elementPosition, const StdString& fieldId); 
     58 
    5359    template <typename T, int Ndim> 
    5460    void readFieldVariableValue(CArray<T, Ndim>& var, const StdString& varId, 
     
    6066    std::set<StdString> readMetaDataDomains_, readValueDomains_; 
    6167    std::set<StdString> readMetaDataAxis_, readValueAxis_; 
     68    std::set<StdString> readMetaDataScalar_, readValueScalar_; 
    6269 
    6370  private: 
  • XIOS/trunk/src/node/field.cpp

    r959 r967  
    132132    if (!grid->doGridHaveDataDistributed()) 
    133133    { 
    134        if (0 == client->clientRank) 
     134       if (client->isServerLeader()) 
    135135       { 
    136136          for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++) 
     
    149149          } 
    150150          client->sendEvent(event); 
    151        } else client->sendEvent(event); 
     151       }  
     152       else client->sendEvent(event); 
    152153    } 
    153154    else 
  • XIOS/trunk/src/node/grid.cpp

    r957 r967  
    499499     if (!doGridHaveDataDistributed()) 
    500500     { 
    501         if (0 == client->clientRank) 
     501        if (client->isServerLeader()) 
    502502        { 
    503503          size_t ssize = clientDistribution_->getLocalDataIndexOnClient().size(); 
    504           for (int rank = 0; rank < client->serverSize; ++rank) 
     504          const std::list<int>& ranks = client->getRanksServerLeader(); 
     505          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    505506          { 
    506             connectedServerRank_.push_back(rank); 
    507             connectedDataSize_[rank] = ssize; 
     507            connectedServerRank_.push_back(*itRank); 
     508            connectedDataSize_[*itRank] = ssize; 
    508509          } 
    509510        } 
     
    975976        connectedServerRank_.push_back(rank); 
    976977        connectedDataSize_[rank] = 1; 
     978        nbSenders[rank] = 1; 
    977979      } 
    978980    } 
     
    10231025    list<CArray<size_t,1> > listOutIndex; 
    10241026 
    1025     if (0 == client->clientRank) 
    1026     { 
    1027       for (int rank = 0; rank < client->serverSize; ++rank) 
    1028       { 
     1027    if (client->isServerLeader()) 
     1028    { 
     1029      const std::list<int>& ranks = client->getRanksServerLeader(); 
     1030      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1031      { 
     1032        int rank = *itRank; 
    10291033        int nb = 1; 
    10301034        storeIndex_toSrv.insert(std::make_pair(rank, CArray<int,1>(nb))); 
     
    10451049        event.push(rank, 1, listMsg.back()); 
    10461050      } 
    1047  
    10481051      client->sendEvent(event); 
    10491052    } 
     
    10671070    if (!doGridHaveDataDistributed()) 
    10681071    { 
    1069       if (0 == client->clientRank) 
     1072      if (client->isServerLeader()) 
    10701073      { 
    10711074        int indexSize = globalLocalIndexSendToServer.size(); 
     
    10781081        } 
    10791082 
    1080         for (rank = 0; rank < client->serverSize; ++rank) 
    1081         { 
    1082           storeIndex_toSrv.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer))); 
     1083        //int nbClient = client->clientSize; // This stupid variable signals the servers the number of client connect to them 
     1084        const std::list<int>& ranks = client->getRanksServerLeader(); 
     1085        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1086        { 
     1087          storeIndex_toSrv.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer))); 
    10831088          listOutIndex.push_back(CArray<size_t,1>(outGlobalIndexOnServer)); 
    10841089 
     
    10861091          listMsg.back() << getId() << isDataDistributed_ << isCompressible_ << listOutIndex.back(); 
    10871092 
    1088           event.push(rank, 1, listMsg.back()); 
    1089         } 
    1090  
     1093          event.push(*itRank, 1, listMsg.back()); 
     1094        } 
    10911095        client->sendEvent(event); 
    10921096      } 
     
    11641168  } 
    11651169 
    1166   void CGrid::computeGridGlobalDimension(const std::vector<CDomain*>& domains, 
    1167                                          const std::vector<CAxis*>& axis, 
    1168                                          const std::vector<CScalar*>& scalars, 
    1169                                          const CArray<int,1>& axisDomainOrder) 
    1170   { 
    1171     globalDim_.resize(domains.size()*2+axis.size()+scalars.size()); 
    1172     int idx = 0, idxDomain = 0, idxAxis = 0, idxScalar = 0; 
    1173     for (int i = 0; i < axisDomainOrder.numElements(); ++i) 
    1174     { 
    1175       if (2 == axisDomainOrder(i)) 
    1176       { 
    1177         if (!(domains[idxDomain]->type.isEmpty()) && (domains[idxDomain]->type==CDomain::type_attr::unstructured)) 
    1178         { 
    1179           positionDimensionDistributed_ = idx; 
    1180         } 
    1181         else 
    1182         { 
    1183           positionDimensionDistributed_ = idx +1; 
    1184         } 
    1185  
    1186         globalDim_[idx]   = domains[idxDomain]->ni_glo.getValue(); 
    1187         globalDim_[idx+1] = domains[idxDomain]->nj_glo.getValue(); 
    1188  
    1189         ++idxDomain; 
    1190         idx += 2; 
    1191       } 
    1192       else if (1 == axisDomainOrder(i)) 
    1193       { 
    1194         globalDim_[idx] = axis[idxAxis]->n_glo.getValue(); 
    1195         ++idxAxis; 
    1196         ++idx; 
    1197       } 
    1198       else 
    1199       { 
    1200         globalDim_[idx] = 1; 
    1201         ++idxScalar; 
    1202         ++idx; 
    1203       } 
    1204     } 
    1205   } 
    1206  
    1207   std::vector<int> CGrid::getGlobalDimension() 
    1208   { 
    1209     return globalDim_; 
    1210   } 
    1211  
    1212   bool CGrid::isScalarGrid() const 
    1213   { 
    1214     return (axisList_.empty() && domList_.empty()); 
    1215   } 
    1216  
    1217   /*! 
    1218     Verify whether one server need to write data 
    1219     There are some cases on which one server has nodata to write. For example, when we 
    1220     just only want to zoom on a domain. 
    1221   */ 
    1222   bool CGrid::doGridHaveDataToWrite() 
    1223   { 
    1224      return (0 != writtenDataSize_); 
    1225   } 
    1226  
    1227   /*! 
    1228     Return size of data which is written on each server 
    1229     Whatever dimension of a grid, data which are written on server must be presented as 
    1230     an one dimension array. 
    1231     \return size of data written on server 
    1232   */ 
    1233   size_t CGrid::getWrittenDataSize() const 
    1234   { 
    1235     return writtenDataSize_; 
    1236   } 
    1237  
    1238   /*! 
    1239     Returns the number of indexes written by each server. 
    1240     \return the number of indexes written by each server 
    1241   */ 
    1242   int CGrid::getNumberWrittenIndexes() const 
    1243   { 
    1244     return numberWrittenIndexes_; 
    1245   } 
    1246  
    1247   /*! 
    1248     Returns the total number of indexes written by the servers. 
    1249     \return the total number of indexes written by the servers 
    1250   */ 
    1251   int CGrid::getTotalNumberWrittenIndexes() const 
    1252   { 
    1253     return totalNumberWrittenIndexes_; 
    1254   } 
    1255  
    1256   /*! 
    1257     Returns the offset of indexes written by each server. 
    1258     \return the offset of indexes written by each server 
    1259   */ 
    1260   int CGrid::getOffsetWrittenIndexes() const 
    1261   { 
    1262     return offsetWrittenIndexes_; 
    1263   } 
    1264  
    1265   CDistributionServer* CGrid::getDistributionServer() 
    1266   { 
    1267     return serverDistribution_; 
    1268   } 
    1269  
    1270   CDistributionClient* CGrid::getDistributionClient() 
    1271   { 
    1272     return clientDistribution_; 
    1273   } 
    1274  
    1275   bool CGrid::doGridHaveDataDistributed() 
    1276   { 
    1277     if (isScalarGrid()) return false; 
    1278     else 
    1279       return isDataDistributed_; 
    1280   } 
    1281  
    12821170  void CGrid::recvIndex(vector<int> ranks, vector<CBufferIn*> buffers) 
    12831171  { 
     
    12941182      buffer >> isDataDistributed_ >> isCompressible_; 
    12951183      size_t dataSize = 0; 
    1296  
    1297       if (isScalarGrid()) 
    1298       { 
    1299         writtenDataSize_ = numberWrittenIndexes_ = totalNumberWrittenIndexes_ = 1; 
    1300         CArray<size_t,1> outIndex; 
    1301         buffer >> outIndex; 
    1302         outIndexFromClient.insert(std::make_pair(rank, outIndex)); 
    1303         std::vector<int> nZoomBegin(1,0), nZoomSize(1,1), nGlob(1,1), nZoomBeginGlobal(1,0); 
    1304         serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize, 
    1305                                                       nZoomBeginGlobal, nGlob); 
    1306         return; 
    1307       } 
    13081184 
    13091185      if (0 == serverDistribution_) 
     
    13781254      } 
    13791255      writtenDataSize_ += dataSize; 
    1380  
     1256       
    13811257      outIndexFromClient.insert(std::make_pair(rank, outIndex)); 
    13821258      connectedDataSize_[rank] = outIndex.numElements(); 
     
    13841260    } 
    13851261 
     1262    // if (isScalarGrid()) return; 
     1263 
    13861264    if (isDataDistributed_) 
    13871265    { 
     
    13941272 
    13951273    nbSenders = CClientServerMappingDistributed::computeConnectedClients(context->client->serverSize, context->client->clientSize, context->client->intraComm, ranks); 
     1274  } 
     1275 
     1276  void CGrid::computeGridGlobalDimension(const std::vector<CDomain*>& domains, 
     1277                                         const std::vector<CAxis*>& axis, 
     1278                                         const std::vector<CScalar*>& scalars, 
     1279                                         const CArray<int,1>& axisDomainOrder) 
     1280  { 
     1281    globalDim_.resize(domains.size()*2+axis.size()+scalars.size()); 
     1282    int idx = 0, idxDomain = 0, idxAxis = 0, idxScalar = 0; 
     1283    for (int i = 0; i < axisDomainOrder.numElements(); ++i) 
     1284    { 
     1285      if (2 == axisDomainOrder(i)) 
     1286      { 
     1287        if (!(domains[idxDomain]->type.isEmpty()) && (domains[idxDomain]->type==CDomain::type_attr::unstructured)) 
     1288        { 
     1289          positionDimensionDistributed_ = idx; 
     1290        } 
     1291        else 
     1292        { 
     1293          positionDimensionDistributed_ = idx +1; 
     1294        } 
     1295 
     1296        globalDim_[idx]   = domains[idxDomain]->ni_glo.getValue(); 
     1297        globalDim_[idx+1] = domains[idxDomain]->nj_glo.getValue(); 
     1298 
     1299        ++idxDomain; 
     1300        idx += 2; 
     1301      } 
     1302      else if (1 == axisDomainOrder(i)) 
     1303      { 
     1304        globalDim_[idx] = axis[idxAxis]->n_glo.getValue(); 
     1305        ++idxAxis; 
     1306        ++idx; 
     1307      } 
     1308      else 
     1309      { 
     1310        globalDim_[idx] = 1; 
     1311        ++idxScalar; 
     1312        ++idx; 
     1313      } 
     1314    } 
     1315  } 
     1316 
     1317  std::vector<int> CGrid::getGlobalDimension() 
     1318  { 
     1319    return globalDim_; 
     1320  } 
     1321 
     1322  bool CGrid::isScalarGrid() const 
     1323  { 
     1324    return (axisList_.empty() && domList_.empty()); 
     1325  } 
     1326 
     1327  /*! 
     1328    Verify whether one server need to write data 
     1329    There are some cases on which one server has nodata to write. For example, when we 
     1330    just only want to zoom on a domain. 
     1331  */ 
     1332  bool CGrid::doGridHaveDataToWrite() 
     1333  { 
     1334     return (0 != writtenDataSize_); 
     1335  } 
     1336 
     1337  /*! 
     1338    Return size of data which is written on each server 
     1339    Whatever dimension of a grid, data which are written on server must be presented as 
     1340    an one dimension array. 
     1341    \return size of data written on server 
     1342  */ 
     1343  size_t CGrid::getWrittenDataSize() const 
     1344  { 
     1345    return writtenDataSize_; 
     1346  } 
     1347 
     1348  /*! 
     1349    Returns the number of indexes written by each server. 
     1350    \return the number of indexes written by each server 
     1351  */ 
     1352  int CGrid::getNumberWrittenIndexes() const 
     1353  { 
     1354    return numberWrittenIndexes_; 
     1355  } 
     1356 
     1357  /*! 
     1358    Returns the total number of indexes written by the servers. 
     1359    \return the total number of indexes written by the servers 
     1360  */ 
     1361  int CGrid::getTotalNumberWrittenIndexes() const 
     1362  { 
     1363    return totalNumberWrittenIndexes_; 
     1364  } 
     1365 
     1366  /*! 
     1367    Returns the offset of indexes written by each server. 
     1368    \return the offset of indexes written by each server 
     1369  */ 
     1370  int CGrid::getOffsetWrittenIndexes() const 
     1371  { 
     1372    return offsetWrittenIndexes_; 
     1373  } 
     1374 
     1375  CDistributionServer* CGrid::getDistributionServer() 
     1376  { 
     1377    return serverDistribution_; 
     1378  } 
     1379 
     1380  CDistributionClient* CGrid::getDistributionClient() 
     1381  { 
     1382    return clientDistribution_; 
     1383  } 
     1384 
     1385  bool CGrid::doGridHaveDataDistributed() 
     1386  { 
     1387    if (isScalarGrid()) return false; 
     1388    else 
     1389      return isDataDistributed_; 
    13961390  } 
    13971391 
Note: See TracChangeset for help on using the changeset viewer.