Changeset 1132


Ignore:
Timestamp:
05/15/17 16:58:35 (4 years ago)
Author:
mhnguyen
Message:

Correcting a minor bug on writting unstructured grid

+) Correct the mapping between received data and written data.
+) Clean some redundant codes

Test
+) On Curie
+) Writing on unstructured grid works correctly

Location:
XIOS/dev/dev_olga/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/dev_olga/src/io/nc4_data_output.cpp

    r1130 r1132  
    7575         if (isWrittenDomain(domid)) return ; 
    7676         else setWrittenDomain(domid); 
    77  
    78         // const std::vector<int>& local_size_write  = domain->getLocalWriteSize(); 
    79         // const std::vector<int>& global_size_write = domain->getGlobalWriteSize(); 
    80         // const std::vector<int>& start_write = domain->getStartWriteIndex(); 
    81         // const std::vector<int>& count_write = domain->getCountWriteIndex(); 
    82         int nvertex = (domain->nvertex.isEmpty()) ? 0 : domain->nvertex; 
     77         
     78         int nvertex = (domain->nvertex.isEmpty()) ? 0 : domain->nvertex; 
    8379 
    8480         StdString dimXid, dimYid ; 
     
    269265                 if (domain->hasLonLat) 
    270266                 { 
    271                    // CArray<size_t, 1>& indexToWrite = domain->localIndexToWriteOnServer; 
    272                    // int nbWritten = indexToWrite.numElements(); 
    273                    // CArray<double,1> writtenLat(nbWritten), writtenLon(nbWritten); 
    274                    // for (int idx = 0; idx < nbWritten; ++idx) 
    275                    // { 
    276                    //    writtenLat(idx) = domain->latvalue(indexToWrite(idx)); 
    277                    //    writtenLon(idx) = domain->lonvalue(indexToWrite(idx)); 
    278                    // } 
    279267                   switch (domain->type) 
    280268                   { 
    281269                     case CDomain::type_attr::curvilinear :                        
    282                          
    283                        // SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0); 
    284                        // SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0); 
    285270                       SuperClassWriter::writeData(writtenLat, latid, isCollective, 0); 
    286271                       SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0); 
    287272                       break; 
    288273                     case CDomain::type_attr::rectilinear : 
    289 //                        CArray<double,1> lat = domain->latvalue(Range(fromStart,toEnd,domain->zoom_ni)) ; 
    290 //                        SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
    291 //                        CArray<double,1> lon = domain->lonvalue(Range(0,domain->zoom_ni-1)) ; 
    292 // //                       CArray<double,1> lon = domain->lonvalue(Range(0,local_size_write[1]-1)) ; 
    293 //                        SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
    294  
    295274                       CArray<double,1> lat = writtenLat(Range(fromStart,toEnd,domain->zoom_ni)) ; 
    296275                       SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
    297276                       CArray<double,1> lon = writtenLon(Range(0,domain->zoom_ni-1)) ; 
    298 //                       CArray<double,1> lon = domain->lonvalue(Range(0,local_size_write[1]-1)) ; 
    299277                       SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
    300278                       break; 
     
    303281                   if (domain->hasBounds) 
    304282                   { 
    305                      // CArray<double,2> writtenBndsLat(nbWritten,2), writtenBndsLon(nbWritten,2); 
    306                      // for (int idx = 0; idx < nbWritten; ++idx) 
    307                      //   for (int nv = 0; nv < domain->nvertex; ++nv) 
    308                      //   { 
    309                      //     writtenBndsLat(idx) = domain->bounds_latvalue(nv, indexToWrite(idx)); 
    310                      //     writtenBndsLon(idx) = domain->bounds_lonvalue(nv, indexToWrite(idx)); 
    311                      //   } 
    312  
    313                      // SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0); 
    314                      // SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0); 
    315283                     SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0); 
    316284                     SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0); 
     
    320288                 if (domain->hasArea) 
    321289                 { 
    322                    // CArray<size_t, 1>& indexToWrite = domain->localIndexToWriteOnServer; 
    323                    // int nbWritten = indexToWrite.numElements(); 
    324                    // CArray<double,1> writtenArea(nbWritten); 
    325                    // for (int idx = 0; idx < nbWritten; ++idx) 
    326                    // { 
    327                    //    writtenArea(idx) = domain->areavalue(indexToWrite(idx));                       
    328                    // } 
    329  
    330                    SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0); 
    331                    // SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0); 
     290                   SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0);                    
    332291                 } 
    333292 
     
    568527      StdString dimVertex = "n" + domainName + "_vertex"; 
    569528      StdString dimTwo = "Two"; 
    570  
    571       const std::vector<int>& local_size_write  = domain->getLocalWriteSize(); 
    572       const std::vector<int>& global_size_write = domain->getGlobalWriteSize(); 
    573       const std::vector<int>& start_write = domain->getStartWriteIndex(); 
    574       const std::vector<int>& count_write = domain->getCountWriteIndex(); 
    575529 
    576530      if (!SuperClassWriter::dimExist(dimTwo)) SuperClassWriter::addDimension(dimTwo, 2); 
     
    766720                 else 
    767721                 { 
    768                    startNodes[0] = start_write[0]; //domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    769                    countNodes[0] = count_write[0]; //domain->zoom_ni_srv ; 
     722                   startNodes[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     723                   countNodes[0] = domain->zoom_ni ; 
    770724                 } 
    771725 
     
    789743                 else 
    790744                 { 
    791                    startEdges[0] = start_write[0]; //domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    792                    countEdges[0] = count_write[0]; 
     745                   startEdges[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     746                   countEdges[0] = domain->zoom_ni; 
    793747                   startNodes[0] = domain->mesh->node_start; 
    794748                   countNodes[0] = domain->mesh->node_count; 
    795                    startEdgeNodes[0] = start_write[0]; //domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
     749                   startEdgeNodes[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
    796750                   startEdgeNodes[1] = 0; 
    797                    countEdgeNodes[0] = count_write[0]; //domain->zoom_ni_srv; 
    798                    countEdgeNodes[1]= 2; 
     751                   countEdgeNodes[0] = domain->zoom_ni; 
     752                   countEdgeNodes[1] = 2; 
    799753                 } 
    800754                SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0, &startNodes, &countNodes); 
     
    825779                 else 
    826780                 { 
    827                    startFaces[0] = start_write[0]; //domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    828                    countFaces[0] = count_write[0]; //domain->zoom_ni_srv ; 
     781                   startFaces[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     782                   countFaces[0] = domain->zoom_ni ; 
    829783                   startNodes[0] = domain->mesh->node_start; 
    830784                   countNodes[0] = domain->mesh->node_count; 
     
    839793                   countEdgeFaces[0] = domain->mesh->edge_count; 
    840794                   countEdgeFaces[1]= 2; 
    841                    startFaceConctv[0] = start_write[0]; //domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    842                    startFaceConctv[1] = 0; //0; 
    843                    countFaceConctv[0] = count_write[0]; //domain->zoom_ni_srv; 
     795                   startFaceConctv[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     796                   startFaceConctv[1] = 0;  
     797                   countFaceConctv[0] = domain->zoom_ni; 
    844798                   countFaceConctv[1] = domain->nvertex; 
    845799                 } 
     
    862816              if (domain->nvertex == 2) 
    863817              { 
    864                 startEdges[0] = start_write[0]; //domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    865                 countEdges[0] = count_write[0]; //domain->zoom_ni_srv ; 
    866                 startEdgeNodes[0] = start_write[0]; //domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    867                 startEdgeNodes[1] = 0; //0; 
    868                 countEdgeNodes[0] = count_write[0]; //domain->zoom_ni_srv; 
     818                startEdges[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     819                countEdges[0] = domain->zoom_ni; 
     820                startEdgeNodes[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     821                startEdgeNodes[1] = 0; 
     822                countEdgeNodes[0] = domain->zoom_ni; 
    869823                countEdgeNodes[1]= 2; 
    870824                SuperClassWriter::writeData(domain->mesh->edge_lat, edge_y, isCollective, 0, &startEdges, &countEdges); 
     
    887841                  SuperClassWriter::writeData(domain->mesh->edge_nodes, edge_nodes, isCollective, 0, &startEdgeNodes, &countEdgeNodes); 
    888842                } 
    889                 startFaces[0] = start_write[0]; //domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    890                 countFaces[0] = count_write[0]; //domain->zoom_ni_srv; 
     843                startFaces[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     844                countFaces[0] = domain->zoom_ni; 
    891845                startEdgeFaces[0] = domain->mesh->edge_start; 
    892846                startEdgeFaces[1]= 0; 
    893847                countEdgeFaces[0] = domain->mesh->edge_count; 
    894848                countEdgeFaces[1]= 2; 
    895                 startFaceConctv[0] = start_write[0]; //domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    896                 startFaceConctv[1] = 0; //0; 
    897                 countFaceConctv[0] = count_write[0]; //domain->zoom_ni_srv; 
    898                 countFaceConctv[1]= domain->nvertex; 
     849                startFaceConctv[0] = domain->zoom_ibegin-domain->global_zoom_ibegin; 
     850                startFaceConctv[1] = 0; 
     851                countFaceConctv[0] = domain->zoom_ni; 
     852                countFaceConctv[1] = domain->nvertex; 
    899853                SuperClassWriter::writeData(domain->mesh->face_lat, face_y, isCollective, 0, &startFaces, &countFaces); 
    900854                SuperClassWriter::writeData(domain->mesh->face_lon, face_x, isCollective, 0, &startFaces, &countFaces); 
     
    962916         string areaId = "area" + appendDomid; 
    963917 
    964         const std::vector<int>& local_size_write  = domain->getLocalWriteSize(); 
    965         const std::vector<int>& global_size_write = domain->getGlobalWriteSize(); 
    966         const std::vector<int>& start_write = domain->getStartWriteIndex(); 
    967         const std::vector<int>& count_write = domain->getCountWriteIndex(); 
    968         int nvertex = (domain->nvertex.isEmpty()) ? 0 : domain->nvertex; 
     918         int nvertex = (domain->nvertex.isEmpty()) ? 0 : domain->nvertex; 
     919 
     920         CArray<size_t, 1>& indexToWrite = domain->localIndexToWriteOnServer; 
     921         int nbWritten = indexToWrite.numElements(); 
     922         CArray<double,1> writtenLat, writtenLon; 
     923         CArray<double,2> writtenBndsLat, writtenBndsLon; 
     924         CArray<double,1> writtenArea; 
     925 
     926         if (domain->hasLonLat) 
     927         { 
     928           writtenLat.resize(nbWritten); 
     929           writtenLon.resize(nbWritten); 
     930           for (int idx = 0; idx < nbWritten; ++idx) 
     931           { 
     932              writtenLat(idx) = domain->latvalue(indexToWrite(idx)); 
     933              writtenLon(idx) = domain->lonvalue(indexToWrite(idx)); 
     934           } 
     935          
     936 
     937           if (domain->hasBounds) 
     938           {          
     939             int nvertex = domain->nvertex, idx; 
     940             writtenBndsLat.resize(nvertex, nbWritten); 
     941             writtenBndsLon.resize(nvertex, nbWritten); 
     942             CArray<double,2>& boundslat = domain->bounds_latvalue; 
     943             CArray<double,2>& boundslon = domain->bounds_lonvalue;    
     944             for (idx = 0; idx < nbWritten; ++idx) 
     945               for (int nv = 0; nv < nvertex; ++nv) 
     946               { 
     947                 writtenBndsLat(nv, idx) = boundslat(nv, int(indexToWrite(idx))); 
     948                 writtenBndsLon(nv, idx) = boundslon(nv, int(indexToWrite(idx))); 
     949               } 
     950           } 
     951         } 
     952 
     953         if (domain->hasArea) 
     954         { 
     955           writtenArea.resize(nbWritten);            
     956           for (int idx = 0; idx < nbWritten; ++idx) 
     957           { 
     958              writtenArea(idx) = domain->areavalue(indexToWrite(idx));                       
     959           } 
     960         } 
    969961 
    970962         try 
     
    975967              { 
    976968                 dim0.push_back(dimXid); 
    977                  SuperClassWriter::addDimension(dimXid, local_size_write[0]); 
     969                 SuperClassWriter::addDimension(dimXid, domain->zoom_ni); 
    978970 
    979971                 lonid = StdString("lon").append(appendDomid); 
     
    10131005                 if (domain->hasLonLat) 
    10141006                 { 
    1015                    SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0); 
    1016                    SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0); 
     1007                   SuperClassWriter::writeData(writtenLat, latid, isCollective, 0); 
     1008                   SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0); 
    10171009                   if (domain->hasBounds) 
    10181010                   { 
    1019                      SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0); 
    1020                      SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0); 
     1011                     SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0); 
     1012                     SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0); 
    10211013                   } 
    10221014                 } 
    10231015 
    10241016                 if (domain->hasArea) 
    1025                    SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0); 
     1017                   SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0); 
    10261018 
    10271019                 SuperClassWriter::definition_start(); 
     
    10361028                 bounds_latid = StdString("bounds_lat").append(appendDomid); 
    10371029                 dim0.push_back(dimXid); 
    1038                  SuperClassWriter::addDimension(dimXid, global_size_write[0]); 
     1030                 SuperClassWriter::addDimension(dimXid, domain->ni_glo); 
    10391031                 if (domain->hasLonLat) 
    10401032                 { 
     
    10821074                 else 
    10831075                 { 
    1084                    start[0]=start_write[0]; 
    1085                    count[0]=count_write[0]; 
    1086                    startBounds[0]=start_write[0]; 
     1076                   start[0]=domain->zoom_ibegin - domain->global_zoom_ibegin; 
     1077                   count[0]=domain->zoom_ni; 
     1078                   startBounds[0]=domain->zoom_ibegin-domain->global_zoom_ibegin; 
    10871079                   startBounds[1]=0 ; 
    1088                    countBounds[0]=count_write[0]; 
     1080                   countBounds[0]=domain->zoom_ni; 
    10891081                   countBounds[1]=nvertex ; 
    10901082                 } 
     
    10921084                 if (domain->hasLonLat) 
    10931085                 { 
    1094                    SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0,&start,&count); 
    1095                    SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0,&start,&count); 
     1086                   SuperClassWriter::writeData(writtenLat, latid, isCollective, 0,&start,&count); 
     1087                   SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0,&start,&count); 
    10961088                   if (domain->hasBounds) 
    10971089                   { 
    1098                      SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0,&startBounds,&countBounds); 
    1099                      SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0,&startBounds,&countBounds); 
     1090                     SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0,&startBounds,&countBounds); 
     1091                     SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0,&startBounds,&countBounds); 
    11001092                   } 
    11011093                 } 
    11021094 
    11031095                 if (domain->hasArea) 
    1104                    SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0, &start, &count); 
     1096                   SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0, &start, &count); 
    11051097 
    11061098                 SuperClassWriter::definition_start(); 
  • XIOS/dev/dev_olga/src/node/domain.cpp

    r1130 r1132  
    13701370       hasBounds = true; 
    13711371     } 
     1372     else if (hasBoundValues) 
     1373     { 
     1374       hasBounds = true;        
     1375     } 
    13721376     else 
    13731377     { 
     
    27732777      }        
    27742778    } 
    2775  
    2776  
    2777  
    2778     // lonvalue.resize(zoom_ni*zoom_nj); 
    2779     // lonvalue = 0; 
    2780  
    2781     // if (hasBounds) 
    2782     // { 
    2783     //   bounds_lonvalue.resize(nvertex,zoom_ni*zoom_nj); 
    2784     //   bounds_lonvalue = 0.; 
    2785     // } 
    2786      
    2787     // if (0 == lonvalue.numElements()) return; 
    2788  
    2789     // for (i = 0; i < nbReceived; ++i) 
    2790     // { 
    2791     //   int rank = recvClientRanks_[i]; 
    2792     //   CArray<int,1> &indi = indGlob_[rank], &indj = indGlob_[rank];       
    2793     //   for (ind = 0; ind < indi.numElements(); ++ind) 
    2794     //   { 
    2795     //      iindex = indi(ind) % ni_glo; jindex = indj(ind) / ni_glo; 
    2796     //      index = (iindex - zoom_ibegin) + (jindex - zoom_jbegin) * zoom_ni; 
    2797     //      lonvalue(index) = recvLonValue[i](ind); 
    2798     //      if (hasBounds) 
    2799     //      {           
    2800     //       for (int nv = 0; nv < nvertex; ++nv) 
    2801     //         bounds_lonvalue(nv, index) = recvBoundsLonValue[i](nv, ind); 
    2802     //      }          
    2803     //   } 
    2804     // } 
    28052779  } 
    28062780 
  • XIOS/dev/dev_olga/src/node/file.cpp

    r1130 r1132  
    974974 
    975975   /*! 
     976   \brief Send a message to create a variable group on server side 
     977   \param[in] id String identity of variable group that will be created on server 
     978   \param [in] client client to which we will send this adding action 
     979   */ 
     980   void CFile::sendAddVariableGroup(const string& id, CContextClient* client) 
     981   { 
     982      sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE_GROUP, client); 
     983   } 
     984 
     985   /*! 
    976986   \brief Send a message to create a variable on server side 
    977987      A variable always belongs to a variable group 
     
    983993   } 
    984994 
     995   /* 
     996     Send message to add a variable into a file within a certain client 
     997     \param [in] id String identity of a variable 
     998     \param [in] client client to which we will send this adding action 
     999   */ 
    9851000   void CFile::sendAddVariable(const string& id, CContextClient* client) 
    9861001   { 
  • XIOS/dev/dev_olga/src/node/file.hpp

    r1129 r1132  
    133133         void sendAddVariable(const string& id, CContextClient* client); 
    134134         void sendAddVariableGroup(const string& id = ""); 
     135         void sendAddVariableGroup(const string& id, CContextClient* client); 
    135136 
    136137         // Receive info from client 
  • XIOS/dev/dev_olga/src/node/grid.cpp

    r1129 r1132  
    632632            CArray<size_t,1>& localIndex = outLocalIndexStoreOnClient[rank]; 
    633633            size_t nbIndex = 0; 
     634             
     635            // Keep this code for this moment but it should be removed (or moved to DEBUG) to improve performance 
    634636            for (size_t idx = 0; idx < globalIndex.numElements(); ++idx) 
    635637            { 
     
    640642            } 
    641643 
     644             
    642645            if (nbIndex != localIndex.numElements()) 
    643646                 ERROR("void CGrid::computeClientIndex()", 
Note: See TracChangeset for help on using the changeset viewer.