Ignore:
Timestamp:
08/24/15 14:53:23 (9 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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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 
Note: See TracChangeset for help on using the changeset viewer.