Ignore:
Timestamp:
10/09/14 12:28:26 (10 years ago)
Author:
mhnguyen
Message:

Making a wrapper of NetCdf? C functions

+) Add a wrapper class for NetCdf? functions
+) Add a class to manage exception for NetCdf? functions
+) Replace direct call to netcdf functions by functions of the wrapper

Test
+) On Curie
+) In case of error, exception is thrown and more information is provided

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r488 r498  
    1010#include "context.hpp" 
    1111#include "context_server.hpp" 
     12#include "netCdfException.hpp" 
     13#include "exception.hpp" 
    1214 
    1315namespace xios 
    … …  
    105107*/ 
    106108 
    107          switch (SuperClass::type) 
    108          { 
    109             case (MULTI_FILE) : 
    110             { 
    111 //               if (domain->isEmpty()) return; 
    112  
    113                if (server->intraCommSize > 1) 
    114                { 
    115 //                 SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue()); 
    116 //                 SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue()); 
    117                } 
    118  
    119                switch (domain->type) 
    120                { 
    121                  case CDomain::type_attr::curvilinear : 
    122                    dim0.push_back(dimYid); dim0.push_back(dimXid); 
    123                    lonid = StdString("nav_lon").append(appendDomid); 
    124                    latid = StdString("nav_lat").append(appendDomid); 
    125                    break ; 
    126                  case CDomain::type_attr::regular : 
    127                    lonid = StdString("lon").append(appendDomid); 
    128                    latid = StdString("lat").append(appendDomid); 
    129                    dim0.push_back(dimYid); 
    130                    dim1.push_back(dimXid); 
    131                    break; 
    132                  case CDomain::type_attr::unstructured : 
    133                    lonid = StdString("lon").append(appendDomid); 
    134                    latid = StdString("lat").append(appendDomid); 
    135                    bounds_lonid=string("bounds_lon").append(appendDomid); 
    136                    bounds_latid=string("bounds_lat").append(appendDomid); 
    137                    dim0.push_back(dimXid); 
    138                    break; 
    139                } 
    140  
    141                if (domain->type == CDomain::type_attr::unstructured) 
    142                { 
    143                  SuperClassWriter::addDimension(dimXid, domain->nj_glo); 
    144                } 
    145                else 
    146                { 
    147                  SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv); 
    148                  SuperClassWriter::addDimension(dimYid, domain->zoom_nj_srv); 
    149                } 
    150  
    151                if (server->intraCommSize > 1) 
    152                { 
    153                   if (domain->type != CDomain::type_attr::unstructured) 
    154                   { 
    155                     this->writeLocalAttributes(domain->zoom_ibegin_srv, 
    156                                                domain->zoom_ni_srv, 
    157                                                domain->zoom_jbegin_srv, 
    158                                                domain->zoom_nj_srv, 
    159                                                appendDomid); 
    160  
    161                     if (singleDomain) this->writeLocalAttributes_IOIPSL(domain->zoom_ibegin_srv, 
    162                                                domain->zoom_ni_srv, 
    163                                                domain->zoom_jbegin_srv, 
    164                                                domain->zoom_nj_srv, 
    165                                                domain->ni_glo,domain->nj_glo, 
    166                                                server->intraCommRank,server->intraCommSize); 
    167                  } 
    168                } 
    169  
    170                switch (domain->type) 
    171                { 
    172                  case CDomain::type_attr::curvilinear : 
    173                    SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    174                    SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    175                    break ; 
    176                   case CDomain::type_attr::regular : 
    177                     SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    178                     SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
    179                     break ; 
    180                   case CDomain::type_attr::unstructured : 
    181                     SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    182                     SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    183                } 
    184  
    185                this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    186                this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
    187  
    188                dim0.clear(); 
    189                if (domain->type != CDomain::type_attr::unstructured) dim0.push_back(dimYid); 
    190                dim0.push_back(dimXid); 
    191  
    192  
    193 // supress mask               if (server->intraCommSize > 1) 
    194 // supress mask               { 
    195 // supress mask                  SuperClassWriter::addVariable(maskid, NC_INT, dim0); 
    196 // supress mask 
    197 // supress mask                  this->writeMaskAttributes(maskid, 
    198 // supress mask                     domain->data_dim.getValue()/*, 
    199 // supress mask                     domain->data_ni.getValue(), 
    200 // supress mask                     domain->data_nj.getValue(), 
    201 // supress mask                     domain->data_ibegin.getValue(), 
    202 // supress mask                     domain->data_jbegin.getValue()*/); 
    203 // supress mask               } 
    204  
    205                //SuperClassWriter::setDefaultValue(maskid, &dvm); 
    206  
    207                SuperClassWriter::definition_end(); 
    208  
    209                switch (domain->type) 
    210                { 
    211                  case CDomain::type_attr::curvilinear : 
    212                    SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
    213                    SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
    214                    break; 
    215                  case CDomain::type_attr::regular : 
    216                    CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
    217                    SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
    218                    CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
    219                    SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
    220                    break; 
    221                } 
    222                SuperClassWriter::definition_start(); 
    223  
    224                break; 
    225             } 
    226             case (ONE_FILE) : 
    227             { 
    228                SuperClassWriter::addDimension(dimXid, domain->zoom_ni.getValue()); 
    229                SuperClassWriter::addDimension(dimYid, domain->zoom_nj.getValue()); 
    230  
    231  
    232                switch (domain->type) 
    233                { 
    234                  case CDomain::type_attr::curvilinear : 
    235                    dim0.push_back(dimYid); dim0.push_back(dimXid); 
    236                    lonid = StdString("nav_lon").append(appendDomid); 
    237                    latid = StdString("nav_lat").append(appendDomid); 
    238                    SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    239                    SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    240                    break; 
    241  
    242                  case CDomain::type_attr::regular : 
    243                    dim0.push_back(dimYid); 
    244                    dim1.push_back(dimXid); 
    245                    lonid = StdString("lon").append(appendDomid); 
    246                    latid = StdString("lat").append(appendDomid); 
    247                    SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    248                    SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
    249                    break; 
    250                } 
    251                this->writeAxisAttributes 
    252                   (lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    253                this->writeAxisAttributes 
    254                   (latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
    255  
    256  
    257                SuperClassWriter::definition_end(); 
    258                switch (domain->type) 
    259                { 
    260                  case CDomain::type_attr::curvilinear : 
    261                  { 
    262                    std::vector<StdSize> start(2) ; 
    263                    std::vector<StdSize> count(2) ; 
    264                    if (domain->isEmpty()) 
     109         try 
     110         { 
     111           switch (SuperClass::type) 
     112           { 
     113              case (MULTI_FILE) : 
     114              { 
     115  //               if (domain->isEmpty()) return; 
     116 
     117                 if (server->intraCommSize > 1) 
     118                 { 
     119  //                 SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue()); 
     120  //                 SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue()); 
     121                 } 
     122 
     123                 switch (domain->type) 
     124                 { 
     125                   case CDomain::type_attr::curvilinear : 
     126                     dim0.push_back(dimYid); dim0.push_back(dimXid); 
     127                     lonid = StdString("nav_lon").append(appendDomid); 
     128                     latid = StdString("nav_lat").append(appendDomid); 
     129                     break ; 
     130                   case CDomain::type_attr::regular : 
     131                     lonid = StdString("lon").append(appendDomid); 
     132                     latid = StdString("lat").append(appendDomid); 
     133                     dim0.push_back(dimYid); 
     134                     dim1.push_back(dimXid); 
     135                     break; 
     136                   case CDomain::type_attr::unstructured : 
     137                     lonid = StdString("lon").append(appendDomid); 
     138                     latid = StdString("lat").append(appendDomid); 
     139                     bounds_lonid=string("bounds_lon").append(appendDomid); 
     140                     bounds_latid=string("bounds_lat").append(appendDomid); 
     141                     dim0.push_back(dimXid); 
     142                     break; 
     143                 } 
     144 
     145                 if (domain->type == CDomain::type_attr::unstructured) 
     146                 { 
     147                   SuperClassWriter::addDimension(dimXid, domain->nj_glo); 
     148                 } 
     149                 else 
     150                 { 
     151                   SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv); 
     152                   SuperClassWriter::addDimension(dimYid, domain->zoom_nj_srv); 
     153                 } 
     154 
     155                 if (server->intraCommSize > 1) 
     156                 { 
     157                    if (domain->type != CDomain::type_attr::unstructured) 
     158                    { 
     159                      this->writeLocalAttributes(domain->zoom_ibegin_srv, 
     160                                                 domain->zoom_ni_srv, 
     161                                                 domain->zoom_jbegin_srv, 
     162                                                 domain->zoom_nj_srv, 
     163                                                 appendDomid); 
     164 
     165                      if (singleDomain) this->writeLocalAttributes_IOIPSL(domain->zoom_ibegin_srv, 
     166                                                 domain->zoom_ni_srv, 
     167                                                 domain->zoom_jbegin_srv, 
     168                                                 domain->zoom_nj_srv, 
     169                                                 domain->ni_glo,domain->nj_glo, 
     170                                                 server->intraCommRank,server->intraCommSize); 
     171                   } 
     172                 } 
     173 
     174                 switch (domain->type) 
     175                 { 
     176                   case CDomain::type_attr::curvilinear : 
     177                     SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     178                     SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     179                     break ; 
     180                    case CDomain::type_attr::regular : 
     181                      SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     182                      SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     183                      break ; 
     184                    case CDomain::type_attr::unstructured : 
     185                      SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     186                      SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     187                 } 
     188 
     189                 this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
     190                 this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     191 
     192                 dim0.clear(); 
     193                 if (domain->type != CDomain::type_attr::unstructured) dim0.push_back(dimYid); 
     194                 dim0.push_back(dimXid); 
     195 
     196 
     197  // supress mask               if (server->intraCommSize > 1) 
     198  // supress mask               { 
     199  // supress mask                  SuperClassWriter::addVariable(maskid, NC_INT, dim0); 
     200  // supress mask 
     201  // supress mask                  this->writeMaskAttributes(maskid, 
     202  // supress mask                     domain->data_dim.getValue()/*, 
     203  // supress mask                     domain->data_ni.getValue(), 
     204  // supress mask                     domain->data_nj.getValue(), 
     205  // supress mask                     domain->data_ibegin.getValue(), 
     206  // supress mask                     domain->data_jbegin.getValue()*/); 
     207  // supress mask               } 
     208 
     209                 //SuperClassWriter::setDefaultValue(maskid, &dvm); 
     210 
     211                 SuperClassWriter::definition_end(); 
     212 
     213                 switch (domain->type) 
     214                 { 
     215                   case CDomain::type_attr::curvilinear : 
     216                     SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
     217                     SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
     218                     break; 
     219                   case CDomain::type_attr::regular : 
     220                     CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
     221                     SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
     222                     CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
     223                     SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
     224                     break; 
     225                 } 
     226                 SuperClassWriter::definition_start(); 
     227 
     228                 break; 
     229              } 
     230              case (ONE_FILE) : 
     231              { 
     232                 SuperClassWriter::addDimension(dimXid, domain->zoom_ni.getValue()); 
     233                 SuperClassWriter::addDimension(dimYid, domain->zoom_nj.getValue()); 
     234 
     235 
     236                 switch (domain->type) 
     237                 { 
     238                   case CDomain::type_attr::curvilinear : 
     239                     dim0.push_back(dimYid); dim0.push_back(dimXid); 
     240                     lonid = StdString("nav_lon").append(appendDomid); 
     241                     latid = StdString("nav_lat").append(appendDomid); 
     242                     SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     243                     SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     244                     break; 
     245 
     246                   case CDomain::type_attr::regular : 
     247                     dim0.push_back(dimYid); 
     248                     dim1.push_back(dimXid); 
     249                     lonid = StdString("lon").append(appendDomid); 
     250                     latid = StdString("lat").append(appendDomid); 
     251                     SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     252                     SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     253                     break; 
     254                 } 
     255                 this->writeAxisAttributes 
     256                    (lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
     257                 this->writeAxisAttributes 
     258                    (latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     259 
     260 
     261                 SuperClassWriter::definition_end(); 
     262                 switch (domain->type) 
     263                 { 
     264                   case CDomain::type_attr::curvilinear : 
    265265                   { 
    266                      start[0]=0 ; start [1]=0 ; 
    267                      count[0]=0 ; count[1]=0 ; 
     266                     std::vector<StdSize> start(2) ; 
     267                     std::vector<StdSize> count(2) ; 
     268                     if (domain->isEmpty()) 
     269                     { 
     270                       start[0]=0 ; start [1]=0 ; 
     271                       count[0]=0 ; count[1]=0 ; 
     272                     } 
     273                     else 
     274                     { 
     275                       start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
     276                       count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ; 
     277                     } 
     278 
     279                     SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
     280                     SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     281                     break; 
    268282                   } 
    269                    else 
     283                   case CDomain::type_attr::regular : 
    270284                   { 
    271                      start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
    272                      count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ; 
     285                     std::vector<StdSize> start(1) ; 
     286                     std::vector<StdSize> count(1) ; 
     287                     if (domain->isEmpty()) 
     288                     { 
     289                       start[0]=0 ; 
     290                       count[0]=0 ; 
     291                       SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
     292                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);                 } 
     293                     else 
     294                     { 
     295                       start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
     296                       count[0]=domain->zoom_nj_srv ; 
     297                       CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
     298                       SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
     299 
     300                       start[0]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; 
     301                       count[0]=domain->zoom_ni_srv ; 
     302                       CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
     303                       SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count); 
     304                     } 
     305                     break; 
    273306                   } 
    274  
    275                    SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    276                    SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
    277                    break; 
    278                  } 
    279                  case CDomain::type_attr::regular : 
    280                  { 
    281                    std::vector<StdSize> start(1) ; 
    282                    std::vector<StdSize> count(1) ; 
    283                    if (domain->isEmpty()) 
    284                    { 
    285                      start[0]=0 ; 
    286                      count[0]=0 ; 
    287                      SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    288                      SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);                 } 
    289                    else 
    290                    { 
    291                      start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
    292                      count[0]=domain->zoom_nj_srv ; 
    293                      CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
    294                      SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
    295  
    296                      start[0]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; 
    297                      count[0]=domain->zoom_ni_srv ; 
    298                      CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
    299                      SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count); 
    300                    } 
    301                    break; 
    302                  } 
    303                } 
    304                SuperClassWriter::definition_start(); 
    305                break; 
    306             } 
    307             default : 
    308                ERROR("CNc4DataOutput::writeDomain(domain)", 
    309                      << "[ type = " << SuperClass::type << "]" 
    310                      << " not implemented yet !"); 
    311          } 
     307                 } 
     308                 SuperClassWriter::definition_start(); 
     309                 break; 
     310              } 
     311              default : 
     312                 ERROR("CNc4DataOutput::writeDomain(domain)", 
     313                       << "[ type = " << SuperClass::type << "]" 
     314                       << " not implemented yet !"); 
     315           } 
     316         } 
     317         catch (CNetCdfException& e) 
     318         { 
     319           StdString msg("On writing the domain : "); 
     320           msg.append(domid); msg.append("\n"); 
     321           msg.append("In the context : "); 
     322           msg.append(context->getId()); msg.append("\n"); 
     323           msg.append(e.what()); 
     324           ERROR("CNc4DataOutput::writeDomain_(CDomain* domain)", << msg); 
     325         } 
     326 
    312327         domain->addRelFile(this->filename); 
    313328      } 
    … …  
    335350         string lonid,latid,bounds_lonid,bounds_latid ; 
    336351 
    337          switch (SuperClass::type) 
    338          { 
    339             case (MULTI_FILE) : 
    340             { 
    341                lonid = StdString("lon").append(appendDomid); 
    342                latid = StdString("lat").append(appendDomid); 
    343                dim0.push_back(dimXid); 
    344  
    345                SuperClassWriter::addDimension(dimXid, domain->zoom_nj_srv); 
    346                SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    347                SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    348  
    349                bounds_lonid = StdString("bounds_lon").append(appendDomid); 
    350                bounds_latid = StdString("bounds_lat").append(appendDomid); 
    351  
    352  
    353                this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    354                if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
    355                this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
    356                if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
    357                if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
    358                dim0.clear(); 
    359                if (domain->hasBounds) 
    360                { 
     352         try 
     353         { 
     354           switch (SuperClass::type) 
     355           { 
     356              case (MULTI_FILE) : 
     357              { 
     358                 lonid = StdString("lon").append(appendDomid); 
     359                 latid = StdString("lat").append(appendDomid); 
    361360                 dim0.push_back(dimXid); 
    362                  dim0.push_back(dimVertId); 
    363                  SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
    364                  SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
    365                } 
    366  
    367                dim0.clear(); 
    368                dim0.push_back(dimXid); 
    369  
    370                SuperClassWriter::definition_end(); 
    371  
    372                SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
    373                SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
    374  
    375                if (domain->hasBounds) 
    376                { 
    377                  SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0); 
    378                  SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0); 
    379                } 
    380                SuperClassWriter::definition_start(); 
    381                break ; 
    382             } 
    383  
    384             case (ONE_FILE) : 
    385             { 
    386                lonid = StdString("lon").append(appendDomid); 
    387                latid = StdString("lat").append(appendDomid); 
    388                bounds_lonid = StdString("bounds_lon").append(appendDomid); 
    389                bounds_latid = StdString("bounds_lat").append(appendDomid); 
    390                dim0.push_back(dimXid); 
    391                SuperClassWriter::addDimension(dimXid, domain->nj_glo); 
    392                SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    393                SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    394                this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    395                if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
    396                this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
    397                if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
    398                if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
    399                dim0.clear(); 
    400  
    401                if (domain->hasBounds) 
    402                { 
     361 
     362                 SuperClassWriter::addDimension(dimXid, domain->zoom_nj_srv); 
     363                 SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     364                 SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     365 
     366                 bounds_lonid = StdString("bounds_lon").append(appendDomid); 
     367                 bounds_latid = StdString("bounds_lat").append(appendDomid); 
     368 
     369 
     370                 this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
     371                 if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
     372                 this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     373                 if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
     374                 if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     375                 dim0.clear(); 
     376                 if (domain->hasBounds) 
     377                 { 
     378                   dim0.push_back(dimXid); 
     379                   dim0.push_back(dimVertId); 
     380                   SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
     381                   SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
     382                 } 
     383 
     384                 dim0.clear(); 
    403385                 dim0.push_back(dimXid); 
    404                  dim0.push_back(dimVertId); 
    405                  SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
    406                  SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
    407                } 
    408  
    409                SuperClassWriter::definition_end(); 
    410  
    411                std::vector<StdSize> start(1), startBounds(2) ; 
    412                std::vector<StdSize> count(1), countBounds(2) ; 
    413                if (domain->isEmpty()) 
    414                { 
    415                  start[0]=0 ; 
    416                  count[0]=0 ; 
    417                  startBounds[1]=0 ; 
    418                  countBounds[1]=domain->nvertex ; 
    419                  startBounds[0]=0 ; 
    420                  countBounds[0]=0 ; 
    421                } 
    422                else 
    423                { 
    424                  start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ; 
    425                  count[0]=domain->zoom_nj_srv ; 
    426                  startBounds[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ; 
    427                  startBounds[1]=0 ; 
    428                  countBounds[0]=domain->zoom_nj_srv ; 
    429                  countBounds[1]=domain->nvertex ; 
    430                } 
    431                SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    432                SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
    433                if (domain->hasBounds) 
    434                { 
    435                  SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&startBounds,&countBounds); 
    436                  SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds); 
    437                } 
    438  
    439  
    440                SuperClassWriter::definition_start(); 
    441  
    442                break; 
    443             } 
    444             default : 
    445                ERROR("CNc4DataOutput::writeDomain(domain)", 
    446                      << "[ type = " << SuperClass::type << "]" 
    447                      << " not implemented yet !"); 
     386 
     387                 SuperClassWriter::definition_end(); 
     388 
     389                 SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
     390                 SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
     391 
     392                 if (domain->hasBounds) 
     393                 { 
     394                   SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0); 
     395                   SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0); 
     396                 } 
     397                 SuperClassWriter::definition_start(); 
     398                 break ; 
     399              } 
     400 
     401              case (ONE_FILE) : 
     402              { 
     403                 lonid = StdString("lon").append(appendDomid); 
     404                 latid = StdString("lat").append(appendDomid); 
     405                 bounds_lonid = StdString("bounds_lon").append(appendDomid); 
     406                 bounds_latid = StdString("bounds_lat").append(appendDomid); 
     407                 dim0.push_back(dimXid); 
     408                 SuperClassWriter::addDimension(dimXid, domain->nj_glo); 
     409                 SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     410                 SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     411                 this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
     412                 if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
     413                 this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     414                 if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
     415                 if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     416                 dim0.clear(); 
     417 
     418                 if (domain->hasBounds) 
     419                 { 
     420                   dim0.push_back(dimXid); 
     421                   dim0.push_back(dimVertId); 
     422                   SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
     423                   SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
     424                 } 
     425 
     426                 SuperClassWriter::definition_end(); 
     427 
     428                 std::vector<StdSize> start(1), startBounds(2) ; 
     429                 std::vector<StdSize> count(1), countBounds(2) ; 
     430                 if (domain->isEmpty()) 
     431                 { 
     432                   start[0]=0 ; 
     433                   count[0]=0 ; 
     434                   startBounds[1]=0 ; 
     435                   countBounds[1]=domain->nvertex ; 
     436                   startBounds[0]=0 ; 
     437                   countBounds[0]=0 ; 
     438                 } 
     439                 else 
     440                 { 
     441                   start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ; 
     442                   count[0]=domain->zoom_nj_srv ; 
     443                   startBounds[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ; 
     444                   startBounds[1]=0 ; 
     445                   countBounds[0]=domain->zoom_nj_srv ; 
     446                   countBounds[1]=domain->nvertex ; 
     447                 } 
     448                 SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
     449                 SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     450                 if (domain->hasBounds) 
     451                 { 
     452                   SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&startBounds,&countBounds); 
     453                   SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds); 
     454                 } 
     455 
     456 
     457                 SuperClassWriter::definition_start(); 
     458 
     459                 break; 
     460              } 
     461              default : 
     462                 ERROR("CNc4DataOutput::writeDomain(domain)", 
     463                       << "[ type = " << SuperClass::type << "]" 
     464                       << " not implemented yet !"); 
     465           } 
     466         } 
     467         catch (CNetCdfException& e) 
     468         { 
     469           StdString msg("On writing the domain : "); 
     470           msg.append(domid); msg.append("\n"); 
     471           msg.append("In the context : "); 
     472           msg.append(context->getId()); msg.append("\n"); 
     473           msg.append(e.what()); 
     474           ERROR("CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)", << msg); 
    448475         } 
    449476         domain->addRelFile(this->filename); 
    … …  
    458485         StdSize zoom_begin=axis->zoom_begin.getValue()-1 ; 
    459486 
     487 
    460488         std::vector<StdString> dims; 
    461489         StdString axisid = (!axis->name.isEmpty()) 
    462490                           ? axis->name.getValue() : axis->getId(); 
    463          SuperClassWriter::addDimension(axisid, zoom_size); 
    464          dims.push_back(axisid); 
    465  
    466          switch (SuperClass::type) 
    467          { 
    468             case (MULTI_FILE ) : 
    469             {} 
    470             case (ONE_FILE) : 
    471             { 
    472                SuperClassWriter::addVariable(axisid, NC_FLOAT, dims); 
    473  
    474                SuperClassWriter::addAttribute("axis", StdString("Z"), &axisid); 
    475  
    476                if (!axis->standard_name.isEmpty()) 
    477                   SuperClassWriter::addAttribute 
    478                      ("standard_name",  axis->standard_name.getValue(), &axisid); 
    479  
    480                if (!axis->long_name.isEmpty()) 
    481                   SuperClassWriter::addAttribute 
    482                      ("long_name", axis->long_name.getValue(), &axisid); 
    483  
    484                if (!axis->unit.isEmpty()) 
    485                   SuperClassWriter::addAttribute 
    486                      ("units", axis->unit.getValue(), &axisid); 
    487  
    488               if (!axis->positive.isEmpty()) 
    489                 if (axis->positive==CAxis::positive_attr::up) SuperClassWriter::addAttribute("positive", string("up"), &axisid); 
    490                 else   SuperClassWriter::addAttribute("positive", string("down"), &axisid); 
    491  
    492                SuperClassWriter::definition_end(); 
    493  
    494                CArray<double,1> axis_value(zoom_size) ; 
    495                for(StdSize i = 0 ; i < zoom_size ; i++) axis_value(i)=axis->value(i+zoom_begin) ; 
    496                SuperClassWriter::writeData(axis_value, axisid, isCollective, 0); 
    497  
    498                SuperClassWriter::definition_start(); 
    499  
    500                break; 
    501             } 
    502             default : 
    503                ERROR("CNc4DataOutput::writeDomain(domain)", 
    504                      << "[ type = " << SuperClass::type << "]" 
    505                      << " not implemented yet !"); 
     491         try 
     492         { 
     493           SuperClassWriter::addDimension(axisid, zoom_size); 
     494           dims.push_back(axisid); 
     495 
     496           switch (SuperClass::type) 
     497           { 
     498              case (MULTI_FILE ) : 
     499              {} 
     500              case (ONE_FILE) : 
     501              { 
     502                 SuperClassWriter::addVariable(axisid, NC_FLOAT, dims); 
     503 
     504                 SuperClassWriter::addAttribute("axis", StdString("Z"), &axisid); 
     505 
     506                 if (!axis->standard_name.isEmpty()) 
     507                    SuperClassWriter::addAttribute 
     508                       ("standard_name",  axis->standard_name.getValue(), &axisid); 
     509 
     510                 if (!axis->long_name.isEmpty()) 
     511                    SuperClassWriter::addAttribute 
     512                       ("long_name", axis->long_name.getValue(), &axisid); 
     513 
     514                 if (!axis->unit.isEmpty()) 
     515                    SuperClassWriter::addAttribute 
     516                       ("units", axis->unit.getValue(), &axisid); 
     517 
     518                if (!axis->positive.isEmpty()) 
     519                  if (axis->positive==CAxis::positive_attr::up) SuperClassWriter::addAttribute("positive", string("up"), &axisid); 
     520                  else   SuperClassWriter::addAttribute("positive", string("down"), &axisid); 
     521 
     522                 SuperClassWriter::definition_end(); 
     523 
     524                 CArray<double,1> axis_value(zoom_size) ; 
     525                 for(StdSize i = 0 ; i < zoom_size ; i++) axis_value(i)=axis->value(i+zoom_begin) ; 
     526                 SuperClassWriter::writeData(axis_value, axisid, isCollective, 0); 
     527 
     528                 SuperClassWriter::definition_start(); 
     529 
     530                 break; 
     531              } 
     532              default : 
     533                 ERROR("CNc4DataOutput::writeDomain(domain)", 
     534                       << "[ type = " << SuperClass::type << "]" 
     535                       << " not implemented yet !"); 
     536           } 
     537         } 
     538         catch (CNetCdfException& e) 
     539         { 
     540           StdString msg("On writing the axis : "); 
     541           msg.append(axisid); msg.append("\n"); 
     542           msg.append("In the context : "); 
     543           CContext* context = CContext::getCurrent() ; 
     544           msg.append(context->getId()); msg.append("\n"); 
     545           msg.append(e.what()); 
     546           ERROR("CNc4DataOutput::writeAxis_(CAxis* axis)", << msg); 
    506547         } 
    507548         axis->addRelFile(this->filename); 
    … …  
    510551     void CNc4DataOutput::writeTimeDimension_(void) 
    511552     { 
    512        SuperClassWriter::addDimension("time_counter"); 
    513        SuperClassWriter::addDimension("time_bounds", 2); 
     553       try 
     554       { 
     555        SuperClassWriter::addDimension("time_counter"); 
     556        SuperClassWriter::addDimension("time_bounds", 2); 
     557       } 
     558       catch (CNetCdfException& e) 
     559       { 
     560         StdString msg("On writing time dimension : time_couter, time_bounds \n"); 
     561         msg.append("In the context : "); 
     562         CContext* context = CContext::getCurrent() ; 
     563         msg.append(context->getId()); msg.append("\n"); 
     564         msg.append(e.what()); 
     565         ERROR("CNc4DataOutput::writeTimeDimension_(void)", << msg); 
     566       } 
    514567     } 
    515568      //-------------------------------------------------------------- 
    … …  
    614667         dims.push_back(dimXid); 
    615668 
    616          SuperClassWriter::addVariable(fieldid, type, dims); 
    617  
    618          if (!field->standard_name.isEmpty()) 
    619             SuperClassWriter::addAttribute 
    620                ("standard_name",  field->standard_name.getValue(), &fieldid); 
    621  
    622          if (!field->long_name.isEmpty()) 
    623             SuperClassWriter::addAttribute 
    624                ("long_name", field->long_name.getValue(), &fieldid); 
    625  
    626          if (!field->unit.isEmpty()) 
    627             SuperClassWriter::addAttribute 
    628                ("units", field->unit.getValue(), &fieldid); 
    629  
    630           if (!field->valid_min.isEmpty()) 
    631             SuperClassWriter::addAttribute 
    632                ("valid_min", field->valid_min.getValue(), &fieldid); 
    633  
    634          if (!field->valid_max.isEmpty()) 
    635             SuperClassWriter::addAttribute 
    636                ("valid_max", field->valid_max.getValue(), &fieldid); 
    637  
    638           if (!field->scale_factor.isEmpty()) 
    639             SuperClassWriter::addAttribute 
    640                ("scale_factor", field->scale_factor.getValue(), &fieldid); 
    641  
    642            if (!field->add_offset.isEmpty()) 
    643             SuperClassWriter::addAttribute 
    644                ("add_offset", field->add_offset.getValue(), &fieldid); 
    645  
    646          SuperClassWriter::addAttribute 
    647                ("online_operation", field->operation.getValue(), &fieldid); 
    648  
    649         // write child variables as attributes 
    650  
    651  
    652          vector<CVariable*> listVars = field->getAllVariables() ; 
    653          for (vector<CVariable*>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(*it, fieldid) ; 
    654  
    655  
    656          if (wtime) 
    657          { 
    658             CDuration duration ; 
    659  
    660             duration=CDuration::FromString(field->freq_op) ; 
    661             duration.solveTimeStep(*(context->calendar)); 
    662             SuperClassWriter::addAttribute("interval_operation", duration.toString(), &fieldid); 
    663  
    664             duration=CDuration::FromString(field->getRelFile()->output_freq) ; 
    665             duration.solveTimeStep(*(context->calendar)); 
    666             SuperClassWriter::addAttribute("interval_write", duration.toString(), &fieldid); 
    667          } 
    668  
    669          if (!field->default_value.isEmpty()) 
    670          { 
    671             double default_value = field->default_value.getValue(); 
    672             float fdefault_value = (float)default_value; 
    673             if (type == NC_DOUBLE) 
    674                SuperClassWriter::setDefaultValue(fieldid, &default_value); 
    675             else 
    676                SuperClassWriter::setDefaultValue(fieldid, &fdefault_value); 
    677          } 
    678          else 
    679          { 
    680             double * default_value = NULL; 
    681             SuperClassWriter::setDefaultValue(fieldid, default_value); 
    682          } 
    683  
    684          {  // Ecriture des coordonnées 
    685  
    686             StdString coordstr; //boost::algorithm::join(coodinates, " ") 
    687             std::vector<StdString>::iterator 
    688                itc = coodinates.begin(), endc = coodinates.end(); 
    689  
    690             for (; itc!= endc; itc++) 
    691             { 
    692                StdString & coord = *itc; 
    693                if (itc+1 != endc) 
    694                      coordstr.append(coord).append(" "); 
    695                else  coordstr.append(coord); 
    696             } 
    697  
    698             SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid); 
    699  
    700          } 
    701  
     669         try 
     670         { 
     671           SuperClassWriter::addVariable(fieldid, type, dims); 
     672 
     673           if (!field->standard_name.isEmpty()) 
     674              SuperClassWriter::addAttribute 
     675                 ("standard_name",  field->standard_name.getValue(), &fieldid); 
     676 
     677           if (!field->long_name.isEmpty()) 
     678              SuperClassWriter::addAttribute 
     679                 ("long_name", field->long_name.getValue(), &fieldid); 
     680 
     681           if (!field->unit.isEmpty()) 
     682              SuperClassWriter::addAttribute 
     683                 ("units", field->unit.getValue(), &fieldid); 
     684 
     685            if (!field->valid_min.isEmpty()) 
     686              SuperClassWriter::addAttribute 
     687                 ("valid_min", field->valid_min.getValue(), &fieldid); 
     688 
     689           if (!field->valid_max.isEmpty()) 
     690              SuperClassWriter::addAttribute 
     691                 ("valid_max", field->valid_max.getValue(), &fieldid); 
     692 
     693            if (!field->scale_factor.isEmpty()) 
     694              SuperClassWriter::addAttribute 
     695                 ("scale_factor", field->scale_factor.getValue(), &fieldid); 
     696 
     697             if (!field->add_offset.isEmpty()) 
     698              SuperClassWriter::addAttribute 
     699                 ("add_offset", field->add_offset.getValue(), &fieldid); 
     700 
     701           SuperClassWriter::addAttribute 
     702                 ("online_operation", field->operation.getValue(), &fieldid); 
     703 
     704          // write child variables as attributes 
     705 
     706 
     707           vector<CVariable*> listVars = field->getAllVariables() ; 
     708           for (vector<CVariable*>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(*it, fieldid) ; 
     709 
     710 
     711           if (wtime) 
     712           { 
     713              CDuration duration ; 
     714 
     715              duration=CDuration::FromString(field->freq_op) ; 
     716              duration.solveTimeStep(*(context->calendar)); 
     717              SuperClassWriter::addAttribute("interval_operation", duration.toString(), &fieldid); 
     718 
     719              duration=CDuration::FromString(field->getRelFile()->output_freq) ; 
     720              duration.solveTimeStep(*(context->calendar)); 
     721              SuperClassWriter::addAttribute("interval_write", duration.toString(), &fieldid); 
     722           } 
     723 
     724           if (!field->default_value.isEmpty()) 
     725           { 
     726              double default_value = field->default_value.getValue(); 
     727              float fdefault_value = (float)default_value; 
     728              if (type == NC_DOUBLE) 
     729                 SuperClassWriter::setDefaultValue(fieldid, &default_value); 
     730              else 
     731                 SuperClassWriter::setDefaultValue(fieldid, &fdefault_value); 
     732           } 
     733           else 
     734           { 
     735              double * default_value = NULL; 
     736              SuperClassWriter::setDefaultValue(fieldid, default_value); 
     737           } 
     738 
     739           {  // Ecriture des coordonnées 
     740 
     741              StdString coordstr; //boost::algorithm::join(coodinates, " ") 
     742              std::vector<StdString>::iterator 
     743                 itc = coodinates.begin(), endc = coodinates.end(); 
     744 
     745              for (; itc!= endc; itc++) 
     746              { 
     747                 StdString & coord = *itc; 
     748                 if (itc+1 != endc) 
     749                       coordstr.append(coord).append(" "); 
     750                 else  coordstr.append(coord); 
     751              } 
     752 
     753              SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid); 
     754 
     755           } 
     756         } 
     757         catch (CNetCdfException& e) 
     758         { 
     759           StdString msg("On writing field : "); 
     760           msg.append(fieldid); msg.append("\n"); 
     761           msg.append("In the context : "); 
     762           msg.append(context->getId()); msg.append("\n"); 
     763           msg.append(e.what()); 
     764           ERROR("CNc4DataOutput::writeField_(CField* field)", << msg); 
     765         } 
    702766      } 
    703767 
    … …  
    711775                               ? file->description.getValue() 
    712776                               : StdString("Created by xios"); 
    713          this->writeFileAttributes(filename, description, 
    714                                    StdString ("CF-1.1"), 
    715                                    StdString("An IPSL model"), 
    716                                    this->getTimeStamp()); 
     777         try 
     778         { 
     779           this->writeFileAttributes(filename, description, 
     780                                     StdString ("CF-1.1"), 
     781                                     StdString("An IPSL model"), 
     782                                     this->getTimeStamp()); 
     783         } 
     784         catch (CNetCdfException& e) 
     785         { 
     786           StdString msg("On writing file : "); 
     787           msg.append(filename); msg.append("\n"); 
     788           msg.append("In the context : "); 
     789           CContext* context = CContext::getCurrent() ; 
     790           msg.append(context->getId()); msg.append("\n"); 
     791           msg.append(e.what()); 
     792           ERROR("CNc4DataOutput::writeFile_ (CFile* file)", << msg); 
     793         } 
    717794         if (file->nbDomain==1) singleDomain=true ; 
    718795         else singleDomain=false ; 
    … …  
    726803        else return ; 
    727804 
    728         if (var->getVarType()==CVariable::t_int) addAttribute(name,var->getData<int>(),&fieldId) ; 
    729         else if (var->getVarType()==CVariable::t_short_int) addAttribute(name,var->getData<short int>(),&fieldId) ; 
    730         else if (var->getVarType()==CVariable::t_long_int) addAttribute(name,var->getData<long int>(),&fieldId) ; 
    731         else if (var->getVarType()==CVariable::t_float) addAttribute(name,var->getData<float>(),&fieldId) ; 
    732         else if (var->getVarType()==CVariable::t_double) addAttribute(name,var->getData<double>(),&fieldId) ; 
    733         else addAttribute(name,var->getData<string>(),&fieldId) ; 
     805        try 
     806        { 
     807          if (var->getVarType()==CVariable::t_int) addAttribute(name,var->getData<int>(),&fieldId) ; 
     808          else if (var->getVarType()==CVariable::t_short_int) addAttribute(name,var->getData<short int>(),&fieldId) ; 
     809          else if (var->getVarType()==CVariable::t_long_int) addAttribute(name,var->getData<long int>(),&fieldId) ; 
     810          else if (var->getVarType()==CVariable::t_float) addAttribute(name,var->getData<float>(),&fieldId) ; 
     811          else if (var->getVarType()==CVariable::t_double) addAttribute(name,var->getData<double>(),&fieldId) ; 
     812          else addAttribute(name,var->getData<string>(),&fieldId) ; 
     813        } 
     814       catch (CNetCdfException& e) 
     815       { 
     816         StdString msg("On writing attributes of variable with name : "); 
     817         msg.append(name); msg.append("in the field "); msg.append(fieldId); msg.append("\n"); 
     818         msg.append("In the context : "); 
     819         CContext* context = CContext::getCurrent() ; 
     820         msg.append(context->getId()); msg.append("\n"); 
     821         msg.append(e.what()); 
     822         ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)", << msg); 
     823       } 
    734824     } 
    735825 
    … …  
    740830        else if (var->hasId()) name=var->getId() ; 
    741831        else return ; 
    742  
    743         if (var->getVarType()==CVariable::t_int) addAttribute(name,var->getData<int>()) ; 
    744         else if (var->getVarType()==CVariable::t_short_int) addAttribute(name,var->getData<short int>()) ; 
    745         else if (var->getVarType()==CVariable::t_long_int) addAttribute(name,var->getData<long int>()) ; 
    746         else if (var->getVarType()==CVariable::t_float) addAttribute(name,var->getData<float>()) ; 
    747         else if (var->getVarType()==CVariable::t_double) addAttribute(name,var->getData<double>()) ; 
    748         else addAttribute(name,var->getData<string>()) ; 
     832        try 
     833        { 
     834          if (var->getVarType()==CVariable::t_int) addAttribute(name,var->getData<int>()) ; 
     835          else if (var->getVarType()==CVariable::t_short_int) addAttribute(name,var->getData<short int>()) ; 
     836          else if (var->getVarType()==CVariable::t_long_int) addAttribute(name,var->getData<long int>()) ; 
     837          else if (var->getVarType()==CVariable::t_float) addAttribute(name,var->getData<float>()) ; 
     838          else if (var->getVarType()==CVariable::t_double) addAttribute(name,var->getData<double>()) ; 
     839          else addAttribute(name,var->getData<string>()) ; 
     840        } 
     841       catch (CNetCdfException& e) 
     842       { 
     843         StdString msg("On writing attributes of variable with name : "); 
     844         msg.append(name); msg.append("\n"); 
     845         msg.append("In the context : "); 
     846         CContext* context = CContext::getCurrent() ; 
     847         msg.append(context->getId()); msg.append("\n"); 
     848         msg.append(e.what()); 
     849         ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var)", << msg); 
     850       } 
    749851     } 
    750852 
    751853      void CNc4DataOutput::syncFile_ (void) 
    752854      { 
    753          SuperClassWriter::sync() ; 
     855        try 
     856        { 
     857          SuperClassWriter::sync() ; 
     858        } 
     859        catch (CNetCdfException& e) 
     860        { 
     861         StdString msg("On synchronizing the write among processes"); 
     862         msg.append("In the context : "); 
     863         CContext* context = CContext::getCurrent() ; 
     864         msg.append(context->getId()); msg.append("\n"); 
     865         msg.append(e.what()); 
     866         ERROR("CNc4DataOutput::syncFile_ (void)", << msg); 
     867        } 
    754868      } 
    755869 
    756870      void CNc4DataOutput::closeFile_ (void) 
    757871      { 
    758          SuperClassWriter::close() ; 
     872        try 
     873        { 
     874          SuperClassWriter::close() ; 
     875        } 
     876        catch (CNetCdfException& e) 
     877        { 
     878         StdString msg("On closing file"); 
     879         msg.append("In the context : "); 
     880         CContext* context = CContext::getCurrent() ; 
     881         msg.append(context->getId()); msg.append("\n"); 
     882         msg.append(e.what()); 
     883         ERROR("CNc4DataOutput::syncFile_ (void)", << msg); 
     884        } 
     885 
    759886      } 
    760887 
    … …  
    842969         } 
    843970 
    844          if (grid->hasAxis()) // 3D 
    845          { 
    846             CAxis* axis = grid->axis ; 
    847             CArray<double,3> field_data3D(domain->zoom_ni_srv,domain->zoom_nj_srv,axis->zoom_size) ; 
    848             if (!field->default_value.isEmpty()) field_data3D = field->default_value ; 
    849  
    850             field->outputField(field_data3D); 
    851  
    852             if (!field->prec.isEmpty() && field->prec==2) field_data3D=round(field_data3D) ; 
    853  
    854             switch (SuperClass::type) 
     971         try 
     972         { 
     973           if (grid->hasAxis()) // 3D 
    855974           { 
    856               case (MULTI_FILE) : 
     975              CAxis* axis = grid->axis ; 
     976              CArray<double,3> field_data3D(domain->zoom_ni_srv,domain->zoom_nj_srv,axis->zoom_size) ; 
     977              if (!field->default_value.isEmpty()) field_data3D = field->default_value ; 
     978 
     979              field->outputField(field_data3D); 
     980 
     981              if (!field->prec.isEmpty() && field->prec==2) field_data3D=round(field_data3D) ; 
     982 
     983              switch (SuperClass::type) 
     984             { 
     985                case (MULTI_FILE) : 
     986                { 
     987                   SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1); 
     988                   if (wtime) 
     989                   { 
     990                     SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
     991                     SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
     992                     SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
     993                     SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
     994                   } 
     995                   break ; 
     996                } 
     997                case (ONE_FILE) : 
     998                { 
     999                   std::vector<StdSize> start(3) ; 
     1000                   std::vector<StdSize> count(3) ; 
     1001                   if (domain->isEmpty()) 
     1002                   { 
     1003                     start[0]=0 ; start[1]=0 ; start[2]=0 ; 
     1004                     count[0]=0 ; count[1]=0 ; start[2]=0 ; 
     1005                   } 
     1006                   else 
     1007                   { 
     1008  //                 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 ; 
     1009                     start[2]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; start[0]=0 ; 
     1010                     count[2]=domain->zoom_ni_srv ; count[1]=domain->zoom_nj_srv ; count[0] = axis->zoom_size.getValue(); 
     1011                   } 
     1012                   SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1,&start,&count ); 
     1013                   if (wtime) 
     1014                   { 
     1015                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot ); 
     1016                     SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot ); 
     1017                     SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot ); 
     1018                     SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
     1019                   } 
     1020                   break; 
     1021                } 
     1022              } 
     1023 
     1024           } 
     1025           else // 2D 
     1026           { 
     1027              CArray<double,2> field_data2D(domain->zoom_ni_srv,domain->zoom_nj_srv) ; 
     1028              if (!field->default_value.isEmpty()) field_data2D = field->default_value ; 
     1029              field->outputField(field_data2D); 
     1030              if (!field->prec.isEmpty() && field->prec==2) field_data2D=round(field_data2D) ; 
     1031              switch (SuperClass::type) 
    8571032              { 
    858                  SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1); 
    859                  if (wtime) 
    860                  { 
    861                    SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
    862                    SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
    863                    SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
    864                    SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
    865                  } 
    866                  break ; 
     1033                case (MULTI_FILE) : 
     1034                { 
     1035                  SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1); 
     1036                  if (wtime) 
     1037                  { 
     1038                    SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
     1039                    SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
     1040                    SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
     1041                    SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
     1042                  } 
     1043                  break; 
     1044                } 
     1045                case (ONE_FILE) : 
     1046                { 
     1047                   std::vector<StdSize> start(2) ; 
     1048                   std::vector<StdSize> count(2) ; 
     1049                   if (domain->isEmpty()) 
     1050                   { 
     1051                     start[0]=0 ; start[1]=0 ; 
     1052                     count[0]=0 ; count[1]=0 ; 
     1053                   } 
     1054                   else 
     1055                   { 
     1056                     start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
     1057                     count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ; 
     1058                   } 
     1059 
     1060                   SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1,&start,&count); 
     1061                   if (wtime) 
     1062                   { 
     1063                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot); 
     1064                     SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot); 
     1065                     SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot); 
     1066                     SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
     1067                   } 
     1068                   break; 
     1069 
     1070                } 
    8671071              } 
    868               case (ONE_FILE) : 
    869               { 
    870                  std::vector<StdSize> start(3) ; 
    871                  std::vector<StdSize> count(3) ; 
    872                  if (domain->isEmpty()) 
    873                  { 
    874                    start[0]=0 ; start[1]=0 ; start[2]=0 ; 
    875                    count[0]=0 ; count[1]=0 ; start[2]=0 ; 
    876                  } 
    877                  else 
    878                  { 
    879 //                 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 ; 
    880                    start[2]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; start[0]=0 ; 
    881                    count[2]=domain->zoom_ni_srv ; count[1]=domain->zoom_nj_srv ; count[0] = axis->zoom_size.getValue(); 
    882                  } 
    883                  SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1,&start,&count ); 
    884                  if (wtime) 
    885                  { 
    886                    SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot ); 
    887                    SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot ); 
    888                    SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot ); 
    889                    SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
    890                  } 
    891                  break; 
    892               } 
    893             } 
    894  
    895          } 
    896          else // 2D 
    897          { 
    898             CArray<double,2> field_data2D(domain->zoom_ni_srv,domain->zoom_nj_srv) ; 
    899             if (!field->default_value.isEmpty()) field_data2D = field->default_value ; 
    900             field->outputField(field_data2D); 
    901             if (!field->prec.isEmpty() && field->prec==2) field_data2D=round(field_data2D) ; 
    902             switch (SuperClass::type) 
    903             { 
    904               case (MULTI_FILE) : 
    905               { 
    906                 SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1); 
    907                 if (wtime) 
    908                 { 
    909                   SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
    910                   SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
    911                   SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
    912                   SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
    913                 } 
    914                 break; 
    915               } 
    916               case (ONE_FILE) : 
    917               { 
    918                  std::vector<StdSize> start(2) ; 
    919                  std::vector<StdSize> count(2) ; 
    920                  if (domain->isEmpty()) 
    921                  { 
    922                    start[0]=0 ; start[1]=0 ; 
    923                    count[0]=0 ; count[1]=0 ; 
    924                  } 
    925                  else 
    926                  { 
    927                    start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
    928                    count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ; 
    929                  } 
    930  
    931                  SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1,&start,&count); 
    932                  if (wtime) 
    933                  { 
    934                    SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot); 
    935                    SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot); 
    936                    SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot); 
    937                    SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
    938                  } 
    939                  break; 
    940  
    941               } 
    942             } 
     1072           } 
     1073         } 
     1074         catch (CNetCdfException& e) 
     1075         { 
     1076           StdString msg("On writing field data: "); 
     1077           msg.append(fieldid); msg.append("\n"); 
     1078           msg.append("In the context : "); 
     1079           msg.append(context->getId()); msg.append("\n"); 
     1080           msg.append(e.what()); 
     1081           ERROR("CNc4DataOutput::writeFieldData_ (CField*  field)", << msg); 
    9431082         } 
    9441083      } 
    … …  
    9731112         } 
    9741113 
    975          // Adding time_instant or time_centered 
    976          std::vector<StdString> dims; 
    977          dims.push_back(timeid); 
    978          if (!SuperClassWriter::varExist(axisid)) 
    979          { 
    980             SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims); 
    981  
    982             CDate timeOrigin=cal->getTimeOrigin() ; 
    983             StdOStringStream oss2; 
    984 //            oss2<<initDate.getYear()<<"-"<<initDate.getMonth()<<"-"<<initDate.getDay()<<" " 
    985 //                <<initDate.getHour()<<"-"<<initDate.getMinute()<<"-"<<initDate.getSecond() ; 
    986             StdString strInitdate=oss2.str() ; 
    987             StdString strTimeOrigin=timeOrigin.toString() ; 
    988             this->writeTimeAxisAttributes 
    989                (axisid, cal->getType(), 
    990                 StdString("seconds since ").append(strTimeOrigin), 
    991                 strTimeOrigin, axisBoundId); 
    992          } 
    993  
    994          // Adding time_instant_bounds or time_centered_bounds variables 
    995          if (!SuperClassWriter::varExist(axisBoundId)) 
    996          { 
    997             dims.clear() ; 
    998             dims.push_back(timeid); 
    999             dims.push_back(timeBoundId); 
    1000             SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims); 
    1001          } 
    1002  
    1003          // Adding time_counter 
    1004          axisid = "time_counter" ; 
    1005          axisBoundId = "time_counter_bounds" ; 
    1006          dims.clear() ; 
    1007          dims.push_back(timeid); 
    1008          if (!SuperClassWriter::varExist(axisid)) 
    1009          { 
    1010             SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims); 
    1011             SuperClassWriter::addAttribute("axis", string("T"), &axisid); 
    1012             CDate timeOrigin=cal->getTimeOrigin() ; 
    1013             StdString strTimeOrigin=timeOrigin.toString() ; 
    1014  
    1015             this->writeTimeAxisAttributes 
    1016                (axisid, cal->getType(), 
    1017                 StdString("seconds since ").append(strTimeOrigin), 
    1018                 strTimeOrigin, axisBoundId); 
    1019          } 
    1020  
    1021          // Adding time_counter_bound dimension 
    1022          if (!SuperClassWriter::varExist(axisBoundId)) 
    1023          { 
    1024             dims.clear(); 
    1025             dims.push_back(timeid); 
    1026             dims.push_back(timeBoundId); 
    1027             SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims); 
     1114         try 
     1115         { 
     1116          // Adding time_instant or time_centered 
     1117           std::vector<StdString> dims; 
     1118           dims.push_back(timeid); 
     1119           if (!SuperClassWriter::varExist(axisid)) 
     1120           { 
     1121              SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims); 
     1122 
     1123              CDate timeOrigin=cal->getTimeOrigin() ; 
     1124              StdOStringStream oss2; 
     1125  //            oss2<<initDate.getYear()<<"-"<<initDate.getMonth()<<"-"<<initDate.getDay()<<" " 
     1126  //                <<initDate.getHour()<<"-"<<initDate.getMinute()<<"-"<<initDate.getSecond() ; 
     1127              StdString strInitdate=oss2.str() ; 
     1128              StdString strTimeOrigin=timeOrigin.toString() ; 
     1129              this->writeTimeAxisAttributes 
     1130                 (axisid, cal->getType(), 
     1131                  StdString("seconds since ").append(strTimeOrigin), 
     1132                  strTimeOrigin, axisBoundId); 
     1133           } 
     1134 
     1135           // Adding time_instant_bounds or time_centered_bounds variables 
     1136           if (!SuperClassWriter::varExist(axisBoundId)) 
     1137           { 
     1138              dims.clear() ; 
     1139              dims.push_back(timeid); 
     1140              dims.push_back(timeBoundId); 
     1141              SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims); 
     1142           } 
     1143 
     1144           // Adding time_counter 
     1145           axisid = "time_counter" ; 
     1146           axisBoundId = "time_counter_bounds" ; 
     1147           dims.clear() ; 
     1148           dims.push_back(timeid); 
     1149           if (!SuperClassWriter::varExist(axisid)) 
     1150           { 
     1151              SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims); 
     1152              SuperClassWriter::addAttribute("axis", string("T"), &axisid); 
     1153              CDate timeOrigin=cal->getTimeOrigin() ; 
     1154              StdString strTimeOrigin=timeOrigin.toString() ; 
     1155 
     1156              this->writeTimeAxisAttributes 
     1157                 (axisid, cal->getType(), 
     1158                  StdString("seconds since ").append(strTimeOrigin), 
     1159                  strTimeOrigin, axisBoundId); 
     1160           } 
     1161 
     1162           // Adding time_counter_bound dimension 
     1163           if (!SuperClassWriter::varExist(axisBoundId)) 
     1164           { 
     1165              dims.clear(); 
     1166              dims.push_back(timeid); 
     1167              dims.push_back(timeBoundId); 
     1168              SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims); 
     1169           } 
     1170         } 
     1171         catch (CNetCdfException& e) 
     1172         { 
     1173           StdString msg("On writing time axis data: "); 
     1174           msg.append("In the context : "); 
     1175           CContext* context = CContext::getCurrent() ; 
     1176           msg.append(context->getId()); msg.append("\n"); 
     1177           msg.append(e.what()); 
     1178           ERROR("CNc4DataOutput::writeTimeAxis_ (CField*    field, \ 
     1179                  const boost::shared_ptr<CCalendar> cal)", << msg); 
    10281180         } 
    10291181      } 
    … …  
    10401192                                                   const StdString & title) 
    10411193      { 
    1042          SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name); 
    1043          SuperClassWriter::addAttribute("long_name",     long_name    , &axis_name); 
    1044          SuperClassWriter::addAttribute("title",         title        , &axis_name); 
    1045          SuperClassWriter::addAttribute("calendar",      calendar     , &axis_name); 
    1046          SuperClassWriter::addAttribute("units",         units        , &axis_name); 
    1047          SuperClassWriter::addAttribute("time_origin",   time_origin  , &axis_name); 
    1048          SuperClassWriter::addAttribute("bounds",        time_bounds  , &axis_name); 
     1194         try 
     1195         { 
     1196           SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name); 
     1197           SuperClassWriter::addAttribute("long_name",     long_name    , &axis_name); 
     1198           SuperClassWriter::addAttribute("title",         title        , &axis_name); 
     1199           SuperClassWriter::addAttribute("calendar",      calendar     , &axis_name); 
     1200           SuperClassWriter::addAttribute("units",         units        , &axis_name); 
     1201           SuperClassWriter::addAttribute("time_origin",   time_origin  , &axis_name); 
     1202           SuperClassWriter::addAttribute("bounds",        time_bounds  , &axis_name); 
     1203         } 
     1204         catch (CNetCdfException& e) 
     1205         { 
     1206           StdString msg("On writing time axis Attribute: "); 
     1207           msg.append("In the context : "); 
     1208           CContext* context = CContext::getCurrent() ; 
     1209           msg.append(context->getId()); msg.append("\n"); 
     1210           msg.append(e.what()); 
     1211           ERROR("CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name, \ 
     1212                                                   const StdString & calendar,\ 
     1213                                                   const StdString & units, \ 
     1214                                                   const StdString & time_origin, \ 
     1215                                                   const StdString & time_bounds, \ 
     1216                                                   const StdString & standard_name, \ 
     1217                                                   const StdString & long_name, \ 
     1218                                                   const StdString & title)", << msg); 
     1219         } 
    10491220      } 
    10501221 
    … …  
    10581229                                               const StdString & nav_model) 
    10591230      { 
    1060          SuperClassWriter::addAttribute("axis"         , axis         , &axis_name); 
    1061          SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name); 
    1062          SuperClassWriter::addAttribute("long_name"    , long_name    , &axis_name); 
    1063          SuperClassWriter::addAttribute("units"        , units        , &axis_name); 
    1064          SuperClassWriter::addAttribute("nav_model"    , nav_model    , &axis_name); 
     1231         try 
     1232         { 
     1233          SuperClassWriter::addAttribute("axis"         , axis         , &axis_name); 
     1234          SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name); 
     1235          SuperClassWriter::addAttribute("long_name"    , long_name    , &axis_name); 
     1236          SuperClassWriter::addAttribute("units"        , units        , &axis_name); 
     1237          SuperClassWriter::addAttribute("nav_model"    , nav_model    , &axis_name); 
     1238         } 
     1239         catch (CNetCdfException& e) 
     1240         { 
     1241           StdString msg("On writing Axis Attribute: "); 
     1242           msg.append("In the context : "); 
     1243           CContext* context = CContext::getCurrent() ; 
     1244           msg.append(context->getId()); msg.append("\n"); 
     1245           msg.append(e.what()); 
     1246           ERROR("CNc4DataOutput::writeAxisAttributes(const StdString & axis_name, \ 
     1247                                               const StdString & axis, \ 
     1248                                               const StdString & standard_name, \ 
     1249                                               const StdString & long_name, \ 
     1250                                               const StdString & units, \ 
     1251                                               const StdString & nav_model)", << msg); 
     1252         } 
    10651253      } 
    10661254 
    … …  
    10701258         (int ibegin, int ni, int jbegin, int nj, StdString domid) 
    10711259      { 
     1260        try 
     1261        { 
    10721262         SuperClassWriter::addAttribute(StdString("ibegin").append(domid), ibegin); 
    10731263         SuperClassWriter::addAttribute(StdString("ni"    ).append(domid), ni); 
    10741264         SuperClassWriter::addAttribute(StdString("jbegin").append(domid), jbegin); 
    10751265         SuperClassWriter::addAttribute(StdString("nj"    ).append(domid), nj); 
     1266        } 
     1267        catch (CNetCdfException& e) 
     1268        { 
     1269           StdString msg("On writing Local Attributes: "); 
     1270           msg.append("In the context : "); 
     1271           CContext* context = CContext::getCurrent() ; 
     1272           msg.append(context->getId()); msg.append("\n"); 
     1273           msg.append(e.what()); 
     1274           ERROR("CNc4DataOutput::writeLocalAttributes \ 
     1275                  (int ibegin, int ni, int jbegin, int nj, StdString domid)", << msg); 
     1276        } 
     1277 
    10761278      } 
    10771279 
    … …  
    10811283         CArray<int,1> array(2) ; 
    10821284 
    1083          SuperClassWriter::addAttribute("DOMAIN_number_total",size ) ; 
    1084          SuperClassWriter::addAttribute("DOMAIN_number", rank) ; 
    1085          array=1,2 ; 
    1086          SuperClassWriter::addAttribute("DOMAIN_dimensions_ids",array) ; 
    1087          array=ni_glo,nj_glo ; 
    1088          SuperClassWriter::addAttribute("DOMAIN_size_global", array) ; 
    1089          array=ni,nj ; 
    1090          SuperClassWriter::addAttribute("DOMAIN_size_local", array) ; 
    1091          array=ibegin,jbegin ; 
    1092          SuperClassWriter::addAttribute("DOMAIN_position_first", array) ; 
    1093          array=ibegin+ni-1,jbegin+nj-1 ; 
    1094          SuperClassWriter::addAttribute("DOMAIN_position_last",array) ; 
    1095          array=0,0 ; 
    1096          SuperClassWriter::addAttribute("DOMAIN_halo_size_start", array) ; 
    1097          SuperClassWriter::addAttribute("DOMAIN_halo_size_end", array); 
    1098          SuperClassWriter::addAttribute("DOMAIN_type",string("box")) ; 
    1099 /* 
    1100          SuperClassWriter::addAttribute("DOMAIN_DIM_N001",string("x")) ; 
    1101          SuperClassWriter::addAttribute("DOMAIN_DIM_N002",string("y")) ; 
    1102          SuperClassWriter::addAttribute("DOMAIN_DIM_N003",string("axis_A")) ; 
    1103          SuperClassWriter::addAttribute("DOMAIN_DIM_N004",string("time_counter")) ; 
    1104 */ 
    1105  
     1285         try 
     1286         { 
     1287           SuperClassWriter::addAttribute("DOMAIN_number_total",size ) ; 
     1288           SuperClassWriter::addAttribute("DOMAIN_number", rank) ; 
     1289           array=1,2 ; 
     1290           SuperClassWriter::addAttribute("DOMAIN_dimensions_ids",array) ; 
     1291           array=ni_glo,nj_glo ; 
     1292           SuperClassWriter::addAttribute("DOMAIN_size_global", array) ; 
     1293           array=ni,nj ; 
     1294           SuperClassWriter::addAttribute("DOMAIN_size_local", array) ; 
     1295           array=ibegin,jbegin ; 
     1296           SuperClassWriter::addAttribute("DOMAIN_position_first", array) ; 
     1297           array=ibegin+ni-1,jbegin+nj-1 ; 
     1298           SuperClassWriter::addAttribute("DOMAIN_position_last",array) ; 
     1299           array=0,0 ; 
     1300           SuperClassWriter::addAttribute("DOMAIN_halo_size_start", array) ; 
     1301           SuperClassWriter::addAttribute("DOMAIN_halo_size_end", array); 
     1302           SuperClassWriter::addAttribute("DOMAIN_type",string("box")) ; 
     1303  /* 
     1304           SuperClassWriter::addAttribute("DOMAIN_DIM_N001",string("x")) ; 
     1305           SuperClassWriter::addAttribute("DOMAIN_DIM_N002",string("y")) ; 
     1306           SuperClassWriter::addAttribute("DOMAIN_DIM_N003",string("axis_A")) ; 
     1307           SuperClassWriter::addAttribute("DOMAIN_DIM_N004",string("time_counter")) ; 
     1308  */ 
     1309         } 
     1310         catch (CNetCdfException& e) 
     1311         { 
     1312           StdString msg("On writing Local Attributes IOI PSL \n"); 
     1313           msg.append("In the context : "); 
     1314           CContext* context = CContext::getCurrent() ; 
     1315           msg.append(context->getId()); msg.append("\n"); 
     1316           msg.append(e.what()); 
     1317           ERROR("CNc4DataOutput::writeLocalAttributes_IOIPSL \ 
     1318                  (int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size)", << msg); 
     1319         } 
    11061320      } 
    11071321      //--------------------------------------------------------------- 
    … …  
    11131327                                                const StdString & timeStamp) 
    11141328      { 
    1115          SuperClassWriter::addAttribute("name"       , name); 
    1116          SuperClassWriter::addAttribute("description", description); 
    1117          SuperClassWriter::addAttribute("conventions", conventions); 
    1118          SuperClassWriter::addAttribute("production" , production); 
    1119          SuperClassWriter::addAttribute("timeStamp"  , timeStamp); 
     1329         try 
     1330         { 
     1331           SuperClassWriter::addAttribute("name"       , name); 
     1332           SuperClassWriter::addAttribute("description", description); 
     1333           SuperClassWriter::addAttribute("conventions", conventions); 
     1334           SuperClassWriter::addAttribute("production" , production); 
     1335           SuperClassWriter::addAttribute("timeStamp"  , timeStamp); 
     1336         } 
     1337         catch (CNetCdfException& e) 
     1338         { 
     1339           StdString msg("On writing File Attributes \n "); 
     1340           msg.append("In the context : "); 
     1341           CContext* context = CContext::getCurrent() ; 
     1342           msg.append(context->getId()); msg.append("\n"); 
     1343           msg.append(e.what()); 
     1344           ERROR("CNc4DataOutput:: writeFileAttributes(const StdString & name, \ 
     1345                                                const StdString & description, \ 
     1346                                                const StdString & conventions, \ 
     1347                                                const StdString & production, \ 
     1348                                                const StdString & timeStamp)", << msg); 
     1349         } 
    11201350      } 
    11211351 
    … …  
    11291359                                               int data_jbegin) 
    11301360      { 
    1131          SuperClassWriter::addAttribute("data_dim"   , data_dim   , &mask_name); 
    1132          SuperClassWriter::addAttribute("data_ni"    , data_ni    , &mask_name); 
    1133          SuperClassWriter::addAttribute("data_nj"    , data_nj    , &mask_name); 
    1134          SuperClassWriter::addAttribute("data_ibegin", data_ibegin, &mask_name); 
    1135          SuperClassWriter::addAttribute("data_jbegin", data_jbegin, &mask_name); 
     1361         try 
     1362         { 
     1363           SuperClassWriter::addAttribute("data_dim"   , data_dim   , &mask_name); 
     1364           SuperClassWriter::addAttribute("data_ni"    , data_ni    , &mask_name); 
     1365           SuperClassWriter::addAttribute("data_nj"    , data_nj    , &mask_name); 
     1366           SuperClassWriter::addAttribute("data_ibegin", data_ibegin, &mask_name); 
     1367           SuperClassWriter::addAttribute("data_jbegin", data_jbegin, &mask_name); 
     1368         } 
     1369         catch (CNetCdfException& e) 
     1370         { 
     1371           StdString msg("On writing Mask Attributes \n "); 
     1372           msg.append("In the context : "); 
     1373           CContext* context = CContext::getCurrent() ; 
     1374           msg.append(context->getId()); msg.append("\n"); 
     1375           msg.append(e.what()); 
     1376           ERROR("CNc4DataOutput::writeMaskAttributes(const StdString & mask_name, \ 
     1377                                               int data_dim, \ 
     1378                                               int data_ni, \ 
     1379                                               int data_nj, \ 
     1380                                               int data_ibegin, \ 
     1381                                               int data_jbegin)", << msg); 
     1382         } 
    11361383      } 
    11371384 
Note: See TracChangeset for help on using the changeset viewer.