Ignore:
Timestamp:
12/07/22 18:42:46 (19 months ago)
Author:
ymipsl
Message:

Add bounds management for rectilinear domain.
First try.
YM

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS2/trunk/src/io/nc4_data_output.cpp

    r2434 r2440  
    142142         } 
    143143 
    144          StdString dimVertId = StdString("nvertex").append(appendDomid); 
     144         StdString dimVertId ; 
     145         if (domain->type==CDomain::type_attr::rectilinear)  dimVertId=StdString("domain_nbounds").append(appendDomid); 
     146         else dimVertId=StdString("nvertex").append(appendDomid); 
    145147 
    146148         string lonid,latid,bounds_lonid,bounds_latid ; 
    … …  
    181183           if (domain->hasBounds) 
    182184           {          
    183              int nvertex = domain->nvertex, idx; 
    184              writtenBndsLat.resize(nvertex, nbWritten); 
    185              writtenBndsLon.resize(nvertex, nbWritten); 
     185             int idx; 
     186             int nvertexValue = (domain->type==CDomain::type_attr::rectilinear || type==CDomain::type_attr::curvilinear) ? 4 : domain->nvertex ; 
     187 
     188             writtenBndsLat.resize(nvertexValue, nbWritten); 
     189             writtenBndsLon.resize(nvertexValue, nbWritten); 
    186190             CArray<double,2>& boundslat = domain->bounds_latvalue; 
    187191             CArray<double,2>& boundslon = domain->bounds_lonvalue;    
    188192             for (idx = 0; idx < nbWritten; ++idx) 
    189                for (int nv = 0; nv < nvertex; ++nv) 
     193               for (int nv = 0; nv < nvertexValue; ++nv) 
    190194               { 
    191195                 if (indexToWrite(idx) < 0) 
    … …  
    244248 
    245249                 if (domain->hasBounds) 
    246                    SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     250                 {   
     251                    
     252                   if (domain->type==CDomain::type_attr::rectilinear) SuperClassWriter::addDimension(dimVertId,2); 
     253                   else if (domain->type==CDomain::type_attr::curvilinear) SuperClassWriter::addDimension(dimVertId,4); 
     254                   else SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     255                 } 
    247256 
    248257                 int commRank ; 
    … …  
    290299                     SuperClassWriter::addAttribute("bounds", bounds_latid, &latid); 
    291300 
    292                      dim0.clear(); 
    293                      dim0.push_back(dimYid); 
    294                      dim0.push_back(dimXid); 
    295                      dim0.push_back(dimVertId); 
    296                      SuperClassWriter::addVariable(bounds_lonid, typePrec, dim0, compressionLevel); 
    297                      SuperClassWriter::addVariable(bounds_latid, typePrec, dim0, compressionLevel); 
     301                     if (domain->type==CDomain::type_attr::curvilinear) 
     302                     { 
     303                       dim0.clear(); 
     304                       dim0.push_back(dimYid); 
     305                       dim0.push_back(dimXid); 
     306                       dim0.push_back(dimVertId); 
     307                       SuperClassWriter::addVariable(bounds_lonid, typePrec, dim0, compressionLevel); 
     308                       SuperClassWriter::addVariable(bounds_latid, typePrec, dim0, compressionLevel); 
     309                     } 
     310                     else if(domain->type==CDomain::type_attr::rectilinear) 
     311                     { 
     312                       dim0.clear(); 
     313                       dim0.push_back(dimXid); 
     314                       dim0.push_back(dimVertId); 
     315                       SuperClassWriter::addVariable(bounds_lonid, typePrec, dim0, compressionLevel); 
     316                       dim0.clear(); 
     317                       dim0.push_back(dimYid); 
     318                       dim0.push_back(dimVertId); 
     319                       SuperClassWriter::addVariable(bounds_latid, typePrec, dim0, compressionLevel); 
     320                     } 
     321 
    298322                   } 
    299323                 } 
    300  
    301                  dim0.clear(); 
    302                  dim0.push_back(dimYid); 
    303                  dim0.push_back(dimXid); 
    304  
     324                 
    305325 
    306326  // supress mask               if (server->intraCommSize > 1) 
    … …  
    334354                       SuperClassWriter::writeData(writtenLat, latid, isCollective, 0); 
    335355                       SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0); 
     356                       if (domain->hasBounds) 
     357                       { 
     358                          SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0); 
     359                          SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0); 
     360                       } 
    336361                       break; 
    337362                     case CDomain::type_attr::rectilinear : 
    … …  
    340365                       CArray<double,1> lon = writtenLon(Range(0,domain->ni-1)) ; 
    341366                       SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
     367                       if (domain->hasBounds) 
     368                       { 
     369                          CArray<double,2> BoundsLon = writtenBndsLon(Range(0,1),Range(0,domain->ni-1)); 
     370                          CArray<double,2> BoundsLat = writtenBndsLat(Range(1,2),Range(fromStart,toEnd,domain->ni)); 
     371                          SuperClassWriter::writeData(BoundsLon.copy(), bounds_lonid, isCollective, 0); 
     372                          SuperClassWriter::writeData(BoundsLat.copy(), bounds_latid, isCollective, 0); 
     373                       } 
    342374                       break; 
    343                    } 
    344  
    345                    if (domain->hasBounds) 
    346                    { 
    347                      SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0); 
    348                      SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0); 
    349375                   } 
    350376                 } 
    … …  
    365391 
    366392                 if (domain->hasBounds) 
    367                    SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     393                 {   
     394                    
     395                   if (domain->type==CDomain::type_attr::rectilinear) SuperClassWriter::addDimension(dimVertId,2); 
     396                   else if (domain->type==CDomain::type_attr::curvilinear) SuperClassWriter::addDimension(dimVertId,4); 
     397                   else SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     398                 } 
    368399 
    369400                 if (domain->hasLonLat) 
    … …  
    403434                     SuperClassWriter::addAttribute("bounds", bounds_latid, &latid); 
    404435 
    405                      dim0.clear(); 
    406                      dim0.push_back(dimYid); 
    407                      dim0.push_back(dimXid); 
    408                      dim0.push_back(dimVertId); 
    409                      SuperClassWriter::addVariable(bounds_lonid, typePrec, dim0, compressionLevel); 
    410                      SuperClassWriter::addVariable(bounds_latid, typePrec, dim0, compressionLevel); 
     436                     if (domain->type==CDomain::type_attr::curvilinear) 
     437                     { 
     438                       dim0.clear(); 
     439                       dim0.push_back(dimYid); 
     440                       dim0.push_back(dimXid); 
     441                       dim0.push_back(dimVertId); 
     442                       SuperClassWriter::addVariable(bounds_lonid, typePrec, dim0, compressionLevel); 
     443                       SuperClassWriter::addVariable(bounds_latid, typePrec, dim0, compressionLevel); 
     444                     } 
     445                     else if(domain->type==CDomain::type_attr::rectilinear) 
     446                     { 
     447                       dim0.clear(); 
     448                       dim0.push_back(dimXid); 
     449                       dim0.push_back(dimVertId); 
     450                       SuperClassWriter::addVariable(bounds_lonid, typePrec, dim0, compressionLevel); 
     451                       dim0.clear(); 
     452                       dim0.push_back(dimYid); 
     453                       dim0.push_back(dimVertId); 
     454                       SuperClassWriter::addVariable(bounds_latid, typePrec, dim0, compressionLevel); 
     455                     } 
     456 
    411457                   } 
     458 
     459 
     460 
     461 
    412462                 } 
    413463 
    … …  
    448498                       SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0,&start,&count); 
    449499                     } 
    450                      break; 
    451                    } 
    452                    case CDomain::type_attr::rectilinear : 
    453                    { 
     500                     if (domain->hasBounds) 
     501                     { 
     502                       std::vector<StdSize> start(3); 
     503                       std::vector<StdSize> count(3); 
     504                      //  if (domain->isEmpty()) 
     505                      //  { 
     506                      //   start[2] = start[1] = start[0] = 0; 
     507                      //   count[2] = count[1] = count[0] = 0; 
     508                      // } 
     509                      // else 
     510                       { 
     511                         start[2] = 0; 
     512                         start[1] = domain->ibegin; 
     513                         start[0] = domain->jbegin; 
     514                         count[2] = 4; 
     515                         count[1] = domain->ni; 
     516                         count[0] = domain->nj; 
     517                        } 
     518                        SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0, &start, &count); 
     519                        SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0, &start, &count); 
     520                      } 
     521                    break; 
     522                  } 
     523                  case CDomain::type_attr::rectilinear : 
     524                  { 
    454525                     if (domain->hasLonLat) 
    455526                     { 
    … …  
    476547                       } 
    477548                     } 
     549                     
     550                     if (domain->hasBounds) 
     551                     { 
     552                       std::vector<StdSize> start(2); 
     553                       std::vector<StdSize> count(2); 
     554                       if (domain->isEmpty()) 
     555                       { 
     556                         start[1] = start[0] = 0; 
     557                         count[1] = count[0] = 0; 
     558                         SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0,&start,&count); 
     559                         SuperClassWriter::writeData(writtenBndsLon, bounds_latid, isCollective, 0,&start,&count); 
     560                       } 
     561                       else 
     562                       { 
     563                         start[1]=0 ; 
     564                         count[1]=2 ; 
     565                         start[0]=domain->jbegin; 
     566                         count[0]=domain->nj; 
     567                         CArray<double,2> BoundsLat = writtenBndsLat(Range(1,2),Range(fromStart,toEnd,domain->ni)); 
     568                         SuperClassWriter::writeData(CArray<double,2>(BoundsLat.copy()), bounds_latid, isCollective, 0,&start,&count); 
     569                          
     570                         start[1]=0 ; 
     571                         count[1]=2 ; 
     572                         start[0]=domain->ibegin; 
     573                         count[0]=domain->ni; 
     574                         CArray<double,2> BoundsLon = writtenBndsLon(Range(0,1),Range(0,domain->ni-1)); 
     575                         SuperClassWriter::writeData(CArray<double,2>(BoundsLon.copy()), bounds_lonid, isCollective, 0,&start,&count); 
     576                       } 
     577                     } 
    478578                     break; 
    479579                   } 
    480                  } 
    481  
    482                  if (domain->hasBounds) 
    483                  { 
    484                    std::vector<StdSize> start(3); 
    485                    std::vector<StdSize> count(3); 
    486                    if (domain->isEmpty()) 
    487                    { 
    488                      start[2] = start[1] = start[0] = 0; 
    489                      count[2] = count[1] = count[0] = 0; 
    490                    } 
    491                    else 
    492                    { 
    493                      start[2] = 0; 
    494                      start[1] = domain->ibegin; 
    495                      start[0] = domain->jbegin; 
    496                      count[2] = domain->nvertex; 
    497                      count[1] = domain->ni; 
    498                      count[0] = domain->nj; 
    499                    } 
    500                   
    501                    SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0, &start, &count); 
    502                    SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0, &start, &count); 
    503580                 } 
    504581 
Note: See TracChangeset for help on using the changeset viewer.