Changeset 665


Ignore:
Timestamp:
08/24/15 14:53:23 (6 years ago)
Author:
mhnguyen
Message:

Changing longitude and latitude (as well as their bounds) be optional

+) Seperate sendIndex, sendLonLat and sendArea

Test
+) On Curie
+) test_client and test_complete are correct

Location:
XIOS/trunk/src
Files:
5 edited

Legend:

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

    r664 r665  
    2828      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false) 
    2929      , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0) 
    30       , isClientAfterTransformationChecked(false) 
     30      , isClientAfterTransformationChecked(false), hasLonLat(false) 
    3131      , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client() 
    3232   { /* Ne rien faire de plus */ } 
     
    3737      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false) 
    3838      , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0) 
    39       , isClientAfterTransformationChecked(false) 
     39      , isClientAfterTransformationChecked(false), hasLonLat(false) 
    4040      , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client() 
    4141   { /* Ne rien faire de plus */ } 
     
    574574 
    575575   //---------------------------------------------------------------- 
    576  
    577576   void CDomain::completeLonLatClient(void) 
    578577   { 
    579578     completeLonClient(); 
    580579     completeLatClient(); 
    581 //      int i,j,k ; 
    582 //      CArray<double,1> lonvalue_temp(ni*nj) ; 
    583 //      CArray<double,1> latvalue_temp(ni*nj) ; 
    584 //      CArray<double,2> bounds_lon_temp(nvertex,ni*nj); 
    585 //      CArray<double,2> bounds_lat_temp(nvertex,ni*nj); 
    586 // 
    587 //      if (type.isEmpty()) 
    588 //      { 
    589 //        if ( lonvalue.numElements() == ni*nj && latvalue.numElements() == ni*nj ) 
    590 //        { 
    591 //          type.setValue(type_attr::curvilinear) ; 
    592 //          isCurvilinear=true ; 
    593 //        } 
    594 //        else if ( lonvalue.numElements() == ni && latvalue.numElements() == nj ) 
    595 //        { 
    596 //          type.setValue(type_attr::regular) ; 
    597 //          isCurvilinear=false ; 
    598 //        } 
    599 //        else ERROR("void CDomain::completeLonLatClient(void)",<<"the grid is nor curvilinear, nor cartesian, because the size of longitude and latitude array is not coherent with the domain size"<<endl 
    600 //                                                              <<"lonvalue size = " << lonvalue.numElements() << "different of ni or ni*nj"<<endl 
    601 //                                                              <<"latvalue size = " << latvalue.numElements() << "different of nj or ni*nj" ) ; 
    602 //      } 
    603 //      if (type==type_attr::curvilinear || type==type_attr::unstructured) 
    604 //      { 
    605 //        lonvalue_temp=lonvalue ; 
    606 //        latvalue_temp=latvalue ; 
    607 //        if (hasBounds) bounds_lon_temp=bounds_lon ; 
    608 //        if (hasBounds) bounds_lat_temp=bounds_lat ; 
    609 //      }checkBounds 
    610 //      else 
    611 //      { 
    612 //        for(j=0;j<nj;j++) 
    613 //          for(i=0;i<ni;i++) 
    614 //          { 
    615 //            k=j*ni+i ; 
    616 //            lonvalue_temp(k)=lonvalue(i) ; 
    617 //            latvalue_temp(k)=latvalue(j) ; 
    618 //            if (hasBounds) 
    619 //            { 
    620 //              for(int n=0;n<nvertex;n++) 
    621 //              { 
    622 //                bounds_lon_temp(n,k)=bounds_lon(n,i) ; 
    623 //                bounds_lat_temp(n,k)=bounds_lat(n,j) ; 
    624 //              } 
    625 //            } 
    626 //          } 
    627 //      } 
    628 // 
    629 //      StdSize dm = zoom_ni_client * zoom_nj_client; 
    630 // 
    631 //      // Make sure that this attribute is non-empty for every client. 
    632 //      if (0 != dm) 
    633 //      { 
    634 //        lonvalue.resize(dm); 
    635 //        latvalue.resize(dm); 
    636 //      } 
    637 // 
    638 // 
    639 //      for (int i = 0; i < zoom_ni_client; i++) 
    640 //      { 
    641 //        for (int j = 0; j < zoom_nj_client; j++) 
    642 //        { 
    643 //          lonvalue(i + j * zoom_ni_client) = lonvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
    644 //          latvalue(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client - jbegin)*ni ); 
    645 //          if (hasBounds) 
    646 //          { 
    647 //            for(int n=0;n<nvertex;n++) 
    648 //            { 
    649 //              bounds_lon(n,i + j * zoom_ni_client) = bounds_lon_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
    650 //              bounds_lat(n,i + j * zoom_ni_client) = bounds_lat_temp( n, (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client -jbegin)*ni ); 
    651 //            } 
    652 //          } 
    653 //        } 
    654 //      } 
    655     } 
     580   } 
    656581 
    657582 
    658583   //---------------------------------------------------------------- 
    659  
    660584   void CDomain::checkZoom(void) 
    661585   { 
     
    763687   } 
    764688 
     689   void CDomain::checkLonLat() 
     690   { 
     691     hasLonLat = (!latvalue_1d.isEmpty() && !lonvalue_1d.isEmpty()) || 
     692                 (!latvalue_2d.isEmpty() && !lonvalue_2d.isEmpty()); 
     693   } 
     694 
    765695   void CDomain::checkAttributesOnClientAfterTransformation() 
    766696   { 
     
    772702     { 
    773703       this->checkMask(); 
    774        this->computeConnectedServer(); 
    775        this->completeLonLatClient(); 
     704       if (hasLonLat || hasArea) this->computeConnectedServer(); 
     705       if (hasLonLat) this->completeLonLatClient(); 
    776706     } 
    777707 
     
    790720      this->checkBounds(); 
    791721      this->checkArea(); 
     722      this->checkLonLat(); 
    792723 
    793724      if (context->hasClient) 
     
    815746     if (context->hasClient) 
    816747     { 
    817        sendServerAttribut() ; 
    818        sendLonLatArea() ; 
     748       sendServerAttribut(); 
     749       if (hasLonLat || hasArea) sendLonLatArea(); 
    819750     } 
    820751 
     
    829760      this->checkDomain(); 
    830761      this->checkZoom(); 
     762      this->checkLonLat(); 
    831763      this->checkBounds(); 
    832764      this->checkArea(); 
     
    1015947  } 
    1016948 
    1017   void CDomain::sendLonLatArea(void) 
     949  void CDomain::sendIndex() 
    1018950  { 
    1019951    int ns, n, i, j, ind, nv, idx; 
     
    1021953    CContextClient* client=context->client; 
    1022954 
    1023     // send lon lat for each connected server 
    1024955    CEventClient eventIndex(getType(), EVENT_ID_INDEX); 
    1025     CEventClient eventLon(getType(), EVENT_ID_LON); 
    1026     CEventClient eventLat(getType(), EVENT_ID_LAT); 
    1027     CEventClient eventArea(getType(), EVENT_ID_AREA); 
    1028  
    1029     list<CMessage> list_msgsIndex, list_msgsLon, list_msgsLat, list_msgsArea; 
     956 
     957    list<CMessage> list_msgsIndex; 
    1030958    list<CArray<int,1> > list_indi, list_indj; 
    1031     list<CArray<double,1> > list_lon, list_lat; 
    1032     list<CArray<double,2> > list_boundslon, list_boundslat; 
    1033     list<CArray<double,1> > list_area; 
    1034959 
    1035960    std::map<int, std::vector<size_t> >::const_iterator it, iteMap; 
     
    1045970      list_indi.push_back(CArray<int,1>(nbData)); 
    1046971      list_indj.push_back(CArray<int,1>(nbData)); 
     972 
     973      CArray<int,1>& indi = list_indi.back(); 
     974      CArray<int,1>& indj = list_indj.back(); 
     975      const std::vector<size_t>& temp = it->second; 
     976      for (n = 0; n < nbData; ++n) 
     977      { 
     978        idx = static_cast<int>(it->second[n]); 
     979        indi(n) = i_index(idx); 
     980        indj(n) = j_index(idx); 
     981      } 
     982 
     983      list_msgsIndex.push_back(CMessage()); 
     984 
     985      list_msgsIndex.back() << this->getId() << (int)type; // enum ne fonctionne pour les message => ToFix 
     986      list_msgsIndex.back() << isCurvilinear; 
     987      list_msgsIndex.back() << list_indi.back() << list_indj.back(); 
     988 
     989      eventIndex.push(rank, nbConnectedClients_[rank], list_msgsIndex.back()); 
     990    } 
     991 
     992    client->sendEvent(eventIndex); 
     993  } 
     994 
     995  void CDomain::sendArea() 
     996  { 
     997    if (!hasArea) return; 
     998 
     999    int ns, n, i, j, ind, nv, idx; 
     1000    CContext* context = CContext::getCurrent(); 
     1001    CContextClient* client=context->client; 
     1002 
     1003    // send area for each connected server 
     1004    CEventClient eventArea(getType(), EVENT_ID_AREA); 
     1005 
     1006    list<CMessage> list_msgsArea; 
     1007    list<CArray<double,1> > list_area; 
     1008 
     1009    std::map<int, std::vector<size_t> >::const_iterator it, iteMap; 
     1010    iteMap = indSrv_.end(); 
     1011    for (int k = 0; k < connectedServerRank_.size(); ++k) 
     1012    { 
     1013      int nbData = 0; 
     1014      int rank = connectedServerRank_[k]; 
     1015      it = indSrv_.find(rank); 
     1016      if (iteMap != it) 
     1017        nbData = it->second.size(); 
     1018      list_area.push_back(CArray<double,1>(nbData)); 
     1019 
     1020      const std::vector<size_t>& temp = it->second; 
     1021      for (n = 0; n < nbData; ++n) 
     1022      { 
     1023        idx = static_cast<int>(it->second[n]); 
     1024        i = i_index(idx); 
     1025        j = j_index(idx); 
     1026        if (hasArea) 
     1027          list_area.back()(n) = area(i - ibegin, j - jbegin); 
     1028      } 
     1029 
     1030      list_msgsArea.push_back(CMessage()); 
     1031      list_msgsArea.back() << this->getId() << list_area.back(); 
     1032      eventArea.push(rank, nbConnectedClients_[rank], list_msgsArea.back()); 
     1033    } 
     1034    client->sendEvent(eventArea); 
     1035  } 
     1036 
     1037  void CDomain::sendLonLat() 
     1038  { 
     1039    if (!hasLonLat) return; 
     1040 
     1041    int ns, n, i, j, ind, nv, idx; 
     1042    CContext* context = CContext::getCurrent(); 
     1043    CContextClient* client=context->client; 
     1044 
     1045    // send lon lat for each connected server 
     1046    CEventClient eventLon(getType(), EVENT_ID_LON); 
     1047    CEventClient eventLat(getType(), EVENT_ID_LAT); 
     1048 
     1049    list<CMessage> list_msgsLon, list_msgsLat; 
     1050    list<CArray<double,1> > list_lon, list_lat; 
     1051    list<CArray<double,2> > list_boundslon, list_boundslat; 
     1052 
     1053    std::map<int, std::vector<size_t> >::const_iterator it, iteMap; 
     1054    iteMap = indSrv_.end(); 
     1055    for (int k = 0; k < connectedServerRank_.size(); ++k) 
     1056    { 
     1057      int nbData = 0; 
     1058      int rank = connectedServerRank_[k]; 
     1059      it = indSrv_.find(rank); 
     1060      if (iteMap != it) 
     1061        nbData = it->second.size(); 
     1062 
    10471063      list_lon.push_back(CArray<double,1>(nbData)); 
    10481064      list_lat.push_back(CArray<double,1>(nbData)); 
     
    10531069        list_boundslat.push_back(CArray<double,2>(nvertex, nbData)); 
    10541070      } 
    1055       if (hasArea) 
    1056         list_area.push_back(CArray<double,1>(nbData)); 
    1057  
    1058       CArray<int,1>& indi = list_indi.back(); 
    1059       CArray<int,1>& indj = list_indj.back(); 
     1071 
    10601072      CArray<double,1>& lon = list_lon.back(); 
    10611073      CArray<double,1>& lat = list_lat.back(); 
     
    10821094          } 
    10831095        } 
    1084  
    1085         indi(n) = i; 
    1086         indj(n) = j; 
    1087  
    1088         if (hasArea) 
    1089           list_area.back()(n) = area(i - ibegin, j - jbegin); 
    1090       } 
    1091  
    1092       list_msgsIndex.push_back(CMessage()); 
    1093  
    1094       list_msgsIndex.back() << this->getId() << (int)type; // enum ne fonctionne pour les message => ToFix 
    1095       list_msgsIndex.back() << isCurvilinear; 
    1096       list_msgsIndex.back() << list_indi.back() << list_indj.back(); 
     1096      } 
    10971097 
    10981098      list_msgsLon.push_back(CMessage()); 
     
    11081108      } 
    11091109 
    1110       eventIndex.push(rank, nbConnectedClients_[rank], list_msgsIndex.back()); 
    11111110      eventLon.push(rank, nbConnectedClients_[rank], list_msgsLon.back()); 
    11121111      eventLat.push(rank, nbConnectedClients_[rank], list_msgsLat.back()); 
    1113  
    1114       if (hasArea) 
    1115       { 
    1116         list_msgsArea.push_back(CMessage()); 
    1117         list_msgsArea.back() << this->getId() << list_area.back(); 
    1118         eventArea.push(rank, nbConnectedClients_[rank], list_msgsArea.back()); 
    1119       } 
    1120     } 
    1121  
    1122     client->sendEvent(eventIndex); 
     1112    } 
     1113 
    11231114    client->sendEvent(eventLon); 
    11241115    client->sendEvent(eventLat); 
    1125     if (hasArea) 
    1126       client->sendEvent(eventArea); 
     1116  } 
     1117 
     1118 
     1119  void CDomain::sendLonLatArea(void) 
     1120  { 
     1121    sendIndex(); 
     1122    sendLonLat(); 
     1123    sendArea(); 
    11271124  } 
    11281125 
  • XIOS/trunk/src/node/domain.hpp

    r664 r665  
    9090         void checkBounds(void); 
    9191         void checkArea(void); 
     92         void checkLonLat(); 
    9293 
    9394 
     
    172173         bool hasBounds ; 
    173174         bool hasArea; 
     175         bool hasLonLat; 
    174176      private: 
    175177         void checkTransformations(); 
     
    178180         void completeLonClient(); 
    179181         void completeLatClient(); 
     182 
     183         void sendIndex(); 
     184         void sendArea(); 
     185         void sendLonLat(); 
    180186 
    181187       private : 
  • XIOS/trunk/src/output/nc4_data_output.cpp

    r664 r665  
    165165                 } 
    166166 
    167                  switch (domain->type) 
    168                  { 
    169                    case CDomain::type_attr::curvilinear : 
    170                      SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    171                      SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    172                      break ; 
    173                     case CDomain::type_attr::rectilinear : 
    174                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    175                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
    176                       break ; 
    177                  } 
    178  
    179                  this->writeAxisAttributes(lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid); 
    180                  this->writeAxisAttributes(latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid); 
    181  
    182                  if (domain->hasBounds) 
    183                  { 
    184                    SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid); 
    185                    SuperClassWriter::addAttribute("bounds", bounds_latid, &latid); 
    186  
    187                    dim0.clear(); 
    188                    dim0.push_back(dimYid); 
    189                    dim0.push_back(dimXid); 
    190                    dim0.push_back(dimVertId); 
    191                    SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
    192                    SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
     167                 if (domain->hasLonLat) 
     168                 { 
     169                   switch (domain->type) 
     170                   { 
     171                     case CDomain::type_attr::curvilinear : 
     172                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     173                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     174                       break ; 
     175                      case CDomain::type_attr::rectilinear : 
     176                        SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     177                        SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     178                        break ; 
     179                   } 
     180 
     181                   this->writeAxisAttributes(lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid); 
     182                   this->writeAxisAttributes(latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid); 
     183 
     184                   if (domain->hasBounds) 
     185                   { 
     186                     SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid); 
     187                     SuperClassWriter::addAttribute("bounds", bounds_latid, &latid); 
     188 
     189                     dim0.clear(); 
     190                     dim0.push_back(dimYid); 
     191                     dim0.push_back(dimXid); 
     192                     dim0.push_back(dimVertId); 
     193                     SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
     194                     SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
     195                   } 
    193196                 } 
    194197 
     
    221224                 SuperClassWriter::definition_end(); 
    222225 
    223                  switch (domain->type) 
    224                  { 
    225                    case CDomain::type_attr::curvilinear : 
    226                      SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
    227                      SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
    228                      break; 
    229                    case CDomain::type_attr::rectilinear : 
    230                      CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
    231                      SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
    232                      CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
    233                      SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
    234                      break; 
    235                  } 
    236  
    237                  if (domain->hasBounds) 
    238                  { 
    239                    SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0); 
    240                    SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0); 
     226                 if (domain->hasLonLat) 
     227                 { 
     228                   switch (domain->type) 
     229                   { 
     230                     case CDomain::type_attr::curvilinear : 
     231                       SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
     232                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
     233                       break; 
     234                     case CDomain::type_attr::rectilinear : 
     235                       CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
     236                       SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
     237                       CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
     238                       SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
     239                       break; 
     240                   } 
     241 
     242                   if (domain->hasBounds) 
     243                   { 
     244                     SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0); 
     245                     SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0); 
     246                   } 
    241247                 } 
    242248 
     
    256262                   SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
    257263 
    258                  switch (domain->type) 
    259                  { 
    260                    case CDomain::type_attr::curvilinear : 
    261                      dim0.push_back(dimYid); dim0.push_back(dimXid); 
    262                      lonid = StdString("nav_lon").append(appendDomid); 
    263                      latid = StdString("nav_lat").append(appendDomid); 
    264                      SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    265                      SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    266                      break; 
    267  
    268                    case CDomain::type_attr::rectilinear : 
     264                 if (domain->hasLonLat) 
     265                 { 
     266                   switch (domain->type) 
     267                   { 
     268                     case CDomain::type_attr::curvilinear : 
     269                       dim0.push_back(dimYid); dim0.push_back(dimXid); 
     270                       lonid = StdString("nav_lon").append(appendDomid); 
     271                       latid = StdString("nav_lat").append(appendDomid); 
     272                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     273                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     274                       break; 
     275 
     276                     case CDomain::type_attr::rectilinear : 
     277                       dim0.push_back(dimYid); 
     278                       dim1.push_back(dimXid); 
     279                       lonid = StdString("lon").append(appendDomid); 
     280                       latid = StdString("lat").append(appendDomid); 
     281                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     282                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     283                       break; 
     284                   } 
     285 
     286                   bounds_lonid = StdString("bounds_lon").append(appendDomid); 
     287                   bounds_latid = StdString("bounds_lat").append(appendDomid); 
     288 
     289                   this->writeAxisAttributes 
     290                      (lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid); 
     291                   this->writeAxisAttributes 
     292                      (latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid); 
     293 
     294                   if (domain->hasBounds) 
     295                   { 
     296                     SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid); 
     297                     SuperClassWriter::addAttribute("bounds", bounds_latid, &latid); 
     298 
     299                     dim0.clear(); 
    269300                     dim0.push_back(dimYid); 
    270                      dim1.push_back(dimXid); 
    271                      lonid = StdString("lon").append(appendDomid); 
    272                      latid = StdString("lat").append(appendDomid); 
    273                      SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    274                      SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
    275                      break; 
    276                  } 
    277  
    278                  bounds_lonid = StdString("bounds_lon").append(appendDomid); 
    279                  bounds_latid = StdString("bounds_lat").append(appendDomid); 
     301                     dim0.push_back(dimXid); 
     302                     dim0.push_back(dimVertId); 
     303                     SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
     304                     SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
     305                   } 
     306                 } 
    280307 
    281308                 if (domain->hasArea) 
     
    287314                   SuperClassWriter::addAttribute("units", StdString("m2"), &areaId); 
    288315                   dim0.clear(); 
    289                  } 
    290  
    291                  this->writeAxisAttributes 
    292                     (lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid); 
    293                  this->writeAxisAttributes 
    294                     (latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid); 
    295  
    296                  if (domain->hasBounds) 
    297                  { 
    298                    SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid); 
    299                    SuperClassWriter::addAttribute("bounds", bounds_latid, &latid); 
    300  
    301                    dim0.clear(); 
    302                    dim0.push_back(dimYid); 
    303                    dim0.push_back(dimXid); 
    304                    dim0.push_back(dimVertId); 
    305                    SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
    306                    SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
    307316                 } 
    308317 
     
    327336                     } 
    328337 
    329                      SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    330                      SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     338                     if (domain->hasLonLat) 
     339                     { 
     340                       SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
     341                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     342                     } 
    331343                     break; 
    332344                   } 
    333345                   case CDomain::type_attr::rectilinear : 
    334346                   { 
    335                      std::vector<StdSize> start(1) ; 
    336                      std::vector<StdSize> count(1) ; 
    337                      if (domain->isEmpty()) 
     347                     if (domain->hasLonLat) 
    338348                     { 
    339                        start[0]=0 ; 
    340                        count[0]=0 ; 
    341                        SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    342                        SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
    343                      } 
    344                      else 
    345                      { 
    346                        start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin; 
    347                        count[0]=domain->zoom_nj_srv ; 
    348                        CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
    349                        SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
    350  
    351                        start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
    352                        count[0]=domain->zoom_ni_srv ; 
    353                        CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
    354                        SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count); 
     349                       std::vector<StdSize> start(1) ; 
     350                       std::vector<StdSize> count(1) ; 
     351                       if (domain->isEmpty()) 
     352                       { 
     353                         start[0]=0 ; 
     354                         count[0]=0 ; 
     355                         SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
     356                         SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     357 
     358                       } 
     359                       else 
     360                       { 
     361                         start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin; 
     362                         count[0]=domain->zoom_nj_srv ; 
     363                         CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
     364                         SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
     365 
     366                         start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin; 
     367                         count[0]=domain->zoom_ni_srv ; 
     368                         CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
     369                         SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count); 
     370                       } 
    355371                     } 
    356372                     break; 
     
    453469              case (MULTI_FILE) : 
    454470              { 
     471                 dim0.push_back(dimXid); 
     472                 SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv); 
     473 
    455474                 lonid = StdString("lon").append(appendDomid); 
    456475                 latid = StdString("lat").append(appendDomid); 
    457                  dim0.push_back(dimXid); 
    458  
    459                  SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv); 
    460                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    461                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    462  
    463476                 bounds_lonid = StdString("bounds_lon").append(appendDomid); 
    464477                 bounds_latid = StdString("bounds_lat").append(appendDomid); 
    465  
    466  
    467                  this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid); 
    468                  if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
    469                  this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid); 
    470                  if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
    471                  if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     478                 if (domain->hasLonLat) 
     479                 { 
     480                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     481                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     482                   this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid); 
     483                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
     484                   this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid); 
     485                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
     486                   if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     487                 } 
     488 
    472489                 dim0.clear(); 
    473490                 if (domain->hasBounds) 
     
    481498                 dim0.clear(); 
    482499                 dim0.push_back(dimXid); 
    483  
    484500                 if (domain->hasArea) 
    485501                 { 
     
    491507                 SuperClassWriter::definition_end(); 
    492508 
    493                  SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
    494                  SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
    495  
    496                  if (domain->hasBounds) 
    497                  { 
    498                    SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0); 
    499                    SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0); 
     509                 if (domain->hasLonLat) 
     510                 { 
     511                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
     512                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
     513                   if (domain->hasBounds) 
     514                   { 
     515                     SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0); 
     516                     SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0); 
     517                   } 
    500518                 } 
    501519 
     
    515533                 dim0.push_back(dimXid); 
    516534                 SuperClassWriter::addDimension(dimXid, domain->nj_glo); 
    517                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    518                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    519                  this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid); 
    520                  if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
    521                  this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid); 
    522                  if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
    523                  if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     535                 if (domain->hasLonLat) 
     536                 { 
     537                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     538                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     539 
     540                   this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid); 
     541                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
     542                   this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid); 
     543                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
     544                   if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     545                 } 
    524546                 dim0.clear(); 
    525547 
     
    563585                   countBounds[1]=domain->nvertex ; 
    564586                 } 
    565                  SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    566                  SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
    567                  if (domain->hasBounds) 
    568                  { 
    569                    SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&startBounds,&countBounds); 
    570                    SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds); 
     587 
     588                 if (domain->hasLonLat) 
     589                 { 
     590                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
     591                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     592                   if (domain->hasBounds) 
     593                   { 
     594                     SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&startBounds,&countBounds); 
     595                     SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds); 
     596                   } 
    571597                 } 
    572598 
  • XIOS/trunk/src/test/test_client.f90

    r664 r665  
    2626  DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo 
    2727  DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm) 
    28   DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), lonvalue(:) ; 
     28  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), lonvalue(:,:) ; 
    2929  INTEGER :: ni,ibegin,iend,nj,jbegin,jend 
    3030  INTEGER :: i,j,l,ts,n 
     
    6464  iend=ibegin+ni-1 ; jend=jbegin+nj-1 
    6565 
    66   ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj)) 
     66  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni,nj)) 
    6767  lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1) 
    6868  lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1) 
     
    7979  CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj,type='curvilinear') 
    8080  CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4) 
    81 !  CALL xios_set_domain_attr("domain_A",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/))) 
    82   CALL xios_set_domain_attr("domain_A",lonvalue_2D=lon,latvalue_2D=lat) 
     81!  CALL xios_set_domain_attr("domain_A",lonvalue_2D=lon,latvalue_2D=lat) 
    8382  CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.) 
    8483 
     
    113112  PRINT *, "xios_date_convert_to_seconds(date - 2.5h) = ", xios_date_convert_to_seconds(date - 2.5 * xios_hour) 
    114113 
    115   ni=0 ; lonvalue(:)=0; lon(:,:)=0 
    116   CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue_2D=lon) 
     114  ni=0 ; lonvalue(:,:)=0; 
     115!  CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue_2D=lon) 
    117116 
    118117  print *,"ni",ni 
  • XIOS/trunk/src/test/test_complete.f90

    r664 r665  
    176176                            time_origin=xios_date(1999, 01, 01, 15, 00, 00)) 
    177177 
    178   CALL xios_set_axis_attr("axis_srf",size=llm ,value=lval) ; 
     178  CALL xios_set_axis_attr("axis_srf",size=llm ,value=lval) 
    179179  CALL xios_set_domain_attr("domain_srf",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj, type='curvilinear') 
    180180  CALL xios_set_domain_attr("domain_srf",data_dim=1, data_ibegin=0, data_ni=nb_pt) 
Note: See TracChangeset for help on using the changeset viewer.