Ignore:
Timestamp:
03/10/15 10:49:02 (9 years ago)
Author:
mhnguyen
Message:

Implementing a grid formed by only one axis or group of axis

+) Add several new attributes to axis. From now on, each axis can be distributed on client side
+) Modify mask of grid to make it more flexible to different dimension
+) Fix some bugs relating to calculation of local data index on client
+) Clean some redundant codes

Test
+) On Curie, only test_new_features.f90
+) Test cases:

  • Grid composed of: 1 domain and 1 axis, 3 axis, 1 axis
  • Mode: Attached and connected
  • No of client-server: 6-2(Connected), 2 (Attached)

+) All tests passed and results are correct

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/output/nc4_data_output.cpp

    r544 r567  
    483483         if (axis->IsWritten(this->filename)) return; 
    484484         axis->checkAttributes(); 
    485          StdSize zoom_size=axis->zoom_size.getValue() ; 
    486          StdSize zoom_begin=axis->zoom_begin.getValue()-1 ; 
     485         StdSize zoom_size_srv=axis->zoom_size_srv; 
     486         StdSize zoom_begin_srv=axis->zoom_begin_srv; 
    487487 
    488488 
    … …  
    492492         try 
    493493         { 
    494            SuperClassWriter::addDimension(axisid, zoom_size); 
     494           SuperClassWriter::addDimension(axisid, zoom_size_srv); 
    495495           dims.push_back(axisid); 
    496496 
    … …  
    527527                 SuperClassWriter::definition_end(); 
    528528 
    529                  CArray<double,1> axis_value(zoom_size) ; 
    530                  for(StdSize i = 0 ; i < zoom_size ; i++) axis_value(i)=axis->value(i+zoom_begin) ; 
     529                 CArray<double,1> axis_value(zoom_size_srv) ; 
     530                 for(StdSize i = 0 ; i < zoom_size_srv ; i++) axis_value(i)=axis->value(i+zoom_begin_srv) ; 
    531531                 SuperClassWriter::writeData(axis_value, axisid, isCollective, 0); 
    532532 
    … …  
    580580         std::vector<StdString> dims, coodinates; 
    581581         CGrid* grid = field->grid; 
    582          CDomain* domain = grid->domain; 
    583  
    584          if (domain->isEmpty()) 
    585            if (SuperClass::type==MULTI_FILE) return ; 
    586  
    587          StdString timeid    = StdString("time_counter"); 
    588          StdString domid     = (!domain->name.isEmpty()) 
    589                              ? domain->name.getValue() : domain->getId(); 
    590          StdString appendDomid  = (singleDomain) ? "" : "_"+domid ; 
    591  
    592 //         bool isCurvilinear = domain->isCurvilinear ; 
    593 //         bool isCurvilinear = (domain->type == CDomain::type_attr::curvilinear) ; 
    594  
    595          StdString dimXid,dimYid ; 
    596  
    597          switch (domain->type) 
    598          { 
    599            case CDomain::type_attr::curvilinear : 
    600              dimXid     = StdString("x").append(appendDomid); 
    601              dimYid     = StdString("y").append(appendDomid); 
    602              break ; 
    603            case CDomain::type_attr::regular : 
    604              dimXid     = StdString("lon").append(appendDomid); 
    605              dimYid     = StdString("lat").append(appendDomid); 
    606              break ; 
    607            case CDomain::type_attr::unstructured : 
    608              dimXid     = StdString("cell").append(appendDomid); 
    609              break ; 
    610         } 
     582         if (!grid->doGridHaveDataToWrite()) 
     583          if (SuperClass::type==MULTI_FILE) return ; 
     584 
     585         CArray<bool,1> axisDomainOrder = grid->axisDomainOrder; 
     586         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0; 
     587         std::vector<StdString> domainList = grid->getDomainList(); 
     588         std::vector<StdString> axisList   = grid->getAxisList(); 
     589 
     590         StdString timeid  = StdString("time_counter"); 
     591         StdString dimXid,dimYid; 
     592         std::deque<StdString> dimIdList, dimCoordList; 
     593 
     594         for (int i = 0; i < numElement; ++i) 
     595         { 
     596           if (axisDomainOrder(i)) 
     597           { 
     598             CDomain* domain = CDomain::get(domainList[idxDomain]); 
     599             StdString domid = (!domain->name.isEmpty()) 
     600                                 ? domain->name.getValue() : domain->getId(); 
     601             StdString appendDomid  = (singleDomain) ? "" : "_"+domid ; 
     602             switch (domain->type) 
     603             { 
     604               case CDomain::type_attr::curvilinear : 
     605                 dimXid     = StdString("x").append(appendDomid); 
     606                 dimIdList.push_back(dimXid); 
     607                 dimYid     = StdString("y").append(appendDomid); 
     608                 dimIdList.push_back(dimYid); 
     609                 dimCoordList.push_back(StdString("nav_lon").append(appendDomid)); 
     610                 dimCoordList.push_back(StdString("nav_lat").append(appendDomid)); 
     611                 break ; 
     612               case CDomain::type_attr::regular : 
     613                 dimXid     = StdString("lon").append(appendDomid); 
     614                 dimIdList.push_back(dimXid); 
     615                 dimYid     = StdString("lat").append(appendDomid); 
     616                 dimIdList.push_back(dimYid); 
     617                 break ; 
     618               case CDomain::type_attr::unstructured : 
     619                 dimXid     = StdString("cell").append(appendDomid); 
     620                 dimIdList.push_back(dimXid); 
     621                 dimCoordList.push_back(StdString("lon").append(appendDomid)); 
     622                 dimCoordList.push_back(StdString("lat").append(appendDomid)); 
     623                 break ; 
     624            } 
     625            ++idxDomain; 
     626           } 
     627           else 
     628           { 
     629             CAxis* axis = CAxis::get(axisList[idxAxis]); 
     630             StdString axisid = (!axis->name.isEmpty()) 
     631                                ? axis->name.getValue() : axis->getId(); 
     632             dimIdList.push_back(axisid); 
     633             dimCoordList.push_back(axisid); 
     634            ++idxAxis; 
     635           } 
     636         } 
    611637 
    612638/* 
    … …  
    648674         } 
    649675 
    650          std::vector<StdString> axisList = grid->getAxisList(); 
    651          if (!axisList.empty()) 
    652          { 
    653            std::vector<StdString>::const_iterator itAxis = axisList.begin(), iteAxis = axisList.end(); 
    654            for (; itAxis != iteAxis; ++itAxis) 
    655            { 
    656              CAxis* axis = CAxis::get(*itAxis); 
    657              StdString axisid = (!axis->name.isEmpty()) 
    658                                 ? axis->name.getValue() : axis->getId(); 
    659  
    660              dims.push_back(axisid); 
    661              coodinates.push_back(axisid); 
    662            } 
    663          } 
    664  
    665          switch (domain->type) 
    666          { 
    667            case CDomain::type_attr::curvilinear : 
    668              coodinates.push_back(StdString("nav_lon").append(appendDomid)); 
    669              coodinates.push_back(StdString("nav_lat").append(appendDomid)); 
    670              break; 
    671            case CDomain::type_attr::regular : 
    672            case CDomain::type_attr::unstructured : 
    673             coodinates.push_back(StdString("lon").append(appendDomid)); 
    674             coodinates.push_back(StdString("lat").append(appendDomid)); 
    675              break; 
    676          } 
    677  
    678          if ( domain->type == CDomain::type_attr::curvilinear || domain->type == CDomain::type_attr::regular)dims.push_back(dimYid); 
    679          dims.push_back(dimXid); 
     676         while (!dimIdList.empty()) 
     677         { 
     678           dims.push_back(dimIdList.back()); 
     679           dimIdList.pop_back(); 
     680         } 
     681 
     682         while (!dimCoordList.empty()) 
     683         { 
     684           coodinates.push_back(dimCoordList.back()); 
     685           dimCoordList.pop_back(); 
     686         } 
    680687 
    681688         try 
    … …  
    772779         } 
    773780      } 
     781 
     782 
     783//      void CNc4DataOutput::writeField_(CField* field) 
     784//      { 
     785//         CContext* context = CContext::getCurrent() ; 
     786//         CContextServer* server=context->server ; 
     787// 
     788//         std::vector<StdString> dims, coodinates; 
     789//         CGrid* grid = field->grid; 
     790//         CDomain* domain = grid->domain; 
     791// 
     792//         if (domain->isEmpty()) 
     793//           if (SuperClass::type==MULTI_FILE) return ; 
     794// 
     795//         StdString timeid    = StdString("time_counter"); 
     796//         StdString domid     = (!domain->name.isEmpty()) 
     797//                             ? domain->name.getValue() : domain->getId(); 
     798//         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ; 
     799// 
     800////         bool isCurvilinear = domain->isCurvilinear ; 
     801////         bool isCurvilinear = (domain->type == CDomain::type_attr::curvilinear) ; 
     802// 
     803//         StdString dimXid,dimYid ; 
     804// 
     805//         switch (domain->type) 
     806//         { 
     807//           case CDomain::type_attr::curvilinear : 
     808//             dimXid     = StdString("x").append(appendDomid); 
     809//             dimYid     = StdString("y").append(appendDomid); 
     810//             break ; 
     811//           case CDomain::type_attr::regular : 
     812//             dimXid     = StdString("lon").append(appendDomid); 
     813//             dimYid     = StdString("lat").append(appendDomid); 
     814//             break ; 
     815//           case CDomain::type_attr::unstructured : 
     816//             dimXid     = StdString("cell").append(appendDomid); 
     817//             break ; 
     818//        } 
     819// 
     820///* 
     821//         StdString lonid_loc = (server->intraCommSize > 1) 
     822//                             ? StdString("lon").append(appendDomid).append("_local") 
     823//                             : lonid; 
     824//         StdString latid_loc = (server->intraCommSize > 1) 
     825//                             ? StdString("lat").append(appendDomid).append("_local") 
     826//                             : latid; 
     827//*/ 
     828//         StdString fieldid   = (!field->name.isEmpty()) 
     829//                             ? field->name.getValue() : field->getBaseFieldReference()->getId(); 
     830// 
     831////         unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue(); 
     832////         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize); 
     833////          bool isCurvilinear = domain->isCurvilinear ; 
     834// 
     835//         nc_type type ; 
     836//         if (field->prec.isEmpty()) type =  NC_FLOAT ; 
     837//         else 
     838//         { 
     839//           if (field->prec==2) type = NC_SHORT ; 
     840//           else if (field->prec==4)  type =  NC_FLOAT ; 
     841//           else if (field->prec==8)   type =  NC_DOUBLE ; 
     842//         } 
     843// 
     844//         bool wtime   = !(!field->operation.isEmpty() && field->foperation->timeType() == func::CFunctor::once); 
     845// 
     846//         if (wtime) 
     847//         { 
     848// 
     849//            //StdOStringStream oss; 
     850//           // oss << "time_" << field->operation.getValue() 
     851//           //     << "_" << field->getRelFile()->output_freq.getValue(); 
     852//          //oss 
     853//            if (field->foperation->timeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant")); 
     854//            else if (field->foperation->timeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered")); 
     855//            dims.push_back(timeid); 
     856//         } 
     857// 
     858//         std::vector<StdString> axisList = grid->getAxisList(); 
     859//         if (!axisList.empty()) 
     860//         { 
     861//           std::vector<StdString>::const_iterator itAxis = axisList.begin(), iteAxis = axisList.end(); 
     862//           for (; itAxis != iteAxis; ++itAxis) 
     863//           { 
     864//             CAxis* axis = CAxis::get(*itAxis); 
     865//             StdString axisid = (!axis->name.isEmpty()) 
     866//                                ? axis->name.getValue() : axis->getId(); 
     867// 
     868//             dims.push_back(axisid); 
     869//             coodinates.push_back(axisid); 
     870//           } 
     871//         } 
     872// 
     873//         switch (domain->type) 
     874//         { 
     875//           case CDomain::type_attr::curvilinear : 
     876//             coodinates.push_back(StdString("nav_lon").append(appendDomid)); 
     877//             coodinates.push_back(StdString("nav_lat").append(appendDomid)); 
     878//             break; 
     879//           case CDomain::type_attr::regular : 
     880//           case CDomain::type_attr::unstructured : 
     881//            coodinates.push_back(StdString("lon").append(appendDomid)); 
     882//            coodinates.push_back(StdString("lat").append(appendDomid)); 
     883//             break; 
     884//         } 
     885// 
     886//         if ( domain->type == CDomain::type_attr::curvilinear || domain->type == CDomain::type_attr::regular)dims.push_back(dimYid); 
     887//         dims.push_back(dimXid); 
     888// 
     889//         try 
     890//         { 
     891//           SuperClassWriter::addVariable(fieldid, type, dims); 
     892// 
     893//           if (!field->standard_name.isEmpty()) 
     894//              SuperClassWriter::addAttribute 
     895//                 ("standard_name",  field->standard_name.getValue(), &fieldid); 
     896// 
     897//           if (!field->long_name.isEmpty()) 
     898//              SuperClassWriter::addAttribute 
     899//                 ("long_name", field->long_name.getValue(), &fieldid); 
     900// 
     901//           if (!field->unit.isEmpty()) 
     902//              SuperClassWriter::addAttribute 
     903//                 ("units", field->unit.getValue(), &fieldid); 
     904// 
     905//            if (!field->valid_min.isEmpty()) 
     906//              SuperClassWriter::addAttribute 
     907//                 ("valid_min", field->valid_min.getValue(), &fieldid); 
     908// 
     909//           if (!field->valid_max.isEmpty()) 
     910//              SuperClassWriter::addAttribute 
     911//                 ("valid_max", field->valid_max.getValue(), &fieldid); 
     912// 
     913//            if (!field->scale_factor.isEmpty()) 
     914//              SuperClassWriter::addAttribute 
     915//                 ("scale_factor", field->scale_factor.getValue(), &fieldid); 
     916// 
     917//             if (!field->add_offset.isEmpty()) 
     918//              SuperClassWriter::addAttribute 
     919//                 ("add_offset", field->add_offset.getValue(), &fieldid); 
     920// 
     921//           SuperClassWriter::addAttribute 
     922//                 ("online_operation", field->operation.getValue(), &fieldid); 
     923// 
     924//          // write child variables as attributes 
     925// 
     926// 
     927//           vector<CVariable*> listVars = field->getAllVariables() ; 
     928//           for (vector<CVariable*>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(*it, fieldid) ; 
     929// 
     930// 
     931//           if (wtime) 
     932//           { 
     933//              CDuration duration = field->freq_op.getValue(); 
     934//              duration.solveTimeStep(*(context->calendar)); 
     935//              SuperClassWriter::addAttribute("interval_operation", duration.toString(), &fieldid); 
     936// 
     937//              duration = field->getRelFile()->output_freq.getValue(); 
     938//              duration.solveTimeStep(*(context->calendar)); 
     939//              SuperClassWriter::addAttribute("interval_write", duration.toString(), &fieldid); 
     940//           } 
     941// 
     942//           if (!field->default_value.isEmpty()) 
     943//           { 
     944//              double default_value = field->default_value.getValue(); 
     945//              float fdefault_value = (float)default_value; 
     946//              if (type == NC_DOUBLE) 
     947//                 SuperClassWriter::setDefaultValue(fieldid, &default_value); 
     948//              else 
     949//                 SuperClassWriter::setDefaultValue(fieldid, &fdefault_value); 
     950//           } 
     951//           else 
     952//              SuperClassWriter::setDefaultValue(fieldid, (double*)NULL); 
     953// 
     954//           {  // Ecriture des coordonnées 
     955// 
     956//              StdString coordstr; //boost::algorithm::join(coodinates, " ") 
     957//              std::vector<StdString>::iterator 
     958//                 itc = coodinates.begin(), endc = coodinates.end(); 
     959// 
     960//              for (; itc!= endc; itc++) 
     961//              { 
     962//                 StdString & coord = *itc; 
     963//                 if (itc+1 != endc) 
     964//                       coordstr.append(coord).append(" "); 
     965//                 else  coordstr.append(coord); 
     966//              } 
     967// 
     968//              SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid); 
     969// 
     970//           } 
     971//         } 
     972//         catch (CNetCdfException& e) 
     973//         { 
     974//           StdString msg("On writing field : "); 
     975//           msg.append(fieldid); msg.append("\n"); 
     976//           msg.append("In the context : "); 
     977//           msg.append(context->getId()); msg.append("\n"); 
     978//           msg.append(e.what()); 
     979//           ERROR("CNc4DataOutput::writeField_(CField* field)", << msg); 
     980//         } 
     981//      } 
    774982 
    775983      //-------------------------------------------------------------- 
    … …  
    9321140 
    9331141         CGrid* grid = field->grid ; 
    934          CDomain* domain = grid->domain ; 
    935  
    936          if(SuperClass::type==MULTI_FILE || !isCollective) if (domain->isEmpty()) return; 
    937  
     1142 
     1143         if (!grid->doGridHaveDataToWrite()) 
     1144          if (SuperClass::type==MULTI_FILE || !isCollective) return ; 
    9381145 
    9391146         StdString fieldid   = (!field->name.isEmpty()) 
    … …  
    9921199         try 
    9931200         { 
    994            if (grid->hasAxis()) // 3D 
     1201           CArray<double,1> fieldData(grid->getWrittenDataSize()); 
     1202           if (!field->default_value.isEmpty()) fieldData = field->default_value; 
     1203           field->outputField(fieldData); 
     1204           if (!field->prec.isEmpty() && field->prec==2) fieldData=round(fieldData) ; 
     1205 
     1206           switch (SuperClass::type) 
    9951207           { 
    996               CAxis* axis = grid->axis ; 
    997               CArray<double,3> field_data3D(domain->zoom_ni_srv,domain->zoom_nj_srv,axis->zoom_size) ; 
    998               if (!field->default_value.isEmpty()) field_data3D = field->default_value ; 
    999  
    1000               field->outputField(field_data3D); 
    1001  
    1002               if (!field->prec.isEmpty() && field->prec==2) field_data3D=round(field_data3D) ; 
    1003  
    1004               switch (SuperClass::type) 
    1005              { 
    1006                 case (MULTI_FILE) : 
     1208              case (MULTI_FILE) : 
     1209              { 
     1210                 SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep()-1); 
     1211                 if (wtime) 
     1212                 { 
     1213                   SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
     1214                   SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
     1215                   SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
     1216                   SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
     1217                 } 
     1218                 break ; 
     1219              } 
     1220              case (ONE_FILE) : 
     1221              { 
     1222                std::vector<int> nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal(); 
     1223                std::vector<int> nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer(); 
     1224                std::vector<int> nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer(); 
     1225 
     1226                int ssize = nZoomBeginGlobal.size(); 
     1227 
     1228                std::vector<StdSize> start(ssize) ; 
     1229                std::vector<StdSize> count(ssize) ; 
     1230 
     1231                for (int i = 0; i < ssize; ++i) 
    10071232                { 
    1008                    SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1); 
    1009                    if (wtime) 
    1010                    { 
    1011                      SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
    1012                      SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
    1013                      SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
    1014                      SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
    1015                    } 
    1016                    break ; 
     1233                  start[i] = nZoomBeginServer[ssize-i-1] - nZoomBeginGlobal[ssize-i-1]; 
     1234                  count[i] = nZoomSizeServer[ssize-i-1]; 
    10171235                } 
    1018                 case (ONE_FILE) : 
    1019                 { 
    1020                    std::vector<StdSize> start(3) ; 
    1021                    std::vector<StdSize> count(3) ; 
    1022                    if (domain->isEmpty()) 
    1023                    { 
    1024                      start[0]=0 ; start[1]=0 ; start[2]=0 ; 
    1025                      count[0]=0 ; count[1]=0 ; start[2]=0 ; 
    1026                    } 
    1027                    else 
    1028                    { 
    1029   //                 start[2]=domain->zoom_ibegin_loc.getValue()-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_loc.getValue()-domain->zoom_jbegin.getValue() ; start[0]=0 ; 
    1030                      start[2]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; start[0]=0 ; 
    1031                      count[2]=domain->zoom_ni_srv ; count[1]=domain->zoom_nj_srv ; count[0] = axis->zoom_size.getValue(); 
    1032                    } 
    1033                    SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1,&start,&count ); 
    1034                    if (wtime) 
    1035                    { 
    1036                      SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot ); 
    1037                      SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot ); 
    1038                      SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot ); 
    1039                      SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
    1040                    } 
    1041                    break; 
    1042                 } 
     1236 
     1237                 SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep()-1,&start,&count ); 
     1238                 if (wtime) 
     1239                 { 
     1240                   SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot ); 
     1241                   SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot ); 
     1242                   SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot ); 
     1243                   SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
     1244                 } 
     1245                 break; 
    10431246              } 
    1044  
    1045            } 
    1046            else // 2D 
    1047            { 
    1048               CArray<double,2> field_data2D(domain->zoom_ni_srv,domain->zoom_nj_srv) ; 
    1049               if (!field->default_value.isEmpty()) field_data2D = field->default_value ; 
    1050               field->outputField(field_data2D); 
    1051               if (!field->prec.isEmpty() && field->prec==2) field_data2D=round(field_data2D) ; 
    1052               switch (SuperClass::type) 
    1053               { 
    1054                 case (MULTI_FILE) : 
    1055                 { 
    1056                   SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1); 
    1057                   if (wtime) 
    1058                   { 
    1059                     SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
    1060                     SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
    1061                     SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
    1062                     SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
    1063                   } 
    1064                   break; 
    1065                 } 
    1066                 case (ONE_FILE) : 
    1067                 { 
    1068                    std::vector<StdSize> start(2) ; 
    1069                    std::vector<StdSize> count(2) ; 
    1070                    if (domain->isEmpty()) 
    1071                    { 
    1072                      start[0]=0 ; start[1]=0 ; 
    1073                      count[0]=0 ; count[1]=0 ; 
    1074                    } 
    1075                    else 
    1076                    { 
    1077                      start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
    1078                      count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ; 
    1079                    } 
    1080  
    1081                    SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1,&start,&count); 
    1082                    if (wtime) 
    1083                    { 
    1084                      SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot); 
    1085                      SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot); 
    1086                      SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot); 
    1087                      SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
    1088                    } 
    1089                    break; 
    1090  
    1091                 } 
    1092               } 
    1093            } 
     1247            } 
    10941248         } 
    10951249         catch (CNetCdfException& e) 
    … …  
    11031257         } 
    11041258      } 
     1259 
     1260//      //--------------------------------------------------------------- 
     1261// 
     1262//      void CNc4DataOutput::writeFieldData_ (CField*  field) 
     1263//      { 
     1264//         CContext* context = CContext::getCurrent() ; 
     1265////          if (field->getRelFile()->isSyncTime()) SuperClassWriter::sync() ; 
     1266//         CContextServer* server=context->server ; 
     1267// 
     1268//         CGrid* grid = field->grid ; 
     1269//         CDomain* domain = grid->domain ; 
     1270// 
     1271//         if(SuperClass::type==MULTI_FILE || !isCollective) if (domain->isEmpty()) return; 
     1272// 
     1273// 
     1274//         StdString fieldid   = (!field->name.isEmpty()) 
     1275//                             ? field->name.getValue() 
     1276//                             : field->getBaseFieldReference()->getId(); 
     1277// 
     1278//         StdOStringStream oss; 
     1279//         string timeAxisId ; 
     1280//         if (field->foperation->timeType() == func::CFunctor::instant)  timeAxisId="time_instant" ; 
     1281//         else if (field->foperation->timeType() == func::CFunctor::centered)  timeAxisId="time_centered" ; 
     1282// 
     1283//         StdString timeBoundId("time_counter_bounds"); 
     1284// 
     1285//         StdString timeAxisBoundId; 
     1286//         if (field->foperation->timeType() == func::CFunctor::instant)  timeAxisBoundId="time_instant_bounds" ; 
     1287//         else if (field->foperation->timeType() == func::CFunctor::centered)  timeAxisBoundId="time_centered_bounds" ; 
     1288// 
     1289//         CArray<double,1> time_data(1) ; 
     1290//         CArray<double,1> time_counter(1) ; 
     1291//         CArray<double,1> time_counter_bound(2); 
     1292//         CArray<double,1> time_data_bound(2); 
     1293// 
     1294//        bool wtime   = !(!field->operation.isEmpty() && (field->foperation->timeType() == func::CFunctor::once)); 
     1295// 
     1296//        if (wtime) 
     1297//        { 
     1298//          time_counter(0)= (Time(*field->last_Write_srv) + Time(*field->lastlast_Write_srv)) / 2; 
     1299//          if (field->foperation->timeType() == func::CFunctor::instant) 
     1300//            time_data(0) = Time(*field->last_Write_srv); 
     1301//          else if (field->foperation->timeType() == func::CFunctor::centered) time_data(0) = time_counter(0); 
     1302// 
     1303//          time_counter_bound(0) = Time(*field->lastlast_Write_srv); 
     1304//          time_counter_bound(1) = Time(*field->last_Write_srv); 
     1305//          if (field->foperation->timeType() == func::CFunctor::instant) 
     1306//            time_data_bound(0) = time_data_bound(1) = Time(*field->last_Write_srv); 
     1307//          else if (field->foperation->timeType() == func::CFunctor::centered) 
     1308//          { 
     1309//            time_data_bound(0) = time_counter_bound(0); 
     1310//            time_data_bound(1) = time_counter_bound(1); 
     1311//          } 
     1312//         } 
     1313// 
     1314//         bool isRoot ; 
     1315//         if (server->intraCommRank==0) isRoot=true ; 
     1316//         else isRoot=false ; 
     1317// 
     1318//         if (!field->scale_factor.isEmpty() || !field->add_offset.isEmpty()) 
     1319//         { 
     1320//           double scaleFactor=1. ; 
     1321//           double addOffset=0. ; 
     1322//           if (!field->scale_factor.isEmpty()) scaleFactor=field->scale_factor ; 
     1323//           if (!field->add_offset.isEmpty()) addOffset=field->add_offset ; 
     1324//           field->scaleFactorAddOffset(scaleFactor,addOffset) ; 
     1325//         } 
     1326// 
     1327//         try 
     1328//         { 
     1329//           if (grid->hasAxis()) // 3D 
     1330//           { 
     1331//              CAxis* axis = grid->axis ; 
     1332//              CArray<double,3> field_data3D(domain->zoom_ni_srv,domain->zoom_nj_srv,axis->zoom_size) ; 
     1333//              if (!field->default_value.isEmpty()) field_data3D = field->default_value ; 
     1334// 
     1335//              field->outputField(field_data3D); 
     1336// 
     1337//              if (!field->prec.isEmpty() && field->prec==2) field_data3D=round(field_data3D) ; 
     1338// 
     1339//              switch (SuperClass::type) 
     1340//             { 
     1341//                case (MULTI_FILE) : 
     1342//                { 
     1343//                   SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1); 
     1344//                   if (wtime) 
     1345//                   { 
     1346//                     SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
     1347//                     SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
     1348//                     SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
     1349//                     SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
     1350//                   } 
     1351//                   break ; 
     1352//                } 
     1353//                case (ONE_FILE) : 
     1354//                { 
     1355//                   std::vector<StdSize> start(3) ; 
     1356//                   std::vector<StdSize> count(3) ; 
     1357//                   if (domain->isEmpty()) 
     1358//                   { 
     1359//                     start[0]=0 ; start[1]=0 ; start[2]=0 ; 
     1360//                     count[0]=0 ; count[1]=0 ; start[2]=0 ; 
     1361//                   } 
     1362//                   else 
     1363//                   { 
     1364//  //                 start[2]=domain->zoom_ibegin_loc.getValue()-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_loc.getValue()-domain->zoom_jbegin.getValue() ; start[0]=0 ; 
     1365//                     start[2]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; start[0]=0 ; 
     1366//                     count[2]=domain->zoom_ni_srv ; count[1]=domain->zoom_nj_srv ; count[0] = axis->zoom_size.getValue(); 
     1367//                   } 
     1368//                   SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1,&start,&count ); 
     1369//                   if (wtime) 
     1370//                   { 
     1371//                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot ); 
     1372//                     SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot ); 
     1373//                     SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot ); 
     1374//                     SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
     1375//                   } 
     1376//                   break; 
     1377//                } 
     1378//              } 
     1379// 
     1380//           } 
     1381//           else // 2D 
     1382//           { 
     1383//              CArray<double,2> field_data2D(domain->zoom_ni_srv,domain->zoom_nj_srv) ; 
     1384//              if (!field->default_value.isEmpty()) field_data2D = field->default_value ; 
     1385//              field->outputField(field_data2D); 
     1386//              if (!field->prec.isEmpty() && field->prec==2) field_data2D=round(field_data2D) ; 
     1387//              switch (SuperClass::type) 
     1388//              { 
     1389//                case (MULTI_FILE) : 
     1390//                { 
     1391//                  SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1); 
     1392//                  if (wtime) 
     1393//                  { 
     1394//                    SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
     1395//                    SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
     1396//                    SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
     1397//                    SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
     1398//                  } 
     1399//                  break; 
     1400//                } 
     1401//                case (ONE_FILE) : 
     1402//                { 
     1403//                   std::vector<StdSize> start(2) ; 
     1404//                   std::vector<StdSize> count(2) ; 
     1405//                   if (domain->isEmpty()) 
     1406//                   { 
     1407//                     start[0]=0 ; start[1]=0 ; 
     1408//                     count[0]=0 ; count[1]=0 ; 
     1409//                   } 
     1410//                   else 
     1411//                   { 
     1412//                     start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
     1413//                     count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ; 
     1414//                   } 
     1415// 
     1416//                   SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1,&start,&count); 
     1417//                   if (wtime) 
     1418//                   { 
     1419//                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot); 
     1420//                     SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot); 
     1421//                     SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot); 
     1422//                     SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
     1423//                   } 
     1424//                   break; 
     1425// 
     1426//                } 
     1427//              } 
     1428//           } 
     1429//         } 
     1430//         catch (CNetCdfException& e) 
     1431//         { 
     1432//           StdString msg("On writing field data: "); 
     1433//           msg.append(fieldid); msg.append("\n"); 
     1434//           msg.append("In the context : "); 
     1435//           msg.append(context->getId()); msg.append("\n"); 
     1436//           msg.append(e.what()); 
     1437//           ERROR("CNc4DataOutput::writeFieldData_ (CField*  field)", << msg); 
     1438//         } 
     1439//      } 
    11051440 
    11061441      //--------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.