Changeset 666


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

Change name of several axis attributes and remove some redundant variable of domain

+) Change name of axis attributes to make them consistent with ones of domain
+) Remove zoom_client_* of domain

Test
+) On Curie
+) All tests pass and are correct

Location:
XIOS/trunk
Files:
30 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/inputs/REMAP/iodef.xml

    r664 r666  
    2727   <domain_definition> 
    2828     <domain id="src_domain" /> 
    29      <domain id="dst_domain" > 
     29     <domain id="dst_domain" domain_ref="src_domain"> 
    3030       <interpolate_from_file_domain file="weight.nc" /> 
    3131     </domain> 
  • XIOS/trunk/src/config/axis_attribute.conf

    r633 r666  
    55DECLARE_ATTRIBUTE(StdString, unit) 
    66 
    7 DECLARE_ATTRIBUTE(int,       size) 
    8 DECLARE_ATTRIBUTE(int,       zoom_begin) 
    9 DECLARE_ATTRIBUTE(int,       zoom_end) 
    10 DECLARE_ATTRIBUTE(int,       zoom_size) 
     7DECLARE_ATTRIBUTE(int,       n_glo) 
    118DECLARE_ENUM2(positive, up, down) 
    129 
     
    2219 
    2320/*LOCAL */ 
    24 DECLARE_ATTRIBUTE(int,       ibegin) 
    25 DECLARE_ATTRIBUTE(int,       ni) 
     21DECLARE_ATTRIBUTE(int,       begin) 
     22DECLARE_ATTRIBUTE(int,       n) 
    2623 
    2724/* LOCAL */ 
  • XIOS/trunk/src/config/domain_attribute.conf

    r664 r666  
    3737 
    3838/* LOCAL */ 
    39 DECLARE_ATTRIBUTE(int             , data_n_index) 
    4039DECLARE_ARRAY(int, 1 , data_i_index) 
    4140DECLARE_ARRAY(int, 1,  data_j_index) 
    4241 
    4342/* LOCAL */ 
    44 //DECLARE_ARRAY(double, 1, lonvalue) 
    45 //DECLARE_ARRAY(double, 1, latvalue) 
    4643DECLARE_ARRAY(double, 1, lonvalue_1d) 
    4744DECLARE_ARRAY(double, 1, latvalue_1d) 
     
    5047 
    5148DECLARE_ATTRIBUTE(int, nvertex) 
    52 //DECLARE_ARRAY(double, 2, bounds_lon) 
    53 //DECLARE_ARRAY(double, 2, bounds_lat) 
    5449DECLARE_ARRAY(double, 2, bounds_lon_1d) 
    5550DECLARE_ARRAY(double, 2, bounds_lat_1d) 
  • XIOS/trunk/src/distribution_client.cpp

    r664 r666  
    9999  for (int k = 0; k < axisSize; ++k) 
    100100  { 
    101     int n = axisList[k]->ni; 
     101    int n = axisList[k]->n; 
    102102    nIndexAxis_[k].resize(n); 
    103103    for (int i = 0; i < n; ++i) 
     
    221221    else // So it's an axis 
    222222    { 
    223       nLocal_.at(indexMap_[idx]) = axisList[axisIndex]->ni.getValue(); 
    224       nGlob_.at(indexMap_[idx]) = axisList[axisIndex]->size.getValue(); 
     223      nLocal_.at(indexMap_[idx]) = axisList[axisIndex]->n.getValue(); 
     224      nGlob_.at(indexMap_[idx]) = axisList[axisIndex]->n_glo.getValue(); 
    225225      nBeginLocal_.at(indexMap_[idx]) = 0; 
    226       nBeginGlobal_.at(indexMap_[idx]) = axisList[axisIndex]->ibegin.getValue(); 
     226      nBeginGlobal_.at(indexMap_[idx]) = axisList[axisIndex]->begin.getValue(); 
    227227      nZoomBegin_.at((indexMap_[idx])) = axisList[axisIndex]->global_zoom_begin; 
    228228      nZoomEnd_.at((indexMap_[idx])) = axisList[axisIndex]->global_zoom_begin + axisList[axisIndex]->global_zoom_size-1; 
     
    636636{ 
    637637   int tempI = dataIndex + dataBegin; 
    638    return ((tempI-1)%ni); 
     638   return ((tempI)%ni); 
    639639} 
    640640 
  • XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp

    r609 r666  
    4444 
    4545 
     46  void cxios_set_axis_begin(axis_Ptr axis_hdl, int begin) 
     47  { 
     48    CTimer::get("XIOS").resume(); 
     49    axis_hdl->begin.setValue(begin); 
     50    CTimer::get("XIOS").suspend(); 
     51  } 
     52 
     53  void cxios_get_axis_begin(axis_Ptr axis_hdl, int* begin) 
     54  { 
     55    CTimer::get("XIOS").resume(); 
     56    *begin = axis_hdl->begin.getInheritedValue(); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_axis_begin(axis_Ptr axis_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = axis_hdl->begin.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    4669  void cxios_set_axis_bounds(axis_Ptr axis_hdl, double* bounds, int extent1, int extent2) 
    4770  { 
     
    140163 
    141164 
    142   void cxios_set_axis_ibegin(axis_Ptr axis_hdl, int ibegin) 
    143   { 
    144     CTimer::get("XIOS").resume(); 
    145     axis_hdl->ibegin.setValue(ibegin); 
    146     CTimer::get("XIOS").suspend(); 
    147   } 
    148  
    149   void cxios_get_axis_ibegin(axis_Ptr axis_hdl, int* ibegin) 
    150   { 
    151     CTimer::get("XIOS").resume(); 
    152     *ibegin = axis_hdl->ibegin.getInheritedValue(); 
    153     CTimer::get("XIOS").suspend(); 
    154   } 
    155  
    156   bool cxios_is_defined_axis_ibegin(axis_Ptr axis_hdl) 
    157   { 
    158      CTimer::get("XIOS").resume(); 
    159      bool isDefined = axis_hdl->ibegin.hasInheritedValue(); 
    160      CTimer::get("XIOS").suspend(); 
    161      return isDefined; 
    162   } 
    163  
    164  
    165165  void cxios_set_axis_long_name(axis_Ptr axis_hdl, const char * long_name, int long_name_size) 
    166166  { 
     
    214214 
    215215 
     216  void cxios_set_axis_n(axis_Ptr axis_hdl, int n) 
     217  { 
     218    CTimer::get("XIOS").resume(); 
     219    axis_hdl->n.setValue(n); 
     220    CTimer::get("XIOS").suspend(); 
     221  } 
     222 
     223  void cxios_get_axis_n(axis_Ptr axis_hdl, int* n) 
     224  { 
     225    CTimer::get("XIOS").resume(); 
     226    *n = axis_hdl->n.getInheritedValue(); 
     227    CTimer::get("XIOS").suspend(); 
     228  } 
     229 
     230  bool cxios_is_defined_axis_n(axis_Ptr axis_hdl) 
     231  { 
     232     CTimer::get("XIOS").resume(); 
     233     bool isDefined = axis_hdl->n.hasInheritedValue(); 
     234     CTimer::get("XIOS").suspend(); 
     235     return isDefined; 
     236  } 
     237 
     238 
     239  void cxios_set_axis_n_glo(axis_Ptr axis_hdl, int n_glo) 
     240  { 
     241    CTimer::get("XIOS").resume(); 
     242    axis_hdl->n_glo.setValue(n_glo); 
     243    CTimer::get("XIOS").suspend(); 
     244  } 
     245 
     246  void cxios_get_axis_n_glo(axis_Ptr axis_hdl, int* n_glo) 
     247  { 
     248    CTimer::get("XIOS").resume(); 
     249    *n_glo = axis_hdl->n_glo.getInheritedValue(); 
     250    CTimer::get("XIOS").suspend(); 
     251  } 
     252 
     253  bool cxios_is_defined_axis_n_glo(axis_Ptr axis_hdl) 
     254  { 
     255     CTimer::get("XIOS").resume(); 
     256     bool isDefined = axis_hdl->n_glo.hasInheritedValue(); 
     257     CTimer::get("XIOS").suspend(); 
     258     return isDefined; 
     259  } 
     260 
     261 
    216262  void cxios_set_axis_name(axis_Ptr axis_hdl, const char * name, int name_size) 
    217263  { 
     
    240286 
    241287 
    242   void cxios_set_axis_ni(axis_Ptr axis_hdl, int ni) 
    243   { 
    244     CTimer::get("XIOS").resume(); 
    245     axis_hdl->ni.setValue(ni); 
    246     CTimer::get("XIOS").suspend(); 
    247   } 
    248  
    249   void cxios_get_axis_ni(axis_Ptr axis_hdl, int* ni) 
    250   { 
    251     CTimer::get("XIOS").resume(); 
    252     *ni = axis_hdl->ni.getInheritedValue(); 
    253     CTimer::get("XIOS").suspend(); 
    254   } 
    255  
    256   bool cxios_is_defined_axis_ni(axis_Ptr axis_hdl) 
    257   { 
    258      CTimer::get("XIOS").resume(); 
    259      bool isDefined = axis_hdl->ni.hasInheritedValue(); 
    260      CTimer::get("XIOS").suspend(); 
    261      return isDefined; 
    262   } 
    263  
    264  
    265288  void cxios_set_axis_positive(axis_Ptr axis_hdl, const char * positive, int positive_size) 
    266289  { 
     
    289312 
    290313 
    291   void cxios_set_axis_size(axis_Ptr axis_hdl, int size) 
    292   { 
    293     CTimer::get("XIOS").resume(); 
    294     axis_hdl->size.setValue(size); 
    295     CTimer::get("XIOS").suspend(); 
    296   } 
    297  
    298   void cxios_get_axis_size(axis_Ptr axis_hdl, int* size) 
    299   { 
    300     CTimer::get("XIOS").resume(); 
    301     *size = axis_hdl->size.getInheritedValue(); 
    302     CTimer::get("XIOS").suspend(); 
    303   } 
    304  
    305   bool cxios_is_defined_axis_size(axis_Ptr axis_hdl) 
    306   { 
    307      CTimer::get("XIOS").resume(); 
    308      bool isDefined = axis_hdl->size.hasInheritedValue(); 
    309      CTimer::get("XIOS").suspend(); 
    310      return isDefined; 
    311   } 
    312  
    313  
    314314  void cxios_set_axis_standard_name(axis_Ptr axis_hdl, const char * standard_name, int standard_name_size) 
    315315  { 
     
    387387     return isDefined; 
    388388  } 
    389  
    390  
    391   void cxios_set_axis_zoom_begin(axis_Ptr axis_hdl, int zoom_begin) 
    392   { 
    393     CTimer::get("XIOS").resume(); 
    394     axis_hdl->zoom_begin.setValue(zoom_begin); 
    395     CTimer::get("XIOS").suspend(); 
    396   } 
    397  
    398   void cxios_get_axis_zoom_begin(axis_Ptr axis_hdl, int* zoom_begin) 
    399   { 
    400     CTimer::get("XIOS").resume(); 
    401     *zoom_begin = axis_hdl->zoom_begin.getInheritedValue(); 
    402     CTimer::get("XIOS").suspend(); 
    403   } 
    404  
    405   bool cxios_is_defined_axis_zoom_begin(axis_Ptr axis_hdl) 
    406   { 
    407      CTimer::get("XIOS").resume(); 
    408      bool isDefined = axis_hdl->zoom_begin.hasInheritedValue(); 
    409      CTimer::get("XIOS").suspend(); 
    410      return isDefined; 
    411   } 
    412  
    413  
    414   void cxios_set_axis_zoom_end(axis_Ptr axis_hdl, int zoom_end) 
    415   { 
    416     CTimer::get("XIOS").resume(); 
    417     axis_hdl->zoom_end.setValue(zoom_end); 
    418     CTimer::get("XIOS").suspend(); 
    419   } 
    420  
    421   void cxios_get_axis_zoom_end(axis_Ptr axis_hdl, int* zoom_end) 
    422   { 
    423     CTimer::get("XIOS").resume(); 
    424     *zoom_end = axis_hdl->zoom_end.getInheritedValue(); 
    425     CTimer::get("XIOS").suspend(); 
    426   } 
    427  
    428   bool cxios_is_defined_axis_zoom_end(axis_Ptr axis_hdl) 
    429   { 
    430      CTimer::get("XIOS").resume(); 
    431      bool isDefined = axis_hdl->zoom_end.hasInheritedValue(); 
    432      CTimer::get("XIOS").suspend(); 
    433      return isDefined; 
    434   } 
    435  
    436  
    437   void cxios_set_axis_zoom_size(axis_Ptr axis_hdl, int zoom_size) 
    438   { 
    439     CTimer::get("XIOS").resume(); 
    440     axis_hdl->zoom_size.setValue(zoom_size); 
    441     CTimer::get("XIOS").suspend(); 
    442   } 
    443  
    444   void cxios_get_axis_zoom_size(axis_Ptr axis_hdl, int* zoom_size) 
    445   { 
    446     CTimer::get("XIOS").resume(); 
    447     *zoom_size = axis_hdl->zoom_size.getInheritedValue(); 
    448     CTimer::get("XIOS").suspend(); 
    449   } 
    450  
    451   bool cxios_is_defined_axis_zoom_size(axis_Ptr axis_hdl) 
    452   { 
    453      CTimer::get("XIOS").resume(); 
    454      bool isDefined = axis_hdl->zoom_size.hasInheritedValue(); 
    455      CTimer::get("XIOS").suspend(); 
    456      return isDefined; 
    457   } 
    458389} 
  • XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp

    r609 r666  
    4444 
    4545 
     46  void cxios_set_axisgroup_begin(axisgroup_Ptr axisgroup_hdl, int begin) 
     47  { 
     48    CTimer::get("XIOS").resume(); 
     49    axisgroup_hdl->begin.setValue(begin); 
     50    CTimer::get("XIOS").suspend(); 
     51  } 
     52 
     53  void cxios_get_axisgroup_begin(axisgroup_Ptr axisgroup_hdl, int* begin) 
     54  { 
     55    CTimer::get("XIOS").resume(); 
     56    *begin = axisgroup_hdl->begin.getInheritedValue(); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_axisgroup_begin(axisgroup_Ptr axisgroup_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = axisgroup_hdl->begin.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    4669  void cxios_set_axisgroup_bounds(axisgroup_Ptr axisgroup_hdl, double* bounds, int extent1, int extent2) 
    4770  { 
     
    166189 
    167190 
    168   void cxios_set_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl, int ibegin) 
    169   { 
    170     CTimer::get("XIOS").resume(); 
    171     axisgroup_hdl->ibegin.setValue(ibegin); 
    172     CTimer::get("XIOS").suspend(); 
    173   } 
    174  
    175   void cxios_get_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl, int* ibegin) 
    176   { 
    177     CTimer::get("XIOS").resume(); 
    178     *ibegin = axisgroup_hdl->ibegin.getInheritedValue(); 
    179     CTimer::get("XIOS").suspend(); 
    180   } 
    181  
    182   bool cxios_is_defined_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl) 
    183   { 
    184      CTimer::get("XIOS").resume(); 
    185      bool isDefined = axisgroup_hdl->ibegin.hasInheritedValue(); 
    186      CTimer::get("XIOS").suspend(); 
    187      return isDefined; 
    188   } 
    189  
    190  
    191191  void cxios_set_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, const char * long_name, int long_name_size) 
    192192  { 
     
    240240 
    241241 
     242  void cxios_set_axisgroup_n(axisgroup_Ptr axisgroup_hdl, int n) 
     243  { 
     244    CTimer::get("XIOS").resume(); 
     245    axisgroup_hdl->n.setValue(n); 
     246    CTimer::get("XIOS").suspend(); 
     247  } 
     248 
     249  void cxios_get_axisgroup_n(axisgroup_Ptr axisgroup_hdl, int* n) 
     250  { 
     251    CTimer::get("XIOS").resume(); 
     252    *n = axisgroup_hdl->n.getInheritedValue(); 
     253    CTimer::get("XIOS").suspend(); 
     254  } 
     255 
     256  bool cxios_is_defined_axisgroup_n(axisgroup_Ptr axisgroup_hdl) 
     257  { 
     258     CTimer::get("XIOS").resume(); 
     259     bool isDefined = axisgroup_hdl->n.hasInheritedValue(); 
     260     CTimer::get("XIOS").suspend(); 
     261     return isDefined; 
     262  } 
     263 
     264 
     265  void cxios_set_axisgroup_n_glo(axisgroup_Ptr axisgroup_hdl, int n_glo) 
     266  { 
     267    CTimer::get("XIOS").resume(); 
     268    axisgroup_hdl->n_glo.setValue(n_glo); 
     269    CTimer::get("XIOS").suspend(); 
     270  } 
     271 
     272  void cxios_get_axisgroup_n_glo(axisgroup_Ptr axisgroup_hdl, int* n_glo) 
     273  { 
     274    CTimer::get("XIOS").resume(); 
     275    *n_glo = axisgroup_hdl->n_glo.getInheritedValue(); 
     276    CTimer::get("XIOS").suspend(); 
     277  } 
     278 
     279  bool cxios_is_defined_axisgroup_n_glo(axisgroup_Ptr axisgroup_hdl) 
     280  { 
     281     CTimer::get("XIOS").resume(); 
     282     bool isDefined = axisgroup_hdl->n_glo.hasInheritedValue(); 
     283     CTimer::get("XIOS").suspend(); 
     284     return isDefined; 
     285  } 
     286 
     287 
    242288  void cxios_set_axisgroup_name(axisgroup_Ptr axisgroup_hdl, const char * name, int name_size) 
    243289  { 
     
    266312 
    267313 
    268   void cxios_set_axisgroup_ni(axisgroup_Ptr axisgroup_hdl, int ni) 
    269   { 
    270     CTimer::get("XIOS").resume(); 
    271     axisgroup_hdl->ni.setValue(ni); 
    272     CTimer::get("XIOS").suspend(); 
    273   } 
    274  
    275   void cxios_get_axisgroup_ni(axisgroup_Ptr axisgroup_hdl, int* ni) 
    276   { 
    277     CTimer::get("XIOS").resume(); 
    278     *ni = axisgroup_hdl->ni.getInheritedValue(); 
    279     CTimer::get("XIOS").suspend(); 
    280   } 
    281  
    282   bool cxios_is_defined_axisgroup_ni(axisgroup_Ptr axisgroup_hdl) 
    283   { 
    284      CTimer::get("XIOS").resume(); 
    285      bool isDefined = axisgroup_hdl->ni.hasInheritedValue(); 
    286      CTimer::get("XIOS").suspend(); 
    287      return isDefined; 
    288   } 
    289  
    290  
    291314  void cxios_set_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, const char * positive, int positive_size) 
    292315  { 
     
    315338 
    316339 
    317   void cxios_set_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int size) 
    318   { 
    319     CTimer::get("XIOS").resume(); 
    320     axisgroup_hdl->size.setValue(size); 
    321     CTimer::get("XIOS").suspend(); 
    322   } 
    323  
    324   void cxios_get_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int* size) 
    325   { 
    326     CTimer::get("XIOS").resume(); 
    327     *size = axisgroup_hdl->size.getInheritedValue(); 
    328     CTimer::get("XIOS").suspend(); 
    329   } 
    330  
    331   bool cxios_is_defined_axisgroup_size(axisgroup_Ptr axisgroup_hdl) 
    332   { 
    333      CTimer::get("XIOS").resume(); 
    334      bool isDefined = axisgroup_hdl->size.hasInheritedValue(); 
    335      CTimer::get("XIOS").suspend(); 
    336      return isDefined; 
    337   } 
    338  
    339  
    340340  void cxios_set_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, const char * standard_name, int standard_name_size) 
    341341  { 
     
    413413     return isDefined; 
    414414  } 
    415  
    416  
    417   void cxios_set_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int zoom_begin) 
    418   { 
    419     CTimer::get("XIOS").resume(); 
    420     axisgroup_hdl->zoom_begin.setValue(zoom_begin); 
    421     CTimer::get("XIOS").suspend(); 
    422   } 
    423  
    424   void cxios_get_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int* zoom_begin) 
    425   { 
    426     CTimer::get("XIOS").resume(); 
    427     *zoom_begin = axisgroup_hdl->zoom_begin.getInheritedValue(); 
    428     CTimer::get("XIOS").suspend(); 
    429   } 
    430  
    431   bool cxios_is_defined_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl) 
    432   { 
    433      CTimer::get("XIOS").resume(); 
    434      bool isDefined = axisgroup_hdl->zoom_begin.hasInheritedValue(); 
    435      CTimer::get("XIOS").suspend(); 
    436      return isDefined; 
    437   } 
    438  
    439  
    440   void cxios_set_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int zoom_end) 
    441   { 
    442     CTimer::get("XIOS").resume(); 
    443     axisgroup_hdl->zoom_end.setValue(zoom_end); 
    444     CTimer::get("XIOS").suspend(); 
    445   } 
    446  
    447   void cxios_get_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int* zoom_end) 
    448   { 
    449     CTimer::get("XIOS").resume(); 
    450     *zoom_end = axisgroup_hdl->zoom_end.getInheritedValue(); 
    451     CTimer::get("XIOS").suspend(); 
    452   } 
    453  
    454   bool cxios_is_defined_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl) 
    455   { 
    456      CTimer::get("XIOS").resume(); 
    457      bool isDefined = axisgroup_hdl->zoom_end.hasInheritedValue(); 
    458      CTimer::get("XIOS").suspend(); 
    459      return isDefined; 
    460   } 
    461  
    462  
    463   void cxios_set_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int zoom_size) 
    464   { 
    465     CTimer::get("XIOS").resume(); 
    466     axisgroup_hdl->zoom_size.setValue(zoom_size); 
    467     CTimer::get("XIOS").suspend(); 
    468   } 
    469  
    470   void cxios_get_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int* zoom_size) 
    471   { 
    472     CTimer::get("XIOS").resume(); 
    473     *zoom_size = axisgroup_hdl->zoom_size.getInheritedValue(); 
    474     CTimer::get("XIOS").suspend(); 
    475   } 
    476  
    477   bool cxios_is_defined_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl) 
    478   { 
    479      CTimer::get("XIOS").resume(); 
    480      bool isDefined = axisgroup_hdl->zoom_size.hasInheritedValue(); 
    481      CTimer::get("XIOS").suspend(); 
    482      return isDefined; 
    483   } 
    484415} 
  • XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp

    r664 r666  
    262262 
    263263 
    264   void cxios_set_domain_data_n_index(domain_Ptr domain_hdl, int data_n_index) 
    265   { 
    266     CTimer::get("XIOS").resume(); 
    267     domain_hdl->data_n_index.setValue(data_n_index); 
    268     CTimer::get("XIOS").suspend(); 
    269   } 
    270  
    271   void cxios_get_domain_data_n_index(domain_Ptr domain_hdl, int* data_n_index) 
    272   { 
    273     CTimer::get("XIOS").resume(); 
    274     *data_n_index = domain_hdl->data_n_index.getInheritedValue(); 
    275     CTimer::get("XIOS").suspend(); 
    276   } 
    277  
    278   bool cxios_is_defined_domain_data_n_index(domain_Ptr domain_hdl) 
    279   { 
    280      CTimer::get("XIOS").resume(); 
    281      bool isDefined = domain_hdl->data_n_index.hasInheritedValue(); 
    282      CTimer::get("XIOS").suspend(); 
    283      return isDefined; 
    284   } 
    285  
    286  
    287264  void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni) 
    288265  { 
  • XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp

    r664 r666  
    262262 
    263263 
    264   void cxios_set_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int data_n_index) 
    265   { 
    266     CTimer::get("XIOS").resume(); 
    267     domaingroup_hdl->data_n_index.setValue(data_n_index); 
    268     CTimer::get("XIOS").suspend(); 
    269   } 
    270  
    271   void cxios_get_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int* data_n_index) 
    272   { 
    273     CTimer::get("XIOS").resume(); 
    274     *data_n_index = domaingroup_hdl->data_n_index.getInheritedValue(); 
    275     CTimer::get("XIOS").suspend(); 
    276   } 
    277  
    278   bool cxios_is_defined_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl) 
    279   { 
    280      CTimer::get("XIOS").resume(); 
    281      bool isDefined = domaingroup_hdl->data_n_index.hasInheritedValue(); 
    282      CTimer::get("XIOS").suspend(); 
    283      return isDefined; 
    284   } 
    285  
    286  
    287264  void cxios_set_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int data_ni) 
    288265  { 
  • XIOS/trunk/src/interface/fortran_attr/axis_interface_attr.F90

    r609 r666  
    3131 
    3232 
     33    SUBROUTINE cxios_set_axis_begin(axis_hdl, begin) BIND(C) 
     34      USE ISO_C_BINDING 
     35      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     36      INTEGER (KIND=C_INT)      , VALUE :: begin 
     37    END SUBROUTINE cxios_set_axis_begin 
     38 
     39    SUBROUTINE cxios_get_axis_begin(axis_hdl, begin) BIND(C) 
     40      USE ISO_C_BINDING 
     41      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     42      INTEGER (KIND=C_INT)             :: begin 
     43    END SUBROUTINE cxios_get_axis_begin 
     44 
     45    FUNCTION cxios_is_defined_axis_begin(axis_hdl) BIND(C) 
     46      USE ISO_C_BINDING 
     47      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_begin 
     48      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     49    END FUNCTION cxios_is_defined_axis_begin 
     50 
     51 
    3352    SUBROUTINE cxios_set_axis_bounds(axis_hdl, bounds, extent1, extent2) BIND(C) 
    3453      USE ISO_C_BINDING 
     
    111130      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    112131    END FUNCTION cxios_is_defined_axis_data_n 
    113  
    114  
    115     SUBROUTINE cxios_set_axis_ibegin(axis_hdl, ibegin) BIND(C) 
    116       USE ISO_C_BINDING 
    117       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    118       INTEGER (KIND=C_INT)      , VALUE :: ibegin 
    119     END SUBROUTINE cxios_set_axis_ibegin 
    120  
    121     SUBROUTINE cxios_get_axis_ibegin(axis_hdl, ibegin) BIND(C) 
    122       USE ISO_C_BINDING 
    123       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    124       INTEGER (KIND=C_INT)             :: ibegin 
    125     END SUBROUTINE cxios_get_axis_ibegin 
    126  
    127     FUNCTION cxios_is_defined_axis_ibegin(axis_hdl) BIND(C) 
    128       USE ISO_C_BINDING 
    129       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_ibegin 
    130       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    131     END FUNCTION cxios_is_defined_axis_ibegin 
    132132 
    133133 
     
    174174 
    175175 
     176    SUBROUTINE cxios_set_axis_n(axis_hdl, n) BIND(C) 
     177      USE ISO_C_BINDING 
     178      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     179      INTEGER (KIND=C_INT)      , VALUE :: n 
     180    END SUBROUTINE cxios_set_axis_n 
     181 
     182    SUBROUTINE cxios_get_axis_n(axis_hdl, n) BIND(C) 
     183      USE ISO_C_BINDING 
     184      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     185      INTEGER (KIND=C_INT)             :: n 
     186    END SUBROUTINE cxios_get_axis_n 
     187 
     188    FUNCTION cxios_is_defined_axis_n(axis_hdl) BIND(C) 
     189      USE ISO_C_BINDING 
     190      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_n 
     191      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     192    END FUNCTION cxios_is_defined_axis_n 
     193 
     194 
     195    SUBROUTINE cxios_set_axis_n_glo(axis_hdl, n_glo) BIND(C) 
     196      USE ISO_C_BINDING 
     197      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     198      INTEGER (KIND=C_INT)      , VALUE :: n_glo 
     199    END SUBROUTINE cxios_set_axis_n_glo 
     200 
     201    SUBROUTINE cxios_get_axis_n_glo(axis_hdl, n_glo) BIND(C) 
     202      USE ISO_C_BINDING 
     203      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     204      INTEGER (KIND=C_INT)             :: n_glo 
     205    END SUBROUTINE cxios_get_axis_n_glo 
     206 
     207    FUNCTION cxios_is_defined_axis_n_glo(axis_hdl) BIND(C) 
     208      USE ISO_C_BINDING 
     209      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_n_glo 
     210      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     211    END FUNCTION cxios_is_defined_axis_n_glo 
     212 
     213 
    176214    SUBROUTINE cxios_set_axis_name(axis_hdl, name, name_size) BIND(C) 
    177215      USE ISO_C_BINDING 
     
    195233 
    196234 
    197     SUBROUTINE cxios_set_axis_ni(axis_hdl, ni) BIND(C) 
    198       USE ISO_C_BINDING 
    199       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    200       INTEGER (KIND=C_INT)      , VALUE :: ni 
    201     END SUBROUTINE cxios_set_axis_ni 
    202  
    203     SUBROUTINE cxios_get_axis_ni(axis_hdl, ni) BIND(C) 
    204       USE ISO_C_BINDING 
    205       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    206       INTEGER (KIND=C_INT)             :: ni 
    207     END SUBROUTINE cxios_get_axis_ni 
    208  
    209     FUNCTION cxios_is_defined_axis_ni(axis_hdl) BIND(C) 
    210       USE ISO_C_BINDING 
    211       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_ni 
    212       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    213     END FUNCTION cxios_is_defined_axis_ni 
    214  
    215  
    216235    SUBROUTINE cxios_set_axis_positive(axis_hdl, positive, positive_size) BIND(C) 
    217236      USE ISO_C_BINDING 
     
    235254 
    236255 
    237     SUBROUTINE cxios_set_axis_size(axis_hdl, size) BIND(C) 
    238       USE ISO_C_BINDING 
    239       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    240       INTEGER (KIND=C_INT)      , VALUE :: size 
    241     END SUBROUTINE cxios_set_axis_size 
    242  
    243     SUBROUTINE cxios_get_axis_size(axis_hdl, size) BIND(C) 
    244       USE ISO_C_BINDING 
    245       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    246       INTEGER (KIND=C_INT)             :: size 
    247     END SUBROUTINE cxios_get_axis_size 
    248  
    249     FUNCTION cxios_is_defined_axis_size(axis_hdl) BIND(C) 
    250       USE ISO_C_BINDING 
    251       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_size 
    252       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    253     END FUNCTION cxios_is_defined_axis_size 
    254  
    255  
    256256    SUBROUTINE cxios_set_axis_standard_name(axis_hdl, standard_name, standard_name_size) BIND(C) 
    257257      USE ISO_C_BINDING 
     
    316316    END FUNCTION cxios_is_defined_axis_value 
    317317 
    318  
    319     SUBROUTINE cxios_set_axis_zoom_begin(axis_hdl, zoom_begin) BIND(C) 
    320       USE ISO_C_BINDING 
    321       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    322       INTEGER (KIND=C_INT)      , VALUE :: zoom_begin 
    323     END SUBROUTINE cxios_set_axis_zoom_begin 
    324  
    325     SUBROUTINE cxios_get_axis_zoom_begin(axis_hdl, zoom_begin) BIND(C) 
    326       USE ISO_C_BINDING 
    327       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    328       INTEGER (KIND=C_INT)             :: zoom_begin 
    329     END SUBROUTINE cxios_get_axis_zoom_begin 
    330  
    331     FUNCTION cxios_is_defined_axis_zoom_begin(axis_hdl) BIND(C) 
    332       USE ISO_C_BINDING 
    333       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_zoom_begin 
    334       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    335     END FUNCTION cxios_is_defined_axis_zoom_begin 
    336  
    337  
    338     SUBROUTINE cxios_set_axis_zoom_end(axis_hdl, zoom_end) BIND(C) 
    339       USE ISO_C_BINDING 
    340       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    341       INTEGER (KIND=C_INT)      , VALUE :: zoom_end 
    342     END SUBROUTINE cxios_set_axis_zoom_end 
    343  
    344     SUBROUTINE cxios_get_axis_zoom_end(axis_hdl, zoom_end) BIND(C) 
    345       USE ISO_C_BINDING 
    346       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    347       INTEGER (KIND=C_INT)             :: zoom_end 
    348     END SUBROUTINE cxios_get_axis_zoom_end 
    349  
    350     FUNCTION cxios_is_defined_axis_zoom_end(axis_hdl) BIND(C) 
    351       USE ISO_C_BINDING 
    352       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_zoom_end 
    353       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    354     END FUNCTION cxios_is_defined_axis_zoom_end 
    355  
    356  
    357     SUBROUTINE cxios_set_axis_zoom_size(axis_hdl, zoom_size) BIND(C) 
    358       USE ISO_C_BINDING 
    359       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    360       INTEGER (KIND=C_INT)      , VALUE :: zoom_size 
    361     END SUBROUTINE cxios_set_axis_zoom_size 
    362  
    363     SUBROUTINE cxios_get_axis_zoom_size(axis_hdl, zoom_size) BIND(C) 
    364       USE ISO_C_BINDING 
    365       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    366       INTEGER (KIND=C_INT)             :: zoom_size 
    367     END SUBROUTINE cxios_get_axis_zoom_size 
    368  
    369     FUNCTION cxios_is_defined_axis_zoom_size(axis_hdl) BIND(C) 
    370       USE ISO_C_BINDING 
    371       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_zoom_size 
    372       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    373     END FUNCTION cxios_is_defined_axis_zoom_size 
    374  
    375318  END INTERFACE 
    376319 
  • XIOS/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90

    r609 r666  
    3131 
    3232 
     33    SUBROUTINE cxios_set_axisgroup_begin(axisgroup_hdl, begin) BIND(C) 
     34      USE ISO_C_BINDING 
     35      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     36      INTEGER (KIND=C_INT)      , VALUE :: begin 
     37    END SUBROUTINE cxios_set_axisgroup_begin 
     38 
     39    SUBROUTINE cxios_get_axisgroup_begin(axisgroup_hdl, begin) BIND(C) 
     40      USE ISO_C_BINDING 
     41      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     42      INTEGER (KIND=C_INT)             :: begin 
     43    END SUBROUTINE cxios_get_axisgroup_begin 
     44 
     45    FUNCTION cxios_is_defined_axisgroup_begin(axisgroup_hdl) BIND(C) 
     46      USE ISO_C_BINDING 
     47      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_begin 
     48      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     49    END FUNCTION cxios_is_defined_axisgroup_begin 
     50 
     51 
    3352    SUBROUTINE cxios_set_axisgroup_bounds(axisgroup_hdl, bounds, extent1, extent2) BIND(C) 
    3453      USE ISO_C_BINDING 
     
    134153 
    135154 
    136     SUBROUTINE cxios_set_axisgroup_ibegin(axisgroup_hdl, ibegin) BIND(C) 
    137       USE ISO_C_BINDING 
    138       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    139       INTEGER (KIND=C_INT)      , VALUE :: ibegin 
    140     END SUBROUTINE cxios_set_axisgroup_ibegin 
    141  
    142     SUBROUTINE cxios_get_axisgroup_ibegin(axisgroup_hdl, ibegin) BIND(C) 
    143       USE ISO_C_BINDING 
    144       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    145       INTEGER (KIND=C_INT)             :: ibegin 
    146     END SUBROUTINE cxios_get_axisgroup_ibegin 
    147  
    148     FUNCTION cxios_is_defined_axisgroup_ibegin(axisgroup_hdl) BIND(C) 
    149       USE ISO_C_BINDING 
    150       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_ibegin 
    151       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    152     END FUNCTION cxios_is_defined_axisgroup_ibegin 
    153  
    154  
    155155    SUBROUTINE cxios_set_axisgroup_long_name(axisgroup_hdl, long_name, long_name_size) BIND(C) 
    156156      USE ISO_C_BINDING 
     
    195195 
    196196 
     197    SUBROUTINE cxios_set_axisgroup_n(axisgroup_hdl, n) BIND(C) 
     198      USE ISO_C_BINDING 
     199      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     200      INTEGER (KIND=C_INT)      , VALUE :: n 
     201    END SUBROUTINE cxios_set_axisgroup_n 
     202 
     203    SUBROUTINE cxios_get_axisgroup_n(axisgroup_hdl, n) BIND(C) 
     204      USE ISO_C_BINDING 
     205      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     206      INTEGER (KIND=C_INT)             :: n 
     207    END SUBROUTINE cxios_get_axisgroup_n 
     208 
     209    FUNCTION cxios_is_defined_axisgroup_n(axisgroup_hdl) BIND(C) 
     210      USE ISO_C_BINDING 
     211      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_n 
     212      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     213    END FUNCTION cxios_is_defined_axisgroup_n 
     214 
     215 
     216    SUBROUTINE cxios_set_axisgroup_n_glo(axisgroup_hdl, n_glo) BIND(C) 
     217      USE ISO_C_BINDING 
     218      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     219      INTEGER (KIND=C_INT)      , VALUE :: n_glo 
     220    END SUBROUTINE cxios_set_axisgroup_n_glo 
     221 
     222    SUBROUTINE cxios_get_axisgroup_n_glo(axisgroup_hdl, n_glo) BIND(C) 
     223      USE ISO_C_BINDING 
     224      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     225      INTEGER (KIND=C_INT)             :: n_glo 
     226    END SUBROUTINE cxios_get_axisgroup_n_glo 
     227 
     228    FUNCTION cxios_is_defined_axisgroup_n_glo(axisgroup_hdl) BIND(C) 
     229      USE ISO_C_BINDING 
     230      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_n_glo 
     231      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     232    END FUNCTION cxios_is_defined_axisgroup_n_glo 
     233 
     234 
    197235    SUBROUTINE cxios_set_axisgroup_name(axisgroup_hdl, name, name_size) BIND(C) 
    198236      USE ISO_C_BINDING 
     
    216254 
    217255 
    218     SUBROUTINE cxios_set_axisgroup_ni(axisgroup_hdl, ni) BIND(C) 
    219       USE ISO_C_BINDING 
    220       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    221       INTEGER (KIND=C_INT)      , VALUE :: ni 
    222     END SUBROUTINE cxios_set_axisgroup_ni 
    223  
    224     SUBROUTINE cxios_get_axisgroup_ni(axisgroup_hdl, ni) BIND(C) 
    225       USE ISO_C_BINDING 
    226       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    227       INTEGER (KIND=C_INT)             :: ni 
    228     END SUBROUTINE cxios_get_axisgroup_ni 
    229  
    230     FUNCTION cxios_is_defined_axisgroup_ni(axisgroup_hdl) BIND(C) 
    231       USE ISO_C_BINDING 
    232       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_ni 
    233       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    234     END FUNCTION cxios_is_defined_axisgroup_ni 
    235  
    236  
    237256    SUBROUTINE cxios_set_axisgroup_positive(axisgroup_hdl, positive, positive_size) BIND(C) 
    238257      USE ISO_C_BINDING 
     
    256275 
    257276 
    258     SUBROUTINE cxios_set_axisgroup_size(axisgroup_hdl, size) BIND(C) 
    259       USE ISO_C_BINDING 
    260       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    261       INTEGER (KIND=C_INT)      , VALUE :: size 
    262     END SUBROUTINE cxios_set_axisgroup_size 
    263  
    264     SUBROUTINE cxios_get_axisgroup_size(axisgroup_hdl, size) BIND(C) 
    265       USE ISO_C_BINDING 
    266       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    267       INTEGER (KIND=C_INT)             :: size 
    268     END SUBROUTINE cxios_get_axisgroup_size 
    269  
    270     FUNCTION cxios_is_defined_axisgroup_size(axisgroup_hdl) BIND(C) 
    271       USE ISO_C_BINDING 
    272       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_size 
    273       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    274     END FUNCTION cxios_is_defined_axisgroup_size 
    275  
    276  
    277277    SUBROUTINE cxios_set_axisgroup_standard_name(axisgroup_hdl, standard_name, standard_name_size) BIND(C) 
    278278      USE ISO_C_BINDING 
     
    337337    END FUNCTION cxios_is_defined_axisgroup_value 
    338338 
    339  
    340     SUBROUTINE cxios_set_axisgroup_zoom_begin(axisgroup_hdl, zoom_begin) BIND(C) 
    341       USE ISO_C_BINDING 
    342       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    343       INTEGER (KIND=C_INT)      , VALUE :: zoom_begin 
    344     END SUBROUTINE cxios_set_axisgroup_zoom_begin 
    345  
    346     SUBROUTINE cxios_get_axisgroup_zoom_begin(axisgroup_hdl, zoom_begin) BIND(C) 
    347       USE ISO_C_BINDING 
    348       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    349       INTEGER (KIND=C_INT)             :: zoom_begin 
    350     END SUBROUTINE cxios_get_axisgroup_zoom_begin 
    351  
    352     FUNCTION cxios_is_defined_axisgroup_zoom_begin(axisgroup_hdl) BIND(C) 
    353       USE ISO_C_BINDING 
    354       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_zoom_begin 
    355       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    356     END FUNCTION cxios_is_defined_axisgroup_zoom_begin 
    357  
    358  
    359     SUBROUTINE cxios_set_axisgroup_zoom_end(axisgroup_hdl, zoom_end) BIND(C) 
    360       USE ISO_C_BINDING 
    361       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    362       INTEGER (KIND=C_INT)      , VALUE :: zoom_end 
    363     END SUBROUTINE cxios_set_axisgroup_zoom_end 
    364  
    365     SUBROUTINE cxios_get_axisgroup_zoom_end(axisgroup_hdl, zoom_end) BIND(C) 
    366       USE ISO_C_BINDING 
    367       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    368       INTEGER (KIND=C_INT)             :: zoom_end 
    369     END SUBROUTINE cxios_get_axisgroup_zoom_end 
    370  
    371     FUNCTION cxios_is_defined_axisgroup_zoom_end(axisgroup_hdl) BIND(C) 
    372       USE ISO_C_BINDING 
    373       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_zoom_end 
    374       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    375     END FUNCTION cxios_is_defined_axisgroup_zoom_end 
    376  
    377  
    378     SUBROUTINE cxios_set_axisgroup_zoom_size(axisgroup_hdl, zoom_size) BIND(C) 
    379       USE ISO_C_BINDING 
    380       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    381       INTEGER (KIND=C_INT)      , VALUE :: zoom_size 
    382     END SUBROUTINE cxios_set_axisgroup_zoom_size 
    383  
    384     SUBROUTINE cxios_get_axisgroup_zoom_size(axisgroup_hdl, zoom_size) BIND(C) 
    385       USE ISO_C_BINDING 
    386       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    387       INTEGER (KIND=C_INT)             :: zoom_size 
    388     END SUBROUTINE cxios_get_axisgroup_zoom_size 
    389  
    390     FUNCTION cxios_is_defined_axisgroup_zoom_size(axisgroup_hdl) BIND(C) 
    391       USE ISO_C_BINDING 
    392       LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_zoom_size 
    393       INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    394     END FUNCTION cxios_is_defined_axisgroup_zoom_size 
    395  
    396339  END INTERFACE 
    397340 
  • XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90

    r664 r666  
    228228 
    229229 
    230     SUBROUTINE cxios_set_domain_data_n_index(domain_hdl, data_n_index) BIND(C) 
    231       USE ISO_C_BINDING 
    232       INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    233       INTEGER (KIND=C_INT)      , VALUE :: data_n_index 
    234     END SUBROUTINE cxios_set_domain_data_n_index 
    235  
    236     SUBROUTINE cxios_get_domain_data_n_index(domain_hdl, data_n_index) BIND(C) 
    237       USE ISO_C_BINDING 
    238       INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    239       INTEGER (KIND=C_INT)             :: data_n_index 
    240     END SUBROUTINE cxios_get_domain_data_n_index 
    241  
    242     FUNCTION cxios_is_defined_domain_data_n_index(domain_hdl) BIND(C) 
    243       USE ISO_C_BINDING 
    244       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_n_index 
    245       INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    246     END FUNCTION cxios_is_defined_domain_data_n_index 
    247  
    248  
    249230    SUBROUTINE cxios_set_domain_data_ni(domain_hdl, data_ni) BIND(C) 
    250231      USE ISO_C_BINDING 
  • XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90

    r664 r666  
    228228 
    229229 
    230     SUBROUTINE cxios_set_domaingroup_data_n_index(domaingroup_hdl, data_n_index) BIND(C) 
    231       USE ISO_C_BINDING 
    232       INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    233       INTEGER (KIND=C_INT)      , VALUE :: data_n_index 
    234     END SUBROUTINE cxios_set_domaingroup_data_n_index 
    235  
    236     SUBROUTINE cxios_get_domaingroup_data_n_index(domaingroup_hdl, data_n_index) BIND(C) 
    237       USE ISO_C_BINDING 
    238       INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    239       INTEGER (KIND=C_INT)             :: data_n_index 
    240     END SUBROUTINE cxios_get_domaingroup_data_n_index 
    241  
    242     FUNCTION cxios_is_defined_domaingroup_data_n_index(domaingroup_hdl) BIND(C) 
    243       USE ISO_C_BINDING 
    244       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_n_index 
    245       INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    246     END FUNCTION cxios_is_defined_domaingroup_data_n_index 
    247  
    248  
    249230    SUBROUTINE cxios_set_domaingroup_data_ni(domaingroup_hdl, data_ni) BIND(C) 
    250231      USE ISO_C_BINDING 
  • XIOS/trunk/src/interface/fortran_attr/iaxis_attr.F90

    r609 r666  
    1212 
    1313  SUBROUTINE xios(set_axis_attr)  & 
    14     ( axis_id, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni  & 
    15     , positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     14    ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     15    , name, positive, standard_name, unit, value ) 
    1616 
    1717    IMPLICIT NONE 
     
    1919      CHARACTER(LEN=*), INTENT(IN) ::axis_id 
    2020      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     21      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    2122      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
    2223      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
    2324      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:) 
    2425      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
    25       INTEGER  , OPTIONAL, INTENT(IN) :: ibegin 
    2626      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    2727      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:) 
    2828      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:) 
     29      INTEGER  , OPTIONAL, INTENT(IN) :: n 
     30      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo 
    2931      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name 
    30       INTEGER  , OPTIONAL, INTENT(IN) :: ni 
    3132      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive 
    32       INTEGER  , OPTIONAL, INTENT(IN) :: size 
    3333      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name 
    3434      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit 
    3535      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value(:) 
    36       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin 
    37       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end 
    38       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size 
    3936 
    4037      CALL xios(get_axis_handle)(axis_id,axis_hdl) 
    4138      CALL xios(set_axis_attr_hdl_)   & 
    42       ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  & 
    43       , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     39      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     40      , name, positive, standard_name, unit, value ) 
    4441 
    4542  END SUBROUTINE xios(set_axis_attr) 
    4643 
    4744  SUBROUTINE xios(set_axis_attr_hdl)  & 
    48     ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  & 
    49     , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     45    ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     46    , name, positive, standard_name, unit, value ) 
    5047 
    5148    IMPLICIT NONE 
    5249      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    5350      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     51      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    5452      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
    5553      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
    5654      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:) 
    5755      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
    58       INTEGER  , OPTIONAL, INTENT(IN) :: ibegin 
    5956      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    6057      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:) 
    6158      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:) 
     59      INTEGER  , OPTIONAL, INTENT(IN) :: n 
     60      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo 
    6261      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name 
    63       INTEGER  , OPTIONAL, INTENT(IN) :: ni 
    6462      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive 
    65       INTEGER  , OPTIONAL, INTENT(IN) :: size 
    6663      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name 
    6764      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit 
    6865      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value(:) 
    69       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin 
    70       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end 
    71       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size 
    7266 
    7367      CALL xios(set_axis_attr_hdl_)  & 
    74       ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  & 
    75       , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     68      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     69      , name, positive, standard_name, unit, value ) 
    7670 
    7771  END SUBROUTINE xios(set_axis_attr_hdl) 
    7872 
    7973  SUBROUTINE xios(set_axis_attr_hdl_)   & 
    80     ( axis_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, ibegin_, long_name_, mask_  & 
    81     , name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_, zoom_end_, zoom_size_  & 
    82      ) 
     74    ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, long_name_, mask_  & 
     75    , n_, n_glo_, name_, positive_, standard_name_, unit_, value_ ) 
    8376 
    8477    IMPLICIT NONE 
    8578      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    8679      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref_ 
     80      INTEGER  , OPTIONAL, INTENT(IN) :: begin_ 
    8781      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_(:,:) 
    8882      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_ 
    8983      INTEGER  , OPTIONAL, INTENT(IN) :: data_index_(:) 
    9084      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_ 
    91       INTEGER  , OPTIONAL, INTENT(IN) :: ibegin_ 
    9285      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_ 
    9386      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:) 
    9487      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:) 
     88      INTEGER  , OPTIONAL, INTENT(IN) :: n_ 
     89      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo_ 
    9590      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_ 
    96       INTEGER  , OPTIONAL, INTENT(IN) :: ni_ 
    9791      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive_ 
    98       INTEGER  , OPTIONAL, INTENT(IN) :: size_ 
    9992      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_ 
    10093      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit_ 
    10194      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value_(:) 
    102       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin_ 
    103       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end_ 
    104       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size_ 
    10595 
    10696      IF (PRESENT(axis_ref_)) THEN 
     
    10898      ENDIF 
    10999 
     100      IF (PRESENT(begin_)) THEN 
     101        CALL cxios_set_axis_begin(axis_hdl%daddr, begin_) 
     102      ENDIF 
     103 
    110104      IF (PRESENT(bounds_)) THEN 
    111105        CALL cxios_set_axis_bounds(axis_hdl%daddr, bounds_, size(bounds_,1), size(bounds_,2)) 
     
    122116      IF (PRESENT(data_n_)) THEN 
    123117        CALL cxios_set_axis_data_n(axis_hdl%daddr, data_n_) 
    124       ENDIF 
    125  
    126       IF (PRESENT(ibegin_)) THEN 
    127         CALL cxios_set_axis_ibegin(axis_hdl%daddr, ibegin_) 
    128118      ENDIF 
    129119 
     
    138128      ENDIF 
    139129 
     130      IF (PRESENT(n_)) THEN 
     131        CALL cxios_set_axis_n(axis_hdl%daddr, n_) 
     132      ENDIF 
     133 
     134      IF (PRESENT(n_glo_)) THEN 
     135        CALL cxios_set_axis_n_glo(axis_hdl%daddr, n_glo_) 
     136      ENDIF 
     137 
    140138      IF (PRESENT(name_)) THEN 
    141139        CALL cxios_set_axis_name(axis_hdl%daddr, name_, len(name_)) 
    142140      ENDIF 
    143141 
    144       IF (PRESENT(ni_)) THEN 
    145         CALL cxios_set_axis_ni(axis_hdl%daddr, ni_) 
    146       ENDIF 
    147  
    148142      IF (PRESENT(positive_)) THEN 
    149143        CALL cxios_set_axis_positive(axis_hdl%daddr, positive_, len(positive_)) 
    150144      ENDIF 
    151145 
    152       IF (PRESENT(size_)) THEN 
    153         CALL cxios_set_axis_size(axis_hdl%daddr, size_) 
    154       ENDIF 
    155  
    156146      IF (PRESENT(standard_name_)) THEN 
    157147        CALL cxios_set_axis_standard_name(axis_hdl%daddr, standard_name_, len(standard_name_)) 
     
    166156      ENDIF 
    167157 
    168       IF (PRESENT(zoom_begin_)) THEN 
    169         CALL cxios_set_axis_zoom_begin(axis_hdl%daddr, zoom_begin_) 
    170       ENDIF 
    171  
    172       IF (PRESENT(zoom_end_)) THEN 
    173         CALL cxios_set_axis_zoom_end(axis_hdl%daddr, zoom_end_) 
    174       ENDIF 
    175  
    176       IF (PRESENT(zoom_size_)) THEN 
    177         CALL cxios_set_axis_zoom_size(axis_hdl%daddr, zoom_size_) 
    178       ENDIF 
    179  
    180158  END SUBROUTINE xios(set_axis_attr_hdl_) 
    181159 
    182160  SUBROUTINE xios(get_axis_attr)  & 
    183     ( axis_id, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni  & 
    184     , positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     161    ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     162    , name, positive, standard_name, unit, value ) 
    185163 
    186164    IMPLICIT NONE 
     
    188166      CHARACTER(LEN=*), INTENT(IN) ::axis_id 
    189167      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     168      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    190169      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
    191170      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
    192171      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:) 
    193172      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
    194       INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin 
    195173      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    196174      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:) 
    197175      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:) 
     176      INTEGER  , OPTIONAL, INTENT(OUT) :: n 
     177      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo 
    198178      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name 
    199       INTEGER  , OPTIONAL, INTENT(OUT) :: ni 
    200179      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive 
    201       INTEGER  , OPTIONAL, INTENT(OUT) :: size 
    202180      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name 
    203181      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit 
    204182      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value(:) 
    205       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin 
    206       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end 
    207       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size 
    208183 
    209184      CALL xios(get_axis_handle)(axis_id,axis_hdl) 
    210185      CALL xios(get_axis_attr_hdl_)   & 
    211       ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  & 
    212       , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     186      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     187      , name, positive, standard_name, unit, value ) 
    213188 
    214189  END SUBROUTINE xios(get_axis_attr) 
    215190 
    216191  SUBROUTINE xios(get_axis_attr_hdl)  & 
    217     ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  & 
    218     , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     192    ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     193    , name, positive, standard_name, unit, value ) 
    219194 
    220195    IMPLICIT NONE 
    221196      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    222197      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     198      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    223199      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
    224200      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
    225201      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:) 
    226202      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
    227       INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin 
    228203      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    229204      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:) 
    230205      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:) 
     206      INTEGER  , OPTIONAL, INTENT(OUT) :: n 
     207      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo 
    231208      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name 
    232       INTEGER  , OPTIONAL, INTENT(OUT) :: ni 
    233209      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive 
    234       INTEGER  , OPTIONAL, INTENT(OUT) :: size 
    235210      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name 
    236211      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit 
    237212      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value(:) 
    238       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin 
    239       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end 
    240       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size 
    241213 
    242214      CALL xios(get_axis_attr_hdl_)  & 
    243       ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  & 
    244       , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     215      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     216      , name, positive, standard_name, unit, value ) 
    245217 
    246218  END SUBROUTINE xios(get_axis_attr_hdl) 
    247219 
    248220  SUBROUTINE xios(get_axis_attr_hdl_)   & 
    249     ( axis_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, ibegin_, long_name_, mask_  & 
    250     , name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_, zoom_end_, zoom_size_  & 
    251      ) 
     221    ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, long_name_, mask_  & 
     222    , n_, n_glo_, name_, positive_, standard_name_, unit_, value_ ) 
    252223 
    253224    IMPLICIT NONE 
    254225      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    255226      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref_ 
     227      INTEGER  , OPTIONAL, INTENT(OUT) :: begin_ 
    256228      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_(:,:) 
    257229      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_ 
    258230      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index_(:) 
    259231      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_ 
    260       INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin_ 
    261232      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_ 
    262233      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:) 
    263234      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:) 
     235      INTEGER  , OPTIONAL, INTENT(OUT) :: n_ 
     236      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo_ 
    264237      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_ 
    265       INTEGER  , OPTIONAL, INTENT(OUT) :: ni_ 
    266238      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive_ 
    267       INTEGER  , OPTIONAL, INTENT(OUT) :: size_ 
    268239      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_ 
    269240      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit_ 
    270241      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value_(:) 
    271       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin_ 
    272       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end_ 
    273       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size_ 
    274242 
    275243      IF (PRESENT(axis_ref_)) THEN 
     
    277245      ENDIF 
    278246 
     247      IF (PRESENT(begin_)) THEN 
     248        CALL cxios_get_axis_begin(axis_hdl%daddr, begin_) 
     249      ENDIF 
     250 
    279251      IF (PRESENT(bounds_)) THEN 
    280252        CALL cxios_get_axis_bounds(axis_hdl%daddr, bounds_, size(bounds_,1), size(bounds_,2)) 
     
    291263      IF (PRESENT(data_n_)) THEN 
    292264        CALL cxios_get_axis_data_n(axis_hdl%daddr, data_n_) 
    293       ENDIF 
    294  
    295       IF (PRESENT(ibegin_)) THEN 
    296         CALL cxios_get_axis_ibegin(axis_hdl%daddr, ibegin_) 
    297265      ENDIF 
    298266 
     
    307275      ENDIF 
    308276 
     277      IF (PRESENT(n_)) THEN 
     278        CALL cxios_get_axis_n(axis_hdl%daddr, n_) 
     279      ENDIF 
     280 
     281      IF (PRESENT(n_glo_)) THEN 
     282        CALL cxios_get_axis_n_glo(axis_hdl%daddr, n_glo_) 
     283      ENDIF 
     284 
    309285      IF (PRESENT(name_)) THEN 
    310286        CALL cxios_get_axis_name(axis_hdl%daddr, name_, len(name_)) 
    311287      ENDIF 
    312288 
    313       IF (PRESENT(ni_)) THEN 
    314         CALL cxios_get_axis_ni(axis_hdl%daddr, ni_) 
    315       ENDIF 
    316  
    317289      IF (PRESENT(positive_)) THEN 
    318290        CALL cxios_get_axis_positive(axis_hdl%daddr, positive_, len(positive_)) 
    319291      ENDIF 
    320292 
    321       IF (PRESENT(size_)) THEN 
    322         CALL cxios_get_axis_size(axis_hdl%daddr, size_) 
    323       ENDIF 
    324  
    325293      IF (PRESENT(standard_name_)) THEN 
    326294        CALL cxios_get_axis_standard_name(axis_hdl%daddr, standard_name_, len(standard_name_)) 
     
    335303      ENDIF 
    336304 
    337       IF (PRESENT(zoom_begin_)) THEN 
    338         CALL cxios_get_axis_zoom_begin(axis_hdl%daddr, zoom_begin_) 
    339       ENDIF 
    340  
    341       IF (PRESENT(zoom_end_)) THEN 
    342         CALL cxios_get_axis_zoom_end(axis_hdl%daddr, zoom_end_) 
    343       ENDIF 
    344  
    345       IF (PRESENT(zoom_size_)) THEN 
    346         CALL cxios_get_axis_zoom_size(axis_hdl%daddr, zoom_size_) 
    347       ENDIF 
    348  
    349305  END SUBROUTINE xios(get_axis_attr_hdl_) 
    350306 
    351307  SUBROUTINE xios(is_defined_axis_attr)  & 
    352     ( axis_id, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni  & 
    353     , positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     308    ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     309    , name, positive, standard_name, unit, value ) 
    354310 
    355311    IMPLICIT NONE 
     
    358314      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref 
    359315      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp 
     316      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
     317      LOGICAL(KIND=C_BOOL) :: begin_tmp 
    360318      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds 
    361319      LOGICAL(KIND=C_BOOL) :: bounds_tmp 
     
    366324      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n 
    367325      LOGICAL(KIND=C_BOOL) :: data_n_tmp 
    368       LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin 
    369       LOGICAL(KIND=C_BOOL) :: ibegin_tmp 
    370326      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    371327      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
    372328      LOGICAL, OPTIONAL, INTENT(OUT) :: mask 
    373329      LOGICAL(KIND=C_BOOL) :: mask_tmp 
     330      LOGICAL, OPTIONAL, INTENT(OUT) :: n 
     331      LOGICAL(KIND=C_BOOL) :: n_tmp 
     332      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo 
     333      LOGICAL(KIND=C_BOOL) :: n_glo_tmp 
    374334      LOGICAL, OPTIONAL, INTENT(OUT) :: name 
    375335      LOGICAL(KIND=C_BOOL) :: name_tmp 
    376       LOGICAL, OPTIONAL, INTENT(OUT) :: ni 
    377       LOGICAL(KIND=C_BOOL) :: ni_tmp 
    378336      LOGICAL, OPTIONAL, INTENT(OUT) :: positive 
    379337      LOGICAL(KIND=C_BOOL) :: positive_tmp 
    380       LOGICAL, OPTIONAL, INTENT(OUT) :: size 
    381       LOGICAL(KIND=C_BOOL) :: size_tmp 
    382338      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name 
    383339      LOGICAL(KIND=C_BOOL) :: standard_name_tmp 
     
    386342      LOGICAL, OPTIONAL, INTENT(OUT) :: value 
    387343      LOGICAL(KIND=C_BOOL) :: value_tmp 
    388       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin 
    389       LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp 
    390       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end 
    391       LOGICAL(KIND=C_BOOL) :: zoom_end_tmp 
    392       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size 
    393       LOGICAL(KIND=C_BOOL) :: zoom_size_tmp 
    394344 
    395345      CALL xios(get_axis_handle)(axis_id,axis_hdl) 
    396346      CALL xios(is_defined_axis_attr_hdl_)   & 
    397       ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  & 
    398       , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     347      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     348      , name, positive, standard_name, unit, value ) 
    399349 
    400350  END SUBROUTINE xios(is_defined_axis_attr) 
    401351 
    402352  SUBROUTINE xios(is_defined_axis_attr_hdl)  & 
    403     ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  & 
    404     , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     353    ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     354    , name, positive, standard_name, unit, value ) 
    405355 
    406356    IMPLICIT NONE 
     
    408358      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref 
    409359      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp 
     360      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
     361      LOGICAL(KIND=C_BOOL) :: begin_tmp 
    410362      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds 
    411363      LOGICAL(KIND=C_BOOL) :: bounds_tmp 
     
    416368      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n 
    417369      LOGICAL(KIND=C_BOOL) :: data_n_tmp 
    418       LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin 
    419       LOGICAL(KIND=C_BOOL) :: ibegin_tmp 
    420370      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    421371      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
    422372      LOGICAL, OPTIONAL, INTENT(OUT) :: mask 
    423373      LOGICAL(KIND=C_BOOL) :: mask_tmp 
     374      LOGICAL, OPTIONAL, INTENT(OUT) :: n 
     375      LOGICAL(KIND=C_BOOL) :: n_tmp 
     376      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo 
     377      LOGICAL(KIND=C_BOOL) :: n_glo_tmp 
    424378      LOGICAL, OPTIONAL, INTENT(OUT) :: name 
    425379      LOGICAL(KIND=C_BOOL) :: name_tmp 
    426       LOGICAL, OPTIONAL, INTENT(OUT) :: ni 
    427       LOGICAL(KIND=C_BOOL) :: ni_tmp 
    428380      LOGICAL, OPTIONAL, INTENT(OUT) :: positive 
    429381      LOGICAL(KIND=C_BOOL) :: positive_tmp 
    430       LOGICAL, OPTIONAL, INTENT(OUT) :: size 
    431       LOGICAL(KIND=C_BOOL) :: size_tmp 
    432382      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name 
    433383      LOGICAL(KIND=C_BOOL) :: standard_name_tmp 
     
    436386      LOGICAL, OPTIONAL, INTENT(OUT) :: value 
    437387      LOGICAL(KIND=C_BOOL) :: value_tmp 
    438       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin 
    439       LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp 
    440       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end 
    441       LOGICAL(KIND=C_BOOL) :: zoom_end_tmp 
    442       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size 
    443       LOGICAL(KIND=C_BOOL) :: zoom_size_tmp 
    444388 
    445389      CALL xios(is_defined_axis_attr_hdl_)  & 
    446       ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  & 
    447       , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size ) 
     390      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  & 
     391      , name, positive, standard_name, unit, value ) 
    448392 
    449393  END SUBROUTINE xios(is_defined_axis_attr_hdl) 
    450394 
    451395  SUBROUTINE xios(is_defined_axis_attr_hdl_)   & 
    452     ( axis_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, ibegin_, long_name_, mask_  & 
    453     , name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_, zoom_end_, zoom_size_  & 
    454      ) 
     396    ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, long_name_, mask_  & 
     397    , n_, n_glo_, name_, positive_, standard_name_, unit_, value_ ) 
    455398 
    456399    IMPLICIT NONE 
     
    458401      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_ 
    459402      LOGICAL(KIND=C_BOOL) :: axis_ref__tmp 
     403      LOGICAL, OPTIONAL, INTENT(OUT) :: begin_ 
     404      LOGICAL(KIND=C_BOOL) :: begin__tmp 
    460405      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_ 
    461406      LOGICAL(KIND=C_BOOL) :: bounds__tmp 
     
    466411      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_ 
    467412      LOGICAL(KIND=C_BOOL) :: data_n__tmp 
    468       LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin_ 
    469       LOGICAL(KIND=C_BOOL) :: ibegin__tmp 
    470413      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_ 
    471414      LOGICAL(KIND=C_BOOL) :: long_name__tmp 
    472415      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_ 
    473416      LOGICAL(KIND=C_BOOL) :: mask__tmp 
     417      LOGICAL, OPTIONAL, INTENT(OUT) :: n_ 
     418      LOGICAL(KIND=C_BOOL) :: n__tmp 
     419      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo_ 
     420      LOGICAL(KIND=C_BOOL) :: n_glo__tmp 
    474421      LOGICAL, OPTIONAL, INTENT(OUT) :: name_ 
    475422      LOGICAL(KIND=C_BOOL) :: name__tmp 
    476       LOGICAL, OPTIONAL, INTENT(OUT) :: ni_ 
    477       LOGICAL(KIND=C_BOOL) :: ni__tmp 
    478423      LOGICAL, OPTIONAL, INTENT(OUT) :: positive_ 
    479424      LOGICAL(KIND=C_BOOL) :: positive__tmp 
    480       LOGICAL, OPTIONAL, INTENT(OUT) :: size_ 
    481       LOGICAL(KIND=C_BOOL) :: size__tmp 
    482425      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_ 
    483426      LOGICAL(KIND=C_BOOL) :: standard_name__tmp 
     
    486429      LOGICAL, OPTIONAL, INTENT(OUT) :: value_ 
    487430      LOGICAL(KIND=C_BOOL) :: value__tmp 
    488       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin_ 
    489       LOGICAL(KIND=C_BOOL) :: zoom_begin__tmp 
    490       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end_ 
    491       LOGICAL(KIND=C_BOOL) :: zoom_end__tmp 
    492       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size_ 
    493       LOGICAL(KIND=C_BOOL) :: zoom_size__tmp 
    494431 
    495432      IF (PRESENT(axis_ref_)) THEN 
     
    498435      ENDIF 
    499436 
     437      IF (PRESENT(begin_)) THEN 
     438        begin__tmp = cxios_is_defined_axis_begin(axis_hdl%daddr) 
     439        begin_ = begin__tmp 
     440      ENDIF 
     441 
    500442      IF (PRESENT(bounds_)) THEN 
    501443        bounds__tmp = cxios_is_defined_axis_bounds(axis_hdl%daddr) 
     
    518460      ENDIF 
    519461 
    520       IF (PRESENT(ibegin_)) THEN 
    521         ibegin__tmp = cxios_is_defined_axis_ibegin(axis_hdl%daddr) 
    522         ibegin_ = ibegin__tmp 
    523       ENDIF 
    524  
    525462      IF (PRESENT(long_name_)) THEN 
    526463        long_name__tmp = cxios_is_defined_axis_long_name(axis_hdl%daddr) 
     
    533470      ENDIF 
    534471 
     472      IF (PRESENT(n_)) THEN 
     473        n__tmp = cxios_is_defined_axis_n(axis_hdl%daddr) 
     474        n_ = n__tmp 
     475      ENDIF 
     476 
     477      IF (PRESENT(n_glo_)) THEN 
     478        n_glo__tmp = cxios_is_defined_axis_n_glo(axis_hdl%daddr) 
     479        n_glo_ = n_glo__tmp 
     480      ENDIF 
     481 
    535482      IF (PRESENT(name_)) THEN 
    536483        name__tmp = cxios_is_defined_axis_name(axis_hdl%daddr) 
     
    538485      ENDIF 
    539486 
    540       IF (PRESENT(ni_)) THEN 
    541         ni__tmp = cxios_is_defined_axis_ni(axis_hdl%daddr) 
    542         ni_ = ni__tmp 
    543       ENDIF 
    544  
    545487      IF (PRESENT(positive_)) THEN 
    546488        positive__tmp = cxios_is_defined_axis_positive(axis_hdl%daddr) 
     
    548490      ENDIF 
    549491 
    550       IF (PRESENT(size_)) THEN 
    551         size__tmp = cxios_is_defined_axis_size(axis_hdl%daddr) 
    552         size_ = size__tmp 
    553       ENDIF 
    554  
    555492      IF (PRESENT(standard_name_)) THEN 
    556493        standard_name__tmp = cxios_is_defined_axis_standard_name(axis_hdl%daddr) 
     
    568505      ENDIF 
    569506 
    570       IF (PRESENT(zoom_begin_)) THEN 
    571         zoom_begin__tmp = cxios_is_defined_axis_zoom_begin(axis_hdl%daddr) 
    572         zoom_begin_ = zoom_begin__tmp 
    573       ENDIF 
    574  
    575       IF (PRESENT(zoom_end_)) THEN 
    576         zoom_end__tmp = cxios_is_defined_axis_zoom_end(axis_hdl%daddr) 
    577         zoom_end_ = zoom_end__tmp 
    578       ENDIF 
    579  
    580       IF (PRESENT(zoom_size_)) THEN 
    581         zoom_size__tmp = cxios_is_defined_axis_zoom_size(axis_hdl%daddr) 
    582         zoom_size_ = zoom_size__tmp 
    583       ENDIF 
    584  
    585507  END SUBROUTINE xios(is_defined_axis_attr_hdl_) 
    586508 
  • XIOS/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90

    r609 r666  
    1212 
    1313  SUBROUTINE xios(set_axisgroup_attr)  & 
    14     ( axisgroup_id, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    15     , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    16      ) 
     14    ( axisgroup_id, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     15    , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    1716 
    1817    IMPLICIT NONE 
     
    2019      CHARACTER(LEN=*), INTENT(IN) ::axisgroup_id 
    2120      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     21      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    2222      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
    2323      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
     
    2525      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
    2626      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref 
    27       INTEGER  , OPTIONAL, INTENT(IN) :: ibegin 
    2827      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    2928      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:) 
    3029      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:) 
     30      INTEGER  , OPTIONAL, INTENT(IN) :: n 
     31      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo 
    3132      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name 
    32       INTEGER  , OPTIONAL, INTENT(IN) :: ni 
    3333      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive 
    34       INTEGER  , OPTIONAL, INTENT(IN) :: size 
    3534      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name 
    3635      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit 
    3736      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value(:) 
    38       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin 
    39       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end 
    40       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size 
    4137 
    4238      CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl) 
    4339      CALL xios(set_axisgroup_attr_hdl_)   & 
    44       ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    45       , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    46        ) 
     40      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     41      , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    4742 
    4843  END SUBROUTINE xios(set_axisgroup_attr) 
    4944 
    5045  SUBROUTINE xios(set_axisgroup_attr_hdl)  & 
    51     ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    52     , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    53      ) 
     46    ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     47    , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    5448 
    5549    IMPLICIT NONE 
    5650      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl 
    5751      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     52      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    5853      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
    5954      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
     
    6156      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
    6257      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref 
    63       INTEGER  , OPTIONAL, INTENT(IN) :: ibegin 
    6458      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    6559      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:) 
    6660      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:) 
     61      INTEGER  , OPTIONAL, INTENT(IN) :: n 
     62      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo 
    6763      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name 
    68       INTEGER  , OPTIONAL, INTENT(IN) :: ni 
    6964      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive 
    70       INTEGER  , OPTIONAL, INTENT(IN) :: size 
    7165      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name 
    7266      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit 
    7367      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value(:) 
    74       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin 
    75       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end 
    76       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size 
    7768 
    7869      CALL xios(set_axisgroup_attr_hdl_)  & 
    79       ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    80       , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    81        ) 
     70      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     71      , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    8272 
    8373  END SUBROUTINE xios(set_axisgroup_attr_hdl) 
    8474 
    8575  SUBROUTINE xios(set_axisgroup_attr_hdl_)   & 
    86     ( axisgroup_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, group_ref_, ibegin_  & 
    87     , long_name_, mask_, name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  & 
    88     , zoom_end_, zoom_size_ ) 
     76    ( axisgroup_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, group_ref_, long_name_  & 
     77    , mask_, n_, n_glo_, name_, positive_, standard_name_, unit_, value_ ) 
    8978 
    9079    IMPLICIT NONE 
    9180      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl 
    9281      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref_ 
     82      INTEGER  , OPTIONAL, INTENT(IN) :: begin_ 
    9383      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_(:,:) 
    9484      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_ 
     
    9686      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_ 
    9787      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref_ 
    98       INTEGER  , OPTIONAL, INTENT(IN) :: ibegin_ 
    9988      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_ 
    10089      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:) 
    10190      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:) 
     91      INTEGER  , OPTIONAL, INTENT(IN) :: n_ 
     92      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo_ 
    10293      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_ 
    103       INTEGER  , OPTIONAL, INTENT(IN) :: ni_ 
    10494      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive_ 
    105       INTEGER  , OPTIONAL, INTENT(IN) :: size_ 
    10695      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_ 
    10796      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit_ 
    10897      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value_(:) 
    109       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin_ 
    110       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end_ 
    111       INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size_ 
    11298 
    11399      IF (PRESENT(axis_ref_)) THEN 
     
    115101      ENDIF 
    116102 
     103      IF (PRESENT(begin_)) THEN 
     104        CALL cxios_set_axisgroup_begin(axisgroup_hdl%daddr, begin_) 
     105      ENDIF 
     106 
    117107      IF (PRESENT(bounds_)) THEN 
    118108        CALL cxios_set_axisgroup_bounds(axisgroup_hdl%daddr, bounds_, size(bounds_,1), size(bounds_,2)) 
     
    133123      IF (PRESENT(group_ref_)) THEN 
    134124        CALL cxios_set_axisgroup_group_ref(axisgroup_hdl%daddr, group_ref_, len(group_ref_)) 
    135       ENDIF 
    136  
    137       IF (PRESENT(ibegin_)) THEN 
    138         CALL cxios_set_axisgroup_ibegin(axisgroup_hdl%daddr, ibegin_) 
    139125      ENDIF 
    140126 
     
    149135      ENDIF 
    150136 
     137      IF (PRESENT(n_)) THEN 
     138        CALL cxios_set_axisgroup_n(axisgroup_hdl%daddr, n_) 
     139      ENDIF 
     140 
     141      IF (PRESENT(n_glo_)) THEN 
     142        CALL cxios_set_axisgroup_n_glo(axisgroup_hdl%daddr, n_glo_) 
     143      ENDIF 
     144 
    151145      IF (PRESENT(name_)) THEN 
    152146        CALL cxios_set_axisgroup_name(axisgroup_hdl%daddr, name_, len(name_)) 
    153147      ENDIF 
    154148 
    155       IF (PRESENT(ni_)) THEN 
    156         CALL cxios_set_axisgroup_ni(axisgroup_hdl%daddr, ni_) 
    157       ENDIF 
    158  
    159149      IF (PRESENT(positive_)) THEN 
    160150        CALL cxios_set_axisgroup_positive(axisgroup_hdl%daddr, positive_, len(positive_)) 
    161151      ENDIF 
    162152 
    163       IF (PRESENT(size_)) THEN 
    164         CALL cxios_set_axisgroup_size(axisgroup_hdl%daddr, size_) 
    165       ENDIF 
    166  
    167153      IF (PRESENT(standard_name_)) THEN 
    168154        CALL cxios_set_axisgroup_standard_name(axisgroup_hdl%daddr, standard_name_, len(standard_name_)) 
     
    177163      ENDIF 
    178164 
    179       IF (PRESENT(zoom_begin_)) THEN 
    180         CALL cxios_set_axisgroup_zoom_begin(axisgroup_hdl%daddr, zoom_begin_) 
    181       ENDIF 
    182  
    183       IF (PRESENT(zoom_end_)) THEN 
    184         CALL cxios_set_axisgroup_zoom_end(axisgroup_hdl%daddr, zoom_end_) 
    185       ENDIF 
    186  
    187       IF (PRESENT(zoom_size_)) THEN 
    188         CALL cxios_set_axisgroup_zoom_size(axisgroup_hdl%daddr, zoom_size_) 
    189       ENDIF 
    190  
    191165  END SUBROUTINE xios(set_axisgroup_attr_hdl_) 
    192166 
    193167  SUBROUTINE xios(get_axisgroup_attr)  & 
    194     ( axisgroup_id, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    195     , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    196      ) 
     168    ( axisgroup_id, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     169    , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    197170 
    198171    IMPLICIT NONE 
     
    200173      CHARACTER(LEN=*), INTENT(IN) ::axisgroup_id 
    201174      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     175      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    202176      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
    203177      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
     
    205179      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
    206180      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref 
    207       INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin 
    208181      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    209182      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:) 
    210183      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:) 
     184      INTEGER  , OPTIONAL, INTENT(OUT) :: n 
     185      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo 
    211186      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name 
    212       INTEGER  , OPTIONAL, INTENT(OUT) :: ni 
    213187      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive 
    214       INTEGER  , OPTIONAL, INTENT(OUT) :: size 
    215188      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name 
    216189      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit 
    217190      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value(:) 
    218       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin 
    219       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end 
    220       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size 
    221191 
    222192      CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl) 
    223193      CALL xios(get_axisgroup_attr_hdl_)   & 
    224       ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    225       , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    226        ) 
     194      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     195      , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    227196 
    228197  END SUBROUTINE xios(get_axisgroup_attr) 
    229198 
    230199  SUBROUTINE xios(get_axisgroup_attr_hdl)  & 
    231     ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    232     , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    233      ) 
     200    ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     201    , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    234202 
    235203    IMPLICIT NONE 
    236204      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl 
    237205      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     206      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    238207      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
    239208      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
     
    241210      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
    242211      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref 
    243       INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin 
    244212      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    245213      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:) 
    246214      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:) 
     215      INTEGER  , OPTIONAL, INTENT(OUT) :: n 
     216      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo 
    247217      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name 
    248       INTEGER  , OPTIONAL, INTENT(OUT) :: ni 
    249218      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive 
    250       INTEGER  , OPTIONAL, INTENT(OUT) :: size 
    251219      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name 
    252220      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit 
    253221      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value(:) 
    254       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin 
    255       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end 
    256       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size 
    257222 
    258223      CALL xios(get_axisgroup_attr_hdl_)  & 
    259       ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    260       , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    261        ) 
     224      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     225      , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    262226 
    263227  END SUBROUTINE xios(get_axisgroup_attr_hdl) 
    264228 
    265229  SUBROUTINE xios(get_axisgroup_attr_hdl_)   & 
    266     ( axisgroup_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, group_ref_, ibegin_  & 
    267     , long_name_, mask_, name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  & 
    268     , zoom_end_, zoom_size_ ) 
     230    ( axisgroup_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, group_ref_, long_name_  & 
     231    , mask_, n_, n_glo_, name_, positive_, standard_name_, unit_, value_ ) 
    269232 
    270233    IMPLICIT NONE 
    271234      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl 
    272235      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref_ 
     236      INTEGER  , OPTIONAL, INTENT(OUT) :: begin_ 
    273237      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_(:,:) 
    274238      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_ 
     
    276240      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_ 
    277241      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref_ 
    278       INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin_ 
    279242      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_ 
    280243      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:) 
    281244      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:) 
     245      INTEGER  , OPTIONAL, INTENT(OUT) :: n_ 
     246      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo_ 
    282247      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_ 
    283       INTEGER  , OPTIONAL, INTENT(OUT) :: ni_ 
    284248      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive_ 
    285       INTEGER  , OPTIONAL, INTENT(OUT) :: size_ 
    286249      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_ 
    287250      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit_ 
    288251      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value_(:) 
    289       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin_ 
    290       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end_ 
    291       INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size_ 
    292252 
    293253      IF (PRESENT(axis_ref_)) THEN 
     
    295255      ENDIF 
    296256 
     257      IF (PRESENT(begin_)) THEN 
     258        CALL cxios_get_axisgroup_begin(axisgroup_hdl%daddr, begin_) 
     259      ENDIF 
     260 
    297261      IF (PRESENT(bounds_)) THEN 
    298262        CALL cxios_get_axisgroup_bounds(axisgroup_hdl%daddr, bounds_, size(bounds_,1), size(bounds_,2)) 
     
    313277      IF (PRESENT(group_ref_)) THEN 
    314278        CALL cxios_get_axisgroup_group_ref(axisgroup_hdl%daddr, group_ref_, len(group_ref_)) 
    315       ENDIF 
    316  
    317       IF (PRESENT(ibegin_)) THEN 
    318         CALL cxios_get_axisgroup_ibegin(axisgroup_hdl%daddr, ibegin_) 
    319279      ENDIF 
    320280 
     
    329289      ENDIF 
    330290 
     291      IF (PRESENT(n_)) THEN 
     292        CALL cxios_get_axisgroup_n(axisgroup_hdl%daddr, n_) 
     293      ENDIF 
     294 
     295      IF (PRESENT(n_glo_)) THEN 
     296        CALL cxios_get_axisgroup_n_glo(axisgroup_hdl%daddr, n_glo_) 
     297      ENDIF 
     298 
    331299      IF (PRESENT(name_)) THEN 
    332300        CALL cxios_get_axisgroup_name(axisgroup_hdl%daddr, name_, len(name_)) 
    333301      ENDIF 
    334302 
    335       IF (PRESENT(ni_)) THEN 
    336         CALL cxios_get_axisgroup_ni(axisgroup_hdl%daddr, ni_) 
    337       ENDIF 
    338  
    339303      IF (PRESENT(positive_)) THEN 
    340304        CALL cxios_get_axisgroup_positive(axisgroup_hdl%daddr, positive_, len(positive_)) 
    341305      ENDIF 
    342306 
    343       IF (PRESENT(size_)) THEN 
    344         CALL cxios_get_axisgroup_size(axisgroup_hdl%daddr, size_) 
    345       ENDIF 
    346  
    347307      IF (PRESENT(standard_name_)) THEN 
    348308        CALL cxios_get_axisgroup_standard_name(axisgroup_hdl%daddr, standard_name_, len(standard_name_)) 
     
    357317      ENDIF 
    358318 
    359       IF (PRESENT(zoom_begin_)) THEN 
    360         CALL cxios_get_axisgroup_zoom_begin(axisgroup_hdl%daddr, zoom_begin_) 
    361       ENDIF 
    362  
    363       IF (PRESENT(zoom_end_)) THEN 
    364         CALL cxios_get_axisgroup_zoom_end(axisgroup_hdl%daddr, zoom_end_) 
    365       ENDIF 
    366  
    367       IF (PRESENT(zoom_size_)) THEN 
    368         CALL cxios_get_axisgroup_zoom_size(axisgroup_hdl%daddr, zoom_size_) 
    369       ENDIF 
    370  
    371319  END SUBROUTINE xios(get_axisgroup_attr_hdl_) 
    372320 
    373321  SUBROUTINE xios(is_defined_axisgroup_attr)  & 
    374     ( axisgroup_id, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    375     , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    376      ) 
     322    ( axisgroup_id, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     323    , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    377324 
    378325    IMPLICIT NONE 
     
    381328      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref 
    382329      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp 
     330      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
     331      LOGICAL(KIND=C_BOOL) :: begin_tmp 
    383332      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds 
    384333      LOGICAL(KIND=C_BOOL) :: bounds_tmp 
     
    391340      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref 
    392341      LOGICAL(KIND=C_BOOL) :: group_ref_tmp 
    393       LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin 
    394       LOGICAL(KIND=C_BOOL) :: ibegin_tmp 
    395342      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    396343      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
    397344      LOGICAL, OPTIONAL, INTENT(OUT) :: mask 
    398345      LOGICAL(KIND=C_BOOL) :: mask_tmp 
     346      LOGICAL, OPTIONAL, INTENT(OUT) :: n 
     347      LOGICAL(KIND=C_BOOL) :: n_tmp 
     348      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo 
     349      LOGICAL(KIND=C_BOOL) :: n_glo_tmp 
    399350      LOGICAL, OPTIONAL, INTENT(OUT) :: name 
    400351      LOGICAL(KIND=C_BOOL) :: name_tmp 
    401       LOGICAL, OPTIONAL, INTENT(OUT) :: ni 
    402       LOGICAL(KIND=C_BOOL) :: ni_tmp 
    403352      LOGICAL, OPTIONAL, INTENT(OUT) :: positive 
    404353      LOGICAL(KIND=C_BOOL) :: positive_tmp 
    405       LOGICAL, OPTIONAL, INTENT(OUT) :: size 
    406       LOGICAL(KIND=C_BOOL) :: size_tmp 
    407354      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name 
    408355      LOGICAL(KIND=C_BOOL) :: standard_name_tmp 
     
    411358      LOGICAL, OPTIONAL, INTENT(OUT) :: value 
    412359      LOGICAL(KIND=C_BOOL) :: value_tmp 
    413       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin 
    414       LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp 
    415       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end 
    416       LOGICAL(KIND=C_BOOL) :: zoom_end_tmp 
    417       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size 
    418       LOGICAL(KIND=C_BOOL) :: zoom_size_tmp 
    419360 
    420361      CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl) 
    421362      CALL xios(is_defined_axisgroup_attr_hdl_)   & 
    422       ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    423       , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    424        ) 
     363      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     364      , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    425365 
    426366  END SUBROUTINE xios(is_defined_axisgroup_attr) 
    427367 
    428368  SUBROUTINE xios(is_defined_axisgroup_attr_hdl)  & 
    429     ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    430     , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    431      ) 
     369    ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     370    , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    432371 
    433372    IMPLICIT NONE 
     
    435374      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref 
    436375      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp 
     376      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
     377      LOGICAL(KIND=C_BOOL) :: begin_tmp 
    437378      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds 
    438379      LOGICAL(KIND=C_BOOL) :: bounds_tmp 
     
    445386      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref 
    446387      LOGICAL(KIND=C_BOOL) :: group_ref_tmp 
    447       LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin 
    448       LOGICAL(KIND=C_BOOL) :: ibegin_tmp 
    449388      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    450389      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
    451390      LOGICAL, OPTIONAL, INTENT(OUT) :: mask 
    452391      LOGICAL(KIND=C_BOOL) :: mask_tmp 
     392      LOGICAL, OPTIONAL, INTENT(OUT) :: n 
     393      LOGICAL(KIND=C_BOOL) :: n_tmp 
     394      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo 
     395      LOGICAL(KIND=C_BOOL) :: n_glo_tmp 
    453396      LOGICAL, OPTIONAL, INTENT(OUT) :: name 
    454397      LOGICAL(KIND=C_BOOL) :: name_tmp 
    455       LOGICAL, OPTIONAL, INTENT(OUT) :: ni 
    456       LOGICAL(KIND=C_BOOL) :: ni_tmp 
    457398      LOGICAL, OPTIONAL, INTENT(OUT) :: positive 
    458399      LOGICAL(KIND=C_BOOL) :: positive_tmp 
    459       LOGICAL, OPTIONAL, INTENT(OUT) :: size 
    460       LOGICAL(KIND=C_BOOL) :: size_tmp 
    461400      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name 
    462401      LOGICAL(KIND=C_BOOL) :: standard_name_tmp 
     
    465404      LOGICAL, OPTIONAL, INTENT(OUT) :: value 
    466405      LOGICAL(KIND=C_BOOL) :: value_tmp 
    467       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin 
    468       LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp 
    469       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end 
    470       LOGICAL(KIND=C_BOOL) :: zoom_end_tmp 
    471       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size 
    472       LOGICAL(KIND=C_BOOL) :: zoom_size_tmp 
    473406 
    474407      CALL xios(is_defined_axisgroup_attr_hdl_)  & 
    475       ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  & 
    476       , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  & 
    477        ) 
     408      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  & 
     409      , mask, n, n_glo, name, positive, standard_name, unit, value ) 
    478410 
    479411  END SUBROUTINE xios(is_defined_axisgroup_attr_hdl) 
    480412 
    481413  SUBROUTINE xios(is_defined_axisgroup_attr_hdl_)   & 
    482     ( axisgroup_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, group_ref_, ibegin_  & 
    483     , long_name_, mask_, name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  & 
    484     , zoom_end_, zoom_size_ ) 
     414    ( axisgroup_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, group_ref_, long_name_  & 
     415    , mask_, n_, n_glo_, name_, positive_, standard_name_, unit_, value_ ) 
    485416 
    486417    IMPLICIT NONE 
     
    488419      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_ 
    489420      LOGICAL(KIND=C_BOOL) :: axis_ref__tmp 
     421      LOGICAL, OPTIONAL, INTENT(OUT) :: begin_ 
     422      LOGICAL(KIND=C_BOOL) :: begin__tmp 
    490423      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_ 
    491424      LOGICAL(KIND=C_BOOL) :: bounds__tmp 
     
    498431      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_ 
    499432      LOGICAL(KIND=C_BOOL) :: group_ref__tmp 
    500       LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin_ 
    501       LOGICAL(KIND=C_BOOL) :: ibegin__tmp 
    502433      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_ 
    503434      LOGICAL(KIND=C_BOOL) :: long_name__tmp 
    504435      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_ 
    505436      LOGICAL(KIND=C_BOOL) :: mask__tmp 
     437      LOGICAL, OPTIONAL, INTENT(OUT) :: n_ 
     438      LOGICAL(KIND=C_BOOL) :: n__tmp 
     439      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo_ 
     440      LOGICAL(KIND=C_BOOL) :: n_glo__tmp 
    506441      LOGICAL, OPTIONAL, INTENT(OUT) :: name_ 
    507442      LOGICAL(KIND=C_BOOL) :: name__tmp 
    508       LOGICAL, OPTIONAL, INTENT(OUT) :: ni_ 
    509       LOGICAL(KIND=C_BOOL) :: ni__tmp 
    510443      LOGICAL, OPTIONAL, INTENT(OUT) :: positive_ 
    511444      LOGICAL(KIND=C_BOOL) :: positive__tmp 
    512       LOGICAL, OPTIONAL, INTENT(OUT) :: size_ 
    513       LOGICAL(KIND=C_BOOL) :: size__tmp 
    514445      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_ 
    515446      LOGICAL(KIND=C_BOOL) :: standard_name__tmp 
     
    518449      LOGICAL, OPTIONAL, INTENT(OUT) :: value_ 
    519450      LOGICAL(KIND=C_BOOL) :: value__tmp 
    520       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin_ 
    521       LOGICAL(KIND=C_BOOL) :: zoom_begin__tmp 
    522       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end_ 
    523       LOGICAL(KIND=C_BOOL) :: zoom_end__tmp 
    524       LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size_ 
    525       LOGICAL(KIND=C_BOOL) :: zoom_size__tmp 
    526451 
    527452      IF (PRESENT(axis_ref_)) THEN 
     
    530455      ENDIF 
    531456 
     457      IF (PRESENT(begin_)) THEN 
     458        begin__tmp = cxios_is_defined_axisgroup_begin(axisgroup_hdl%daddr) 
     459        begin_ = begin__tmp 
     460      ENDIF 
     461 
    532462      IF (PRESENT(bounds_)) THEN 
    533463        bounds__tmp = cxios_is_defined_axisgroup_bounds(axisgroup_hdl%daddr) 
     
    555485      ENDIF 
    556486 
    557       IF (PRESENT(ibegin_)) THEN 
    558         ibegin__tmp = cxios_is_defined_axisgroup_ibegin(axisgroup_hdl%daddr) 
    559         ibegin_ = ibegin__tmp 
    560       ENDIF 
    561  
    562487      IF (PRESENT(long_name_)) THEN 
    563488        long_name__tmp = cxios_is_defined_axisgroup_long_name(axisgroup_hdl%daddr) 
     
    570495      ENDIF 
    571496 
     497      IF (PRESENT(n_)) THEN 
     498        n__tmp = cxios_is_defined_axisgroup_n(axisgroup_hdl%daddr) 
     499        n_ = n__tmp 
     500      ENDIF 
     501 
     502      IF (PRESENT(n_glo_)) THEN 
     503        n_glo__tmp = cxios_is_defined_axisgroup_n_glo(axisgroup_hdl%daddr) 
     504        n_glo_ = n_glo__tmp 
     505      ENDIF 
     506 
    572507      IF (PRESENT(name_)) THEN 
    573508        name__tmp = cxios_is_defined_axisgroup_name(axisgroup_hdl%daddr) 
     
    575510      ENDIF 
    576511 
    577       IF (PRESENT(ni_)) THEN 
    578         ni__tmp = cxios_is_defined_axisgroup_ni(axisgroup_hdl%daddr) 
    579         ni_ = ni__tmp 
    580       ENDIF 
    581  
    582512      IF (PRESENT(positive_)) THEN 
    583513        positive__tmp = cxios_is_defined_axisgroup_positive(axisgroup_hdl%daddr) 
     
    585515      ENDIF 
    586516 
    587       IF (PRESENT(size_)) THEN 
    588         size__tmp = cxios_is_defined_axisgroup_size(axisgroup_hdl%daddr) 
    589         size_ = size__tmp 
    590       ENDIF 
    591  
    592517      IF (PRESENT(standard_name_)) THEN 
    593518        standard_name__tmp = cxios_is_defined_axisgroup_standard_name(axisgroup_hdl%daddr) 
     
    605530      ENDIF 
    606531 
    607       IF (PRESENT(zoom_begin_)) THEN 
    608         zoom_begin__tmp = cxios_is_defined_axisgroup_zoom_begin(axisgroup_hdl%daddr) 
    609         zoom_begin_ = zoom_begin__tmp 
    610       ENDIF 
    611  
    612       IF (PRESENT(zoom_end_)) THEN 
    613         zoom_end__tmp = cxios_is_defined_axisgroup_zoom_end(axisgroup_hdl%daddr) 
    614         zoom_end_ = zoom_end__tmp 
    615       ENDIF 
    616  
    617       IF (PRESENT(zoom_size_)) THEN 
    618         zoom_size__tmp = cxios_is_defined_axisgroup_zoom_size(axisgroup_hdl%daddr) 
    619         zoom_size_ = zoom_size__tmp 
    620       ENDIF 
    621  
    622532  END SUBROUTINE xios(is_defined_axisgroup_attr_hdl_) 
    623533 
  • XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90

    r664 r666  
    1313  SUBROUTINE xios(set_domain_attr)  & 
    1414    ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    15     , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    16     , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    17     , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     15    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     16    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     17    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    1818 
    1919    IMPLICIT NONE 
     
    3030      INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index(:) 
    3131      INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin 
    32       INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index 
    3332      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni 
    3433      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj 
     
    6059      CALL xios(set_domain_attr_hdl_)   & 
    6160      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    62       , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    63       , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    64       , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     61      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     62      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     63      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    6564 
    6665  END SUBROUTINE xios(set_domain_attr) 
     
    6867  SUBROUTINE xios(set_domain_attr_hdl)  & 
    6968    ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    70     , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    71     , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    72     , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     69    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     70    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     71    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    7372 
    7473    IMPLICIT NONE 
     
    8483      INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index(:) 
    8584      INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin 
    86       INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index 
    8785      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni 
    8886      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj 
     
    113111      CALL xios(set_domain_attr_hdl_)  & 
    114112      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    115       , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    116       , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    117       , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     113      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     114      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     115      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    118116 
    119117  END SUBROUTINE xios(set_domain_attr_hdl) 
     
    121119  SUBROUTINE xios(set_domain_attr_hdl_)   & 
    122120    ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    123     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  & 
    124     , domain_group_ref_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  & 
    125     , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  & 
    126     , nvertex_, standard_name_, type_ ) 
     121    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  & 
     122    , domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_  & 
     123    , lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_  & 
     124    , standard_name_, type_ ) 
    127125 
    128126    IMPLICIT NONE 
     
    138136      INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index_(:) 
    139137      INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin_ 
    140       INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index_ 
    141138      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni_ 
    142139      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj_ 
     
    205202      ENDIF 
    206203 
    207       IF (PRESENT(data_n_index_)) THEN 
    208         CALL cxios_set_domain_data_n_index(domain_hdl%daddr, data_n_index_) 
    209       ENDIF 
    210  
    211204      IF (PRESENT(data_ni_)) THEN 
    212205        CALL cxios_set_domain_data_ni(domain_hdl%daddr, data_ni_) 
     
    309302  SUBROUTINE xios(get_domain_attr)  & 
    310303    ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    311     , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    312     , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    313     , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     304    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     305    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     306    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    314307 
    315308    IMPLICIT NONE 
     
    326319      INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index(:) 
    327320      INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin 
    328       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index 
    329321      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni 
    330322      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj 
     
    356348      CALL xios(get_domain_attr_hdl_)   & 
    357349      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    358       , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    359       , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    360       , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     350      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     351      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     352      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    361353 
    362354  END SUBROUTINE xios(get_domain_attr) 
     
    364356  SUBROUTINE xios(get_domain_attr_hdl)  & 
    365357    ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    366     , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    367     , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    368     , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     358    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     359    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     360    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    369361 
    370362    IMPLICIT NONE 
     
    380372      INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index(:) 
    381373      INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin 
    382       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index 
    383374      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni 
    384375      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj 
     
    409400      CALL xios(get_domain_attr_hdl_)  & 
    410401      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    411       , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    412       , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    413       , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     402      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     403      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     404      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    414405 
    415406  END SUBROUTINE xios(get_domain_attr_hdl) 
     
    417408  SUBROUTINE xios(get_domain_attr_hdl_)   & 
    418409    ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    419     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  & 
    420     , domain_group_ref_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  & 
    421     , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  & 
    422     , nvertex_, standard_name_, type_ ) 
     410    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  & 
     411    , domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_  & 
     412    , lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_  & 
     413    , standard_name_, type_ ) 
    423414 
    424415    IMPLICIT NONE 
     
    434425      INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index_(:) 
    435426      INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin_ 
    436       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index_ 
    437427      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni_ 
    438428      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj_ 
     
    501491      ENDIF 
    502492 
    503       IF (PRESENT(data_n_index_)) THEN 
    504         CALL cxios_get_domain_data_n_index(domain_hdl%daddr, data_n_index_) 
    505       ENDIF 
    506  
    507493      IF (PRESENT(data_ni_)) THEN 
    508494        CALL cxios_get_domain_data_ni(domain_hdl%daddr, data_ni_) 
     
    605591  SUBROUTINE xios(is_defined_domain_attr)  & 
    606592    ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    607     , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    608     , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    609     , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     593    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     594    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     595    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    610596 
    611597    IMPLICIT NONE 
     
    632618      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin 
    633619      LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp 
    634       LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index 
    635       LOGICAL(KIND=C_BOOL) :: data_n_index_tmp 
    636620      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni 
    637621      LOGICAL(KIND=C_BOOL) :: data_ni_tmp 
     
    684668      CALL xios(is_defined_domain_attr_hdl_)   & 
    685669      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    686       , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    687       , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    688       , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     670      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     671      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     672      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    689673 
    690674  END SUBROUTINE xios(is_defined_domain_attr) 
     
    692676  SUBROUTINE xios(is_defined_domain_attr_hdl)  & 
    693677    ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    694     , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    695     , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    696     , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     678    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     679    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     680    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    697681 
    698682    IMPLICIT NONE 
     
    718702      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin 
    719703      LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp 
    720       LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index 
    721       LOGICAL(KIND=C_BOOL) :: data_n_index_tmp 
    722704      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni 
    723705      LOGICAL(KIND=C_BOOL) :: data_ni_tmp 
     
    769751      CALL xios(is_defined_domain_attr_hdl_)  & 
    770752      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    771       , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  & 
    772       , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    773       , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
     753      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  & 
     754      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  & 
     755      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type ) 
    774756 
    775757  END SUBROUTINE xios(is_defined_domain_attr_hdl) 
     
    777759  SUBROUTINE xios(is_defined_domain_attr_hdl_)   & 
    778760    ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    779     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  & 
    780     , domain_group_ref_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  & 
    781     , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  & 
    782     , nvertex_, standard_name_, type_ ) 
     761    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  & 
     762    , domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_  & 
     763    , lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_  & 
     764    , standard_name_, type_ ) 
    783765 
    784766    IMPLICIT NONE 
     
    804786      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin_ 
    805787      LOGICAL(KIND=C_BOOL) :: data_jbegin__tmp 
    806       LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index_ 
    807       LOGICAL(KIND=C_BOOL) :: data_n_index__tmp 
    808788      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni_ 
    809789      LOGICAL(KIND=C_BOOL) :: data_ni__tmp 
     
    903883      ENDIF 
    904884 
    905       IF (PRESENT(data_n_index_)) THEN 
    906         data_n_index__tmp = cxios_is_defined_domain_data_n_index(domain_hdl%daddr) 
    907         data_n_index_ = data_n_index__tmp 
    908       ENDIF 
    909  
    910885      IF (PRESENT(data_ni_)) THEN 
    911886        data_ni__tmp = cxios_is_defined_domain_data_ni(domain_hdl%daddr) 
  • XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90

    r664 r666  
    1313  SUBROUTINE xios(set_domaingroup_attr)  & 
    1414    ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    15     , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    16     , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    17     , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    18     , type ) 
     15    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     16    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     17    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     18    ) 
    1919 
    2020    IMPLICIT NONE 
     
    3131      INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index(:) 
    3232      INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin 
    33       INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index 
    3433      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni 
    3534      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj 
     
    6261      CALL xios(set_domaingroup_attr_hdl_)   & 
    6362      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    64       , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    65       , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    66       , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    67       , type ) 
     63      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     64      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     65      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     66      ) 
    6867 
    6968  END SUBROUTINE xios(set_domaingroup_attr) 
     
    7170  SUBROUTINE xios(set_domaingroup_attr_hdl)  & 
    7271    ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    73     , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    74     , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    75     , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    76     , type ) 
     72    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     73    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     74    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     75    ) 
    7776 
    7877    IMPLICIT NONE 
     
    8887      INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index(:) 
    8988      INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin 
    90       INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index 
    9189      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni 
    9290      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj 
     
    118116      CALL xios(set_domaingroup_attr_hdl_)  & 
    119117      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    120       , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    121       , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    122       , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    123       , type ) 
     118      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     119      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     120      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     121      ) 
    124122 
    125123  END SUBROUTINE xios(set_domaingroup_attr_hdl) 
     
    127125  SUBROUTINE xios(set_domaingroup_attr_hdl_)   & 
    128126    ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    129     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  & 
    130     , domain_group_ref_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_  & 
    131     , latvalue_2d_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_  & 
    132     , nj_, nj_glo_, nvertex_, standard_name_, type_ ) 
     127    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  & 
     128    , domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  & 
     129    , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  & 
     130    , nvertex_, standard_name_, type_ ) 
    133131 
    134132    IMPLICIT NONE 
     
    144142      INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index_(:) 
    145143      INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin_ 
    146       INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index_ 
    147144      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni_ 
    148145      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj_ 
     
    212209      ENDIF 
    213210 
    214       IF (PRESENT(data_n_index_)) THEN 
    215         CALL cxios_set_domaingroup_data_n_index(domaingroup_hdl%daddr, data_n_index_) 
    216       ENDIF 
    217  
    218211      IF (PRESENT(data_ni_)) THEN 
    219212        CALL cxios_set_domaingroup_data_ni(domaingroup_hdl%daddr, data_ni_) 
     
    320313  SUBROUTINE xios(get_domaingroup_attr)  & 
    321314    ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    322     , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    323     , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    324     , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    325     , type ) 
     315    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     316    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     317    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     318    ) 
    326319 
    327320    IMPLICIT NONE 
     
    338331      INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index(:) 
    339332      INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin 
    340       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index 
    341333      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni 
    342334      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj 
     
    369361      CALL xios(get_domaingroup_attr_hdl_)   & 
    370362      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    371       , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    372       , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    373       , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    374       , type ) 
     363      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     364      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     365      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     366      ) 
    375367 
    376368  END SUBROUTINE xios(get_domaingroup_attr) 
     
    378370  SUBROUTINE xios(get_domaingroup_attr_hdl)  & 
    379371    ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    380     , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    381     , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    382     , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    383     , type ) 
     372    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     373    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     374    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     375    ) 
    384376 
    385377    IMPLICIT NONE 
     
    395387      INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index(:) 
    396388      INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin 
    397       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index 
    398389      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni 
    399390      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj 
     
    425416      CALL xios(get_domaingroup_attr_hdl_)  & 
    426417      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    427       , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    428       , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    429       , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    430       , type ) 
     418      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     419      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     420      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     421      ) 
    431422 
    432423  END SUBROUTINE xios(get_domaingroup_attr_hdl) 
     
    434425  SUBROUTINE xios(get_domaingroup_attr_hdl_)   & 
    435426    ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    436     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  & 
    437     , domain_group_ref_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_  & 
    438     , latvalue_2d_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_  & 
    439     , nj_, nj_glo_, nvertex_, standard_name_, type_ ) 
     427    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  & 
     428    , domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  & 
     429    , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  & 
     430    , nvertex_, standard_name_, type_ ) 
    440431 
    441432    IMPLICIT NONE 
     
    451442      INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index_(:) 
    452443      INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin_ 
    453       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index_ 
    454444      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni_ 
    455445      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj_ 
     
    519509      ENDIF 
    520510 
    521       IF (PRESENT(data_n_index_)) THEN 
    522         CALL cxios_get_domaingroup_data_n_index(domaingroup_hdl%daddr, data_n_index_) 
    523       ENDIF 
    524  
    525511      IF (PRESENT(data_ni_)) THEN 
    526512        CALL cxios_get_domaingroup_data_ni(domaingroup_hdl%daddr, data_ni_) 
     
    627613  SUBROUTINE xios(is_defined_domaingroup_attr)  & 
    628614    ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    629     , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    630     , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    631     , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    632     , type ) 
     615    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     616    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     617    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     618    ) 
    633619 
    634620    IMPLICIT NONE 
     
    655641      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin 
    656642      LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp 
    657       LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index 
    658       LOGICAL(KIND=C_BOOL) :: data_n_index_tmp 
    659643      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni 
    660644      LOGICAL(KIND=C_BOOL) :: data_ni_tmp 
     
    709693      CALL xios(is_defined_domaingroup_attr_hdl_)   & 
    710694      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    711       , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    712       , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    713       , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    714       , type ) 
     695      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     696      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     697      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     698      ) 
    715699 
    716700  END SUBROUTINE xios(is_defined_domaingroup_attr) 
     
    718702  SUBROUTINE xios(is_defined_domaingroup_attr_hdl)  & 
    719703    ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    720     , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    721     , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    722     , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    723     , type ) 
     704    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     705    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     706    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     707    ) 
    724708 
    725709    IMPLICIT NONE 
     
    745729      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin 
    746730      LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp 
    747       LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index 
    748       LOGICAL(KIND=C_BOOL) :: data_n_index_tmp 
    749731      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni 
    750732      LOGICAL(KIND=C_BOOL) :: data_ni_tmp 
     
    798780      CALL xios(is_defined_domaingroup_attr_hdl_)  & 
    799781      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    800       , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  & 
    801       , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  & 
    802       , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  & 
    803       , type ) 
     782      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  & 
     783      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  & 
     784      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  & 
     785      ) 
    804786 
    805787  END SUBROUTINE xios(is_defined_domaingroup_attr_hdl) 
     
    807789  SUBROUTINE xios(is_defined_domaingroup_attr_hdl_)   & 
    808790    ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    809     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  & 
    810     , domain_group_ref_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_  & 
    811     , latvalue_2d_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_  & 
    812     , nj_, nj_glo_, nvertex_, standard_name_, type_ ) 
     791    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  & 
     792    , domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  & 
     793    , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  & 
     794    , nvertex_, standard_name_, type_ ) 
    813795 
    814796    IMPLICIT NONE 
     
    834816      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin_ 
    835817      LOGICAL(KIND=C_BOOL) :: data_jbegin__tmp 
    836       LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index_ 
    837       LOGICAL(KIND=C_BOOL) :: data_n_index__tmp 
    838818      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni_ 
    839819      LOGICAL(KIND=C_BOOL) :: data_ni__tmp 
     
    935915      ENDIF 
    936916 
    937       IF (PRESENT(data_n_index_)) THEN 
    938         data_n_index__tmp = cxios_is_defined_domaingroup_data_n_index(domaingroup_hdl%daddr) 
    939         data_n_index_ = data_n_index__tmp 
    940       ENDIF 
    941  
    942917      IF (PRESENT(data_ni_)) THEN 
    943918        data_ni__tmp = cxios_is_defined_domaingroup_data_ni(domaingroup_hdl%daddr) 
  • XIOS/trunk/src/node/axis.cpp

    r657 r666  
    7676   void CAxis::checkAttributes(void) 
    7777   { 
    78       if (this->size.isEmpty()) 
     78      if (this->n_glo.isEmpty()) 
    7979         ERROR("CAxis::checkAttributes(void)", 
    80                << "Attribute <size> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be specified"); 
    81       StdSize size = this->size.getValue(); 
    82  
    83       isDistributed_ = !this->ibegin.isEmpty() || !this->ni.isEmpty(); 
    84  
    85       if (!this->ibegin.isEmpty()) 
    86       { 
    87         StdSize ibegin = this->ibegin.getValue(); 
     80               << "Attribute <n_glo> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be specified"); 
     81      StdSize size = this->n_glo.getValue(); 
     82 
     83      isDistributed_ = !this->begin.isEmpty() || !this->n.isEmpty(); 
     84 
     85      if (!this->begin.isEmpty()) 
     86      { 
     87        StdSize ibegin = this->begin.getValue(); 
    8888        if ((ibegin < 0) || (ibegin > size-1)) 
    8989          ERROR("CAxis::checkAttributes(void)", 
    9090                << "Attribute <ibegin> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be non-negative and smaller than size-1"); 
    9191      } 
    92       else this->ibegin.setValue(0); 
    93  
    94       if (!this->ni.isEmpty()) 
    95       { 
    96         StdSize ni = this->ni.getValue(); 
     92      else this->begin.setValue(0); 
     93 
     94      if (!this->n.isEmpty()) 
     95      { 
     96        StdSize ni = this->n.getValue(); 
    9797        if ((ni < 0) || (ni > size)) 
    9898          ERROR("CAxis::checkAttributes(void)", 
    9999                << "Attribute <ni> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be non-negative and smaller than size"); 
    100100      } 
    101       else this->ni.setValue(size); 
     101      else this->n.setValue(size); 
    102102 
    103103      StdSize true_size = value.numElements(); 
    104       if (this->ni.getValue() != true_size) 
     104      if (this->n.getValue() != true_size) 
    105105         ERROR("CAxis::checkAttributes(void)", 
    106106               << "The array \'value\' of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] has a different size that the one defined by the \'size\' attribute"); 
     
    121121      } 
    122122      else if (data_n.isEmpty()) 
    123         data_n.setValue(ni.getValue()); 
     123        data_n.setValue(n.getValue()); 
    124124 
    125125      if (data_index.isEmpty()) 
     
    127127        int dn = data_n.getValue(); 
    128128        data_index.resize(dn); 
    129         for (int i = 0; i < dn; ++i) data_index(i) = (i+1); 
     129        for (int i = 0; i < dn; ++i) data_index(i) = i; 
    130130      } 
    131131   } 
     
    133133   void CAxis::checkZoom(void) 
    134134   { 
    135      if (0 == global_zoom_size) global_zoom_size = this->size.getValue(); 
     135     if (0 == global_zoom_size) global_zoom_size = this->n_glo.getValue(); 
    136136   } 
    137137 
    138138   void CAxis::checkMask() 
    139139   { 
    140       int begin_mask = 0, 
    141           end_mask = ni.getValue()-1; 
    142  
    143       if (!zoom_begin.isEmpty()) 
    144       { 
    145          int zoom_end = zoom_begin.getValue() + zoom_size.getValue() - 1; 
    146  
    147          begin_mask = std::max(ibegin.getValue(), zoom_begin.getValue()); 
    148          end_mask   = std::min(ibegin.getValue() + ni.getValue()-1, zoom_end); 
    149  
    150          begin_mask -= ibegin.getValue(); 
    151          end_mask   -= ibegin.getValue(); 
    152       } 
    153  
    154  
    155140      if (!mask.isEmpty()) 
    156141      { 
    157          if (mask.extent(0) != ni) 
     142         if (mask.extent(0) != n) 
    158143            ERROR("CAxis::checkMask(void)", 
    159144                  << "the mask has not the same size than the local axis" << endl 
    160                   << "Local size is " << ni << "x" << endl 
     145                  << "Local size is " << n << "x" << endl 
    161146                  << "Mask size is " << mask.extent(0) << "x"); 
    162          for (int i = 0; i < ni; ++i) 
    163          { 
    164            if (i < begin_mask && i > end_mask)  mask(i) = false; 
    165          } 
    166147      } 
    167148      else // (!mask.hasValue()) 
    168149      { // Si aucun masque n'est défini, 
    169150        // on en crée un nouveau qui valide l'intégralité du domaine. 
    170          mask.resize(ni); 
    171          for (int i = 0; i < ni.getValue(); ++i) 
     151         mask.resize(n); 
     152         for (int i = 0; i < n.getValue(); ++i) 
    172153         { 
    173                if (i >= begin_mask && i <= end_mask) 
    174                  mask(i) = true; 
    175                else  mask(i) = false; 
     154           mask(i) = true; 
    176155         } 
    177156      } 
     
    182161    if (!bounds.isEmpty()) 
    183162    { 
    184       if (bounds.extent(0) != ni || bounds.extent(1) != 2) 
     163      if (bounds.extent(0) != n || bounds.extent(1) != 2) 
    185164          ERROR("CAxis::checkAttributes(void)", 
    186165                << "The bounds array of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be of dimension axis size x 2" << endl 
    187                 << "Axis size is " << ni << endl 
     166                << "Axis size is " << n << endl 
    188167                << "Bounds size is "<< bounds.extent(0) << " x " << bounds.extent(1)); 
    189168      hasBounds_ = true; 
     
    255234  void CAxis::sendValue() 
    256235  { 
    257      if (ni.getValue() == size.getValue()) 
     236     if (n.getValue() == n_glo.getValue()) 
    258237     { 
    259238       sendNonDistributedValue(); 
     
    272251    int nbServer = client->serverSize; 
    273252    int range, clientSize = client->clientSize; 
     253    size_t ni = this->n.getValue(); 
     254    size_t ibegin = this->begin.getValue(); 
    274255 
    275256    CArray<size_t,1> globalIndexAxis(ni); 
    276     size_t ibegin = this->ibegin.getValue(); 
    277257    int zoom_end = global_zoom_begin+global_zoom_size-1; 
    278258    std::vector<size_t> globalAxisZoom; 
     
    285265 
    286266    std::vector<int> nGlobDomain(1); 
    287     nGlobDomain[0] = size.getValue(); 
     267    nGlobDomain[0] = n_glo.getValue(); 
    288268 
    289269    size_t globalSizeIndex = 1, indexBegin, indexEnd; 
     
    348328    int zoom_end = global_zoom_begin+global_zoom_size-1; 
    349329    int nb =0; 
    350     for (size_t idx = 0; idx < ni; ++idx) 
    351     { 
    352       size_t globalIndex = ibegin + idx; 
     330    for (size_t idx = 0; idx < n; ++idx) 
     331    { 
     332      size_t globalIndex = begin + idx; 
    353333      if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end) ++nb; 
    354334    } 
     
    356336    CArray<double,1> val(nb); 
    357337    nb = 0; 
    358     for (size_t idx = 0; idx < ni; ++idx) 
    359     { 
    360       size_t globalIndex = ibegin + idx; 
     338    for (size_t idx = 0; idx < n; ++idx) 
     339    { 
     340      size_t globalIndex = begin + idx; 
    361341      if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end) 
    362342      { 
     
    424404      { 
    425405        idx = static_cast<int>(it->second[n]); 
    426         ind = idx - ibegin; 
     406        ind = idx - begin; 
    427407 
    428408        val(n) = value(ind); 
     
    602582    } 
    603583 
    604     if (size == ni) 
     584    if (n_glo == n) 
    605585    { 
    606586      zoom_begin_srv = global_zoom_begin; 
  • XIOS/trunk/src/node/domain.cpp

    r665 r666  
    138138     checkLocalIDomain(); 
    139139     checkLocalJDomain(); 
    140  
    141      ibegin_client = ibegin; ni_client = ni; iend_client = ibegin + ni - 1; 
    142      jbegin_client = jbegin; nj_client = nj; jend_client = jbegin + nj - 1; 
    143140 
    144141     if (i_index.isEmpty()) 
     
    340337            data_i_index.resize(dni) ; 
    341338            data_j_index.resize(dni) ; 
    342             data_n_index.setValue(dni); 
     339 
    343340            for (int i = 0; i < dni; ++i) 
    344341            { 
     
    353350            data_j_index.resize(dni) ; 
    354351 
    355             data_n_index.setValue(dni); 
    356  
    357352            for(int count = 0, j = 0; j  < data_nj.getValue(); ++j) 
    358353            { 
     
    367362   } 
    368363 
    369    void CDomain::completeLonClient() 
     364   //---------------------------------------------------------------- 
     365   void CDomain::completeLonLatClient(void) 
    370366   { 
    371367     int i,j,k ; 
    372368     CArray<double,1> lonvalue_temp(ni*nj) ; 
    373369     CArray<double,2> bounds_lon_temp(nvertex,ni*nj); 
    374  
    375      if (!lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty()) 
    376        ERROR("CDomain::completeLonLatClient(void)", 
    377             <<"Only one longitude value can be used but both lonvalue_1d and lonvalue_2d are defined! "<<endl 
    378             <<"Define only one longitude value: lonvalue_1d or lonvalue_2d "); 
    379  
    380      if (!lonvalue_1d.isEmpty() && lonvalue_2d.isEmpty()) 
    381      { 
    382        if (lonvalue_1d.numElements() != i_index.numElements()) 
    383          ERROR("CDomain::completeLonLatClient(void)", 
    384                <<"lonvalue_1d has not the same size as the local domain"<<endl 
    385                <<"Local size is "<<i_index.numElements()<<endl 
    386                <<"lonvalue_1d size is "<<lonvalue_1d.numElements()); 
    387      } 
    388  
    389      if (lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty()) 
    390      { 
    391         if ((lonvalue_2d.extent(0) != ni) || 
    392             (lonvalue_2d.extent(1) != nj)) 
    393            ERROR("CDomain::completeLonLatClient(void)", 
    394                  <<"the lonvalue has not the same size as the local domain"<<endl 
    395                  <<"Local size is "<<ni<<"x"<<nj<<endl 
    396                  <<"Lonvalue size is "<<lonvalue_2d.extent(0)<<"x"<<lonvalue_2d.extent(1)); 
    397      } 
     370     CArray<double,1> latvalue_temp(ni*nj) ; 
     371     CArray<double,2> bounds_lat_temp(nvertex,ni*nj); 
    398372 
    399373     if (!lonvalue_2d.isEmpty()) 
     
    403377          { 
    404378            lonvalue_temp(i+j*ni) = lonvalue_2d(i,j); 
     379            latvalue_temp(i+j*ni) = latvalue_2d(i,j); 
    405380            if (hasBounds) 
    406381            { 
    407382              k=j*ni+i; 
    408               for(int n=0;n<nvertex;++n) bounds_lon_temp(n,k) = bounds_lon_2d(n,i,j); 
     383              for(int n=0;n<nvertex;++n) 
     384              { 
     385                bounds_lon_temp(n,k) = bounds_lon_2d(n,i,j); 
     386                bounds_lat_temp(n,k) = bounds_lat_2d(n,i,j); 
     387              } 
    409388            } 
    410389          } 
     
    415394       if (type_attr::rectilinear == type) 
    416395       { 
    417          if (ni == lonvalue_1d.numElements()) 
     396         if ((ni == lonvalue_1d.numElements()) && (nj == latvalue_1d.numElements())) 
    418397         { 
    419398           for(j=0;j<nj;++j) 
     
    422401               k=j*ni+i; 
    423402               lonvalue_temp(k) = lonvalue_1d(i); 
     403               latvalue_temp(k) = latvalue_1d(j); 
    424404               if (hasBounds) 
    425405               { 
    426                  for(int n=0;n<nvertex;++n) bounds_lon_temp(n,k) = bounds_lon_1d(n,i); 
     406                 for(int n=0;n<nvertex;++n) 
     407                 { 
     408                   bounds_lon_temp(n,k) = bounds_lon_1d(n,i); 
     409                   bounds_lat_temp(n,k) = bounds_lat_1d(n,j); 
     410                 } 
    427411               } 
    428412             } 
     
    430414          else 
    431415            ERROR("CDomain::completeLonClient(void)", 
    432                  <<"The lonvalue_1d has not the same size as the local domain"<<endl 
    433                  <<"Local size is "<<ni<<endl 
    434                  <<"Lonvalue_1d size is "<<lonvalue_1d.numElements()); 
     416                 <<"lonvalue_1d and latvalue_1d has not the same size as the local domain"<<endl 
     417                 <<"Local size is "<<ni<<"x " << nj<< endl 
     418                 <<"lonvalue_1d size is "<<lonvalue_1d.numElements() 
     419                 <<"latvalue_1d size is "<<latvalue_1d.numElements()); 
    435420       } 
    436421       else if (type==type_attr::curvilinear || type==type_attr::unstructured) 
    437422       { 
    438423         lonvalue_temp=lonvalue_1d; 
     424         latvalue_temp=latvalue_1d; 
    439425         if (hasBounds) 
    440426         { 
    441427           bounds_lon_temp=bounds_lon_1d; 
    442          } 
    443        } 
    444      } 
    445  
    446      StdSize dm = zoom_ni_client * zoom_nj_client; 
    447  
    448       // Make sure that this attribute is non-empty for every client. 
    449      if (0 != dm) 
    450      { 
    451        lonvalue_client.resize(dm); 
    452        if (hasBounds) bounds_lon_client.resize(nvertex, dm); 
    453      } 
    454  
    455  
    456      for (i = 0; i < zoom_ni_client; ++i) 
    457      { 
    458        for (j = 0; j < zoom_nj_client; ++j) 
    459        { 
    460          lonvalue_client(i + j * zoom_ni_client) = lonvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
    461          if (hasBounds) 
    462          { 
    463            for(int n=0;n<nvertex;n++) 
    464            { 
    465              bounds_lon_client(n,i + j * zoom_ni_client) = bounds_lon_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
    466            } 
    467          } 
    468        } 
    469      } 
    470    } 
    471  
    472    void CDomain::completeLatClient() 
    473    { 
    474      int i,j,k; 
    475      CArray<double,1> latvalue_temp(ni*nj) ; 
    476      CArray<double,2> bounds_lat_temp(nvertex,ni*nj); 
    477  
    478      if (!latvalue_1d.isEmpty() && !latvalue_2d.isEmpty()) 
    479        ERROR("CDomain::completeLonLatClient(void)", 
    480             <<"Only one longitude value can be used but both latvalue_1d and latvalue_2d are defined! "<<endl 
    481             <<"Define only one longitude value: latvalue_1d or latvalue_2d "); 
    482  
    483      if (!latvalue_1d.isEmpty() && latvalue_2d.isEmpty()) 
    484      { 
    485        if (latvalue_1d.numElements() != i_index.numElements()) 
    486          ERROR("CDomain::completeLonLatClient(void)", 
    487                <<"the latvalue_1d has not the same size as the local domain"<<endl 
    488                <<"Local size is "<<i_index.numElements()<<endl 
    489                <<"Mask size is "<<latvalue_1d.numElements()); 
    490      } 
    491  
    492      if (latvalue_1d.isEmpty() && !latvalue_2d.isEmpty()) 
    493      { 
    494         if ((latvalue_2d.extent(0) != ni) || 
    495             (latvalue_2d.extent(1) != nj)) 
    496            ERROR("CDomain::completeLonLatClient(void)", 
    497                  <<"the mask has not the same size as the local domain"<<endl 
    498                  <<"Local size is "<<ni<<"x"<<nj<<endl 
    499                  <<"Mask size is "<<latvalue_2d.extent(0)<<"x"<<latvalue_2d.extent(1)); 
    500      } 
    501  
    502      if (!latvalue_2d.isEmpty()) 
    503      { 
    504         for (j = 0; j < nj; ++j) 
    505           for (i = 0; i < ni; ++i) 
    506           { 
    507             latvalue_temp(i+j*ni) = latvalue_2d(i,j); 
    508             if (hasBounds) 
    509             { 
    510               k=j*ni+i; 
    511               for(int n=0;n<nvertex;n++) bounds_lat_temp(n,k) = bounds_lat_2d(n,i,j); 
    512             } 
    513           } 
    514      } 
    515  
    516      if (!latvalue_1d.isEmpty()) 
    517      { 
    518        if (type_attr::rectilinear == type) 
    519        { 
    520  
    521          if (nj == latvalue_1d.numElements()) 
    522          { 
    523            for(j=0;j<nj;++j) 
    524              for(i=0;i<ni;++i) 
    525              { 
    526                k=j*ni+i; 
    527                latvalue_temp(k) = latvalue_1d(j); 
    528                if (hasBounds) 
    529                { 
    530                  for(int n=0;n<nvertex;n++) bounds_lat_temp(n,k) = bounds_lat_1d(n,j); 
    531                } 
    532              } 
    533           } 
    534           else 
    535             ERROR("CDomain::completeLonClient(void)", 
    536                  <<"The latvalue_1d has not the same size as the local domain"<<endl 
    537                  <<"Local size is "<<nj<<endl 
    538                  <<"Latvalue_1d size is "<<latvalue_1d.numElements()); 
    539        } 
    540        else if (type==type_attr::curvilinear || type==type_attr::unstructured) 
    541        { 
    542          latvalue_temp=latvalue_1d; 
    543          if (hasBounds) 
    544          { 
    545428           bounds_lat_temp=bounds_lat_1d; 
    546429         } 
     
    548431     } 
    549432 
    550      StdSize dm = zoom_ni_client * zoom_nj_client; 
     433    int i_ind,j_ind; 
     434    int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
     435    int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
     436 
     437    int globalIndexCountZoom = 0; 
     438    int nbIndex = i_index.numElements(); 
     439    for (i = 0; i < nbIndex; ++i) 
     440    { 
     441      i_ind=i_index(i); 
     442      j_ind=j_index(i); 
     443 
     444      if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
     445      { 
     446        ++globalIndexCountZoom; 
     447      } 
     448    } 
    551449 
    552450      // Make sure that this attribute is non-empty for every client. 
    553      if (0 != dm) 
    554      { 
    555        latvalue_client.resize(dm); 
    556        if (hasBounds) bounds_lat_client.resize(nvertex,dm); 
    557      } 
    558  
    559      for (i = 0; i < zoom_ni_client; i++) 
    560      { 
    561        for (j = 0; j < zoom_nj_client; j++) 
     451     if (0 != globalIndexCountZoom) 
     452     { 
     453       lonvalue_client.resize(globalIndexCountZoom); 
     454       latvalue_client.resize(globalIndexCountZoom); 
     455       if (hasBounds) 
    562456       { 
    563          latvalue_client(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
     457         bounds_lon_client.resize(nvertex,globalIndexCountZoom); 
     458         bounds_lat_client.resize(nvertex,globalIndexCountZoom); 
     459       } 
     460     } 
     461 
     462     int nCountZoom = 0; 
     463     for (i = 0; i < nbIndex; ++i) 
     464     { 
     465       i_ind=i_index(i); 
     466       j_ind=j_index(i); 
     467 
     468       if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
     469       { 
     470         lonvalue_client(nCountZoom) = lonvalue_temp(i); 
     471         latvalue_client(nCountZoom) = latvalue_temp(i); 
    564472         if (hasBounds) 
    565473         { 
    566            for(int n=0;n<nvertex;n++) 
     474           for (int n = 0; n < nvertex; ++n) 
    567475           { 
    568              bounds_lat_client(n,i + j * zoom_ni_client) = bounds_lat_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
     476             bounds_lon_client(n,nCountZoom) = bounds_lon_temp(n,i); 
     477             bounds_lat_client(n,nCountZoom) = bounds_lat_temp(n,i); 
    569478           } 
    570479         } 
     480         ++nCountZoom; 
    571481       } 
    572482     } 
    573    } 
    574  
    575    //---------------------------------------------------------------- 
    576    void CDomain::completeLonLatClient(void) 
    577    { 
    578      completeLonClient(); 
    579      completeLatClient(); 
    580    } 
    581  
    582  
    583    //---------------------------------------------------------------- 
    584    void CDomain::checkZoom(void) 
    585    { 
    586       int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ; 
    587       zoom_ibegin_client = ibegin_client > global_zoom_ibegin ? ibegin_client : global_zoom_ibegin ; 
    588       zoom_iend_client = iend_client < global_zoom_iend ? iend_client : global_zoom_iend ; 
    589       zoom_ni_client=zoom_iend_client-zoom_ibegin_client+1 ; 
    590       if (zoom_ni_client<0) zoom_ni_client=0 ; 
    591  
    592  
    593       int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ; 
    594       zoom_jbegin_client = jbegin_client > global_zoom_jbegin ? jbegin_client : global_zoom_jbegin ; 
    595       zoom_jend_client = jend_client < global_zoom_jend ? jend_client : global_zoom_jend ; 
    596       zoom_nj_client=zoom_jend_client-zoom_jbegin_client+1 ; 
    597       if (zoom_nj_client<0) zoom_nj_client=0; 
    598483   } 
    599484 
     
    691576     hasLonLat = (!latvalue_1d.isEmpty() && !lonvalue_1d.isEmpty()) || 
    692577                 (!latvalue_2d.isEmpty() && !lonvalue_2d.isEmpty()); 
     578     if (hasLonLat) 
     579     { 
     580       if (!lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty()) 
     581         ERROR("CDomain::completeLonLatClient(void)", 
     582              <<"Only one longitude value can be used but both lonvalue_1d and lonvalue_2d are defined! "<<endl 
     583              <<"Define only one longitude value: lonvalue_1d or lonvalue_2d "); 
     584 
     585       if (!lonvalue_1d.isEmpty() && lonvalue_2d.isEmpty()) 
     586       { 
     587         if (lonvalue_1d.numElements() != i_index.numElements()) 
     588           ERROR("CDomain::completeLonLatClient(void)", 
     589                 <<"lonvalue_1d has not the same size as the local domain"<<endl 
     590                 <<"Local size is "<<i_index.numElements()<<endl 
     591                 <<"lonvalue_1d size is "<<lonvalue_1d.numElements()); 
     592       } 
     593 
     594       if (lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty()) 
     595       { 
     596          if ((lonvalue_2d.extent(0) != ni) || 
     597              (lonvalue_2d.extent(1) != nj)) 
     598             ERROR("CDomain::completeLonLatClient(void)", 
     599                   <<"the lonvalue has not the same size as the local domain"<<endl 
     600                   <<"Local size is "<<ni<<"x"<<nj<<endl 
     601                   <<"Lonvalue size is "<<lonvalue_2d.extent(0)<<"x"<<lonvalue_2d.extent(1)); 
     602       } 
     603 
     604       if (!latvalue_1d.isEmpty() && !latvalue_2d.isEmpty()) 
     605         ERROR("CDomain::completeLonLatClient(void)", 
     606              <<"Only one longitude value can be used but both latvalue_1d and latvalue_2d are defined! "<<endl 
     607              <<"Define only one longitude value: latvalue_1d or latvalue_2d "); 
     608 
     609       if (!latvalue_1d.isEmpty() && latvalue_2d.isEmpty()) 
     610       { 
     611         if (latvalue_1d.numElements() != i_index.numElements()) 
     612           ERROR("CDomain::completeLonLatClient(void)", 
     613                 <<"the latvalue_1d has not the same size as the local domain"<<endl 
     614                 <<"Local size is "<<i_index.numElements()<<endl 
     615                 <<"Mask size is "<<latvalue_1d.numElements()); 
     616       } 
     617 
     618       if (latvalue_1d.isEmpty() && !latvalue_2d.isEmpty()) 
     619       { 
     620          if ((latvalue_2d.extent(0) != ni) || 
     621              (latvalue_2d.extent(1) != nj)) 
     622             ERROR("CDomain::completeLonLatClient(void)", 
     623                   <<"the mask has not the same size as the local domain"<<endl 
     624                   <<"Local size is "<<ni<<"x"<<nj<<endl 
     625                   <<"Mask size is "<<latvalue_2d.extent(0)<<"x"<<latvalue_2d.extent(1)); 
     626       } 
     627     } 
    693628   } 
    694629 
     
    697632     CContext* context=CContext::getCurrent() ; 
    698633 
    699      this->checkZoom(); 
    700634     if (this->isClientAfterTransformationChecked) return; 
    701635     if (context->hasClient) 
     
    742676     CContext* context=CContext::getCurrent() ; 
    743677 
    744      this->checkZoom(); 
    745678     if (this->isChecked) return; 
    746679     if (context->hasClient) 
     
    759692 
    760693      this->checkDomain(); 
    761       this->checkZoom(); 
    762694      this->checkLonLat(); 
    763695      this->checkBounds(); 
     
    769701         this->checkDomainData(); 
    770702         this->checkCompression(); 
    771          this->completeLonLatClient(); 
     703 
    772704      } 
    773705      else 
     
    777709      if (context->hasClient) 
    778710      { 
    779         computeConnectedServer() ; 
    780         sendServerAttribut() ; 
    781         sendLonLatArea() ; 
     711        this->computeConnectedServer(); 
     712        this->completeLonLatClient(); 
     713        this->sendServerAttribut(); 
     714        this->sendLonLatArea(); 
    782715      } 
    783716 
     
    837770  void CDomain::computeConnectedServer(void) 
    838771  { 
    839     ibegin_client=ibegin; ni_client=ni; iend_client=ibegin_client + ni_client - 1; 
    840     jbegin_client=jbegin; nj_client=nj; jend_client=jbegin_client + nj_client - 1; 
    841  
    842772    CContext* context=CContext::getCurrent() ; 
    843773    CContextClient* client=context->client ; 
     
    846776 
    847777    int i,j,i_ind,j_ind, nbIndex; 
    848     int zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ; 
    849     int zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ; 
     778    int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ; 
     779    int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ; 
    850780 
    851781    // Precompute number of index 
     
    857787      j_ind=j_index(i); 
    858788 
    859       if (i_ind >= global_zoom_ibegin && i_ind <= zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= zoom_jend) 
     789      if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
    860790      { 
    861791        ++globalIndexCountZoom; 
     
    878808      globalIndexDomain(globalIndexCount) = globalIndex; 
    879809      ++globalIndexCount; 
    880       if (i_ind >= global_zoom_ibegin && i_ind <= zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= zoom_jend) 
     810      if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
    881811      { 
    882812        globalIndexDomainZoom(globalIndexCountZoom) = globalIndex; 
     
    10761006      { 
    10771007        idx = static_cast<int>(it->second[n]); 
    1078         i = i_index(idx); 
    1079         j = j_index(idx); 
    1080         ind = (i - zoom_ibegin_client) + (j - zoom_jbegin_client) * zoom_ni_client; 
    1081  
    1082         lon(n) = lonvalue_client(ind); 
    1083         lat(n) = latvalue_client(ind); 
     1008        lon(n) = lonvalue_client(idx); 
     1009        lat(n) = latvalue_client(idx); 
    10841010 
    10851011        if (hasBounds) 
     
    10881014          CArray<double,2>& boundslat = list_boundslat.back(); 
    10891015 
    1090           for (nv = 0; nv < nvertex; nv++) 
     1016          for (nv = 0; nv < nvertex; ++nv) 
    10911017          { 
    1092             boundslon(nv, n) = bounds_lon_client(nv, ind); 
    1093             boundslat(nv, n) = bounds_lat_client(nv, ind); 
     1018            boundslon(nv, n) = bounds_lon_client(nv, idx); 
     1019            boundslat(nv, n) = bounds_lat_client(nv, idx); 
    10941020          } 
    10951021        } 
     
    12521178      if (hasBounds) 
    12531179      { 
    1254         for (int nv = 0; nv < nvertex; nv++) 
     1180        for (int nv = 0; nv < nvertex; ++nv) 
    12551181          bounds_lon_srv(nv, ind_srv) = boundslon(nv, ind); 
    12561182      } 
  • XIOS/trunk/src/node/domain.hpp

    r665 r666  
    7777 
    7878      private : 
    79  
    8079         void checkDomain(void); 
    81  
    8280         void checkLocalIDomain(void); 
    8381         void checkLocalJDomain(void); 
     
    8785         void checkCompression(void); 
    8886 
    89          void checkZoom(void); 
    9087         void checkBounds(void); 
    9188         void checkArea(void); 
    9289         void checkLonLat(); 
    93  
    9490 
    9591      public : 
     
    107103 
    108104 
    109          int ni_client,ibegin_client,iend_client ; 
    110          int zoom_ni_client,zoom_ibegin_client,zoom_iend_client ; 
    111  
    112          int nj_client,jbegin_client,jend_client ; 
    113          int zoom_nj_client,zoom_jbegin_client,zoom_jend_client ; 
     105//         int ni_client,ibegin_client,iend_client ; 
     106//         int zoom_ni_client,zoom_ibegin_client,zoom_iend_client ; 
     107// 
     108//         int nj_client,jbegin_client,jend_client ; 
     109//         int zoom_nj_client,zoom_jbegin_client,zoom_jend_client ; 
    114110 
    115111         int ni_srv,ibegin_srv,iend_srv ; 
     
    133129 
    134130 
    135         CArray<int,2> mapConnectedServer ;  // (ni,nj) => mapped to connected server number, -1 if no server is target 
     131//        CArray<int,2> mapConnectedServer ;  // (ni,nj) => mapped to connected server number, -1 if no server is target 
    136132 
    137133        int global_zoom_ibegin, global_zoom_ni; 
    138134        int global_zoom_jbegin, global_zoom_nj; 
    139 //        CArray<bool,1> maskInter; 
    140135 
    141136      public : 
    142  
    143137         /// Mutateur /// 
    144138         void addRelFile(const StdString & filename); 
     
    178172         void setTransformations(const TransMapTypes&); 
    179173         void computeNGlobDomain(); 
    180          void completeLonClient(); 
    181          void completeLatClient(); 
    182174 
    183175         void sendIndex(); 
  • XIOS/trunk/src/node/grid.cpp

    r664 r666  
    686686      else 
    687687      { 
    688         globalDim_[idx] = axis[idxAxis]->size.getValue(); 
     688        globalDim_[idx] = axis[idxAxis]->n_glo.getValue(); 
    689689        ++idxAxis; 
    690690        ++idx; 
     
    807807            nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size_srv; 
    808808            nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin; 
    809             nGlob[indexMap[i]] = axisList[axisId]->size; 
     809            nGlob[indexMap[i]] = axisList[axisId]->n_glo; 
    810810            ++axisId; 
    811811          } 
  • XIOS/trunk/src/node/zoom_axis.cpp

    r623 r666  
    2525  void CZoomAxis::checkValid(CAxis* axisDest) 
    2626  { 
    27     int axisIBegin, axisNi, axisSize; 
     27    int axisIBegin, axisNi, axisGlobalSize; 
    2828    int zoom_begin, zoom_end, zoom_size; 
    2929 
    30     axisIBegin = axisDest->ibegin.getValue(); 
    31     axisNi     = axisDest->ni.getValue(); 
    32     axisSize   = axisDest->size.getValue(); 
     30    axisIBegin = axisDest->begin.getValue(); 
     31    axisNi     = axisDest->n.getValue(); 
     32    axisGlobalSize   = axisDest->n_glo.getValue(); 
    3333 
    3434    zoom_begin = (this->zoom_begin.isEmpty()) ?  0 : this->zoom_begin.getValue() ; 
    35     zoom_size  = (this->zoom_size.isEmpty()) ?  axisSize : this->zoom_size.getValue() ; 
    36     zoom_end   = (this->zoom_end.isEmpty()) ?  (axisSize - 1) : this->zoom_end.getValue() ; 
     35    zoom_size  = (this->zoom_size.isEmpty()) ?  axisGlobalSize : this->zoom_size.getValue() ; 
     36    zoom_end   = (this->zoom_end.isEmpty()) ?  (axisGlobalSize - 1) : this->zoom_end.getValue() ; 
    3737 
    3838    if (this->zoom_begin.isEmpty()) zoom_begin=zoom_end-zoom_size+1; 
     
    4040    if (this->zoom_end.isEmpty()) zoom_end=zoom_begin+zoom_size-1; 
    4141 
    42     if ((zoom_begin < 0) || (zoom_begin > axisSize-1) || (zoom_end<0) || (zoom_end>axisSize-1) || (zoom_size<1) || (zoom_size>axisSize) || (zoom_begin>zoom_end)) 
     42    if ((zoom_begin < 0) || (zoom_begin > axisGlobalSize-1) || (zoom_end<0) || (zoom_end>axisGlobalSize-1) || (zoom_size<1) || (zoom_size>axisGlobalSize) || (zoom_begin>zoom_end)) 
    4343      ERROR("CZoomAxis::checkAttributes(void)", 
    4444            << "One or more attributes among <zoom_begin>, <zoom_end>, <zoom_size> of axis transformation [ id = '" << axisDest->getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified"); 
  • XIOS/trunk/src/test/test_client.f90

    r665 r666  
    7676  PRINT *, "calendar_type = ", calendar_type 
    7777 
    78   CALL xios_set_axis_attr("axis_A",size=llm ,value=lval) ; 
     78  CALL xios_set_axis_attr("axis_A",n_glo=llm ,value=lval) ; 
    7979  CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj,type='curvilinear') 
    8080  CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4) 
  • XIOS/trunk/src/test/test_complete.f90

    r665 r666  
    8787                            time_origin=xios_date(1999, 01, 01, 15, 00, 00)) 
    8888 
    89   CALL xios_set_axis_attr("axis_atm",size=llm ,value=lval) ; 
     89  CALL xios_set_axis_attr("axis_atm",n_glo=llm ,value=lval) ; 
    9090 
    9191  CALL xios_set_domain_attr("domain_atm",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj, type='curvilinear') 
     
    176176                            time_origin=xios_date(1999, 01, 01, 15, 00, 00)) 
    177177 
    178   CALL xios_set_axis_attr("axis_srf",size=llm ,value=lval) 
     178  CALL xios_set_axis_attr("axis_srf",n_glo=llm ,value=lval) 
    179179  CALL xios_set_domain_attr("domain_srf",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj, type='curvilinear') 
    180180  CALL xios_set_domain_attr("domain_srf",data_dim=1, data_ibegin=0, data_ni=nb_pt) 
    181   CALL xios_set_domain_attr("domain_srf",data_n_index=nb_pt, data_i_index=kindex) 
     181  CALL xios_set_domain_attr("domain_srf",data_i_index=kindex) 
    182182  CALL xios_set_domain_attr("domain_srf",lonvalue_2D=lon,latvalue_2D=lat) 
    183183 
  • XIOS/trunk/src/test/test_new_features.f90

    r664 r666  
    125125  PRINT *, "calendar_type = ", calendar_type 
    126126 
    127   CALL xios_set_axis_attr("axis_A", size=ni_glo, ibegin=ibegin, ni=ni, value=lval_ni) 
    128   CALL xios_set_axis_attr("axis_B", size=nj_glo, ibegin=jbegin, ni=nj, value=lval_nj, mask=mask) 
    129   CALL xios_set_axis_attr("axis_C", size=llm, value=lval) 
    130   CALL xios_set_axis_attr("axis_D", size=llm, ibegin=axisBegin, ni=nAxis, value=lvaln) 
    131   CALL xios_set_axis_attr("axis_G", size=llmInterPolated, value=lvalnInterp, ibegin=axisterpBegin, ni=nAxisinterp) 
     127  CALL xios_set_axis_attr("axis_A", n_glo=ni_glo, begin=ibegin, n=ni, value=lval_ni) 
     128  CALL xios_set_axis_attr("axis_B", n_glo=nj_glo, begin=jbegin, n=nj, value=lval_nj, mask=mask) 
     129  CALL xios_set_axis_attr("axis_C", n_glo=llm, value=lval) 
     130  CALL xios_set_axis_attr("axis_D", n_glo=llm, begin=axisBegin, n=nAxis, value=lvaln) 
     131  CALL xios_set_axis_attr("axis_G", n_glo=llmInterPolated, value=lvalnInterp, begin=axisterpBegin, n=nAxisinterp) 
    132132  CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj) 
    133133  CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4) 
  • XIOS/trunk/src/test/test_unstruct_complete.f90

    r664 r666  
    199199  CALL xios_set_current_context(ctx_hdl) 
    200200 
    201   CALL xios_set_axis_attr("axis_srf",size=llm ,value=lval) ; 
     201  CALL xios_set_axis_attr("axis_srf",n_glo=llm ,value=lval) ; 
    202202  CALL xios_set_domain_attr("domain_srf", ni_glo=ncell_glo, ni=ncell, ibegin=1, i_index=i_index) 
    203203  CALL xios_set_domain_attr("domain_srf", type='unstructured', data_dim=1, data_ni=data_n_index, & 
    204                                           data_n_index=data_n_index, data_i_index=data_i_index) 
     204                                          data_i_index=data_i_index) 
    205205  CALL xios_set_domain_attr("domain_srf", lonvalue_1D=lon, latvalue_1D=lat) 
    206206  CALL xios_set_domain_attr("domain_srf", nvertex=4, bounds_lon_1D=bounds_lon, bounds_lat_1D=bounds_lat) 
  • XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp

    r630 r666  
    2020  interpAxis->checkValid(axisSource); 
    2121  order_ = interpAxis->order.getValue(); 
    22   if (order_ >= axisSource->size.getValue()) 
     22  if (order_ >= axisSource->n_glo.getValue()) 
    2323  { 
    2424    ERROR("CAxisAlgorithmInterpolate::CAxisAlgorithmInterpolate(CAxis* axisDestination, CAxis* axisSource, CInterpolateAxis* interpAxis)", 
    25            << "Order of interpolation is greater than size of axis source" 
    26            << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl 
     25           << "Order of interpolation is greater than global size of axis source" 
     26           << "Size of axis source " <<axisSource->getId() << " is " << axisSource->n_glo.getValue()  << std::endl 
    2727           << "Order of interpolation is " << order_ ); 
    2828  } 
     
    4343  int nbClient = client->clientSize; 
    4444 
    45   int srcSize  = axisSrc_->size.getValue(); 
     45  int srcSize  = axisSrc_->n_glo.getValue(); 
    4646  int numValue = axisValue.numElements(); 
    4747 
     
    6767  const double sfmax = NumTraits<double>::sfmax(); 
    6868 
    69   int ibegin = axisDest_->ibegin.getValue(); 
     69  int ibegin = axisDest_->begin.getValue(); 
    7070  CArray<double,1>& axisDestValue = axisDest_->value; 
    7171  int numValue = axisDestValue.numElements(); 
     
    131131  std::map<int, std::vector<std::pair<int,double> > >::const_iterator itb = interpolatingIndexValues.begin(), it, 
    132132                                                                      ite = interpolatingIndexValues.end(); 
    133   int ibegin = axisDest_->ibegin.getValue(); 
     133  int ibegin = axisDest_->begin.getValue(); 
    134134  for (it = itb; it != ite; ++it) 
    135135  { 
     
    169169  int nbClient = client->clientSize; 
    170170 
    171   int srcSize  = axisSrc_->size.getValue(); 
     171  int srcSize  = axisSrc_->n_glo.getValue(); 
    172172  int numValue = axisValue.numElements(); 
    173173 
     
    191191    int* recvIndexBuff = new int [srcSize]; 
    192192 
    193     int ibegin = axisSrc_->ibegin.getValue(); 
     193    int ibegin = axisSrc_->begin.getValue(); 
    194194    for (int idx = 0; idx < numValue; ++idx) 
    195195    { 
  • XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp

    r630 r666  
    1717 : CAxisAlgorithmTransformation(axisDestination, axisSource) 
    1818{ 
    19   if (axisDestination->size.getValue() != axisSource->size.getValue()) 
     19  if (axisDestination->n_glo.getValue() != axisSource->n_glo.getValue()) 
    2020  { 
    2121    ERROR("CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource)", 
    22            << "Two axis have different size" 
    23            << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl 
    24            << "Size of axis destionation " <<axisDestination->getId() << " is " << axisDestination->size.getValue()); 
     22           << "Two axis have different global size" 
     23           << "Size of axis source " <<axisSource->getId() << " is " << axisSource->n_glo.getValue()  << std::endl 
     24           << "Size of axis destionation " <<axisDestination->getId() << " is " << axisDestination->n_glo.getValue()); 
    2525  } 
    2626 
    2727  this->computeIndexSourceMapping(); 
    28   int niSrc   = axisSrc_->ni.getValue(); 
    29   int sizeSrc = axisSrc_->size.getValue(); 
     28  int niSrc   = axisSrc_->n.getValue(); 
     29  int sizeSrc = axisSrc_->n_glo.getValue(); 
    3030  if (niSrc != sizeSrc) updateAxisValue(); 
    3131  else 
     
    6060  CContextClient* client=context->client; 
    6161 
    62   int niSrc     = axisSrc_->ni.getValue(); 
    63   int ibeginSrc = axisSrc_->ibegin.getValue(); 
     62  int niSrc     = axisSrc_->n.getValue(); 
     63  int ibeginSrc = axisSrc_->begin.getValue(); 
    6464 
    6565  CTransformationMapping transformationMap(axisDest_, axisSrc_); 
     
    128128 } 
    129129 
    130  int ibeginDest = axisDest_->ibegin.getValue(); 
     130 int ibeginDest = axisDest_->begin.getValue(); 
    131131 currentRecvBuff = recvBuff; 
    132132 for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) 
  • XIOS/trunk/src/transformation/axis_algorithm_transformation.cpp

    r631 r666  
    1717 : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(axisSource) 
    1818{ 
    19   axisDestGlobalSize_ = axisDestination->size.getValue(); 
    20   int niDest = axisDestination->ni.getValue(); 
    21   int ibeginDest = axisDestination->ibegin.getValue(); 
     19  axisDestGlobalSize_ = axisDestination->n_glo.getValue(); 
     20  int niDest = axisDestination->n.getValue(); 
     21  int ibeginDest = axisDestination->begin.getValue(); 
    2222 
    2323  for (int idx = 0; idx < niDest; ++idx) 
  • XIOS/trunk/src/transformation/axis_algorithm_zoom.cpp

    r630 r666  
    1919  zoomSize_  = zoomAxis->zoom_size.getValue(); 
    2020 
    21   if (zoomSize_ > axisSource->size.getValue()) 
     21  if (zoomSize_ > axisSource->n_glo.getValue()) 
    2222  { 
    2323    ERROR("CAxisAlgorithmZoom::CAxisAlgorithmZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis)", 
    24            << "Zoom size is greater than size of axis source" 
    25            << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl 
     24           << "Zoom size is greater than global size of axis source" 
     25           << "Global size of axis source " <<axisSource->getId() << " is " << axisSource->n_glo.getValue()  << std::endl 
    2626           << "Zoom size is " << zoomSize_ ); 
    2727  } 
     
    3535void CAxisAlgorithmZoom::computeIndexSourceMapping() 
    3636{ 
    37   StdSize niSource = axisSrc_->ni.getValue(); 
    38   StdSize ibeginSource = axisSrc_->ibegin.getValue(); 
     37  StdSize niSource = axisSrc_->n.getValue(); 
     38  StdSize ibeginSource = axisSrc_->begin.getValue(); 
    3939  StdSize iendSource = ibeginSource + niSource - 1; 
    4040 
     
    7373{ 
    7474  StdSize niMask = axisDest_->mask.numElements(); 
    75   StdSize iBeginMask = axisDest_->ibegin.getValue(); 
     75  StdSize iBeginMask = axisDest_->begin.getValue(); 
    7676  StdSize globalIndexMask = 0; 
    7777  std::map<int, std::vector<int> >& transMap = this->transformationMapping_; 
  • XIOS/trunk/src/transformation/transformation_mapping.cpp

    r634 r666  
    4545  int clientRank = client->clientRank; 
    4646 
    47   int niSrc     = source->ni.getValue(); 
    48   int ibeginSrc = source->ibegin.getValue(); 
     47  int niSrc     = source->n.getValue(); 
     48  int ibeginSrc = source->begin.getValue(); 
    4949 
    5050  boost::unordered_map<size_t,int> globalIndexOfAxisSource; 
Note: See TracChangeset for help on using the changeset viewer.