Changeset 664


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

Changing some domain attributes

+) Longitude and latitude from now on can be 2 dimension array

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

Location:
XIOS/trunk
Files:
23 edited

Legend:

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

    r660 r664  
    1414   <file_definition type="multiple_file" par_access="collective" output_freq="1ts" output_level="10" enabled=".TRUE."> 
    1515     <file id="output" name="output"> 
    16         <field field_ref="src_field" name="field" /> 
     16<!--        <field field_ref="src_field" name="field" />--> 
    1717     </file> 
    1818     <file id="output_dst" name="output_dst"> 
  • XIOS/trunk/inputs/Version2/iodef.xml

    r657 r664  
    2828     </file> 
    2929     <file id="output_Axis_transformed" name="output_Axis_transformed" type="one_file"> 
    30 <!--        <field field_ref="field_Axis_transformed" />--> 
     30        <field field_ref="field_Axis_transformed" /> 
    3131     </file> 
    3232     <file id="output_Axis_transformed_interpolated" name="output_Axis_transformed_interpolated"> 
     
    3434     </file> 
    3535     <file id="output_Domain_transformed_interpolated" name="output_Domain_transformed_interpolated"> 
    36         <field field_ref="field_Domain_transformed_Interpolated" /> 
     36<!--        <field field_ref="field_Domain_transformed_Interpolated" />--> 
    3737     </file> 
    3838     <file id="output_Scalar" name="output_Scalar" type="one_file"> 
     
    6767     <domain id="domain_A_zoom" domain_ref="domain_A"> 
    6868<!--       <zoom_domain zoom_ibegin="1" zoom_ni="3" zoom_jbegin="0" zoom_nj="2"/>--> 
    69        <zoom_domain zoom_ibegin="39" zoom_ni="20" zoom_jbegin="39" zoom_nj="20"/> 
     69       <zoom_domain zoom_ibegin="1" zoom_ni="9" zoom_jbegin="0" zoom_nj="2"/> 
    7070<!--       <zoom_domain zoom_ibegin="0" zoom_ni="2" zoom_jbegin="0" zoom_nj="2"/>--> 
    7171     </domain> 
  • XIOS/trunk/src/attribute_array_decl.cpp

    r567 r664  
    77  template class CAttributeArray<double,1> ; 
    88  template class CAttributeArray<double,2> ; 
     9  template class CAttributeArray<double,3> ; 
    910  template class CAttributeArray<int,1> ; 
    1011  template class CAttributeArray<int,2> ; 
  • XIOS/trunk/src/config/domain_attribute.conf

    r657 r664  
    2424 
    2525/* LOCAL */ 
    26 DECLARE_ARRAY(bool, 1 , mask_1D) 
    27 DECLARE_ARRAY(bool, 2 , mask_2D) 
    28 DECLARE_ARRAY(bool, 2 , mask) 
     26DECLARE_ARRAY(bool, 1 , mask_1d) 
     27DECLARE_ARRAY(bool, 2 , mask_2d) 
    2928 
    3029/* GLOBAL */ 
     
    4342 
    4443/* LOCAL */ 
    45 DECLARE_ARRAY(double, 1, lonvalue) 
    46 DECLARE_ARRAY(double, 1, latvalue) 
     44//DECLARE_ARRAY(double, 1, lonvalue) 
     45//DECLARE_ARRAY(double, 1, latvalue) 
     46DECLARE_ARRAY(double, 1, lonvalue_1d) 
     47DECLARE_ARRAY(double, 1, latvalue_1d) 
     48DECLARE_ARRAY(double, 2, lonvalue_2d) 
     49DECLARE_ARRAY(double, 2, latvalue_2d) 
     50 
    4751DECLARE_ATTRIBUTE(int, nvertex) 
    48 DECLARE_ARRAY(double, 2, bounds_lon) 
    49 DECLARE_ARRAY(double, 2, bounds_lat) 
     52//DECLARE_ARRAY(double, 2, bounds_lon) 
     53//DECLARE_ARRAY(double, 2, bounds_lat) 
     54DECLARE_ARRAY(double, 2, bounds_lon_1d) 
     55DECLARE_ARRAY(double, 2, bounds_lat_1d) 
     56DECLARE_ARRAY(double, 3, bounds_lon_2d) 
     57DECLARE_ARRAY(double, 3, bounds_lat_2d) 
     58 
    5059DECLARE_ARRAY(double, 2, area) 
    5160 
    52 DECLARE_ENUM3(type,regular,curvilinear,unstructured) //rectilinear 
     61DECLARE_ENUM3(type,rectilinear,curvilinear,unstructured) 
    5362DECLARE_ATTRIBUTE(StdString, domain_ref) 
    5463 
  • XIOS/trunk/src/distribution_client.cpp

    r663 r664  
    132132  for (int i = 0; i < domainNum_;++i) 
    133133  { 
    134     domainMasks_[i].resize(domList[i]->mask.extent(0), domList[i]->mask.extent(1)); 
    135     domainMasks_[i] = domList[i]->mask; 
     134    domainMasks_[i].resize(domList[i]->mask_1d.numElements()); 
     135    domainMasks_[i] = domList[i]->mask_1d; 
    136136  } 
    137137 
     
    274274        if ((iIdx >= nBeginLocal_[indexMap_[i]]) && (iIdx < nLocal_[indexMap_[i]]) && 
    275275           (jIdx >= nBeginLocal_[indexMap_[i]+1]) && (jIdx < nLocal_[indexMap_[i]+1]) && 
    276            (domainMasks_[idxDomain](iIdx, jIdx))) 
     276           (domainMasks_[idxDomain](iIdx + jIdx*nLocal_[indexMap_[i]]))) 
    277277        { 
    278278          (localDomainIndex_[idxDomain]).push_back(iIdx); 
  • XIOS/trunk/src/distribution_client.hpp

    r657 r664  
    9898    std::vector<CArray<int,1> > dataIndex_; //!< Data index 
    9999 
    100     std::vector<CArray<bool,2> > domainMasks_; //!< Domain mask 
     100    std::vector<CArray<bool,1> > domainMasks_; //!< Domain mask 
    101101    std::vector<CArray<bool,1> > axisMasks_; //!< Axis mask 
    102102 
  • XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp

    r657 r664  
    4343 
    4444 
    45   void cxios_set_domain_bounds_lat(domain_Ptr domain_hdl, double* bounds_lat, int extent1, int extent2) 
    46   { 
    47     CTimer::get("XIOS").resume(); 
    48     CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData); 
    49     domain_hdl->bounds_lat.reference(tmp.copy()); 
    50      CTimer::get("XIOS").suspend(); 
    51   } 
    52  
    53   void cxios_get_domain_bounds_lat(domain_Ptr domain_hdl, double* bounds_lat, int extent1, int extent2) 
    54   { 
    55     CTimer::get("XIOS").resume(); 
    56     CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData); 
    57     tmp=domain_hdl->bounds_lat.getInheritedValue(); 
    58      CTimer::get("XIOS").suspend(); 
    59   } 
    60  
    61   bool cxios_is_defined_domain_bounds_lat(domain_Ptr domain_hdl) 
    62   { 
    63      CTimer::get("XIOS").resume(); 
    64      bool isDefined = domain_hdl->bounds_lat.hasInheritedValue(); 
    65      CTimer::get("XIOS").suspend(); 
    66      return isDefined; 
    67   } 
    68  
    69  
    70   void cxios_set_domain_bounds_lon(domain_Ptr domain_hdl, double* bounds_lon, int extent1, int extent2) 
    71   { 
    72     CTimer::get("XIOS").resume(); 
    73     CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData); 
    74     domain_hdl->bounds_lon.reference(tmp.copy()); 
    75      CTimer::get("XIOS").suspend(); 
    76   } 
    77  
    78   void cxios_get_domain_bounds_lon(domain_Ptr domain_hdl, double* bounds_lon, int extent1, int extent2) 
    79   { 
    80     CTimer::get("XIOS").resume(); 
    81     CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData); 
    82     tmp=domain_hdl->bounds_lon.getInheritedValue(); 
    83      CTimer::get("XIOS").suspend(); 
    84   } 
    85  
    86   bool cxios_is_defined_domain_bounds_lon(domain_Ptr domain_hdl) 
    87   { 
    88      CTimer::get("XIOS").resume(); 
    89      bool isDefined = domain_hdl->bounds_lon.hasInheritedValue(); 
     45  void cxios_set_domain_bounds_lat_1d(domain_Ptr domain_hdl, double* bounds_lat_1d, int extent1, int extent2) 
     46  { 
     47    CTimer::get("XIOS").resume(); 
     48    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData); 
     49    domain_hdl->bounds_lat_1d.reference(tmp.copy()); 
     50     CTimer::get("XIOS").suspend(); 
     51  } 
     52 
     53  void cxios_get_domain_bounds_lat_1d(domain_Ptr domain_hdl, double* bounds_lat_1d, int extent1, int extent2) 
     54  { 
     55    CTimer::get("XIOS").resume(); 
     56    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData); 
     57    tmp=domain_hdl->bounds_lat_1d.getInheritedValue(); 
     58     CTimer::get("XIOS").suspend(); 
     59  } 
     60 
     61  bool cxios_is_defined_domain_bounds_lat_1d(domain_Ptr domain_hdl) 
     62  { 
     63     CTimer::get("XIOS").resume(); 
     64     bool isDefined = domain_hdl->bounds_lat_1d.hasInheritedValue(); 
     65     CTimer::get("XIOS").suspend(); 
     66     return isDefined; 
     67  } 
     68 
     69 
     70  void cxios_set_domain_bounds_lat_2d(domain_Ptr domain_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3) 
     71  { 
     72    CTimer::get("XIOS").resume(); 
     73    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData); 
     74    domain_hdl->bounds_lat_2d.reference(tmp.copy()); 
     75     CTimer::get("XIOS").suspend(); 
     76  } 
     77 
     78  void cxios_get_domain_bounds_lat_2d(domain_Ptr domain_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3) 
     79  { 
     80    CTimer::get("XIOS").resume(); 
     81    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData); 
     82    tmp=domain_hdl->bounds_lat_2d.getInheritedValue(); 
     83     CTimer::get("XIOS").suspend(); 
     84  } 
     85 
     86  bool cxios_is_defined_domain_bounds_lat_2d(domain_Ptr domain_hdl) 
     87  { 
     88     CTimer::get("XIOS").resume(); 
     89     bool isDefined = domain_hdl->bounds_lat_2d.hasInheritedValue(); 
     90     CTimer::get("XIOS").suspend(); 
     91     return isDefined; 
     92  } 
     93 
     94 
     95  void cxios_set_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int extent1, int extent2) 
     96  { 
     97    CTimer::get("XIOS").resume(); 
     98    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData); 
     99    domain_hdl->bounds_lon_1d.reference(tmp.copy()); 
     100     CTimer::get("XIOS").suspend(); 
     101  } 
     102 
     103  void cxios_get_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int extent1, int extent2) 
     104  { 
     105    CTimer::get("XIOS").resume(); 
     106    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData); 
     107    tmp=domain_hdl->bounds_lon_1d.getInheritedValue(); 
     108     CTimer::get("XIOS").suspend(); 
     109  } 
     110 
     111  bool cxios_is_defined_domain_bounds_lon_1d(domain_Ptr domain_hdl) 
     112  { 
     113     CTimer::get("XIOS").resume(); 
     114     bool isDefined = domain_hdl->bounds_lon_1d.hasInheritedValue(); 
     115     CTimer::get("XIOS").suspend(); 
     116     return isDefined; 
     117  } 
     118 
     119 
     120  void cxios_set_domain_bounds_lon_2d(domain_Ptr domain_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3) 
     121  { 
     122    CTimer::get("XIOS").resume(); 
     123    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData); 
     124    domain_hdl->bounds_lon_2d.reference(tmp.copy()); 
     125     CTimer::get("XIOS").suspend(); 
     126  } 
     127 
     128  void cxios_get_domain_bounds_lon_2d(domain_Ptr domain_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3) 
     129  { 
     130    CTimer::get("XIOS").resume(); 
     131    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData); 
     132    tmp=domain_hdl->bounds_lon_2d.getInheritedValue(); 
     133     CTimer::get("XIOS").suspend(); 
     134  } 
     135 
     136  bool cxios_is_defined_domain_bounds_lon_2d(domain_Ptr domain_hdl) 
     137  { 
     138     CTimer::get("XIOS").resume(); 
     139     bool isDefined = domain_hdl->bounds_lon_2d.hasInheritedValue(); 
    90140     CTimer::get("XIOS").suspend(); 
    91141     return isDefined; 
     
    429479 
    430480 
    431   void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1) 
    432   { 
    433     CTimer::get("XIOS").resume(); 
    434     CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData); 
    435     domain_hdl->latvalue.reference(tmp.copy()); 
    436      CTimer::get("XIOS").suspend(); 
    437   } 
    438  
    439   void cxios_get_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1) 
    440   { 
    441     CTimer::get("XIOS").resume(); 
    442     CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData); 
    443     tmp=domain_hdl->latvalue.getInheritedValue(); 
    444      CTimer::get("XIOS").suspend(); 
    445   } 
    446  
    447   bool cxios_is_defined_domain_latvalue(domain_Ptr domain_hdl) 
    448   { 
    449      CTimer::get("XIOS").resume(); 
    450      bool isDefined = domain_hdl->latvalue.hasInheritedValue(); 
     481  void cxios_set_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int extent1) 
     482  { 
     483    CTimer::get("XIOS").resume(); 
     484    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData); 
     485    domain_hdl->latvalue_1d.reference(tmp.copy()); 
     486     CTimer::get("XIOS").suspend(); 
     487  } 
     488 
     489  void cxios_get_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int extent1) 
     490  { 
     491    CTimer::get("XIOS").resume(); 
     492    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData); 
     493    tmp=domain_hdl->latvalue_1d.getInheritedValue(); 
     494     CTimer::get("XIOS").suspend(); 
     495  } 
     496 
     497  bool cxios_is_defined_domain_latvalue_1d(domain_Ptr domain_hdl) 
     498  { 
     499     CTimer::get("XIOS").resume(); 
     500     bool isDefined = domain_hdl->latvalue_1d.hasInheritedValue(); 
     501     CTimer::get("XIOS").suspend(); 
     502     return isDefined; 
     503  } 
     504 
     505 
     506  void cxios_set_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int extent1, int extent2) 
     507  { 
     508    CTimer::get("XIOS").resume(); 
     509    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData); 
     510    domain_hdl->latvalue_2d.reference(tmp.copy()); 
     511     CTimer::get("XIOS").suspend(); 
     512  } 
     513 
     514  void cxios_get_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int extent1, int extent2) 
     515  { 
     516    CTimer::get("XIOS").resume(); 
     517    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData); 
     518    tmp=domain_hdl->latvalue_2d.getInheritedValue(); 
     519     CTimer::get("XIOS").suspend(); 
     520  } 
     521 
     522  bool cxios_is_defined_domain_latvalue_2d(domain_Ptr domain_hdl) 
     523  { 
     524     CTimer::get("XIOS").resume(); 
     525     bool isDefined = domain_hdl->latvalue_2d.hasInheritedValue(); 
    451526     CTimer::get("XIOS").suspend(); 
    452527     return isDefined; 
     
    480555 
    481556 
    482   void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1) 
    483   { 
    484     CTimer::get("XIOS").resume(); 
    485     CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData); 
    486     domain_hdl->lonvalue.reference(tmp.copy()); 
    487      CTimer::get("XIOS").suspend(); 
    488   } 
    489  
    490   void cxios_get_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1) 
    491   { 
    492     CTimer::get("XIOS").resume(); 
    493     CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData); 
    494     tmp=domain_hdl->lonvalue.getInheritedValue(); 
    495      CTimer::get("XIOS").suspend(); 
    496   } 
    497  
    498   bool cxios_is_defined_domain_lonvalue(domain_Ptr domain_hdl) 
    499   { 
    500      CTimer::get("XIOS").resume(); 
    501      bool isDefined = domain_hdl->lonvalue.hasInheritedValue(); 
    502      CTimer::get("XIOS").suspend(); 
    503      return isDefined; 
    504   } 
    505  
    506  
    507   void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2) 
    508   { 
    509     CTimer::get("XIOS").resume(); 
    510     CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData); 
    511     domain_hdl->mask.reference(tmp.copy()); 
    512      CTimer::get("XIOS").suspend(); 
    513   } 
    514  
    515   void cxios_get_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2) 
    516   { 
    517     CTimer::get("XIOS").resume(); 
    518     CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData); 
    519     tmp=domain_hdl->mask.getInheritedValue(); 
    520      CTimer::get("XIOS").suspend(); 
    521   } 
    522  
    523   bool cxios_is_defined_domain_mask(domain_Ptr domain_hdl) 
    524   { 
    525      CTimer::get("XIOS").resume(); 
    526      bool isDefined = domain_hdl->mask.hasInheritedValue(); 
     557  void cxios_set_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int extent1) 
     558  { 
     559    CTimer::get("XIOS").resume(); 
     560    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData); 
     561    domain_hdl->lonvalue_1d.reference(tmp.copy()); 
     562     CTimer::get("XIOS").suspend(); 
     563  } 
     564 
     565  void cxios_get_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int extent1) 
     566  { 
     567    CTimer::get("XIOS").resume(); 
     568    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData); 
     569    tmp=domain_hdl->lonvalue_1d.getInheritedValue(); 
     570     CTimer::get("XIOS").suspend(); 
     571  } 
     572 
     573  bool cxios_is_defined_domain_lonvalue_1d(domain_Ptr domain_hdl) 
     574  { 
     575     CTimer::get("XIOS").resume(); 
     576     bool isDefined = domain_hdl->lonvalue_1d.hasInheritedValue(); 
     577     CTimer::get("XIOS").suspend(); 
     578     return isDefined; 
     579  } 
     580 
     581 
     582  void cxios_set_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int extent1, int extent2) 
     583  { 
     584    CTimer::get("XIOS").resume(); 
     585    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData); 
     586    domain_hdl->lonvalue_2d.reference(tmp.copy()); 
     587     CTimer::get("XIOS").suspend(); 
     588  } 
     589 
     590  void cxios_get_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int extent1, int extent2) 
     591  { 
     592    CTimer::get("XIOS").resume(); 
     593    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData); 
     594    tmp=domain_hdl->lonvalue_2d.getInheritedValue(); 
     595     CTimer::get("XIOS").suspend(); 
     596  } 
     597 
     598  bool cxios_is_defined_domain_lonvalue_2d(domain_Ptr domain_hdl) 
     599  { 
     600     CTimer::get("XIOS").resume(); 
     601     bool isDefined = domain_hdl->lonvalue_2d.hasInheritedValue(); 
     602     CTimer::get("XIOS").suspend(); 
     603     return isDefined; 
     604  } 
     605 
     606 
     607  void cxios_set_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int extent1) 
     608  { 
     609    CTimer::get("XIOS").resume(); 
     610    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData); 
     611    domain_hdl->mask_1d.reference(tmp.copy()); 
     612     CTimer::get("XIOS").suspend(); 
     613  } 
     614 
     615  void cxios_get_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int extent1) 
     616  { 
     617    CTimer::get("XIOS").resume(); 
     618    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData); 
     619    tmp=domain_hdl->mask_1d.getInheritedValue(); 
     620     CTimer::get("XIOS").suspend(); 
     621  } 
     622 
     623  bool cxios_is_defined_domain_mask_1d(domain_Ptr domain_hdl) 
     624  { 
     625     CTimer::get("XIOS").resume(); 
     626     bool isDefined = domain_hdl->mask_1d.hasInheritedValue(); 
     627     CTimer::get("XIOS").suspend(); 
     628     return isDefined; 
     629  } 
     630 
     631 
     632  void cxios_set_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int extent1, int extent2) 
     633  { 
     634    CTimer::get("XIOS").resume(); 
     635    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData); 
     636    domain_hdl->mask_2d.reference(tmp.copy()); 
     637     CTimer::get("XIOS").suspend(); 
     638  } 
     639 
     640  void cxios_get_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int extent1, int extent2) 
     641  { 
     642    CTimer::get("XIOS").resume(); 
     643    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData); 
     644    tmp=domain_hdl->mask_2d.getInheritedValue(); 
     645     CTimer::get("XIOS").suspend(); 
     646  } 
     647 
     648  bool cxios_is_defined_domain_mask_2d(domain_Ptr domain_hdl) 
     649  { 
     650     CTimer::get("XIOS").resume(); 
     651     bool isDefined = domain_hdl->mask_2d.hasInheritedValue(); 
    527652     CTimer::get("XIOS").suspend(); 
    528653     return isDefined; 
  • XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp

    r657 r664  
    4343 
    4444 
    45   void cxios_set_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl, double* bounds_lat, int extent1, int extent2) 
    46   { 
    47     CTimer::get("XIOS").resume(); 
    48     CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData); 
    49     domaingroup_hdl->bounds_lat.reference(tmp.copy()); 
    50      CTimer::get("XIOS").suspend(); 
    51   } 
    52  
    53   void cxios_get_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl, double* bounds_lat, int extent1, int extent2) 
    54   { 
    55     CTimer::get("XIOS").resume(); 
    56     CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData); 
    57     tmp=domaingroup_hdl->bounds_lat.getInheritedValue(); 
    58      CTimer::get("XIOS").suspend(); 
    59   } 
    60  
    61   bool cxios_is_defined_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl) 
    62   { 
    63      CTimer::get("XIOS").resume(); 
    64      bool isDefined = domaingroup_hdl->bounds_lat.hasInheritedValue(); 
    65      CTimer::get("XIOS").suspend(); 
    66      return isDefined; 
    67   } 
    68  
    69  
    70   void cxios_set_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl, double* bounds_lon, int extent1, int extent2) 
    71   { 
    72     CTimer::get("XIOS").resume(); 
    73     CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData); 
    74     domaingroup_hdl->bounds_lon.reference(tmp.copy()); 
    75      CTimer::get("XIOS").suspend(); 
    76   } 
    77  
    78   void cxios_get_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl, double* bounds_lon, int extent1, int extent2) 
    79   { 
    80     CTimer::get("XIOS").resume(); 
    81     CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData); 
    82     tmp=domaingroup_hdl->bounds_lon.getInheritedValue(); 
    83      CTimer::get("XIOS").suspend(); 
    84   } 
    85  
    86   bool cxios_is_defined_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl) 
    87   { 
    88      CTimer::get("XIOS").resume(); 
    89      bool isDefined = domaingroup_hdl->bounds_lon.hasInheritedValue(); 
     45  void cxios_set_domaingroup_bounds_lat_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lat_1d, int extent1, int extent2) 
     46  { 
     47    CTimer::get("XIOS").resume(); 
     48    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData); 
     49    domaingroup_hdl->bounds_lat_1d.reference(tmp.copy()); 
     50     CTimer::get("XIOS").suspend(); 
     51  } 
     52 
     53  void cxios_get_domaingroup_bounds_lat_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lat_1d, int extent1, int extent2) 
     54  { 
     55    CTimer::get("XIOS").resume(); 
     56    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData); 
     57    tmp=domaingroup_hdl->bounds_lat_1d.getInheritedValue(); 
     58     CTimer::get("XIOS").suspend(); 
     59  } 
     60 
     61  bool cxios_is_defined_domaingroup_bounds_lat_1d(domaingroup_Ptr domaingroup_hdl) 
     62  { 
     63     CTimer::get("XIOS").resume(); 
     64     bool isDefined = domaingroup_hdl->bounds_lat_1d.hasInheritedValue(); 
     65     CTimer::get("XIOS").suspend(); 
     66     return isDefined; 
     67  } 
     68 
     69 
     70  void cxios_set_domaingroup_bounds_lat_2d(domaingroup_Ptr domaingroup_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3) 
     71  { 
     72    CTimer::get("XIOS").resume(); 
     73    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData); 
     74    domaingroup_hdl->bounds_lat_2d.reference(tmp.copy()); 
     75     CTimer::get("XIOS").suspend(); 
     76  } 
     77 
     78  void cxios_get_domaingroup_bounds_lat_2d(domaingroup_Ptr domaingroup_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3) 
     79  { 
     80    CTimer::get("XIOS").resume(); 
     81    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData); 
     82    tmp=domaingroup_hdl->bounds_lat_2d.getInheritedValue(); 
     83     CTimer::get("XIOS").suspend(); 
     84  } 
     85 
     86  bool cxios_is_defined_domaingroup_bounds_lat_2d(domaingroup_Ptr domaingroup_hdl) 
     87  { 
     88     CTimer::get("XIOS").resume(); 
     89     bool isDefined = domaingroup_hdl->bounds_lat_2d.hasInheritedValue(); 
     90     CTimer::get("XIOS").suspend(); 
     91     return isDefined; 
     92  } 
     93 
     94 
     95  void cxios_set_domaingroup_bounds_lon_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_1d, int extent1, int extent2) 
     96  { 
     97    CTimer::get("XIOS").resume(); 
     98    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData); 
     99    domaingroup_hdl->bounds_lon_1d.reference(tmp.copy()); 
     100     CTimer::get("XIOS").suspend(); 
     101  } 
     102 
     103  void cxios_get_domaingroup_bounds_lon_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_1d, int extent1, int extent2) 
     104  { 
     105    CTimer::get("XIOS").resume(); 
     106    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData); 
     107    tmp=domaingroup_hdl->bounds_lon_1d.getInheritedValue(); 
     108     CTimer::get("XIOS").suspend(); 
     109  } 
     110 
     111  bool cxios_is_defined_domaingroup_bounds_lon_1d(domaingroup_Ptr domaingroup_hdl) 
     112  { 
     113     CTimer::get("XIOS").resume(); 
     114     bool isDefined = domaingroup_hdl->bounds_lon_1d.hasInheritedValue(); 
     115     CTimer::get("XIOS").suspend(); 
     116     return isDefined; 
     117  } 
     118 
     119 
     120  void cxios_set_domaingroup_bounds_lon_2d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3) 
     121  { 
     122    CTimer::get("XIOS").resume(); 
     123    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData); 
     124    domaingroup_hdl->bounds_lon_2d.reference(tmp.copy()); 
     125     CTimer::get("XIOS").suspend(); 
     126  } 
     127 
     128  void cxios_get_domaingroup_bounds_lon_2d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3) 
     129  { 
     130    CTimer::get("XIOS").resume(); 
     131    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData); 
     132    tmp=domaingroup_hdl->bounds_lon_2d.getInheritedValue(); 
     133     CTimer::get("XIOS").suspend(); 
     134  } 
     135 
     136  bool cxios_is_defined_domaingroup_bounds_lon_2d(domaingroup_Ptr domaingroup_hdl) 
     137  { 
     138     CTimer::get("XIOS").resume(); 
     139     bool isDefined = domaingroup_hdl->bounds_lon_2d.hasInheritedValue(); 
    90140     CTimer::get("XIOS").suspend(); 
    91141     return isDefined; 
     
    455505 
    456506 
    457   void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1) 
    458   { 
    459     CTimer::get("XIOS").resume(); 
    460     CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData); 
    461     domaingroup_hdl->latvalue.reference(tmp.copy()); 
    462      CTimer::get("XIOS").suspend(); 
    463   } 
    464  
    465   void cxios_get_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1) 
    466   { 
    467     CTimer::get("XIOS").resume(); 
    468     CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData); 
    469     tmp=domaingroup_hdl->latvalue.getInheritedValue(); 
    470      CTimer::get("XIOS").suspend(); 
    471   } 
    472  
    473   bool cxios_is_defined_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl) 
    474   { 
    475      CTimer::get("XIOS").resume(); 
    476      bool isDefined = domaingroup_hdl->latvalue.hasInheritedValue(); 
     507  void cxios_set_domaingroup_latvalue_1d(domaingroup_Ptr domaingroup_hdl, double* latvalue_1d, int extent1) 
     508  { 
     509    CTimer::get("XIOS").resume(); 
     510    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData); 
     511    domaingroup_hdl->latvalue_1d.reference(tmp.copy()); 
     512     CTimer::get("XIOS").suspend(); 
     513  } 
     514 
     515  void cxios_get_domaingroup_latvalue_1d(domaingroup_Ptr domaingroup_hdl, double* latvalue_1d, int extent1) 
     516  { 
     517    CTimer::get("XIOS").resume(); 
     518    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData); 
     519    tmp=domaingroup_hdl->latvalue_1d.getInheritedValue(); 
     520     CTimer::get("XIOS").suspend(); 
     521  } 
     522 
     523  bool cxios_is_defined_domaingroup_latvalue_1d(domaingroup_Ptr domaingroup_hdl) 
     524  { 
     525     CTimer::get("XIOS").resume(); 
     526     bool isDefined = domaingroup_hdl->latvalue_1d.hasInheritedValue(); 
     527     CTimer::get("XIOS").suspend(); 
     528     return isDefined; 
     529  } 
     530 
     531 
     532  void cxios_set_domaingroup_latvalue_2d(domaingroup_Ptr domaingroup_hdl, double* latvalue_2d, int extent1, int extent2) 
     533  { 
     534    CTimer::get("XIOS").resume(); 
     535    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData); 
     536    domaingroup_hdl->latvalue_2d.reference(tmp.copy()); 
     537     CTimer::get("XIOS").suspend(); 
     538  } 
     539 
     540  void cxios_get_domaingroup_latvalue_2d(domaingroup_Ptr domaingroup_hdl, double* latvalue_2d, int extent1, int extent2) 
     541  { 
     542    CTimer::get("XIOS").resume(); 
     543    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData); 
     544    tmp=domaingroup_hdl->latvalue_2d.getInheritedValue(); 
     545     CTimer::get("XIOS").suspend(); 
     546  } 
     547 
     548  bool cxios_is_defined_domaingroup_latvalue_2d(domaingroup_Ptr domaingroup_hdl) 
     549  { 
     550     CTimer::get("XIOS").resume(); 
     551     bool isDefined = domaingroup_hdl->latvalue_2d.hasInheritedValue(); 
    477552     CTimer::get("XIOS").suspend(); 
    478553     return isDefined; 
     
    506581 
    507582 
    508   void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1) 
    509   { 
    510     CTimer::get("XIOS").resume(); 
    511     CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData); 
    512     domaingroup_hdl->lonvalue.reference(tmp.copy()); 
    513      CTimer::get("XIOS").suspend(); 
    514   } 
    515  
    516   void cxios_get_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1) 
    517   { 
    518     CTimer::get("XIOS").resume(); 
    519     CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData); 
    520     tmp=domaingroup_hdl->lonvalue.getInheritedValue(); 
    521      CTimer::get("XIOS").suspend(); 
    522   } 
    523  
    524   bool cxios_is_defined_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl) 
    525   { 
    526      CTimer::get("XIOS").resume(); 
    527      bool isDefined = domaingroup_hdl->lonvalue.hasInheritedValue(); 
    528      CTimer::get("XIOS").suspend(); 
    529      return isDefined; 
    530   } 
    531  
    532  
    533   void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2) 
    534   { 
    535     CTimer::get("XIOS").resume(); 
    536     CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData); 
    537     domaingroup_hdl->mask.reference(tmp.copy()); 
    538      CTimer::get("XIOS").suspend(); 
    539   } 
    540  
    541   void cxios_get_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2) 
    542   { 
    543     CTimer::get("XIOS").resume(); 
    544     CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData); 
    545     tmp=domaingroup_hdl->mask.getInheritedValue(); 
    546      CTimer::get("XIOS").suspend(); 
    547   } 
    548  
    549   bool cxios_is_defined_domaingroup_mask(domaingroup_Ptr domaingroup_hdl) 
    550   { 
    551      CTimer::get("XIOS").resume(); 
    552      bool isDefined = domaingroup_hdl->mask.hasInheritedValue(); 
     583  void cxios_set_domaingroup_lonvalue_1d(domaingroup_Ptr domaingroup_hdl, double* lonvalue_1d, int extent1) 
     584  { 
     585    CTimer::get("XIOS").resume(); 
     586    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData); 
     587    domaingroup_hdl->lonvalue_1d.reference(tmp.copy()); 
     588     CTimer::get("XIOS").suspend(); 
     589  } 
     590 
     591  void cxios_get_domaingroup_lonvalue_1d(domaingroup_Ptr domaingroup_hdl, double* lonvalue_1d, int extent1) 
     592  { 
     593    CTimer::get("XIOS").resume(); 
     594    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData); 
     595    tmp=domaingroup_hdl->lonvalue_1d.getInheritedValue(); 
     596     CTimer::get("XIOS").suspend(); 
     597  } 
     598 
     599  bool cxios_is_defined_domaingroup_lonvalue_1d(domaingroup_Ptr domaingroup_hdl) 
     600  { 
     601     CTimer::get("XIOS").resume(); 
     602     bool isDefined = domaingroup_hdl->lonvalue_1d.hasInheritedValue(); 
     603     CTimer::get("XIOS").suspend(); 
     604     return isDefined; 
     605  } 
     606 
     607 
     608  void cxios_set_domaingroup_lonvalue_2d(domaingroup_Ptr domaingroup_hdl, double* lonvalue_2d, int extent1, int extent2) 
     609  { 
     610    CTimer::get("XIOS").resume(); 
     611    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData); 
     612    domaingroup_hdl->lonvalue_2d.reference(tmp.copy()); 
     613     CTimer::get("XIOS").suspend(); 
     614  } 
     615 
     616  void cxios_get_domaingroup_lonvalue_2d(domaingroup_Ptr domaingroup_hdl, double* lonvalue_2d, int extent1, int extent2) 
     617  { 
     618    CTimer::get("XIOS").resume(); 
     619    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData); 
     620    tmp=domaingroup_hdl->lonvalue_2d.getInheritedValue(); 
     621     CTimer::get("XIOS").suspend(); 
     622  } 
     623 
     624  bool cxios_is_defined_domaingroup_lonvalue_2d(domaingroup_Ptr domaingroup_hdl) 
     625  { 
     626     CTimer::get("XIOS").resume(); 
     627     bool isDefined = domaingroup_hdl->lonvalue_2d.hasInheritedValue(); 
     628     CTimer::get("XIOS").suspend(); 
     629     return isDefined; 
     630  } 
     631 
     632 
     633  void cxios_set_domaingroup_mask_1d(domaingroup_Ptr domaingroup_hdl, bool* mask_1d, int extent1) 
     634  { 
     635    CTimer::get("XIOS").resume(); 
     636    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData); 
     637    domaingroup_hdl->mask_1d.reference(tmp.copy()); 
     638     CTimer::get("XIOS").suspend(); 
     639  } 
     640 
     641  void cxios_get_domaingroup_mask_1d(domaingroup_Ptr domaingroup_hdl, bool* mask_1d, int extent1) 
     642  { 
     643    CTimer::get("XIOS").resume(); 
     644    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData); 
     645    tmp=domaingroup_hdl->mask_1d.getInheritedValue(); 
     646     CTimer::get("XIOS").suspend(); 
     647  } 
     648 
     649  bool cxios_is_defined_domaingroup_mask_1d(domaingroup_Ptr domaingroup_hdl) 
     650  { 
     651     CTimer::get("XIOS").resume(); 
     652     bool isDefined = domaingroup_hdl->mask_1d.hasInheritedValue(); 
     653     CTimer::get("XIOS").suspend(); 
     654     return isDefined; 
     655  } 
     656 
     657 
     658  void cxios_set_domaingroup_mask_2d(domaingroup_Ptr domaingroup_hdl, bool* mask_2d, int extent1, int extent2) 
     659  { 
     660    CTimer::get("XIOS").resume(); 
     661    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData); 
     662    domaingroup_hdl->mask_2d.reference(tmp.copy()); 
     663     CTimer::get("XIOS").suspend(); 
     664  } 
     665 
     666  void cxios_get_domaingroup_mask_2d(domaingroup_Ptr domaingroup_hdl, bool* mask_2d, int extent1, int extent2) 
     667  { 
     668    CTimer::get("XIOS").resume(); 
     669    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData); 
     670    tmp=domaingroup_hdl->mask_2d.getInheritedValue(); 
     671     CTimer::get("XIOS").suspend(); 
     672  } 
     673 
     674  bool cxios_is_defined_domaingroup_mask_2d(domaingroup_Ptr domaingroup_hdl) 
     675  { 
     676     CTimer::get("XIOS").resume(); 
     677     bool isDefined = domaingroup_hdl->mask_2d.hasInheritedValue(); 
    553678     CTimer::get("XIOS").suspend(); 
    554679     return isDefined; 
  • XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90

    r657 r664  
    3333 
    3434 
    35     SUBROUTINE cxios_set_domain_bounds_lat(domain_hdl, bounds_lat, extent1, extent2) BIND(C) 
    36       USE ISO_C_BINDING 
    37       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    38       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat 
    39       INTEGER (kind = C_INT), VALUE  :: extent1 
    40       INTEGER (kind = C_INT), VALUE  :: extent2 
    41     END SUBROUTINE cxios_set_domain_bounds_lat 
    42  
    43     SUBROUTINE cxios_get_domain_bounds_lat(domain_hdl, bounds_lat, extent1, extent2) BIND(C) 
    44       USE ISO_C_BINDING 
    45       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    46       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat 
    47       INTEGER (kind = C_INT), VALUE  :: extent1 
    48       INTEGER (kind = C_INT), VALUE  :: extent2 
    49     END SUBROUTINE cxios_get_domain_bounds_lat 
    50  
    51     FUNCTION cxios_is_defined_domain_bounds_lat(domain_hdl) BIND(C) 
    52       USE ISO_C_BINDING 
    53       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lat 
    54       INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    55     END FUNCTION cxios_is_defined_domain_bounds_lat 
    56  
    57  
    58     SUBROUTINE cxios_set_domain_bounds_lon(domain_hdl, bounds_lon, extent1, extent2) BIND(C) 
    59       USE ISO_C_BINDING 
    60       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    61       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon 
    62       INTEGER (kind = C_INT), VALUE  :: extent1 
    63       INTEGER (kind = C_INT), VALUE  :: extent2 
    64     END SUBROUTINE cxios_set_domain_bounds_lon 
    65  
    66     SUBROUTINE cxios_get_domain_bounds_lon(domain_hdl, bounds_lon, extent1, extent2) BIND(C) 
    67       USE ISO_C_BINDING 
    68       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    69       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon 
    70       INTEGER (kind = C_INT), VALUE  :: extent1 
    71       INTEGER (kind = C_INT), VALUE  :: extent2 
    72     END SUBROUTINE cxios_get_domain_bounds_lon 
    73  
    74     FUNCTION cxios_is_defined_domain_bounds_lon(domain_hdl) BIND(C) 
    75       USE ISO_C_BINDING 
    76       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lon 
    77       INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    78     END FUNCTION cxios_is_defined_domain_bounds_lon 
     35    SUBROUTINE cxios_set_domain_bounds_lat_1d(domain_hdl, bounds_lat_1d, extent1, extent2) BIND(C) 
     36      USE ISO_C_BINDING 
     37      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     38      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_1d 
     39      INTEGER (kind = C_INT), VALUE  :: extent1 
     40      INTEGER (kind = C_INT), VALUE  :: extent2 
     41    END SUBROUTINE cxios_set_domain_bounds_lat_1d 
     42 
     43    SUBROUTINE cxios_get_domain_bounds_lat_1d(domain_hdl, bounds_lat_1d, extent1, extent2) BIND(C) 
     44      USE ISO_C_BINDING 
     45      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     46      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_1d 
     47      INTEGER (kind = C_INT), VALUE  :: extent1 
     48      INTEGER (kind = C_INT), VALUE  :: extent2 
     49    END SUBROUTINE cxios_get_domain_bounds_lat_1d 
     50 
     51    FUNCTION cxios_is_defined_domain_bounds_lat_1d(domain_hdl) BIND(C) 
     52      USE ISO_C_BINDING 
     53      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lat_1d 
     54      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     55    END FUNCTION cxios_is_defined_domain_bounds_lat_1d 
     56 
     57 
     58    SUBROUTINE cxios_set_domain_bounds_lat_2d(domain_hdl, bounds_lat_2d, extent1, extent2, extent3) BIND(C) 
     59      USE ISO_C_BINDING 
     60      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     61      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_2d 
     62      INTEGER (kind = C_INT), VALUE  :: extent1 
     63      INTEGER (kind = C_INT), VALUE  :: extent2 
     64      INTEGER (kind = C_INT), VALUE  :: extent3 
     65    END SUBROUTINE cxios_set_domain_bounds_lat_2d 
     66 
     67    SUBROUTINE cxios_get_domain_bounds_lat_2d(domain_hdl, bounds_lat_2d, extent1, extent2, extent3) BIND(C) 
     68      USE ISO_C_BINDING 
     69      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     70      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_2d 
     71      INTEGER (kind = C_INT), VALUE  :: extent1 
     72      INTEGER (kind = C_INT), VALUE  :: extent2 
     73      INTEGER (kind = C_INT), VALUE  :: extent3 
     74    END SUBROUTINE cxios_get_domain_bounds_lat_2d 
     75 
     76    FUNCTION cxios_is_defined_domain_bounds_lat_2d(domain_hdl) BIND(C) 
     77      USE ISO_C_BINDING 
     78      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lat_2d 
     79      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     80    END FUNCTION cxios_is_defined_domain_bounds_lat_2d 
     81 
     82 
     83    SUBROUTINE cxios_set_domain_bounds_lon_1d(domain_hdl, bounds_lon_1d, extent1, extent2) BIND(C) 
     84      USE ISO_C_BINDING 
     85      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     86      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_1d 
     87      INTEGER (kind = C_INT), VALUE  :: extent1 
     88      INTEGER (kind = C_INT), VALUE  :: extent2 
     89    END SUBROUTINE cxios_set_domain_bounds_lon_1d 
     90 
     91    SUBROUTINE cxios_get_domain_bounds_lon_1d(domain_hdl, bounds_lon_1d, extent1, extent2) BIND(C) 
     92      USE ISO_C_BINDING 
     93      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     94      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_1d 
     95      INTEGER (kind = C_INT), VALUE  :: extent1 
     96      INTEGER (kind = C_INT), VALUE  :: extent2 
     97    END SUBROUTINE cxios_get_domain_bounds_lon_1d 
     98 
     99    FUNCTION cxios_is_defined_domain_bounds_lon_1d(domain_hdl) BIND(C) 
     100      USE ISO_C_BINDING 
     101      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lon_1d 
     102      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     103    END FUNCTION cxios_is_defined_domain_bounds_lon_1d 
     104 
     105 
     106    SUBROUTINE cxios_set_domain_bounds_lon_2d(domain_hdl, bounds_lon_2d, extent1, extent2, extent3) BIND(C) 
     107      USE ISO_C_BINDING 
     108      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     109      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_2d 
     110      INTEGER (kind = C_INT), VALUE  :: extent1 
     111      INTEGER (kind = C_INT), VALUE  :: extent2 
     112      INTEGER (kind = C_INT), VALUE  :: extent3 
     113    END SUBROUTINE cxios_set_domain_bounds_lon_2d 
     114 
     115    SUBROUTINE cxios_get_domain_bounds_lon_2d(domain_hdl, bounds_lon_2d, extent1, extent2, extent3) BIND(C) 
     116      USE ISO_C_BINDING 
     117      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     118      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_2d 
     119      INTEGER (kind = C_INT), VALUE  :: extent1 
     120      INTEGER (kind = C_INT), VALUE  :: extent2 
     121      INTEGER (kind = C_INT), VALUE  :: extent3 
     122    END SUBROUTINE cxios_get_domain_bounds_lon_2d 
     123 
     124    FUNCTION cxios_is_defined_domain_bounds_lon_2d(domain_hdl) BIND(C) 
     125      USE ISO_C_BINDING 
     126      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lon_2d 
     127      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     128    END FUNCTION cxios_is_defined_domain_bounds_lon_2d 
    79129 
    80130 
     
    357407 
    358408 
    359     SUBROUTINE cxios_set_domain_latvalue(domain_hdl, latvalue, extent1) BIND(C) 
    360       USE ISO_C_BINDING 
    361       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    362       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue 
    363       INTEGER (kind = C_INT), VALUE  :: extent1 
    364     END SUBROUTINE cxios_set_domain_latvalue 
    365  
    366     SUBROUTINE cxios_get_domain_latvalue(domain_hdl, latvalue, extent1) BIND(C) 
    367       USE ISO_C_BINDING 
    368       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    369       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue 
    370       INTEGER (kind = C_INT), VALUE  :: extent1 
    371     END SUBROUTINE cxios_get_domain_latvalue 
    372  
    373     FUNCTION cxios_is_defined_domain_latvalue(domain_hdl) BIND(C) 
    374       USE ISO_C_BINDING 
    375       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_latvalue 
    376       INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    377     END FUNCTION cxios_is_defined_domain_latvalue 
     409    SUBROUTINE cxios_set_domain_latvalue_1d(domain_hdl, latvalue_1d, extent1) BIND(C) 
     410      USE ISO_C_BINDING 
     411      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     412      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_1d 
     413      INTEGER (kind = C_INT), VALUE  :: extent1 
     414    END SUBROUTINE cxios_set_domain_latvalue_1d 
     415 
     416    SUBROUTINE cxios_get_domain_latvalue_1d(domain_hdl, latvalue_1d, extent1) BIND(C) 
     417      USE ISO_C_BINDING 
     418      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     419      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_1d 
     420      INTEGER (kind = C_INT), VALUE  :: extent1 
     421    END SUBROUTINE cxios_get_domain_latvalue_1d 
     422 
     423    FUNCTION cxios_is_defined_domain_latvalue_1d(domain_hdl) BIND(C) 
     424      USE ISO_C_BINDING 
     425      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_latvalue_1d 
     426      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     427    END FUNCTION cxios_is_defined_domain_latvalue_1d 
     428 
     429 
     430    SUBROUTINE cxios_set_domain_latvalue_2d(domain_hdl, latvalue_2d, extent1, extent2) BIND(C) 
     431      USE ISO_C_BINDING 
     432      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     433      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_2d 
     434      INTEGER (kind = C_INT), VALUE  :: extent1 
     435      INTEGER (kind = C_INT), VALUE  :: extent2 
     436    END SUBROUTINE cxios_set_domain_latvalue_2d 
     437 
     438    SUBROUTINE cxios_get_domain_latvalue_2d(domain_hdl, latvalue_2d, extent1, extent2) BIND(C) 
     439      USE ISO_C_BINDING 
     440      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     441      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_2d 
     442      INTEGER (kind = C_INT), VALUE  :: extent1 
     443      INTEGER (kind = C_INT), VALUE  :: extent2 
     444    END SUBROUTINE cxios_get_domain_latvalue_2d 
     445 
     446    FUNCTION cxios_is_defined_domain_latvalue_2d(domain_hdl) BIND(C) 
     447      USE ISO_C_BINDING 
     448      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_latvalue_2d 
     449      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     450    END FUNCTION cxios_is_defined_domain_latvalue_2d 
    378451 
    379452 
     
    399472 
    400473 
    401     SUBROUTINE cxios_set_domain_lonvalue(domain_hdl, lonvalue, extent1) BIND(C) 
    402       USE ISO_C_BINDING 
    403       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    404       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue 
    405       INTEGER (kind = C_INT), VALUE  :: extent1 
    406     END SUBROUTINE cxios_set_domain_lonvalue 
    407  
    408     SUBROUTINE cxios_get_domain_lonvalue(domain_hdl, lonvalue, extent1) BIND(C) 
    409       USE ISO_C_BINDING 
    410       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    411       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue 
    412       INTEGER (kind = C_INT), VALUE  :: extent1 
    413     END SUBROUTINE cxios_get_domain_lonvalue 
    414  
    415     FUNCTION cxios_is_defined_domain_lonvalue(domain_hdl) BIND(C) 
    416       USE ISO_C_BINDING 
    417       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lonvalue 
    418       INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    419     END FUNCTION cxios_is_defined_domain_lonvalue 
    420  
    421  
    422     SUBROUTINE cxios_set_domain_mask(domain_hdl, mask, extent1, extent2) BIND(C) 
    423       USE ISO_C_BINDING 
    424       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    425       LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask 
    426       INTEGER (kind = C_INT), VALUE  :: extent1 
    427       INTEGER (kind = C_INT), VALUE  :: extent2 
    428     END SUBROUTINE cxios_set_domain_mask 
    429  
    430     SUBROUTINE cxios_get_domain_mask(domain_hdl, mask, extent1, extent2) BIND(C) 
    431       USE ISO_C_BINDING 
    432       INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
    433       LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask 
    434       INTEGER (kind = C_INT), VALUE  :: extent1 
    435       INTEGER (kind = C_INT), VALUE  :: extent2 
    436     END SUBROUTINE cxios_get_domain_mask 
    437  
    438     FUNCTION cxios_is_defined_domain_mask(domain_hdl) BIND(C) 
    439       USE ISO_C_BINDING 
    440       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_mask 
    441       INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    442     END FUNCTION cxios_is_defined_domain_mask 
     474    SUBROUTINE cxios_set_domain_lonvalue_1d(domain_hdl, lonvalue_1d, extent1) BIND(C) 
     475      USE ISO_C_BINDING 
     476      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     477      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_1d 
     478      INTEGER (kind = C_INT), VALUE  :: extent1 
     479    END SUBROUTINE cxios_set_domain_lonvalue_1d 
     480 
     481    SUBROUTINE cxios_get_domain_lonvalue_1d(domain_hdl, lonvalue_1d, extent1) BIND(C) 
     482      USE ISO_C_BINDING 
     483      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     484      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_1d 
     485      INTEGER (kind = C_INT), VALUE  :: extent1 
     486    END SUBROUTINE cxios_get_domain_lonvalue_1d 
     487 
     488    FUNCTION cxios_is_defined_domain_lonvalue_1d(domain_hdl) BIND(C) 
     489      USE ISO_C_BINDING 
     490      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lonvalue_1d 
     491      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     492    END FUNCTION cxios_is_defined_domain_lonvalue_1d 
     493 
     494 
     495    SUBROUTINE cxios_set_domain_lonvalue_2d(domain_hdl, lonvalue_2d, extent1, extent2) BIND(C) 
     496      USE ISO_C_BINDING 
     497      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     498      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_2d 
     499      INTEGER (kind = C_INT), VALUE  :: extent1 
     500      INTEGER (kind = C_INT), VALUE  :: extent2 
     501    END SUBROUTINE cxios_set_domain_lonvalue_2d 
     502 
     503    SUBROUTINE cxios_get_domain_lonvalue_2d(domain_hdl, lonvalue_2d, extent1, extent2) BIND(C) 
     504      USE ISO_C_BINDING 
     505      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     506      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_2d 
     507      INTEGER (kind = C_INT), VALUE  :: extent1 
     508      INTEGER (kind = C_INT), VALUE  :: extent2 
     509    END SUBROUTINE cxios_get_domain_lonvalue_2d 
     510 
     511    FUNCTION cxios_is_defined_domain_lonvalue_2d(domain_hdl) BIND(C) 
     512      USE ISO_C_BINDING 
     513      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lonvalue_2d 
     514      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     515    END FUNCTION cxios_is_defined_domain_lonvalue_2d 
     516 
     517 
     518    SUBROUTINE cxios_set_domain_mask_1d(domain_hdl, mask_1d, extent1) BIND(C) 
     519      USE ISO_C_BINDING 
     520      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     521      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_1d 
     522      INTEGER (kind = C_INT), VALUE  :: extent1 
     523    END SUBROUTINE cxios_set_domain_mask_1d 
     524 
     525    SUBROUTINE cxios_get_domain_mask_1d(domain_hdl, mask_1d, extent1) BIND(C) 
     526      USE ISO_C_BINDING 
     527      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     528      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_1d 
     529      INTEGER (kind = C_INT), VALUE  :: extent1 
     530    END SUBROUTINE cxios_get_domain_mask_1d 
     531 
     532    FUNCTION cxios_is_defined_domain_mask_1d(domain_hdl) BIND(C) 
     533      USE ISO_C_BINDING 
     534      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_mask_1d 
     535      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     536    END FUNCTION cxios_is_defined_domain_mask_1d 
     537 
     538 
     539    SUBROUTINE cxios_set_domain_mask_2d(domain_hdl, mask_2d, extent1, extent2) BIND(C) 
     540      USE ISO_C_BINDING 
     541      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     542      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_2d 
     543      INTEGER (kind = C_INT), VALUE  :: extent1 
     544      INTEGER (kind = C_INT), VALUE  :: extent2 
     545    END SUBROUTINE cxios_set_domain_mask_2d 
     546 
     547    SUBROUTINE cxios_get_domain_mask_2d(domain_hdl, mask_2d, extent1, extent2) BIND(C) 
     548      USE ISO_C_BINDING 
     549      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl 
     550      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_2d 
     551      INTEGER (kind = C_INT), VALUE  :: extent1 
     552      INTEGER (kind = C_INT), VALUE  :: extent2 
     553    END SUBROUTINE cxios_get_domain_mask_2d 
     554 
     555    FUNCTION cxios_is_defined_domain_mask_2d(domain_hdl) BIND(C) 
     556      USE ISO_C_BINDING 
     557      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_mask_2d 
     558      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     559    END FUNCTION cxios_is_defined_domain_mask_2d 
    443560 
    444561 
  • XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90

    r657 r664  
    3333 
    3434 
    35     SUBROUTINE cxios_set_domaingroup_bounds_lat(domaingroup_hdl, bounds_lat, extent1, extent2) BIND(C) 
    36       USE ISO_C_BINDING 
    37       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    38       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat 
    39       INTEGER (kind = C_INT), VALUE  :: extent1 
    40       INTEGER (kind = C_INT), VALUE  :: extent2 
    41     END SUBROUTINE cxios_set_domaingroup_bounds_lat 
    42  
    43     SUBROUTINE cxios_get_domaingroup_bounds_lat(domaingroup_hdl, bounds_lat, extent1, extent2) BIND(C) 
    44       USE ISO_C_BINDING 
    45       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    46       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat 
    47       INTEGER (kind = C_INT), VALUE  :: extent1 
    48       INTEGER (kind = C_INT), VALUE  :: extent2 
    49     END SUBROUTINE cxios_get_domaingroup_bounds_lat 
    50  
    51     FUNCTION cxios_is_defined_domaingroup_bounds_lat(domaingroup_hdl) BIND(C) 
    52       USE ISO_C_BINDING 
    53       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lat 
    54       INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    55     END FUNCTION cxios_is_defined_domaingroup_bounds_lat 
    56  
    57  
    58     SUBROUTINE cxios_set_domaingroup_bounds_lon(domaingroup_hdl, bounds_lon, extent1, extent2) BIND(C) 
    59       USE ISO_C_BINDING 
    60       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    61       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon 
    62       INTEGER (kind = C_INT), VALUE  :: extent1 
    63       INTEGER (kind = C_INT), VALUE  :: extent2 
    64     END SUBROUTINE cxios_set_domaingroup_bounds_lon 
    65  
    66     SUBROUTINE cxios_get_domaingroup_bounds_lon(domaingroup_hdl, bounds_lon, extent1, extent2) BIND(C) 
    67       USE ISO_C_BINDING 
    68       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    69       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon 
    70       INTEGER (kind = C_INT), VALUE  :: extent1 
    71       INTEGER (kind = C_INT), VALUE  :: extent2 
    72     END SUBROUTINE cxios_get_domaingroup_bounds_lon 
    73  
    74     FUNCTION cxios_is_defined_domaingroup_bounds_lon(domaingroup_hdl) BIND(C) 
    75       USE ISO_C_BINDING 
    76       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lon 
    77       INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    78     END FUNCTION cxios_is_defined_domaingroup_bounds_lon 
     35    SUBROUTINE cxios_set_domaingroup_bounds_lat_1d(domaingroup_hdl, bounds_lat_1d, extent1, extent2) BIND(C) 
     36      USE ISO_C_BINDING 
     37      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     38      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_1d 
     39      INTEGER (kind = C_INT), VALUE  :: extent1 
     40      INTEGER (kind = C_INT), VALUE  :: extent2 
     41    END SUBROUTINE cxios_set_domaingroup_bounds_lat_1d 
     42 
     43    SUBROUTINE cxios_get_domaingroup_bounds_lat_1d(domaingroup_hdl, bounds_lat_1d, extent1, extent2) BIND(C) 
     44      USE ISO_C_BINDING 
     45      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     46      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_1d 
     47      INTEGER (kind = C_INT), VALUE  :: extent1 
     48      INTEGER (kind = C_INT), VALUE  :: extent2 
     49    END SUBROUTINE cxios_get_domaingroup_bounds_lat_1d 
     50 
     51    FUNCTION cxios_is_defined_domaingroup_bounds_lat_1d(domaingroup_hdl) BIND(C) 
     52      USE ISO_C_BINDING 
     53      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lat_1d 
     54      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     55    END FUNCTION cxios_is_defined_domaingroup_bounds_lat_1d 
     56 
     57 
     58    SUBROUTINE cxios_set_domaingroup_bounds_lat_2d(domaingroup_hdl, bounds_lat_2d, extent1, extent2, extent3) BIND(C) 
     59      USE ISO_C_BINDING 
     60      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     61      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_2d 
     62      INTEGER (kind = C_INT), VALUE  :: extent1 
     63      INTEGER (kind = C_INT), VALUE  :: extent2 
     64      INTEGER (kind = C_INT), VALUE  :: extent3 
     65    END SUBROUTINE cxios_set_domaingroup_bounds_lat_2d 
     66 
     67    SUBROUTINE cxios_get_domaingroup_bounds_lat_2d(domaingroup_hdl, bounds_lat_2d, extent1, extent2, extent3) BIND(C) 
     68      USE ISO_C_BINDING 
     69      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     70      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_2d 
     71      INTEGER (kind = C_INT), VALUE  :: extent1 
     72      INTEGER (kind = C_INT), VALUE  :: extent2 
     73      INTEGER (kind = C_INT), VALUE  :: extent3 
     74    END SUBROUTINE cxios_get_domaingroup_bounds_lat_2d 
     75 
     76    FUNCTION cxios_is_defined_domaingroup_bounds_lat_2d(domaingroup_hdl) BIND(C) 
     77      USE ISO_C_BINDING 
     78      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lat_2d 
     79      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     80    END FUNCTION cxios_is_defined_domaingroup_bounds_lat_2d 
     81 
     82 
     83    SUBROUTINE cxios_set_domaingroup_bounds_lon_1d(domaingroup_hdl, bounds_lon_1d, extent1, extent2) BIND(C) 
     84      USE ISO_C_BINDING 
     85      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     86      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_1d 
     87      INTEGER (kind = C_INT), VALUE  :: extent1 
     88      INTEGER (kind = C_INT), VALUE  :: extent2 
     89    END SUBROUTINE cxios_set_domaingroup_bounds_lon_1d 
     90 
     91    SUBROUTINE cxios_get_domaingroup_bounds_lon_1d(domaingroup_hdl, bounds_lon_1d, extent1, extent2) BIND(C) 
     92      USE ISO_C_BINDING 
     93      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     94      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_1d 
     95      INTEGER (kind = C_INT), VALUE  :: extent1 
     96      INTEGER (kind = C_INT), VALUE  :: extent2 
     97    END SUBROUTINE cxios_get_domaingroup_bounds_lon_1d 
     98 
     99    FUNCTION cxios_is_defined_domaingroup_bounds_lon_1d(domaingroup_hdl) BIND(C) 
     100      USE ISO_C_BINDING 
     101      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lon_1d 
     102      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     103    END FUNCTION cxios_is_defined_domaingroup_bounds_lon_1d 
     104 
     105 
     106    SUBROUTINE cxios_set_domaingroup_bounds_lon_2d(domaingroup_hdl, bounds_lon_2d, extent1, extent2, extent3) BIND(C) 
     107      USE ISO_C_BINDING 
     108      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     109      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_2d 
     110      INTEGER (kind = C_INT), VALUE  :: extent1 
     111      INTEGER (kind = C_INT), VALUE  :: extent2 
     112      INTEGER (kind = C_INT), VALUE  :: extent3 
     113    END SUBROUTINE cxios_set_domaingroup_bounds_lon_2d 
     114 
     115    SUBROUTINE cxios_get_domaingroup_bounds_lon_2d(domaingroup_hdl, bounds_lon_2d, extent1, extent2, extent3) BIND(C) 
     116      USE ISO_C_BINDING 
     117      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     118      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_2d 
     119      INTEGER (kind = C_INT), VALUE  :: extent1 
     120      INTEGER (kind = C_INT), VALUE  :: extent2 
     121      INTEGER (kind = C_INT), VALUE  :: extent3 
     122    END SUBROUTINE cxios_get_domaingroup_bounds_lon_2d 
     123 
     124    FUNCTION cxios_is_defined_domaingroup_bounds_lon_2d(domaingroup_hdl) BIND(C) 
     125      USE ISO_C_BINDING 
     126      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lon_2d 
     127      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     128    END FUNCTION cxios_is_defined_domaingroup_bounds_lon_2d 
    79129 
    80130 
     
    378428 
    379429 
    380     SUBROUTINE cxios_set_domaingroup_latvalue(domaingroup_hdl, latvalue, extent1) BIND(C) 
    381       USE ISO_C_BINDING 
    382       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    383       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue 
    384       INTEGER (kind = C_INT), VALUE  :: extent1 
    385     END SUBROUTINE cxios_set_domaingroup_latvalue 
    386  
    387     SUBROUTINE cxios_get_domaingroup_latvalue(domaingroup_hdl, latvalue, extent1) BIND(C) 
    388       USE ISO_C_BINDING 
    389       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    390       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue 
    391       INTEGER (kind = C_INT), VALUE  :: extent1 
    392     END SUBROUTINE cxios_get_domaingroup_latvalue 
    393  
    394     FUNCTION cxios_is_defined_domaingroup_latvalue(domaingroup_hdl) BIND(C) 
    395       USE ISO_C_BINDING 
    396       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_latvalue 
    397       INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    398     END FUNCTION cxios_is_defined_domaingroup_latvalue 
     430    SUBROUTINE cxios_set_domaingroup_latvalue_1d(domaingroup_hdl, latvalue_1d, extent1) BIND(C) 
     431      USE ISO_C_BINDING 
     432      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     433      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_1d 
     434      INTEGER (kind = C_INT), VALUE  :: extent1 
     435    END SUBROUTINE cxios_set_domaingroup_latvalue_1d 
     436 
     437    SUBROUTINE cxios_get_domaingroup_latvalue_1d(domaingroup_hdl, latvalue_1d, extent1) BIND(C) 
     438      USE ISO_C_BINDING 
     439      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     440      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_1d 
     441      INTEGER (kind = C_INT), VALUE  :: extent1 
     442    END SUBROUTINE cxios_get_domaingroup_latvalue_1d 
     443 
     444    FUNCTION cxios_is_defined_domaingroup_latvalue_1d(domaingroup_hdl) BIND(C) 
     445      USE ISO_C_BINDING 
     446      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_latvalue_1d 
     447      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     448    END FUNCTION cxios_is_defined_domaingroup_latvalue_1d 
     449 
     450 
     451    SUBROUTINE cxios_set_domaingroup_latvalue_2d(domaingroup_hdl, latvalue_2d, extent1, extent2) BIND(C) 
     452      USE ISO_C_BINDING 
     453      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     454      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_2d 
     455      INTEGER (kind = C_INT), VALUE  :: extent1 
     456      INTEGER (kind = C_INT), VALUE  :: extent2 
     457    END SUBROUTINE cxios_set_domaingroup_latvalue_2d 
     458 
     459    SUBROUTINE cxios_get_domaingroup_latvalue_2d(domaingroup_hdl, latvalue_2d, extent1, extent2) BIND(C) 
     460      USE ISO_C_BINDING 
     461      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     462      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_2d 
     463      INTEGER (kind = C_INT), VALUE  :: extent1 
     464      INTEGER (kind = C_INT), VALUE  :: extent2 
     465    END SUBROUTINE cxios_get_domaingroup_latvalue_2d 
     466 
     467    FUNCTION cxios_is_defined_domaingroup_latvalue_2d(domaingroup_hdl) BIND(C) 
     468      USE ISO_C_BINDING 
     469      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_latvalue_2d 
     470      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     471    END FUNCTION cxios_is_defined_domaingroup_latvalue_2d 
    399472 
    400473 
     
    420493 
    421494 
    422     SUBROUTINE cxios_set_domaingroup_lonvalue(domaingroup_hdl, lonvalue, extent1) BIND(C) 
    423       USE ISO_C_BINDING 
    424       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    425       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue 
    426       INTEGER (kind = C_INT), VALUE  :: extent1 
    427     END SUBROUTINE cxios_set_domaingroup_lonvalue 
    428  
    429     SUBROUTINE cxios_get_domaingroup_lonvalue(domaingroup_hdl, lonvalue, extent1) BIND(C) 
    430       USE ISO_C_BINDING 
    431       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    432       REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue 
    433       INTEGER (kind = C_INT), VALUE  :: extent1 
    434     END SUBROUTINE cxios_get_domaingroup_lonvalue 
    435  
    436     FUNCTION cxios_is_defined_domaingroup_lonvalue(domaingroup_hdl) BIND(C) 
    437       USE ISO_C_BINDING 
    438       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lonvalue 
    439       INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    440     END FUNCTION cxios_is_defined_domaingroup_lonvalue 
    441  
    442  
    443     SUBROUTINE cxios_set_domaingroup_mask(domaingroup_hdl, mask, extent1, extent2) BIND(C) 
    444       USE ISO_C_BINDING 
    445       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    446       LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask 
    447       INTEGER (kind = C_INT), VALUE  :: extent1 
    448       INTEGER (kind = C_INT), VALUE  :: extent2 
    449     END SUBROUTINE cxios_set_domaingroup_mask 
    450  
    451     SUBROUTINE cxios_get_domaingroup_mask(domaingroup_hdl, mask, extent1, extent2) BIND(C) 
    452       USE ISO_C_BINDING 
    453       INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
    454       LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask 
    455       INTEGER (kind = C_INT), VALUE  :: extent1 
    456       INTEGER (kind = C_INT), VALUE  :: extent2 
    457     END SUBROUTINE cxios_get_domaingroup_mask 
    458  
    459     FUNCTION cxios_is_defined_domaingroup_mask(domaingroup_hdl) BIND(C) 
    460       USE ISO_C_BINDING 
    461       LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_mask 
    462       INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    463     END FUNCTION cxios_is_defined_domaingroup_mask 
     495    SUBROUTINE cxios_set_domaingroup_lonvalue_1d(domaingroup_hdl, lonvalue_1d, extent1) BIND(C) 
     496      USE ISO_C_BINDING 
     497      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     498      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_1d 
     499      INTEGER (kind = C_INT), VALUE  :: extent1 
     500    END SUBROUTINE cxios_set_domaingroup_lonvalue_1d 
     501 
     502    SUBROUTINE cxios_get_domaingroup_lonvalue_1d(domaingroup_hdl, lonvalue_1d, extent1) BIND(C) 
     503      USE ISO_C_BINDING 
     504      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     505      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_1d 
     506      INTEGER (kind = C_INT), VALUE  :: extent1 
     507    END SUBROUTINE cxios_get_domaingroup_lonvalue_1d 
     508 
     509    FUNCTION cxios_is_defined_domaingroup_lonvalue_1d(domaingroup_hdl) BIND(C) 
     510      USE ISO_C_BINDING 
     511      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lonvalue_1d 
     512      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     513    END FUNCTION cxios_is_defined_domaingroup_lonvalue_1d 
     514 
     515 
     516    SUBROUTINE cxios_set_domaingroup_lonvalue_2d(domaingroup_hdl, lonvalue_2d, extent1, extent2) BIND(C) 
     517      USE ISO_C_BINDING 
     518      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     519      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_2d 
     520      INTEGER (kind = C_INT), VALUE  :: extent1 
     521      INTEGER (kind = C_INT), VALUE  :: extent2 
     522    END SUBROUTINE cxios_set_domaingroup_lonvalue_2d 
     523 
     524    SUBROUTINE cxios_get_domaingroup_lonvalue_2d(domaingroup_hdl, lonvalue_2d, extent1, extent2) BIND(C) 
     525      USE ISO_C_BINDING 
     526      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     527      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_2d 
     528      INTEGER (kind = C_INT), VALUE  :: extent1 
     529      INTEGER (kind = C_INT), VALUE  :: extent2 
     530    END SUBROUTINE cxios_get_domaingroup_lonvalue_2d 
     531 
     532    FUNCTION cxios_is_defined_domaingroup_lonvalue_2d(domaingroup_hdl) BIND(C) 
     533      USE ISO_C_BINDING 
     534      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lonvalue_2d 
     535      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     536    END FUNCTION cxios_is_defined_domaingroup_lonvalue_2d 
     537 
     538 
     539    SUBROUTINE cxios_set_domaingroup_mask_1d(domaingroup_hdl, mask_1d, extent1) BIND(C) 
     540      USE ISO_C_BINDING 
     541      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     542      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_1d 
     543      INTEGER (kind = C_INT), VALUE  :: extent1 
     544    END SUBROUTINE cxios_set_domaingroup_mask_1d 
     545 
     546    SUBROUTINE cxios_get_domaingroup_mask_1d(domaingroup_hdl, mask_1d, extent1) BIND(C) 
     547      USE ISO_C_BINDING 
     548      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     549      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_1d 
     550      INTEGER (kind = C_INT), VALUE  :: extent1 
     551    END SUBROUTINE cxios_get_domaingroup_mask_1d 
     552 
     553    FUNCTION cxios_is_defined_domaingroup_mask_1d(domaingroup_hdl) BIND(C) 
     554      USE ISO_C_BINDING 
     555      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_mask_1d 
     556      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     557    END FUNCTION cxios_is_defined_domaingroup_mask_1d 
     558 
     559 
     560    SUBROUTINE cxios_set_domaingroup_mask_2d(domaingroup_hdl, mask_2d, extent1, extent2) BIND(C) 
     561      USE ISO_C_BINDING 
     562      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     563      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_2d 
     564      INTEGER (kind = C_INT), VALUE  :: extent1 
     565      INTEGER (kind = C_INT), VALUE  :: extent2 
     566    END SUBROUTINE cxios_set_domaingroup_mask_2d 
     567 
     568    SUBROUTINE cxios_get_domaingroup_mask_2d(domaingroup_hdl, mask_2d, extent1, extent2) BIND(C) 
     569      USE ISO_C_BINDING 
     570      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl 
     571      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_2d 
     572      INTEGER (kind = C_INT), VALUE  :: extent1 
     573      INTEGER (kind = C_INT), VALUE  :: extent2 
     574    END SUBROUTINE cxios_get_domaingroup_mask_2d 
     575 
     576    FUNCTION cxios_is_defined_domaingroup_mask_2d(domaingroup_hdl) BIND(C) 
     577      USE ISO_C_BINDING 
     578      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_mask_2d 
     579      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     580    END FUNCTION cxios_is_defined_domaingroup_mask_2d 
    464581 
    465582 
  • XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90

    r657 r664  
    1212 
    1313  SUBROUTINE xios(set_domain_attr)  & 
    14     ( domain_id, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    15     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    16     , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    17     , standard_name, type ) 
     14    ( 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 ) 
    1818 
    1919    IMPLICIT NONE 
     
    2121      CHARACTER(LEN=*), INTENT(IN) ::domain_id 
    2222      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:) 
    23       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat(:,:) 
    24       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon(:,:) 
     23      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:) 
     24      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:) 
     25      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:) 
     26      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:) 
    2527      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim 
    2628      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:) 
     
    3739      INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:) 
    3840      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin 
    39       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue(:) 
     41      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:) 
     42      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:) 
    4043      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    41       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue(:) 
    42       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:) 
    43       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:) 
     44      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:) 
     45      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d(:,:) 
     46      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d(:) 
     47      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:) 
     48      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d(:,:) 
     49      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:) 
    4450      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name 
    4551      INTEGER  , OPTIONAL, INTENT(IN) :: ni 
     
    5359      CALL xios(get_domain_handle)(domain_id,domain_hdl) 
    5460      CALL xios(set_domain_attr_hdl_)   & 
    55       ( domain_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    56       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    57       , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    58       , standard_name, type ) 
     61      ( 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 ) 
    5965 
    6066  END SUBROUTINE xios(set_domain_attr) 
    6167 
    6268  SUBROUTINE xios(set_domain_attr_hdl)  & 
    63     ( domain_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    64     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    65     , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    66     , standard_name, type ) 
     69    ( 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 ) 
    6773 
    6874    IMPLICIT NONE 
    6975      TYPE(txios(domain)) , INTENT(IN) :: domain_hdl 
    7076      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:) 
    71       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat(:,:) 
    72       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon(:,:) 
     77      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:) 
     78      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:) 
     79      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:) 
     80      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:) 
    7381      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim 
    7482      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:) 
     
    8593      INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:) 
    8694      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin 
    87       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue(:) 
     95      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:) 
     96      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:) 
    8897      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    89       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue(:) 
    90       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:) 
    91       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:) 
     98      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:) 
     99      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d(:,:) 
     100      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d(:) 
     101      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:) 
     102      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d(:,:) 
     103      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:) 
    92104      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name 
    93105      INTEGER  , OPTIONAL, INTENT(IN) :: ni 
     
    100112 
    101113      CALL xios(set_domain_attr_hdl_)  & 
    102       ( domain_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    103       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    104       , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    105       , standard_name, type ) 
     114      ( 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 ) 
    106118 
    107119  END SUBROUTINE xios(set_domain_attr_hdl) 
    108120 
    109121  SUBROUTINE xios(set_domain_attr_hdl_)   & 
    110     ( domain_hdl, area_, bounds_lat_, bounds_lon_, data_dim_, data_i_index_, data_ibegin_, data_j_index_  & 
    111     , data_jbegin_, data_n_index_, data_ni_, data_nj_, domain_group_ref_, domain_ref_, i_index_  & 
    112     , ibegin_, j_index_, jbegin_, latvalue_, long_name_, lonvalue_, mask_, name_, ni_, ni_glo_, nj_  & 
    113     , nj_glo_, nvertex_, standard_name_, type_ ) 
     122    ( 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_ ) 
    114127 
    115128    IMPLICIT NONE 
    116129      TYPE(txios(domain)) , INTENT(IN) :: domain_hdl 
    117130      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_(:,:) 
    118       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_(:,:) 
    119       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_(:,:) 
     131      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d_(:,:) 
     132      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d_(:,:,:) 
     133      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d_(:,:) 
     134      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d_(:,:,:) 
    120135      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim_ 
    121136      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index_(:) 
     
    132147      INTEGER  , OPTIONAL, INTENT(IN) :: j_index_(:) 
    133148      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin_ 
    134       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_(:) 
     149      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d_(:) 
     150      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d_(:,:) 
    135151      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_ 
    136       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_(:) 
    137       LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:,:) 
    138       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:) 
     152      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d_(:) 
     153      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d_(:,:) 
     154      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d_(:) 
     155      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d__tmp(:) 
     156      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d_(:,:) 
     157      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d__tmp(:,:) 
    139158      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_ 
    140159      INTEGER  , OPTIONAL, INTENT(IN) :: ni_ 
     
    150169      ENDIF 
    151170 
    152       IF (PRESENT(bounds_lat_)) THEN 
    153         CALL cxios_set_domain_bounds_lat(domain_hdl%daddr, bounds_lat_, size(bounds_lat_,1), size(bounds_lat_,2)) 
    154       ENDIF 
    155  
    156       IF (PRESENT(bounds_lon_)) THEN 
    157         CALL cxios_set_domain_bounds_lon(domain_hdl%daddr, bounds_lon_, size(bounds_lon_,1), size(bounds_lon_,2)) 
     171      IF (PRESENT(bounds_lat_1d_)) THEN 
     172        CALL cxios_set_domain_bounds_lat_1d(domain_hdl%daddr, bounds_lat_1d_, size(bounds_lat_1d_,1), size(bounds_lat_1d_,2)) 
     173      ENDIF 
     174 
     175      IF (PRESENT(bounds_lat_2d_)) THEN 
     176        CALL cxios_set_domain_bounds_lat_2d(domain_hdl%daddr, bounds_lat_2d_, size(bounds_lat_2d_,1), size(bounds_lat_2d_,2), size(bounds_lat_2d_,3)) 
     177      ENDIF 
     178 
     179      IF (PRESENT(bounds_lon_1d_)) THEN 
     180        CALL cxios_set_domain_bounds_lon_1d(domain_hdl%daddr, bounds_lon_1d_, size(bounds_lon_1d_,1), size(bounds_lon_1d_,2)) 
     181      ENDIF 
     182 
     183      IF (PRESENT(bounds_lon_2d_)) THEN 
     184        CALL cxios_set_domain_bounds_lon_2d(domain_hdl%daddr, bounds_lon_2d_, size(bounds_lon_2d_,1), size(bounds_lon_2d_,2), size(bounds_lon_2d_,3)) 
    158185      ENDIF 
    159186 
     
    214241      ENDIF 
    215242 
    216       IF (PRESENT(latvalue_)) THEN 
    217         CALL cxios_set_domain_latvalue(domain_hdl%daddr, latvalue_, size(latvalue_,1)) 
     243      IF (PRESENT(latvalue_1d_)) THEN 
     244        CALL cxios_set_domain_latvalue_1d(domain_hdl%daddr, latvalue_1d_, size(latvalue_1d_,1)) 
     245      ENDIF 
     246 
     247      IF (PRESENT(latvalue_2d_)) THEN 
     248        CALL cxios_set_domain_latvalue_2d(domain_hdl%daddr, latvalue_2d_, size(latvalue_2d_,1), size(latvalue_2d_,2)) 
    218249      ENDIF 
    219250 
     
    222253      ENDIF 
    223254 
    224       IF (PRESENT(lonvalue_)) THEN 
    225         CALL cxios_set_domain_lonvalue(domain_hdl%daddr, lonvalue_, size(lonvalue_,1)) 
    226       ENDIF 
    227  
    228       IF (PRESENT(mask_)) THEN 
    229         ALLOCATE(mask__tmp(size(mask_,1), size(mask_,2))) 
    230         mask__tmp = mask_ 
    231         CALL cxios_set_domain_mask(domain_hdl%daddr, mask__tmp, size(mask_,1), size(mask_,2)) 
     255      IF (PRESENT(lonvalue_1d_)) THEN 
     256        CALL cxios_set_domain_lonvalue_1d(domain_hdl%daddr, lonvalue_1d_, size(lonvalue_1d_,1)) 
     257      ENDIF 
     258 
     259      IF (PRESENT(lonvalue_2d_)) THEN 
     260        CALL cxios_set_domain_lonvalue_2d(domain_hdl%daddr, lonvalue_2d_, size(lonvalue_2d_,1), size(lonvalue_2d_,2)) 
     261      ENDIF 
     262 
     263      IF (PRESENT(mask_1d_)) THEN 
     264        ALLOCATE(mask_1d__tmp(size(mask_1d_,1))) 
     265        mask_1d__tmp = mask_1d_ 
     266        CALL cxios_set_domain_mask_1d(domain_hdl%daddr, mask_1d__tmp, size(mask_1d_,1)) 
     267      ENDIF 
     268 
     269      IF (PRESENT(mask_2d_)) THEN 
     270        ALLOCATE(mask_2d__tmp(size(mask_2d_,1), size(mask_2d_,2))) 
     271        mask_2d__tmp = mask_2d_ 
     272        CALL cxios_set_domain_mask_2d(domain_hdl%daddr, mask_2d__tmp, size(mask_2d_,1), size(mask_2d_,2)) 
    232273      ENDIF 
    233274 
     
    267308 
    268309  SUBROUTINE xios(get_domain_attr)  & 
    269     ( domain_id, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    270     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    271     , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    272     , standard_name, type ) 
     310    ( 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 ) 
    273314 
    274315    IMPLICIT NONE 
     
    276317      CHARACTER(LEN=*), INTENT(IN) ::domain_id 
    277318      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:) 
    278       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat(:,:) 
    279       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon(:,:) 
     319      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:) 
     320      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:) 
     321      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:) 
     322      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:) 
    280323      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim 
    281324      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:) 
     
    292335      INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:) 
    293336      INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin 
    294       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue(:) 
     337      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:) 
     338      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:) 
    295339      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    296       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue(:) 
    297       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:) 
    298       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:) 
     340      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:) 
     341      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d(:,:) 
     342      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d(:) 
     343      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:) 
     344      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d(:,:) 
     345      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:) 
    299346      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name 
    300347      INTEGER  , OPTIONAL, INTENT(OUT) :: ni 
     
    308355      CALL xios(get_domain_handle)(domain_id,domain_hdl) 
    309356      CALL xios(get_domain_attr_hdl_)   & 
    310       ( domain_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    311       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    312       , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    313       , standard_name, type ) 
     357      ( 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 ) 
    314361 
    315362  END SUBROUTINE xios(get_domain_attr) 
    316363 
    317364  SUBROUTINE xios(get_domain_attr_hdl)  & 
    318     ( domain_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    319     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    320     , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    321     , standard_name, type ) 
     365    ( 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 ) 
    322369 
    323370    IMPLICIT NONE 
    324371      TYPE(txios(domain)) , INTENT(IN) :: domain_hdl 
    325372      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:) 
    326       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat(:,:) 
    327       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon(:,:) 
     373      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:) 
     374      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:) 
     375      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:) 
     376      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:) 
    328377      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim 
    329378      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:) 
     
    340389      INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:) 
    341390      INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin 
    342       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue(:) 
     391      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:) 
     392      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:) 
    343393      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    344       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue(:) 
    345       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:) 
    346       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:) 
     394      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:) 
     395      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d(:,:) 
     396      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d(:) 
     397      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:) 
     398      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d(:,:) 
     399      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:) 
    347400      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name 
    348401      INTEGER  , OPTIONAL, INTENT(OUT) :: ni 
     
    355408 
    356409      CALL xios(get_domain_attr_hdl_)  & 
    357       ( domain_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    358       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    359       , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    360       , standard_name, type ) 
     410      ( 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 ) 
    361414 
    362415  END SUBROUTINE xios(get_domain_attr_hdl) 
    363416 
    364417  SUBROUTINE xios(get_domain_attr_hdl_)   & 
    365     ( domain_hdl, area_, bounds_lat_, bounds_lon_, data_dim_, data_i_index_, data_ibegin_, data_j_index_  & 
    366     , data_jbegin_, data_n_index_, data_ni_, data_nj_, domain_group_ref_, domain_ref_, i_index_  & 
    367     , ibegin_, j_index_, jbegin_, latvalue_, long_name_, lonvalue_, mask_, name_, ni_, ni_glo_, nj_  & 
    368     , nj_glo_, nvertex_, standard_name_, type_ ) 
     418    ( 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_ ) 
    369423 
    370424    IMPLICIT NONE 
    371425      TYPE(txios(domain)) , INTENT(IN) :: domain_hdl 
    372426      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_(:,:) 
    373       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_(:,:) 
    374       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_(:,:) 
     427      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d_(:,:) 
     428      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d_(:,:,:) 
     429      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d_(:,:) 
     430      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d_(:,:,:) 
    375431      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim_ 
    376432      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index_(:) 
     
    387443      INTEGER  , OPTIONAL, INTENT(OUT) :: j_index_(:) 
    388444      INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin_ 
    389       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_(:) 
     445      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d_(:) 
     446      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d_(:,:) 
    390447      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_ 
    391       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_(:) 
    392       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:,:) 
    393       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:) 
     448      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d_(:) 
     449      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d_(:,:) 
     450      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d_(:) 
     451      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d__tmp(:) 
     452      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d_(:,:) 
     453      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d__tmp(:,:) 
    394454      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_ 
    395455      INTEGER  , OPTIONAL, INTENT(OUT) :: ni_ 
     
    405465      ENDIF 
    406466 
    407       IF (PRESENT(bounds_lat_)) THEN 
    408         CALL cxios_get_domain_bounds_lat(domain_hdl%daddr, bounds_lat_, size(bounds_lat_,1), size(bounds_lat_,2)) 
    409       ENDIF 
    410  
    411       IF (PRESENT(bounds_lon_)) THEN 
    412         CALL cxios_get_domain_bounds_lon(domain_hdl%daddr, bounds_lon_, size(bounds_lon_,1), size(bounds_lon_,2)) 
     467      IF (PRESENT(bounds_lat_1d_)) THEN 
     468        CALL cxios_get_domain_bounds_lat_1d(domain_hdl%daddr, bounds_lat_1d_, size(bounds_lat_1d_,1), size(bounds_lat_1d_,2)) 
     469      ENDIF 
     470 
     471      IF (PRESENT(bounds_lat_2d_)) THEN 
     472        CALL cxios_get_domain_bounds_lat_2d(domain_hdl%daddr, bounds_lat_2d_, size(bounds_lat_2d_,1), size(bounds_lat_2d_,2), size(bounds_lat_2d_,3)) 
     473      ENDIF 
     474 
     475      IF (PRESENT(bounds_lon_1d_)) THEN 
     476        CALL cxios_get_domain_bounds_lon_1d(domain_hdl%daddr, bounds_lon_1d_, size(bounds_lon_1d_,1), size(bounds_lon_1d_,2)) 
     477      ENDIF 
     478 
     479      IF (PRESENT(bounds_lon_2d_)) THEN 
     480        CALL cxios_get_domain_bounds_lon_2d(domain_hdl%daddr, bounds_lon_2d_, size(bounds_lon_2d_,1), size(bounds_lon_2d_,2), size(bounds_lon_2d_,3)) 
    413481      ENDIF 
    414482 
     
    469537      ENDIF 
    470538 
    471       IF (PRESENT(latvalue_)) THEN 
    472         CALL cxios_get_domain_latvalue(domain_hdl%daddr, latvalue_, size(latvalue_,1)) 
     539      IF (PRESENT(latvalue_1d_)) THEN 
     540        CALL cxios_get_domain_latvalue_1d(domain_hdl%daddr, latvalue_1d_, size(latvalue_1d_,1)) 
     541      ENDIF 
     542 
     543      IF (PRESENT(latvalue_2d_)) THEN 
     544        CALL cxios_get_domain_latvalue_2d(domain_hdl%daddr, latvalue_2d_, size(latvalue_2d_,1), size(latvalue_2d_,2)) 
    473545      ENDIF 
    474546 
     
    477549      ENDIF 
    478550 
    479       IF (PRESENT(lonvalue_)) THEN 
    480         CALL cxios_get_domain_lonvalue(domain_hdl%daddr, lonvalue_, size(lonvalue_,1)) 
    481       ENDIF 
    482  
    483       IF (PRESENT(mask_)) THEN 
    484         ALLOCATE(mask__tmp(size(mask_,1), size(mask_,2))) 
    485         CALL cxios_get_domain_mask(domain_hdl%daddr, mask__tmp, size(mask_,1), size(mask_,2)) 
    486         mask_ = mask__tmp 
     551      IF (PRESENT(lonvalue_1d_)) THEN 
     552        CALL cxios_get_domain_lonvalue_1d(domain_hdl%daddr, lonvalue_1d_, size(lonvalue_1d_,1)) 
     553      ENDIF 
     554 
     555      IF (PRESENT(lonvalue_2d_)) THEN 
     556        CALL cxios_get_domain_lonvalue_2d(domain_hdl%daddr, lonvalue_2d_, size(lonvalue_2d_,1), size(lonvalue_2d_,2)) 
     557      ENDIF 
     558 
     559      IF (PRESENT(mask_1d_)) THEN 
     560        ALLOCATE(mask_1d__tmp(size(mask_1d_,1))) 
     561        CALL cxios_get_domain_mask_1d(domain_hdl%daddr, mask_1d__tmp, size(mask_1d_,1)) 
     562        mask_1d_ = mask_1d__tmp 
     563      ENDIF 
     564 
     565      IF (PRESENT(mask_2d_)) THEN 
     566        ALLOCATE(mask_2d__tmp(size(mask_2d_,1), size(mask_2d_,2))) 
     567        CALL cxios_get_domain_mask_2d(domain_hdl%daddr, mask_2d__tmp, size(mask_2d_,1), size(mask_2d_,2)) 
     568        mask_2d_ = mask_2d__tmp 
    487569      ENDIF 
    488570 
     
    522604 
    523605  SUBROUTINE xios(is_defined_domain_attr)  & 
    524     ( domain_id, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    525     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    526     , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    527     , standard_name, type ) 
     606    ( 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 ) 
    528610 
    529611    IMPLICIT NONE 
     
    532614      LOGICAL, OPTIONAL, INTENT(OUT) :: area 
    533615      LOGICAL(KIND=C_BOOL) :: area_tmp 
    534       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat 
    535       LOGICAL(KIND=C_BOOL) :: bounds_lat_tmp 
    536       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon 
    537       LOGICAL(KIND=C_BOOL) :: bounds_lon_tmp 
     616      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d 
     617      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp 
     618      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d 
     619      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp 
     620      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d 
     621      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp 
     622      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d 
     623      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp 
    538624      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim 
    539625      LOGICAL(KIND=C_BOOL) :: data_dim_tmp 
     
    564650      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin 
    565651      LOGICAL(KIND=C_BOOL) :: jbegin_tmp 
    566       LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue 
    567       LOGICAL(KIND=C_BOOL) :: latvalue_tmp 
     652      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d 
     653      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp 
     654      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d 
     655      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp 
    568656      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    569657      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
    570       LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue 
    571       LOGICAL(KIND=C_BOOL) :: lonvalue_tmp 
    572       LOGICAL, OPTIONAL, INTENT(OUT) :: mask 
    573       LOGICAL(KIND=C_BOOL) :: mask_tmp 
     658      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d 
     659      LOGICAL(KIND=C_BOOL) :: lonvalue_1d_tmp 
     660      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d 
     661      LOGICAL(KIND=C_BOOL) :: lonvalue_2d_tmp 
     662      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d 
     663      LOGICAL(KIND=C_BOOL) :: mask_1d_tmp 
     664      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d 
     665      LOGICAL(KIND=C_BOOL) :: mask_2d_tmp 
    574666      LOGICAL, OPTIONAL, INTENT(OUT) :: name 
    575667      LOGICAL(KIND=C_BOOL) :: name_tmp 
     
    591683      CALL xios(get_domain_handle)(domain_id,domain_hdl) 
    592684      CALL xios(is_defined_domain_attr_hdl_)   & 
    593       ( domain_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    594       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    595       , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    596       , standard_name, type ) 
     685      ( 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 ) 
    597689 
    598690  END SUBROUTINE xios(is_defined_domain_attr) 
    599691 
    600692  SUBROUTINE xios(is_defined_domain_attr_hdl)  & 
    601     ( domain_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    602     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    603     , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    604     , standard_name, type ) 
     693    ( 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 ) 
    605697 
    606698    IMPLICIT NONE 
     
    608700      LOGICAL, OPTIONAL, INTENT(OUT) :: area 
    609701      LOGICAL(KIND=C_BOOL) :: area_tmp 
    610       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat 
    611       LOGICAL(KIND=C_BOOL) :: bounds_lat_tmp 
    612       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon 
    613       LOGICAL(KIND=C_BOOL) :: bounds_lon_tmp 
     702      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d 
     703      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp 
     704      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d 
     705      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp 
     706      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d 
     707      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp 
     708      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d 
     709      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp 
    614710      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim 
    615711      LOGICAL(KIND=C_BOOL) :: data_dim_tmp 
     
    640736      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin 
    641737      LOGICAL(KIND=C_BOOL) :: jbegin_tmp 
    642       LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue 
    643       LOGICAL(KIND=C_BOOL) :: latvalue_tmp 
     738      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d 
     739      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp 
     740      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d 
     741      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp 
    644742      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    645743      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
    646       LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue 
    647       LOGICAL(KIND=C_BOOL) :: lonvalue_tmp 
    648       LOGICAL, OPTIONAL, INTENT(OUT) :: mask 
    649       LOGICAL(KIND=C_BOOL) :: mask_tmp 
     744      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d 
     745      LOGICAL(KIND=C_BOOL) :: lonvalue_1d_tmp 
     746      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d 
     747      LOGICAL(KIND=C_BOOL) :: lonvalue_2d_tmp 
     748      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d 
     749      LOGICAL(KIND=C_BOOL) :: mask_1d_tmp 
     750      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d 
     751      LOGICAL(KIND=C_BOOL) :: mask_2d_tmp 
    650752      LOGICAL, OPTIONAL, INTENT(OUT) :: name 
    651753      LOGICAL(KIND=C_BOOL) :: name_tmp 
     
    666768 
    667769      CALL xios(is_defined_domain_attr_hdl_)  & 
    668       ( domain_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    669       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, i_index, ibegin  & 
    670       , j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  & 
    671       , standard_name, type ) 
     770      ( 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 ) 
    672774 
    673775  END SUBROUTINE xios(is_defined_domain_attr_hdl) 
    674776 
    675777  SUBROUTINE xios(is_defined_domain_attr_hdl_)   & 
    676     ( domain_hdl, area_, bounds_lat_, bounds_lon_, data_dim_, data_i_index_, data_ibegin_, data_j_index_  & 
    677     , data_jbegin_, data_n_index_, data_ni_, data_nj_, domain_group_ref_, domain_ref_, i_index_  & 
    678     , ibegin_, j_index_, jbegin_, latvalue_, long_name_, lonvalue_, mask_, name_, ni_, ni_glo_, nj_  & 
    679     , nj_glo_, nvertex_, standard_name_, type_ ) 
     778    ( 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_ ) 
    680783 
    681784    IMPLICIT NONE 
     
    683786      LOGICAL, OPTIONAL, INTENT(OUT) :: area_ 
    684787      LOGICAL(KIND=C_BOOL) :: area__tmp 
    685       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_ 
    686       LOGICAL(KIND=C_BOOL) :: bounds_lat__tmp 
    687       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_ 
    688       LOGICAL(KIND=C_BOOL) :: bounds_lon__tmp 
     788      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d_ 
     789      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d__tmp 
     790      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d_ 
     791      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d__tmp 
     792      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d_ 
     793      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d__tmp 
     794      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d_ 
     795      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d__tmp 
    689796      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim_ 
    690797      LOGICAL(KIND=C_BOOL) :: data_dim__tmp 
     
    715822      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin_ 
    716823      LOGICAL(KIND=C_BOOL) :: jbegin__tmp 
    717       LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_ 
    718       LOGICAL(KIND=C_BOOL) :: latvalue__tmp 
     824      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d_ 
     825      LOGICAL(KIND=C_BOOL) :: latvalue_1d__tmp 
     826      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d_ 
     827      LOGICAL(KIND=C_BOOL) :: latvalue_2d__tmp 
    719828      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_ 
    720829      LOGICAL(KIND=C_BOOL) :: long_name__tmp 
    721       LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_ 
    722       LOGICAL(KIND=C_BOOL) :: lonvalue__tmp 
    723       LOGICAL, OPTIONAL, INTENT(OUT) :: mask_ 
    724       LOGICAL(KIND=C_BOOL) :: mask__tmp 
     830      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d_ 
     831      LOGICAL(KIND=C_BOOL) :: lonvalue_1d__tmp 
     832      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d_ 
     833      LOGICAL(KIND=C_BOOL) :: lonvalue_2d__tmp 
     834      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d_ 
     835      LOGICAL(KIND=C_BOOL) :: mask_1d__tmp 
     836      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d_ 
     837      LOGICAL(KIND=C_BOOL) :: mask_2d__tmp 
    725838      LOGICAL, OPTIONAL, INTENT(OUT) :: name_ 
    726839      LOGICAL(KIND=C_BOOL) :: name__tmp 
     
    745858      ENDIF 
    746859 
    747       IF (PRESENT(bounds_lat_)) THEN 
    748         bounds_lat__tmp = cxios_is_defined_domain_bounds_lat(domain_hdl%daddr) 
    749         bounds_lat_ = bounds_lat__tmp 
    750       ENDIF 
    751  
    752       IF (PRESENT(bounds_lon_)) THEN 
    753         bounds_lon__tmp = cxios_is_defined_domain_bounds_lon(domain_hdl%daddr) 
    754         bounds_lon_ = bounds_lon__tmp 
     860      IF (PRESENT(bounds_lat_1d_)) THEN 
     861        bounds_lat_1d__tmp = cxios_is_defined_domain_bounds_lat_1d(domain_hdl%daddr) 
     862        bounds_lat_1d_ = bounds_lat_1d__tmp 
     863      ENDIF 
     864 
     865      IF (PRESENT(bounds_lat_2d_)) THEN 
     866        bounds_lat_2d__tmp = cxios_is_defined_domain_bounds_lat_2d(domain_hdl%daddr) 
     867        bounds_lat_2d_ = bounds_lat_2d__tmp 
     868      ENDIF 
     869 
     870      IF (PRESENT(bounds_lon_1d_)) THEN 
     871        bounds_lon_1d__tmp = cxios_is_defined_domain_bounds_lon_1d(domain_hdl%daddr) 
     872        bounds_lon_1d_ = bounds_lon_1d__tmp 
     873      ENDIF 
     874 
     875      IF (PRESENT(bounds_lon_2d_)) THEN 
     876        bounds_lon_2d__tmp = cxios_is_defined_domain_bounds_lon_2d(domain_hdl%daddr) 
     877        bounds_lon_2d_ = bounds_lon_2d__tmp 
    755878      ENDIF 
    756879 
     
    825948      ENDIF 
    826949 
    827       IF (PRESENT(latvalue_)) THEN 
    828         latvalue__tmp = cxios_is_defined_domain_latvalue(domain_hdl%daddr) 
    829         latvalue_ = latvalue__tmp 
     950      IF (PRESENT(latvalue_1d_)) THEN 
     951        latvalue_1d__tmp = cxios_is_defined_domain_latvalue_1d(domain_hdl%daddr) 
     952        latvalue_1d_ = latvalue_1d__tmp 
     953      ENDIF 
     954 
     955      IF (PRESENT(latvalue_2d_)) THEN 
     956        latvalue_2d__tmp = cxios_is_defined_domain_latvalue_2d(domain_hdl%daddr) 
     957        latvalue_2d_ = latvalue_2d__tmp 
    830958      ENDIF 
    831959 
     
    835963      ENDIF 
    836964 
    837       IF (PRESENT(lonvalue_)) THEN 
    838         lonvalue__tmp = cxios_is_defined_domain_lonvalue(domain_hdl%daddr) 
    839         lonvalue_ = lonvalue__tmp 
    840       ENDIF 
    841  
    842       IF (PRESENT(mask_)) THEN 
    843         mask__tmp = cxios_is_defined_domain_mask(domain_hdl%daddr) 
    844         mask_ = mask__tmp 
     965      IF (PRESENT(lonvalue_1d_)) THEN 
     966        lonvalue_1d__tmp = cxios_is_defined_domain_lonvalue_1d(domain_hdl%daddr) 
     967        lonvalue_1d_ = lonvalue_1d__tmp 
     968      ENDIF 
     969 
     970      IF (PRESENT(lonvalue_2d_)) THEN 
     971        lonvalue_2d__tmp = cxios_is_defined_domain_lonvalue_2d(domain_hdl%daddr) 
     972        lonvalue_2d_ = lonvalue_2d__tmp 
     973      ENDIF 
     974 
     975      IF (PRESENT(mask_1d_)) THEN 
     976        mask_1d__tmp = cxios_is_defined_domain_mask_1d(domain_hdl%daddr) 
     977        mask_1d_ = mask_1d__tmp 
     978      ENDIF 
     979 
     980      IF (PRESENT(mask_2d_)) THEN 
     981        mask_2d__tmp = cxios_is_defined_domain_mask_2d(domain_hdl%daddr) 
     982        mask_2d_ = mask_2d__tmp 
    845983      ENDIF 
    846984 
  • XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90

    r657 r664  
    1212 
    1313  SUBROUTINE xios(set_domaingroup_attr)  & 
    14     ( domaingroup_id, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    15     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    16     , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    17     , nvertex, standard_name, type ) 
     14    ( 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 ) 
    1819 
    1920    IMPLICIT NONE 
     
    2122      CHARACTER(LEN=*), INTENT(IN) ::domaingroup_id 
    2223      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:) 
    23       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat(:,:) 
    24       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon(:,:) 
     24      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:) 
     25      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:) 
     26      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:) 
     27      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:) 
    2528      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim 
    2629      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:) 
     
    3841      INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:) 
    3942      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin 
    40       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue(:) 
     43      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:) 
     44      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:) 
    4145      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    42       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue(:) 
    43       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:) 
    44       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:) 
     46      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:) 
     47      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d(:,:) 
     48      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d(:) 
     49      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:) 
     50      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d(:,:) 
     51      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:) 
    4552      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name 
    4653      INTEGER  , OPTIONAL, INTENT(IN) :: ni 
     
    5461      CALL xios(get_domaingroup_handle)(domaingroup_id,domaingroup_hdl) 
    5562      CALL xios(set_domaingroup_attr_hdl_)   & 
    56       ( domaingroup_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    57       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    58       , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    59       , nvertex, standard_name, type ) 
     63      ( 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 ) 
    6068 
    6169  END SUBROUTINE xios(set_domaingroup_attr) 
    6270 
    6371  SUBROUTINE xios(set_domaingroup_attr_hdl)  & 
    64     ( domaingroup_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    65     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    66     , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    67     , nvertex, standard_name, type ) 
     72    ( 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 ) 
    6877 
    6978    IMPLICIT NONE 
    7079      TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl 
    7180      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:) 
    72       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat(:,:) 
    73       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon(:,:) 
     81      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:) 
     82      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:) 
     83      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:) 
     84      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:) 
    7485      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim 
    7586      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:) 
     
    8798      INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:) 
    8899      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin 
    89       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue(:) 
     100      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:) 
     101      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:) 
    90102      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    91       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue(:) 
    92       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:) 
    93       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:) 
     103      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:) 
     104      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d(:,:) 
     105      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d(:) 
     106      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:) 
     107      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d(:,:) 
     108      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:) 
    94109      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name 
    95110      INTEGER  , OPTIONAL, INTENT(IN) :: ni 
     
    102117 
    103118      CALL xios(set_domaingroup_attr_hdl_)  & 
    104       ( domaingroup_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    105       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    106       , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    107       , nvertex, standard_name, type ) 
     119      ( 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 ) 
    108124 
    109125  END SUBROUTINE xios(set_domaingroup_attr_hdl) 
    110126 
    111127  SUBROUTINE xios(set_domaingroup_attr_hdl_)   & 
    112     ( domaingroup_hdl, area_, bounds_lat_, bounds_lon_, data_dim_, data_i_index_, data_ibegin_, data_j_index_  & 
    113     , data_jbegin_, data_n_index_, data_ni_, data_nj_, domain_group_ref_, domain_ref_, group_ref_  & 
    114     , i_index_, ibegin_, j_index_, jbegin_, latvalue_, long_name_, lonvalue_, mask_, name_, ni_  & 
    115     , ni_glo_, nj_, nj_glo_, nvertex_, standard_name_, type_ ) 
     128    ( 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_ ) 
    116133 
    117134    IMPLICIT NONE 
    118135      TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl 
    119136      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_(:,:) 
    120       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_(:,:) 
    121       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_(:,:) 
     137      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d_(:,:) 
     138      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d_(:,:,:) 
     139      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d_(:,:) 
     140      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d_(:,:,:) 
    122141      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim_ 
    123142      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index_(:) 
     
    135154      INTEGER  , OPTIONAL, INTENT(IN) :: j_index_(:) 
    136155      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin_ 
    137       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_(:) 
     156      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d_(:) 
     157      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d_(:,:) 
    138158      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_ 
    139       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_(:) 
    140       LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:,:) 
    141       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:) 
     159      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d_(:) 
     160      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d_(:,:) 
     161      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d_(:) 
     162      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d__tmp(:) 
     163      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d_(:,:) 
     164      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d__tmp(:,:) 
    142165      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_ 
    143166      INTEGER  , OPTIONAL, INTENT(IN) :: ni_ 
     
    153176      ENDIF 
    154177 
    155       IF (PRESENT(bounds_lat_)) THEN 
    156         CALL cxios_set_domaingroup_bounds_lat(domaingroup_hdl%daddr, bounds_lat_, size(bounds_lat_,1), size(bounds_lat_,2)) 
    157       ENDIF 
    158  
    159       IF (PRESENT(bounds_lon_)) THEN 
    160         CALL cxios_set_domaingroup_bounds_lon(domaingroup_hdl%daddr, bounds_lon_, size(bounds_lon_,1), size(bounds_lon_,2)) 
     178      IF (PRESENT(bounds_lat_1d_)) THEN 
     179        CALL cxios_set_domaingroup_bounds_lat_1d(domaingroup_hdl%daddr, bounds_lat_1d_, size(bounds_lat_1d_,1), size(bounds_lat_1d_,2)) 
     180      ENDIF 
     181 
     182      IF (PRESENT(bounds_lat_2d_)) THEN 
     183        CALL cxios_set_domaingroup_bounds_lat_2d(domaingroup_hdl%daddr, bounds_lat_2d_, size(bounds_lat_2d_,1), size(bounds_lat_2d_,2), size(bounds_lat_2d_,3)) 
     184      ENDIF 
     185 
     186      IF (PRESENT(bounds_lon_1d_)) THEN 
     187        CALL cxios_set_domaingroup_bounds_lon_1d(domaingroup_hdl%daddr, bounds_lon_1d_, size(bounds_lon_1d_,1), size(bounds_lon_1d_,2)) 
     188      ENDIF 
     189 
     190      IF (PRESENT(bounds_lon_2d_)) THEN 
     191        CALL cxios_set_domaingroup_bounds_lon_2d(domaingroup_hdl%daddr, bounds_lon_2d_, size(bounds_lon_2d_,1), size(bounds_lon_2d_,2), size(bounds_lon_2d_,3)) 
    161192      ENDIF 
    162193 
     
    221252      ENDIF 
    222253 
    223       IF (PRESENT(latvalue_)) THEN 
    224         CALL cxios_set_domaingroup_latvalue(domaingroup_hdl%daddr, latvalue_, size(latvalue_,1)) 
     254      IF (PRESENT(latvalue_1d_)) THEN 
     255        CALL cxios_set_domaingroup_latvalue_1d(domaingroup_hdl%daddr, latvalue_1d_, size(latvalue_1d_,1)) 
     256      ENDIF 
     257 
     258      IF (PRESENT(latvalue_2d_)) THEN 
     259        CALL cxios_set_domaingroup_latvalue_2d(domaingroup_hdl%daddr, latvalue_2d_, size(latvalue_2d_,1), size(latvalue_2d_,2)) 
    225260      ENDIF 
    226261 
     
    229264      ENDIF 
    230265 
    231       IF (PRESENT(lonvalue_)) THEN 
    232         CALL cxios_set_domaingroup_lonvalue(domaingroup_hdl%daddr, lonvalue_, size(lonvalue_,1)) 
    233       ENDIF 
    234  
    235       IF (PRESENT(mask_)) THEN 
    236         ALLOCATE(mask__tmp(size(mask_,1), size(mask_,2))) 
    237         mask__tmp = mask_ 
    238         CALL cxios_set_domaingroup_mask(domaingroup_hdl%daddr, mask__tmp, size(mask_,1), size(mask_,2)) 
     266      IF (PRESENT(lonvalue_1d_)) THEN 
     267        CALL cxios_set_domaingroup_lonvalue_1d(domaingroup_hdl%daddr, lonvalue_1d_, size(lonvalue_1d_,1)) 
     268      ENDIF 
     269 
     270      IF (PRESENT(lonvalue_2d_)) THEN 
     271        CALL cxios_set_domaingroup_lonvalue_2d(domaingroup_hdl%daddr, lonvalue_2d_, size(lonvalue_2d_,1), size(lonvalue_2d_,2)) 
     272      ENDIF 
     273 
     274      IF (PRESENT(mask_1d_)) THEN 
     275        ALLOCATE(mask_1d__tmp(size(mask_1d_,1))) 
     276        mask_1d__tmp = mask_1d_ 
     277        CALL cxios_set_domaingroup_mask_1d(domaingroup_hdl%daddr, mask_1d__tmp, size(mask_1d_,1)) 
     278      ENDIF 
     279 
     280      IF (PRESENT(mask_2d_)) THEN 
     281        ALLOCATE(mask_2d__tmp(size(mask_2d_,1), size(mask_2d_,2))) 
     282        mask_2d__tmp = mask_2d_ 
     283        CALL cxios_set_domaingroup_mask_2d(domaingroup_hdl%daddr, mask_2d__tmp, size(mask_2d_,1), size(mask_2d_,2)) 
    239284      ENDIF 
    240285 
     
    274319 
    275320  SUBROUTINE xios(get_domaingroup_attr)  & 
    276     ( domaingroup_id, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    277     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    278     , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    279     , nvertex, standard_name, type ) 
     321    ( 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 ) 
    280326 
    281327    IMPLICIT NONE 
     
    283329      CHARACTER(LEN=*), INTENT(IN) ::domaingroup_id 
    284330      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:) 
    285       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat(:,:) 
    286       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon(:,:) 
     331      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:) 
     332      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:) 
     333      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:) 
     334      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:) 
    287335      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim 
    288336      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:) 
     
    300348      INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:) 
    301349      INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin 
    302       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue(:) 
     350      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:) 
     351      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:) 
    303352      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    304       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue(:) 
    305       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:) 
    306       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:) 
     353      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:) 
     354      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d(:,:) 
     355      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d(:) 
     356      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:) 
     357      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d(:,:) 
     358      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:) 
    307359      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name 
    308360      INTEGER  , OPTIONAL, INTENT(OUT) :: ni 
     
    316368      CALL xios(get_domaingroup_handle)(domaingroup_id,domaingroup_hdl) 
    317369      CALL xios(get_domaingroup_attr_hdl_)   & 
    318       ( domaingroup_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    319       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    320       , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    321       , nvertex, standard_name, type ) 
     370      ( 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 ) 
    322375 
    323376  END SUBROUTINE xios(get_domaingroup_attr) 
    324377 
    325378  SUBROUTINE xios(get_domaingroup_attr_hdl)  & 
    326     ( domaingroup_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    327     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    328     , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    329     , nvertex, standard_name, type ) 
     379    ( 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 ) 
    330384 
    331385    IMPLICIT NONE 
    332386      TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl 
    333387      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:) 
    334       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat(:,:) 
    335       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon(:,:) 
     388      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:) 
     389      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:) 
     390      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:) 
     391      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:) 
    336392      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim 
    337393      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:) 
     
    349405      INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:) 
    350406      INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin 
    351       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue(:) 
     407      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:) 
     408      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:) 
    352409      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    353       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue(:) 
    354       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:) 
    355       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:) 
     410      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:) 
     411      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d(:,:) 
     412      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d(:) 
     413      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:) 
     414      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d(:,:) 
     415      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:) 
    356416      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name 
    357417      INTEGER  , OPTIONAL, INTENT(OUT) :: ni 
     
    364424 
    365425      CALL xios(get_domaingroup_attr_hdl_)  & 
    366       ( domaingroup_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    367       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    368       , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    369       , nvertex, standard_name, type ) 
     426      ( 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 ) 
    370431 
    371432  END SUBROUTINE xios(get_domaingroup_attr_hdl) 
    372433 
    373434  SUBROUTINE xios(get_domaingroup_attr_hdl_)   & 
    374     ( domaingroup_hdl, area_, bounds_lat_, bounds_lon_, data_dim_, data_i_index_, data_ibegin_, data_j_index_  & 
    375     , data_jbegin_, data_n_index_, data_ni_, data_nj_, domain_group_ref_, domain_ref_, group_ref_  & 
    376     , i_index_, ibegin_, j_index_, jbegin_, latvalue_, long_name_, lonvalue_, mask_, name_, ni_  & 
    377     , ni_glo_, nj_, nj_glo_, nvertex_, standard_name_, type_ ) 
     435    ( 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_ ) 
    378440 
    379441    IMPLICIT NONE 
    380442      TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl 
    381443      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_(:,:) 
    382       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_(:,:) 
    383       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_(:,:) 
     444      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d_(:,:) 
     445      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d_(:,:,:) 
     446      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d_(:,:) 
     447      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d_(:,:,:) 
    384448      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim_ 
    385449      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index_(:) 
     
    397461      INTEGER  , OPTIONAL, INTENT(OUT) :: j_index_(:) 
    398462      INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin_ 
    399       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_(:) 
     463      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d_(:) 
     464      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d_(:,:) 
    400465      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_ 
    401       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_(:) 
    402       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:,:) 
    403       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:) 
     466      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d_(:) 
     467      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d_(:,:) 
     468      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d_(:) 
     469      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d__tmp(:) 
     470      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d_(:,:) 
     471      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d__tmp(:,:) 
    404472      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_ 
    405473      INTEGER  , OPTIONAL, INTENT(OUT) :: ni_ 
     
    415483      ENDIF 
    416484 
    417       IF (PRESENT(bounds_lat_)) THEN 
    418         CALL cxios_get_domaingroup_bounds_lat(domaingroup_hdl%daddr, bounds_lat_, size(bounds_lat_,1), size(bounds_lat_,2)) 
    419       ENDIF 
    420  
    421       IF (PRESENT(bounds_lon_)) THEN 
    422         CALL cxios_get_domaingroup_bounds_lon(domaingroup_hdl%daddr, bounds_lon_, size(bounds_lon_,1), size(bounds_lon_,2)) 
     485      IF (PRESENT(bounds_lat_1d_)) THEN 
     486        CALL cxios_get_domaingroup_bounds_lat_1d(domaingroup_hdl%daddr, bounds_lat_1d_, size(bounds_lat_1d_,1), size(bounds_lat_1d_,2)) 
     487      ENDIF 
     488 
     489      IF (PRESENT(bounds_lat_2d_)) THEN 
     490        CALL cxios_get_domaingroup_bounds_lat_2d(domaingroup_hdl%daddr, bounds_lat_2d_, size(bounds_lat_2d_,1), size(bounds_lat_2d_,2), size(bounds_lat_2d_,3)) 
     491      ENDIF 
     492 
     493      IF (PRESENT(bounds_lon_1d_)) THEN 
     494        CALL cxios_get_domaingroup_bounds_lon_1d(domaingroup_hdl%daddr, bounds_lon_1d_, size(bounds_lon_1d_,1), size(bounds_lon_1d_,2)) 
     495      ENDIF 
     496 
     497      IF (PRESENT(bounds_lon_2d_)) THEN 
     498        CALL cxios_get_domaingroup_bounds_lon_2d(domaingroup_hdl%daddr, bounds_lon_2d_, size(bounds_lon_2d_,1), size(bounds_lon_2d_,2), size(bounds_lon_2d_,3)) 
    423499      ENDIF 
    424500 
     
    483559      ENDIF 
    484560 
    485       IF (PRESENT(latvalue_)) THEN 
    486         CALL cxios_get_domaingroup_latvalue(domaingroup_hdl%daddr, latvalue_, size(latvalue_,1)) 
     561      IF (PRESENT(latvalue_1d_)) THEN 
     562        CALL cxios_get_domaingroup_latvalue_1d(domaingroup_hdl%daddr, latvalue_1d_, size(latvalue_1d_,1)) 
     563      ENDIF 
     564 
     565      IF (PRESENT(latvalue_2d_)) THEN 
     566        CALL cxios_get_domaingroup_latvalue_2d(domaingroup_hdl%daddr, latvalue_2d_, size(latvalue_2d_,1), size(latvalue_2d_,2)) 
    487567      ENDIF 
    488568 
     
    491571      ENDIF 
    492572 
    493       IF (PRESENT(lonvalue_)) THEN 
    494         CALL cxios_get_domaingroup_lonvalue(domaingroup_hdl%daddr, lonvalue_, size(lonvalue_,1)) 
    495       ENDIF 
    496  
    497       IF (PRESENT(mask_)) THEN 
    498         ALLOCATE(mask__tmp(size(mask_,1), size(mask_,2))) 
    499         CALL cxios_get_domaingroup_mask(domaingroup_hdl%daddr, mask__tmp, size(mask_,1), size(mask_,2)) 
    500         mask_ = mask__tmp 
     573      IF (PRESENT(lonvalue_1d_)) THEN 
     574        CALL cxios_get_domaingroup_lonvalue_1d(domaingroup_hdl%daddr, lonvalue_1d_, size(lonvalue_1d_,1)) 
     575      ENDIF 
     576 
     577      IF (PRESENT(lonvalue_2d_)) THEN 
     578        CALL cxios_get_domaingroup_lonvalue_2d(domaingroup_hdl%daddr, lonvalue_2d_, size(lonvalue_2d_,1), size(lonvalue_2d_,2)) 
     579      ENDIF 
     580 
     581      IF (PRESENT(mask_1d_)) THEN 
     582        ALLOCATE(mask_1d__tmp(size(mask_1d_,1))) 
     583        CALL cxios_get_domaingroup_mask_1d(domaingroup_hdl%daddr, mask_1d__tmp, size(mask_1d_,1)) 
     584        mask_1d_ = mask_1d__tmp 
     585      ENDIF 
     586 
     587      IF (PRESENT(mask_2d_)) THEN 
     588        ALLOCATE(mask_2d__tmp(size(mask_2d_,1), size(mask_2d_,2))) 
     589        CALL cxios_get_domaingroup_mask_2d(domaingroup_hdl%daddr, mask_2d__tmp, size(mask_2d_,1), size(mask_2d_,2)) 
     590        mask_2d_ = mask_2d__tmp 
    501591      ENDIF 
    502592 
     
    536626 
    537627  SUBROUTINE xios(is_defined_domaingroup_attr)  & 
    538     ( domaingroup_id, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    539     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    540     , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    541     , nvertex, standard_name, type ) 
     628    ( 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 ) 
    542633 
    543634    IMPLICIT NONE 
     
    546637      LOGICAL, OPTIONAL, INTENT(OUT) :: area 
    547638      LOGICAL(KIND=C_BOOL) :: area_tmp 
    548       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat 
    549       LOGICAL(KIND=C_BOOL) :: bounds_lat_tmp 
    550       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon 
    551       LOGICAL(KIND=C_BOOL) :: bounds_lon_tmp 
     639      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d 
     640      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp 
     641      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d 
     642      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp 
     643      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d 
     644      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp 
     645      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d 
     646      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp 
    552647      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim 
    553648      LOGICAL(KIND=C_BOOL) :: data_dim_tmp 
     
    580675      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin 
    581676      LOGICAL(KIND=C_BOOL) :: jbegin_tmp 
    582       LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue 
    583       LOGICAL(KIND=C_BOOL) :: latvalue_tmp 
     677      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d 
     678      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp 
     679      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d 
     680      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp 
    584681      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    585682      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
    586       LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue 
    587       LOGICAL(KIND=C_BOOL) :: lonvalue_tmp 
    588       LOGICAL, OPTIONAL, INTENT(OUT) :: mask 
    589       LOGICAL(KIND=C_BOOL) :: mask_tmp 
     683      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d 
     684      LOGICAL(KIND=C_BOOL) :: lonvalue_1d_tmp 
     685      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d 
     686      LOGICAL(KIND=C_BOOL) :: lonvalue_2d_tmp 
     687      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d 
     688      LOGICAL(KIND=C_BOOL) :: mask_1d_tmp 
     689      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d 
     690      LOGICAL(KIND=C_BOOL) :: mask_2d_tmp 
    590691      LOGICAL, OPTIONAL, INTENT(OUT) :: name 
    591692      LOGICAL(KIND=C_BOOL) :: name_tmp 
     
    607708      CALL xios(get_domaingroup_handle)(domaingroup_id,domaingroup_hdl) 
    608709      CALL xios(is_defined_domaingroup_attr_hdl_)   & 
    609       ( domaingroup_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    610       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    611       , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    612       , nvertex, standard_name, type ) 
     710      ( 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 ) 
    613715 
    614716  END SUBROUTINE xios(is_defined_domaingroup_attr) 
    615717 
    616718  SUBROUTINE xios(is_defined_domaingroup_attr_hdl)  & 
    617     ( domaingroup_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    618     , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    619     , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    620     , nvertex, standard_name, type ) 
     719    ( 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 ) 
    621724 
    622725    IMPLICIT NONE 
     
    624727      LOGICAL, OPTIONAL, INTENT(OUT) :: area 
    625728      LOGICAL(KIND=C_BOOL) :: area_tmp 
    626       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat 
    627       LOGICAL(KIND=C_BOOL) :: bounds_lat_tmp 
    628       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon 
    629       LOGICAL(KIND=C_BOOL) :: bounds_lon_tmp 
     729      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d 
     730      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp 
     731      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d 
     732      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp 
     733      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d 
     734      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp 
     735      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d 
     736      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp 
    630737      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim 
    631738      LOGICAL(KIND=C_BOOL) :: data_dim_tmp 
     
    658765      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin 
    659766      LOGICAL(KIND=C_BOOL) :: jbegin_tmp 
    660       LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue 
    661       LOGICAL(KIND=C_BOOL) :: latvalue_tmp 
     767      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d 
     768      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp 
     769      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d 
     770      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp 
    662771      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    663772      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
    664       LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue 
    665       LOGICAL(KIND=C_BOOL) :: lonvalue_tmp 
    666       LOGICAL, OPTIONAL, INTENT(OUT) :: mask 
    667       LOGICAL(KIND=C_BOOL) :: mask_tmp 
     773      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d 
     774      LOGICAL(KIND=C_BOOL) :: lonvalue_1d_tmp 
     775      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d 
     776      LOGICAL(KIND=C_BOOL) :: lonvalue_2d_tmp 
     777      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d 
     778      LOGICAL(KIND=C_BOOL) :: mask_1d_tmp 
     779      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d 
     780      LOGICAL(KIND=C_BOOL) :: mask_2d_tmp 
    668781      LOGICAL, OPTIONAL, INTENT(OUT) :: name 
    669782      LOGICAL(KIND=C_BOOL) :: name_tmp 
     
    684797 
    685798      CALL xios(is_defined_domaingroup_attr_hdl_)  & 
    686       ( domaingroup_hdl, area, bounds_lat, bounds_lon, data_dim, data_i_index, data_ibegin, data_j_index  & 
    687       , data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref, group_ref, i_index  & 
    688       , ibegin, j_index, jbegin, latvalue, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  & 
    689       , nvertex, standard_name, type ) 
     799      ( 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 ) 
    690804 
    691805  END SUBROUTINE xios(is_defined_domaingroup_attr_hdl) 
    692806 
    693807  SUBROUTINE xios(is_defined_domaingroup_attr_hdl_)   & 
    694     ( domaingroup_hdl, area_, bounds_lat_, bounds_lon_, data_dim_, data_i_index_, data_ibegin_, data_j_index_  & 
    695     , data_jbegin_, data_n_index_, data_ni_, data_nj_, domain_group_ref_, domain_ref_, group_ref_  & 
    696     , i_index_, ibegin_, j_index_, jbegin_, latvalue_, long_name_, lonvalue_, mask_, name_, ni_  & 
    697     , ni_glo_, nj_, nj_glo_, nvertex_, standard_name_, type_ ) 
     808    ( 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_ ) 
    698813 
    699814    IMPLICIT NONE 
     
    701816      LOGICAL, OPTIONAL, INTENT(OUT) :: area_ 
    702817      LOGICAL(KIND=C_BOOL) :: area__tmp 
    703       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_ 
    704       LOGICAL(KIND=C_BOOL) :: bounds_lat__tmp 
    705       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_ 
    706       LOGICAL(KIND=C_BOOL) :: bounds_lon__tmp 
     818      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d_ 
     819      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d__tmp 
     820      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d_ 
     821      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d__tmp 
     822      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d_ 
     823      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d__tmp 
     824      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d_ 
     825      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d__tmp 
    707826      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim_ 
    708827      LOGICAL(KIND=C_BOOL) :: data_dim__tmp 
     
    735854      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin_ 
    736855      LOGICAL(KIND=C_BOOL) :: jbegin__tmp 
    737       LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_ 
    738       LOGICAL(KIND=C_BOOL) :: latvalue__tmp 
     856      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d_ 
     857      LOGICAL(KIND=C_BOOL) :: latvalue_1d__tmp 
     858      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d_ 
     859      LOGICAL(KIND=C_BOOL) :: latvalue_2d__tmp 
    739860      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_ 
    740861      LOGICAL(KIND=C_BOOL) :: long_name__tmp 
    741       LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_ 
    742       LOGICAL(KIND=C_BOOL) :: lonvalue__tmp 
    743       LOGICAL, OPTIONAL, INTENT(OUT) :: mask_ 
    744       LOGICAL(KIND=C_BOOL) :: mask__tmp 
     862      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d_ 
     863      LOGICAL(KIND=C_BOOL) :: lonvalue_1d__tmp 
     864      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d_ 
     865      LOGICAL(KIND=C_BOOL) :: lonvalue_2d__tmp 
     866      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d_ 
     867      LOGICAL(KIND=C_BOOL) :: mask_1d__tmp 
     868      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d_ 
     869      LOGICAL(KIND=C_BOOL) :: mask_2d__tmp 
    745870      LOGICAL, OPTIONAL, INTENT(OUT) :: name_ 
    746871      LOGICAL(KIND=C_BOOL) :: name__tmp 
     
    765890      ENDIF 
    766891 
    767       IF (PRESENT(bounds_lat_)) THEN 
    768         bounds_lat__tmp = cxios_is_defined_domaingroup_bounds_lat(domaingroup_hdl%daddr) 
    769         bounds_lat_ = bounds_lat__tmp 
    770       ENDIF 
    771  
    772       IF (PRESENT(bounds_lon_)) THEN 
    773         bounds_lon__tmp = cxios_is_defined_domaingroup_bounds_lon(domaingroup_hdl%daddr) 
    774         bounds_lon_ = bounds_lon__tmp 
     892      IF (PRESENT(bounds_lat_1d_)) THEN 
     893        bounds_lat_1d__tmp = cxios_is_defined_domaingroup_bounds_lat_1d(domaingroup_hdl%daddr) 
     894        bounds_lat_1d_ = bounds_lat_1d__tmp 
     895      ENDIF 
     896 
     897      IF (PRESENT(bounds_lat_2d_)) THEN 
     898        bounds_lat_2d__tmp = cxios_is_defined_domaingroup_bounds_lat_2d(domaingroup_hdl%daddr) 
     899        bounds_lat_2d_ = bounds_lat_2d__tmp 
     900      ENDIF 
     901 
     902      IF (PRESENT(bounds_lon_1d_)) THEN 
     903        bounds_lon_1d__tmp = cxios_is_defined_domaingroup_bounds_lon_1d(domaingroup_hdl%daddr) 
     904        bounds_lon_1d_ = bounds_lon_1d__tmp 
     905      ENDIF 
     906 
     907      IF (PRESENT(bounds_lon_2d_)) THEN 
     908        bounds_lon_2d__tmp = cxios_is_defined_domaingroup_bounds_lon_2d(domaingroup_hdl%daddr) 
     909        bounds_lon_2d_ = bounds_lon_2d__tmp 
    775910      ENDIF 
    776911 
     
    850985      ENDIF 
    851986 
    852       IF (PRESENT(latvalue_)) THEN 
    853         latvalue__tmp = cxios_is_defined_domaingroup_latvalue(domaingroup_hdl%daddr) 
    854         latvalue_ = latvalue__tmp 
     987      IF (PRESENT(latvalue_1d_)) THEN 
     988        latvalue_1d__tmp = cxios_is_defined_domaingroup_latvalue_1d(domaingroup_hdl%daddr) 
     989        latvalue_1d_ = latvalue_1d__tmp 
     990      ENDIF 
     991 
     992      IF (PRESENT(latvalue_2d_)) THEN 
     993        latvalue_2d__tmp = cxios_is_defined_domaingroup_latvalue_2d(domaingroup_hdl%daddr) 
     994        latvalue_2d_ = latvalue_2d__tmp 
    855995      ENDIF 
    856996 
     
    8601000      ENDIF 
    8611001 
    862       IF (PRESENT(lonvalue_)) THEN 
    863         lonvalue__tmp = cxios_is_defined_domaingroup_lonvalue(domaingroup_hdl%daddr) 
    864         lonvalue_ = lonvalue__tmp 
    865       ENDIF 
    866  
    867       IF (PRESENT(mask_)) THEN 
    868         mask__tmp = cxios_is_defined_domaingroup_mask(domaingroup_hdl%daddr) 
    869         mask_ = mask__tmp 
     1002      IF (PRESENT(lonvalue_1d_)) THEN 
     1003        lonvalue_1d__tmp = cxios_is_defined_domaingroup_lonvalue_1d(domaingroup_hdl%daddr) 
     1004        lonvalue_1d_ = lonvalue_1d__tmp 
     1005      ENDIF 
     1006 
     1007      IF (PRESENT(lonvalue_2d_)) THEN 
     1008        lonvalue_2d__tmp = cxios_is_defined_domaingroup_lonvalue_2d(domaingroup_hdl%daddr) 
     1009        lonvalue_2d_ = lonvalue_2d__tmp 
     1010      ENDIF 
     1011 
     1012      IF (PRESENT(mask_1d_)) THEN 
     1013        mask_1d__tmp = cxios_is_defined_domaingroup_mask_1d(domaingroup_hdl%daddr) 
     1014        mask_1d_ = mask_1d__tmp 
     1015      ENDIF 
     1016 
     1017      IF (PRESENT(mask_2d_)) THEN 
     1018        mask_2d__tmp = cxios_is_defined_domaingroup_mask_2d(domaingroup_hdl%daddr) 
     1019        mask_2d_ = mask_2d__tmp 
    8701020      ENDIF 
    8711021 
  • XIOS/trunk/src/node/domain.cpp

    r663 r664  
    2727      , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_() 
    2828      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false) 
    29       , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0), maskInter_() 
     29      , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0) 
    3030      , isClientAfterTransformationChecked(false) 
     31      , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client() 
    3132   { /* Ne rien faire de plus */ } 
    3233 
     
    3536      , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_() 
    3637      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false) 
    37       , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0), maskInter_() 
     38      , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0) 
    3839      , isClientAfterTransformationChecked(false) 
     40      , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client() 
    3941   { /* Ne rien faire de plus */ } 
    4042 
     
    9597   void CDomain::checkDomain(void) 
    9698   { 
    97       if (!type.isEmpty() && type==type_attr::unstructured) 
    98       { 
    99          if (ni_glo.isEmpty() || ni_glo <= 0 ) 
    100          { 
    101             ERROR("CDomain::checkAttributes(void)", 
    102                << "[ Id = " << this->getId() << " ] " 
    103                << "The global domain is badly defined," 
    104                << " check the \'ni_glo\'  value !") 
    105          } 
    106          isUnstructed_ = true; 
    107          nj_glo = 1; 
    108          nj = 1; 
    109          jbegin = 0; 
    110          if (ni.isEmpty()) ni = i_index.numElements(); 
    111          j_index.resize(ni); 
    112          for(int i=0;i<ni;++i) j_index(i)=0; 
    113  
    114 //         nj_glo=ni_glo ; 
    115 //         ni_glo=1 ; 
    116 //         if (!ni.isEmpty()) nj=ni ; 
    117 //         if (!ibegin.isEmpty()) jbegin=ibegin ; 
    118 //         if (!iend.isEmpty()) jend=iend ; 
    119 //         if (!i_index.isEmpty()) 
    120 //         { 
    121 //          j_index.resize(1,nj) ; 
    122 //          for(int i=0;i<ni;i++) j_index(0,i)=i_index(i,0) ; 
    123 //          i_index.resize(1,nj) ; 
    124 //          for(int j=0;j<nj;j++) i_index(0,j)=0 ; 
    125 //         } 
    126 // 
    127 //         if (!mask.isEmpty()) 
    128 //         { 
    129 //          CArray<int,2> mask_tmp(nj,1); 
    130 //          mask_tmp = mask ; 
    131 //          mask.resize(1,nj) ; 
    132 //          for(int j=0;j<nj;j++) mask(0,j)=mask_tmp(j,0) ; 
    133 //         } 
    134  
    135          if (!area.isEmpty()) 
    136            area.transposeSelf(1, 0); 
    137       } 
    138       else if ((ni_glo.isEmpty() || ni_glo.getValue() <= 0 ) || 
    139           (nj_glo.isEmpty() || nj_glo.getValue() <= 0 )) 
    140       { 
    141          ERROR("CDomain::checkAttributes(void)", 
    142                << "[ Id = " << this->getId() << " ] " 
    143                << "The global domain is badly defined," 
    144                << " check the \'ni_glo\' et \'nj_glo\' values !") 
    145       } 
    146  
    147       isDistributed_ = !ibegin.isEmpty() || !ni.isEmpty() || !jbegin.isEmpty() || !nj.isEmpty(); 
    148  
    149       checkLocalIDomain(); 
    150       checkLocalJDomain(); 
    151  
    152       ibegin_client = ibegin; ni_client = ni; iend_client = ibegin + ni - 1; 
    153       jbegin_client = jbegin; nj_client = nj; jend_client = jbegin + nj - 1; 
    154  
    155       if (i_index.isEmpty()) 
    156       { 
    157         i_index.resize(ni*nj); 
    158         for (int j = 0; j < nj; ++j) 
    159           for (int i = 0; i < ni; ++i) i_index(i+j*ni) = i+ibegin; 
    160       } 
    161  
    162       if (j_index.isEmpty()) 
    163       { 
    164         j_index.resize(ni*nj); 
    165         for (int j = 0; j < nj; ++j) 
    166           for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin; 
    167       } 
    168       computeNGlobDomain(); 
    169  
    170       if (0 == global_zoom_ni) global_zoom_ni = ni_glo; 
    171       if (0 == global_zoom_nj) global_zoom_nj = nj_glo; 
     99     if (type.isEmpty()) 
     100     { 
     101       ERROR("CDomain::checkDomain(void)", 
     102             << "[ Id = " << this->getId() << " ] " 
     103             << "The domain type is not defined," 
     104             << " check the 'type'  value !") 
     105     } 
     106 
     107     if (type==type_attr::unstructured) 
     108     { 
     109        if (ni_glo.isEmpty() || ni_glo <= 0 ) 
     110        { 
     111           ERROR("CDomain::checkAttributes(void)", 
     112              << "[ Id = " << this->getId() << " ] " 
     113              << "The global domain is badly defined," 
     114              << " check the \'ni_glo\'  value !") 
     115        } 
     116        isUnstructed_ = true; 
     117        nj_glo = 1; 
     118        nj = 1; 
     119        jbegin = 0; 
     120        if (ni.isEmpty()) ni = i_index.numElements(); 
     121        j_index.resize(ni); 
     122        for(int i=0;i<ni;++i) j_index(i)=0; 
     123 
     124        if (!area.isEmpty()) 
     125          area.transposeSelf(1, 0); 
     126     } 
     127     else if ((ni_glo.isEmpty() || ni_glo.getValue() <= 0 ) || 
     128         (nj_glo.isEmpty() || nj_glo.getValue() <= 0 )) 
     129     { 
     130        ERROR("CDomain::checkAttributes(void)", 
     131              << "[ Id = " << this->getId() << " ] " 
     132              << "The global domain is badly defined," 
     133              << " check the \'ni_glo\' et \'nj_glo\' values !") 
     134     } 
     135 
     136     isDistributed_ = !ibegin.isEmpty() || !ni.isEmpty() || !jbegin.isEmpty() || !nj.isEmpty(); 
     137 
     138     checkLocalIDomain(); 
     139     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; 
     143 
     144     if (i_index.isEmpty()) 
     145     { 
     146       i_index.resize(ni*nj); 
     147       for (int j = 0; j < nj; ++j) 
     148         for (int i = 0; i < ni; ++i) i_index(i+j*ni) = i+ibegin; 
     149     } 
     150 
     151     if (j_index.isEmpty()) 
     152     { 
     153       j_index.resize(ni*nj); 
     154       for (int j = 0; j < nj; ++j) 
     155         for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin; 
     156     } 
     157     computeNGlobDomain(); 
     158 
     159     if (0 == global_zoom_ni) global_zoom_ni = ni_glo; 
     160     if (0 == global_zoom_nj) global_zoom_nj = nj_glo; 
    172161   } 
    173162 
     
    229218          jend_mask = jbegin.getValue() + nj.getValue() - 1; 
    230219 
    231       if (!mask_1D.isEmpty() && !mask_2D.isEmpty()) 
     220      if (!mask_1d.isEmpty() && !mask_2d.isEmpty()) 
    232221        ERROR("CDomain::checkMask(void)", 
    233              <<"Only one mask is used but both mask_1D and mask_2D are defined! "<<endl 
    234              <<"Define only one mask: mask_1D or mask_2D "); 
    235  
    236       if (!mask_1D.isEmpty() && mask_2D.isEmpty()) 
    237       { 
    238         if (mask_1D.numElements() != i_index.numElements()) 
     222             <<"Only one mask is used but both mask_1d and mask_2d are defined! "<<endl 
     223             <<"Define only one mask: mask_1d or mask_2d "); 
     224 
     225      if (!mask_1d.isEmpty() && mask_2d.isEmpty()) 
     226      { 
     227        if (mask_1d.numElements() != i_index.numElements()) 
    239228          ERROR("CDomain::checkMask(void)", 
    240                 <<"the mask_1D has not the same size than the local domain"<<endl 
     229                <<"the mask_1d has not the same size as the local domain"<<endl 
    241230                <<"Local size is "<<i_index.numElements()<<endl 
    242                 <<"Mask size is "<<mask_1D.numElements()); 
    243       } 
    244  
    245       if (mask_1D.isEmpty() && !mask_2D.isEmpty()) 
    246       { 
    247          if ((mask_2D.extent(0) != ni) || 
    248              (mask_2D.extent(1) != nj)) 
     231                <<"Mask size is "<<mask_1d.numElements()); 
     232      } 
     233 
     234      if (mask_1d.isEmpty() && !mask_2d.isEmpty()) 
     235      { 
     236         if ((mask_2d.extent(0) != ni) || 
     237             (mask_2d.extent(1) != nj)) 
    249238            ERROR("CDomain::checkMask(void)", 
    250                   <<"the mask has not the same size than the local domain"<<endl 
     239                  <<"the mask has not the same size as the local domain"<<endl 
    251240                  <<"Local size is "<<ni<<"x"<<nj<<endl 
    252                   <<"Mask size is "<<mask.extent(0)<<"x"<<mask.extent(1)); 
    253       } 
    254  
    255       if (!mask_1D.isEmpty()) 
    256       { 
    257         maskInter_.resize(mask_1D.numElements()); 
    258         maskInter_ = mask_1D; 
    259       } 
    260       else if (!mask_2D.isEmpty()) 
    261       { 
    262         maskInter_.resize(mask_2D.extent(0) * mask_2D.extent(0)); 
     241                  <<"Mask size is "<<mask_2d.extent(0)<<"x"<<mask_2d.extent(1)); 
     242      } 
     243 
     244      if (!mask_2d.isEmpty()) 
     245      { 
     246        mask_1d.resize(mask_2d.extent(0) * mask_2d.extent(1)); 
    263247        for (int j = 0; j < nj; ++j) 
    264           for (int i = 0; i < ni; ++i) maskInter_(i+j*ni) = mask_2D(i,j); 
     248          for (int i = 0; i < ni; ++i) mask_1d(i+j*ni) = mask_2d(i,j); 
    265249      } 
    266250      else 
    267251      { 
    268         maskInter_.resize(i_index.numElements()); 
    269         for (int i = 0; i < i_index.numElements(); ++i) maskInter_(i) = true; 
    270       } 
    271  
    272       if (!mask.isEmpty()) 
    273       { 
    274         maskInter_.resize(mask.extent(0) * mask.extent(1)); 
    275         for (int j = 0; j < nj; ++j) 
    276           for (int i = 0; i < ni; ++i) maskInter_(i+j*ni) = mask(i,j); 
    277       } 
    278       else 
    279       { 
    280         maskInter_.resize(ni*nj); 
    281         for (int i = 0; i < maskInter_.numElements(); ++i) maskInter_(i) = true; 
    282       } 
    283  
    284       if (!mask.isEmpty()) 
    285       { 
    286          if ((mask.extent(0) != ni) || 
    287              (mask.extent(1) != nj)) 
    288             ERROR("CDomain::checkAttributes(void)", 
    289                   <<"the mask has not the same size than the local domain"<<endl 
    290                    <<"Local size is "<<ni<<"x"<<nj<<endl 
    291                   <<"Mask size is "<<mask.extent(0)<<"x"<<mask.extent(1)); 
    292 //         for (int i = 0; i < ni; i++) 
    293 //         { 
    294 //            for (int j = 0; j < nj; j++) 
    295 //            { 
    296 //               if (i < ibegin_mask && i > iend_mask && 
    297 //                   j < jbegin_mask && j > jend_mask ) 
    298 //                     mask(i,j) = false; 
    299 //            } 
    300 //         } 
    301       } 
    302       else // (!mask.hasValue()) 
    303       { // Si aucun masque n'est défini, 
    304         // on en crée un nouveau qui valide l'intégralité du domaine. 
    305          mask.resize(ni,nj) ; 
    306          for (int i = 0; i < ni.getValue(); i++) 
    307          { 
    308             for (int j = 0; j < nj.getValue(); j++) 
    309             { 
    310                if (i >= ibegin_mask && i <= iend_mask && 
    311                    j >= jbegin_mask && j <= jend_mask ) 
    312                      mask(i,j) = true; 
    313                else  mask(i,j) = false; 
    314             } 
    315          } 
     252        mask_1d.resize(i_index.numElements()); 
     253        for (int i = 0; i < i_index.numElements(); ++i) mask_1d(i) = true; 
    316254      } 
    317255   } 
     
    319257 
    320258   //---------------------------------------------------------------- 
    321  
    322259   void CDomain::checkDomainData(void) 
    323260   { 
     
    331268      { 
    332269        data_dim.setValue(1); 
    333 //         ERROR("CDomain::checkAttributes(void)", 
    334 //               << "Data dimension undefined !") ; 
    335270      } 
    336271 
     
    366301 
    367302   //---------------------------------------------------------------- 
    368  
    369303   void CDomain::checkCompression(void) 
    370304   { 
    371305      if (!data_i_index.isEmpty()) 
    372306      { 
    373 //         int ssize = data_i_index.numElements(); 
    374 //         if (!data_n_index.isEmpty() && 
    375 //            (data_n_index.getValue() != ssize)) 
    376 //         { 
    377 //            ERROR("CDomain::checkAttributes(void)", 
    378 //                  <<"Dimension data_i_index incompatible with data_n_index.") ; 
    379 //         } 
    380 //         else if (data_n_index.isEmpty()) 
    381 //            data_n_index.setValue(ssize) ; 
    382           if (!data_j_index.isEmpty() && 
    383              (data_j_index.numElements() != data_i_index.numElements())) 
     307        if (!data_j_index.isEmpty() && 
     308           (data_j_index.numElements() != data_i_index.numElements())) 
     309        { 
     310           ERROR("CDomain::checkAttributes(void)", 
     311                 <<"Dimension data_j_index incompatible with data_i_index.") ; 
     312        } 
     313 
     314       if (2 == data_dim.getValue()) 
     315       { 
     316          if (data_j_index.isEmpty()) 
    384317          { 
    385318             ERROR("CDomain::checkAttributes(void)", 
    386                    <<"Dimension data_j_index incompatible with data_i_index.") ; 
     319                   <<"data_j_index must be defined !") ; 
    387320          } 
    388  
    389          if (2 == data_dim.getValue()) 
    390          { 
    391             if (data_j_index.isEmpty()) 
    392             { 
    393                ERROR("CDomain::checkAttributes(void)", 
    394                      <<"data_j_index must be defined !") ; 
    395             } 
    396          } 
    397          else // (1 == data_dim.getValue()) 
    398          { 
    399             if (data_j_index.isEmpty()) 
    400             { 
    401               const int dni = data_ni.getValue(); 
    402               data_j_index.resize(dni); 
    403               for (int j = 0; j < dni; ++j) data_j_index(j) = 0; 
    404             } 
    405  
    406          } 
     321       } 
     322       else // (1 == data_dim.getValue()) 
     323       { 
     324          if (data_j_index.isEmpty()) 
     325          { 
     326            const int dni = data_ni.getValue(); 
     327            data_j_index.resize(dni); 
     328            for (int j = 0; j < dni; ++j) data_j_index(j) = 0; 
     329          } 
     330       } 
    407331      } 
    408332      else 
    409333      { 
    410 //         if (!data_n_index.isEmpty() || 
    411 //            ((data_dim.getValue() == 2) && (!data_j_index.isEmpty()))) 
    412 //            ERROR("CDomain::checkAttributes(void)", << "data_i_index undefined") ; 
    413334         if ((data_dim.getValue() == 2) && (!data_j_index.isEmpty())) 
    414335            ERROR("CDomain::checkAttributes(void)", << "data_i_index undefined") ; 
     
    444365         } 
    445366      } 
    446  
    447 //      if (data_n_index.isEmpty()) 
    448 //      { // -> bloc re-vérifié OK 
    449 //         if (data_dim.getValue() == 1) 
    450 //         { 
    451 //            const int dni = data_ni.getValue(); 
    452 //            data_i_index.resize(dni) ; 
    453 //            data_n_index.setValue(dni); 
    454 //            for (int i = 0; i < dni; i++) data_i_index(i) = i+1 ; 
    455 //         } 
    456 //         else   // (data_dim == 2) 
    457 //         { 
    458 //            const int dni = data_ni.getValue() * data_nj.getValue(); 
    459 //            data_i_index.resize(dni) ; 
    460 //            data_j_index.resize(dni) ; 
    461 // 
    462 //            data_n_index.setValue(dni); 
    463 // 
    464 //            for(int count = 0, j = 0; j  < data_nj.getValue(); j++) 
    465 //            { 
    466 //               for(int i = 0; i < data_ni.getValue(); i++, count++) 
    467 //               { 
    468 //                  data_i_index(count) = i+1 ; 
    469 //                  data_j_index(count) = j+1 ; 
    470 //               } 
    471 //            } 
    472 //         } 
    473 //      } 
    474    } 
    475  
    476    //---------------------------------------------------------------- 
    477  
    478    void CDomain::completeLonLatClient(void) 
    479    { 
    480       int i,j,k ; 
    481       CArray<double,1> lonvalue_temp(ni*nj) ; 
    482       CArray<double,1> latvalue_temp(ni*nj) ; 
    483       CArray<double,2> bounds_lon_temp(nvertex,ni*nj) ; 
    484       CArray<double,2> bounds_lat_temp(nvertex,ni*nj) ; 
    485  
    486       if (type.isEmpty()) 
    487       { 
    488         if ( lonvalue.numElements() == ni*nj && latvalue.numElements() == ni*nj ) 
    489         { 
    490           type.setValue(type_attr::curvilinear) ; 
    491           isCurvilinear=true ; 
    492         } 
    493         else if ( lonvalue.numElements() == ni && latvalue.numElements() == nj ) 
    494         { 
    495           type.setValue(type_attr::regular) ; 
    496           isCurvilinear=false ; 
    497         } 
    498         else ERROR("void CDomain::completeLonLatClient(void)",<<"the grid is nor curvilinear, nor cartesian, because the size of longitude and latitude array is not coherent with the domain size"<<endl 
    499                                                               <<"lonvalue size = " << lonvalue.numElements() << "different of ni or ni*nj"<<endl 
    500                                                               <<"latvalue size = " << latvalue.numElements() << "different of nj or ni*nj" ) ; 
    501       } 
    502       if (type==type_attr::curvilinear || type==type_attr::unstructured) 
    503       { 
    504         lonvalue_temp=lonvalue ; 
    505         latvalue_temp=latvalue ; 
    506         if (hasBounds) bounds_lon_temp=bounds_lon ; 
    507         if (hasBounds) bounds_lat_temp=bounds_lat ; 
    508       } 
    509       else 
    510       { 
    511         for(j=0;j<nj;j++) 
    512           for(i=0;i<ni;i++) 
     367   } 
     368 
     369   void CDomain::completeLonClient() 
     370   { 
     371     int i,j,k ; 
     372     CArray<double,1> lonvalue_temp(ni*nj) ; 
     373     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     } 
     398 
     399     if (!lonvalue_2d.isEmpty()) 
     400     { 
     401        for (j = 0; j < nj; ++j) 
     402          for (i = 0; i < ni; ++i) 
    513403          { 
    514             k=j*ni+i ; 
    515             lonvalue_temp(k)=lonvalue(i) ; 
    516             latvalue_temp(k)=latvalue(j) ; 
     404            lonvalue_temp(i+j*ni) = lonvalue_2d(i,j); 
    517405            if (hasBounds) 
    518406            { 
    519               for(int n=0;n<nvertex;n++) 
    520               { 
    521                 bounds_lon_temp(n,k)=bounds_lon(n,i) ; 
    522                 bounds_lat_temp(n,k)=bounds_lat(n,j) ; 
    523               } 
     407              k=j*ni+i; 
     408              for(int n=0;n<nvertex;++n) bounds_lon_temp(n,k) = bounds_lon_2d(n,i,j); 
    524409            } 
    525410          } 
    526       } 
    527  
    528       StdSize dm = zoom_ni_client * zoom_nj_client; 
     411     } 
     412 
     413     if (!lonvalue_1d.isEmpty()) 
     414     { 
     415       if (type_attr::rectilinear == type) 
     416       { 
     417         if (ni == lonvalue_1d.numElements()) 
     418         { 
     419           for(j=0;j<nj;++j) 
     420             for(i=0;i<ni;++i) 
     421             { 
     422               k=j*ni+i; 
     423               lonvalue_temp(k) = lonvalue_1d(i); 
     424               if (hasBounds) 
     425               { 
     426                 for(int n=0;n<nvertex;++n) bounds_lon_temp(n,k) = bounds_lon_1d(n,i); 
     427               } 
     428             } 
     429          } 
     430          else 
     431            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()); 
     435       } 
     436       else if (type==type_attr::curvilinear || type==type_attr::unstructured) 
     437       { 
     438         lonvalue_temp=lonvalue_1d; 
     439         if (hasBounds) 
     440         { 
     441           bounds_lon_temp=bounds_lon_1d; 
     442         } 
     443       } 
     444     } 
     445 
     446     StdSize dm = zoom_ni_client * zoom_nj_client; 
    529447 
    530448      // Make sure that this attribute is non-empty for every client. 
    531       if (0 != dm) 
    532       { 
    533         lonvalue.resize(dm); 
    534         latvalue.resize(dm); 
    535       } 
    536  
    537  
    538       for (int i = 0; i < zoom_ni_client; i++) 
    539       { 
    540         for (int j = 0; j < zoom_nj_client; j++) 
    541         { 
    542           lonvalue(i + j * zoom_ni_client) = lonvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
    543           latvalue(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client - jbegin)*ni ); 
    544           if (hasBounds) 
     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) 
    545506          { 
    546             for(int n=0;n<nvertex;n++) 
     507            latvalue_temp(i+j*ni) = latvalue_2d(i,j); 
     508            if (hasBounds) 
    547509            { 
    548               bounds_lon(n,i + j * zoom_ni_client) = bounds_lon_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
    549               bounds_lat(n,i + j * zoom_ni_client) = bounds_lat_temp( n, (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client -jbegin)*ni ); 
     510              k=j*ni+i; 
     511              for(int n=0;n<nvertex;n++) bounds_lat_temp(n,k) = bounds_lat_2d(n,i,j); 
    550512            } 
    551513          } 
    552         } 
    553       } 
    554     } 
    555  
     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         { 
     545           bounds_lat_temp=bounds_lat_1d; 
     546         } 
     547       } 
     548     } 
     549 
     550     StdSize dm = zoom_ni_client * zoom_nj_client; 
     551 
     552      // 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++) 
     562       { 
     563         latvalue_client(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
     564         if (hasBounds) 
     565         { 
     566           for(int n=0;n<nvertex;n++) 
     567           { 
     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 ); 
     569           } 
     570         } 
     571       } 
     572     } 
     573   } 
    556574 
    557575   //---------------------------------------------------------------- 
    558576 
     577   void CDomain::completeLonLatClient(void) 
     578   { 
     579     completeLonClient(); 
     580     completeLatClient(); 
     581//      int i,j,k ; 
     582//      CArray<double,1> lonvalue_temp(ni*nj) ; 
     583//      CArray<double,1> latvalue_temp(ni*nj) ; 
     584//      CArray<double,2> bounds_lon_temp(nvertex,ni*nj); 
     585//      CArray<double,2> bounds_lat_temp(nvertex,ni*nj); 
     586// 
     587//      if (type.isEmpty()) 
     588//      { 
     589//        if ( lonvalue.numElements() == ni*nj && latvalue.numElements() == ni*nj ) 
     590//        { 
     591//          type.setValue(type_attr::curvilinear) ; 
     592//          isCurvilinear=true ; 
     593//        } 
     594//        else if ( lonvalue.numElements() == ni && latvalue.numElements() == nj ) 
     595//        { 
     596//          type.setValue(type_attr::regular) ; 
     597//          isCurvilinear=false ; 
     598//        } 
     599//        else ERROR("void CDomain::completeLonLatClient(void)",<<"the grid is nor curvilinear, nor cartesian, because the size of longitude and latitude array is not coherent with the domain size"<<endl 
     600//                                                              <<"lonvalue size = " << lonvalue.numElements() << "different of ni or ni*nj"<<endl 
     601//                                                              <<"latvalue size = " << latvalue.numElements() << "different of nj or ni*nj" ) ; 
     602//      } 
     603//      if (type==type_attr::curvilinear || type==type_attr::unstructured) 
     604//      { 
     605//        lonvalue_temp=lonvalue ; 
     606//        latvalue_temp=latvalue ; 
     607//        if (hasBounds) bounds_lon_temp=bounds_lon ; 
     608//        if (hasBounds) bounds_lat_temp=bounds_lat ; 
     609//      }checkBounds 
     610//      else 
     611//      { 
     612//        for(j=0;j<nj;j++) 
     613//          for(i=0;i<ni;i++) 
     614//          { 
     615//            k=j*ni+i ; 
     616//            lonvalue_temp(k)=lonvalue(i) ; 
     617//            latvalue_temp(k)=latvalue(j) ; 
     618//            if (hasBounds) 
     619//            { 
     620//              for(int n=0;n<nvertex;n++) 
     621//              { 
     622//                bounds_lon_temp(n,k)=bounds_lon(n,i) ; 
     623//                bounds_lat_temp(n,k)=bounds_lat(n,j) ; 
     624//              } 
     625//            } 
     626//          } 
     627//      } 
     628// 
     629//      StdSize dm = zoom_ni_client * zoom_nj_client; 
     630// 
     631//      // Make sure that this attribute is non-empty for every client. 
     632//      if (0 != dm) 
     633//      { 
     634//        lonvalue.resize(dm); 
     635//        latvalue.resize(dm); 
     636//      } 
     637// 
     638// 
     639//      for (int i = 0; i < zoom_ni_client; i++) 
     640//      { 
     641//        for (int j = 0; j < zoom_nj_client; j++) 
     642//        { 
     643//          lonvalue(i + j * zoom_ni_client) = lonvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
     644//          latvalue(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client - jbegin)*ni ); 
     645//          if (hasBounds) 
     646//          { 
     647//            for(int n=0;n<nvertex;n++) 
     648//            { 
     649//              bounds_lon(n,i + j * zoom_ni_client) = bounds_lon_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
     650//              bounds_lat(n,i + j * zoom_ni_client) = bounds_lat_temp( n, (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client -jbegin)*ni ); 
     651//            } 
     652//          } 
     653//        } 
     654//      } 
     655    } 
     656 
     657 
     658   //---------------------------------------------------------------- 
     659 
    559660   void CDomain::checkZoom(void) 
    560661   { 
    561       // compute client zoom indices 
    562       // compute client zoom indices 
    563 //      if (0 == global_zoom_ni) global_zoom_ni = ni_glo; 
    564 //      if (0 == global_zoom_nj) global_zoom_nj = nj_glo; 
    565  
    566662      int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ; 
    567663      zoom_ibegin_client = ibegin_client > global_zoom_ibegin ? ibegin_client : global_zoom_ibegin ; 
     
    580676   void CDomain::checkBounds(void) 
    581677   { 
    582      if (!nvertex.isEmpty() && !bounds_lon.isEmpty() && !bounds_lat.isEmpty()) 
    583      { 
     678     if (!nvertex.isEmpty() && (0 != nvertex.getValue())) 
     679     { 
     680       if (!bounds_lon_1d.isEmpty() && !bounds_lon_2d.isEmpty()) 
     681         ERROR("CDomain::checkBounds(void)", 
     682              <<"Only one longitude boundary value can be used but both bounds_lon_1d and bounds_lon_2d are defined! "<<endl 
     683              <<"Define only one longitude boundary value: lonvalue_1d or bounds_lon_2d "); 
     684 
     685       if (!bounds_lat_1d.isEmpty() && !bounds_lat_2d.isEmpty()) 
     686         ERROR("CDomain::checkBounds(void)", 
     687              <<"Only one latitude boundary value can be used but both bounds_lat_1d and bounds_lat_2d are defined! "<<endl 
     688              <<"Define only one latitude boundary value: bounds_lat_1d or bounds_lat_2d "); 
     689 
     690       if ((!bounds_lon_1d.isEmpty() && bounds_lat_1d.isEmpty()) || (bounds_lon_1d.isEmpty() && !bounds_lat_1d.isEmpty())) 
     691       { 
     692         ERROR("CDomain::checkBounds(void)", 
     693           <<"Only bounds_lon_1d or bounds_lat_1d is defined "<<endl 
     694           <<"Both must be defined "); 
     695       } 
     696 
     697       if ((!bounds_lon_2d.isEmpty() && bounds_lat_2d.isEmpty()) || (bounds_lon_2d.isEmpty() && !bounds_lat_2d.isEmpty())) 
     698       { 
     699         ERROR("CDomain::checkBounds(void)", 
     700           <<"Only bounds_lon_2d or bounds_lat_2d is defined "<<endl 
     701           <<"Both must be defined "); 
     702       } 
     703 
     704       if (!bounds_lon_1d.isEmpty() && (nvertex.getValue() != bounds_lon_1d.extent(0))) 
     705          ERROR("CDomain::checkBounds(void)", 
     706                <<"Only bounds_lon_1d and nvertex are not compatible"<<endl 
     707                <<"bounds_lon_1d dimension is " << bounds_lon_1d.extent(1) 
     708                <<"but nvertex is " << nvertex.getValue()); 
     709 
     710       if (!bounds_lon_2d.isEmpty() && (nvertex.getValue() != bounds_lon_2d.extent(0))) 
     711          ERROR("CDomain::checkBounds(void)", 
     712                <<"Only bounds_lon_2d and nvertex are not compatible"<<endl 
     713                <<"bounds_lon_2d dimension is " << bounds_lon_1d.extent(2) 
     714                <<"but nvertex is " << nvertex.getValue()); 
     715 
     716       if (!bounds_lon_1d.isEmpty() && lonvalue_1d.isEmpty()) 
     717           ERROR("CDomain::checkBounds(void)", 
     718                <<"Both bounds_lon_1d and lonvalue_1d must be defined"<<endl); 
     719 
     720       if (!bounds_lon_2d.isEmpty() && lonvalue_2d.isEmpty()) 
     721           ERROR("CDomain::checkBounds(void)", 
     722                <<"Both bounds_lon_1d and lonvalue_1d must be defined"<<endl); 
     723 
     724       if (!bounds_lat_1d.isEmpty() && (nvertex.getValue() != bounds_lat_1d.extent(0))) 
     725          ERROR("CDomain::checkBounds(void)", 
     726                <<"Only bounds_lat_1d and nvertex are not compatible"<<endl 
     727                <<"bounds_lat_1d dimension is " << bounds_lat_1d.extent(1) 
     728                <<"but nvertex is " << nvertex.getValue()); 
     729 
     730       if (!bounds_lat_2d.isEmpty() && (nvertex.getValue() != bounds_lat_2d.extent(0))) 
     731          ERROR("CDomain::checkBounds(void)", 
     732                <<"Only bounds_lat_2d and nvertex are not compatible"<<endl 
     733                <<"bounds_lat_2d dimension is " << bounds_lat_1d.extent(2) 
     734                <<"but nvertex is " << nvertex.getValue()); 
     735 
     736       if (!bounds_lat_1d.isEmpty() && latvalue_1d.isEmpty()) 
     737           ERROR("CDomain::checkBounds(void)", 
     738                <<"Both bounds_lat_1d and latvalue_1d must be defined"<<endl); 
     739 
     740       if (!bounds_lat_2d.isEmpty() && latvalue_2d.isEmpty()) 
     741           ERROR("CDomain::checkBounds(void)", 
     742                <<"Both bounds_lat_1d and latvalue_1d must be defined"<<endl); 
    584743       hasBounds=true ; 
    585744     } 
     
    604763   } 
    605764 
    606 //   void CDomain::checkAttributesOnClientBeforeTransformation() 
    607 //   { 
    608 //      if (this->isClientBeforeTransformationChecked) return; 
    609 //      CContext* context=CContext::getCurrent(); 
    610 // 
    611 //      this->checkDomain(); 
    612 //      this->checkBounds(); 
    613 //      this->checkArea(); 
    614 // 
    615 //      if (context->hasClient) 
    616 //      { 
    617 //        this->checkDomainData(); 
    618 //        this->checkCompression(); 
    619 //      } 
    620 // 
    621 //      this->isClientBeforeTransformationChecked = true; 
    622 //   } 
    623  
    624765   void CDomain::checkAttributesOnClientAfterTransformation() 
    625766   { 
     
    639780 
    640781   //---------------------------------------------------------------- 
    641    // Divide function checkAttributes into 2 seperate ones 
     782   // Divide function checkAttributes into 2 seperate onescheckBounds 
    642783   // This function only checks all attributes of current domain 
    643784   void CDomain::checkAttributesOnClient() 
     
    658799      else 
    659800      { // CÃŽté serveur uniquement 
    660 //         if (!this->isEmpty()) 
    661 // ne sert plus //   this->completeLonLatServer(); 
    662801      } 
    663802 
     
    676815     if (context->hasClient) 
    677816     { 
    678 //       this->computeConnectedServer(); 
    679 //       this->completeLonLatClient(); 
    680  
    681817       sendServerAttribut() ; 
    682818       sendLonLatArea() ; 
     
    705841      else 
    706842      { // CÃŽté serveur uniquement 
    707 //         if (!this->isEmpty()) 
    708 // ne sert plus //   this->completeLonLatServer(); 
    709843      } 
    710844 
     
    9321066        i = i_index(idx); 
    9331067        j = j_index(idx); 
    934         ind = n; 
    935 //        ind = (i - zoom_ibegin_client) + (j - zoom_jbegin_client) * zoom_ni_client; 
    936  
    937         lon(n) = lonvalue(ind); 
    938         lat(n) = latvalue(ind); 
     1068        ind = (i - zoom_ibegin_client) + (j - zoom_jbegin_client) * zoom_ni_client; 
     1069 
     1070        lon(n) = lonvalue_client(ind); 
     1071        lat(n) = latvalue_client(ind); 
    9391072 
    9401073        if (hasBounds) 
     
    9451078          for (nv = 0; nv < nvertex; nv++) 
    9461079          { 
    947             boundslon(nv, n) = bounds_lon(nv, ind); 
    948             boundslat(nv, n) = bounds_lat(nv, ind); 
     1080            boundslon(nv, n) = bounds_lon_client(nv, ind); 
     1081            boundslat(nv, n) = bounds_lat_client(nv, ind); 
    9491082          } 
    9501083        } 
  • XIOS/trunk/src/node/domain.hpp

    r657 r664  
    120120         CArray<double, 1> lonvalue_srv, latvalue_srv ; 
    121121         CArray<double, 2> bounds_lon_srv, bounds_lat_srv ; 
     122         CArray<double, 1> lonvalue_client, latvalue_client; 
     123         CArray<double, 2> bounds_lon_client, bounds_lat_client; 
    122124         CArray<double, 1> area_srv; 
    123125 
     
    134136        int global_zoom_ibegin, global_zoom_ni; 
    135137        int global_zoom_jbegin, global_zoom_nj; 
    136 //        vector<int> ib_srv, ie_srv, in_srv ; 
    137 //        vector<int> jb_srv, je_srv, jn_srv ; 
     138//        CArray<bool,1> maskInter; 
    138139 
    139140      public : 
     
    175176         void setTransformations(const TransMapTypes&); 
    176177         void computeNGlobDomain(); 
     178         void completeLonClient(); 
     179         void completeLatClient(); 
    177180 
    178181       private : 
     
    189192         std::vector<int> nGlobDomain_; 
    190193         bool isUnstructed_; 
    191          CArray<bool,1> maskInter_; 
     194 
    192195 
    193196 
  • XIOS/trunk/src/node/grid.cpp

    r660 r664  
    200200      int dim = domainP.size() * 2 + axisP.size(); 
    201201 
    202       std::vector<CArray<bool,2>* > domainMasks(domainP.size()); 
    203       for (int i = 0; i < domainMasks.size(); ++i) domainMasks[i] = &(domainP[i]->mask); 
     202      std::vector<CArray<bool,1>* > domainMasks(domainP.size()); 
     203      for (int i = 0; i < domainMasks.size(); ++i) domainMasks[i] = &(domainP[i]->mask_1d); 
    204204      std::vector<CArray<bool,1>* > axisMasks(axisP.size()); 
    205205      for (int i = 0; i < axisMasks.size(); ++i) axisMasks[i] = &(axisP[i]->mask); 
  • XIOS/trunk/src/node/grid.hpp

    r660 r664  
    191191       template<int N> 
    192192       void checkGridMask(CArray<bool,N>& gridMask, 
    193                           const std::vector<CArray<bool,2>* >& domainMasks, 
     193                          const std::vector<CArray<bool,1>* >& domainMasks, 
    194194                          const std::vector<CArray<bool,1>* >& axisMasks, 
    195195                          const CArray<bool,1>& axisDomainOrder); 
     
    267267   template<int N> 
    268268   void CGrid::checkGridMask(CArray<bool,N>& gridMask, 
    269                              const std::vector<CArray<bool,2>* >& domainMasks, 
     269                             const std::vector<CArray<bool,1>* >& domainMasks, 
    270270                             const std::vector<CArray<bool,1>* >& axisMasks, 
    271271                             const CArray<bool,1>& axisDomainOrder) 
     
    274274     int numElement = axisDomainOrder.numElements(); 
    275275     int dim = domainMasks.size() * 2 + axisMasks.size(); 
     276     std::vector<CDomain*> domainP = this->getDomains(); 
    276277 
    277278     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim); 
     
    282283      indexMap[i] = idx; 
    283284      if (true == axisDomainOrder(i)) { 
    284           eachDimSize[indexMap[i]]   = domainMasks[idxDomain]->extent(0); 
    285           eachDimSize[indexMap[i]+1] = domainMasks[idxDomain]->extent(1); 
     285          eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni; 
     286          eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj; 
    286287          idx += 2; ++idxDomain; 
    287288      } 
     
    328329        if (axisDomainOrder(i)) 
    329330        { 
    330           maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]], 
    331                                                           idxLoop[indexMap[i]+1]); 
     331          maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]]); 
    332332          ++idxDomain; 
    333333        } 
  • XIOS/trunk/src/output/nc4_data_output.cpp

    r657 r664  
    8383         StdString dimXid, dimYid ; 
    8484 
    85          bool isRegularDomain = (domain->type == CDomain::type_attr::regular); 
     85         bool isRegularDomain = (domain->type == CDomain::type_attr::rectilinear); 
    8686         switch (domain->type) 
    8787         { 
     
    9090             dimYid     = StdString("y").append(appendDomid); 
    9191             break ; 
    92            case CDomain::type_attr::regular : 
     92           case CDomain::type_attr::rectilinear : 
    9393             dimXid     = StdString("lon").append(appendDomid); 
    9494             dimYid     = StdString("lat").append(appendDomid); 
     
    130130                     latid = StdString("nav_lat").append(appendDomid); 
    131131                     break ; 
    132                    case CDomain::type_attr::regular : 
     132                   case CDomain::type_attr::rectilinear : 
    133133                     lonid = StdString("lon").append(appendDomid); 
    134134                     latid = StdString("lat").append(appendDomid); 
     
    171171                     SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    172172                     break ; 
    173                     case CDomain::type_attr::regular : 
     173                    case CDomain::type_attr::rectilinear : 
    174174                      SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    175175                      SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     
    227227                     SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
    228228                     break; 
    229                    case CDomain::type_attr::regular : 
     229                   case CDomain::type_attr::rectilinear : 
    230230                     CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
    231231                     SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
     
    266266                     break; 
    267267 
    268                    case CDomain::type_attr::regular : 
     268                   case CDomain::type_attr::rectilinear : 
    269269                     dim0.push_back(dimYid); 
    270270                     dim1.push_back(dimXid); 
     
    331331                     break; 
    332332                   } 
    333                    case CDomain::type_attr::regular : 
     333                   case CDomain::type_attr::rectilinear : 
    334334                   { 
    335335                     std::vector<StdSize> start(1) ; 
     
    772772                 dimCoordList.push_back(StdString("nav_lat").append(appendDomid)); 
    773773                 break ; 
    774                case CDomain::type_attr::regular : 
     774               case CDomain::type_attr::rectilinear : 
    775775                 dimXid     = StdString("lon").append(appendDomid); 
    776776                 dimIdList.push_back(dimXid); 
  • XIOS/trunk/src/test/test_client.f90

    r655 r664  
    7777 
    7878  CALL xios_set_axis_attr("axis_A",size=llm ,value=lval) ; 
    79   CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj) 
     79  CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj,type='curvilinear') 
    8080  CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4) 
    81   CALL xios_set_domain_attr("domain_A",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/))) 
     81!  CALL xios_set_domain_attr("domain_A",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/))) 
     82  CALL xios_set_domain_attr("domain_A",lonvalue_2D=lon,latvalue_2D=lat) 
    8283  CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.) 
    8384 
     
    112113  PRINT *, "xios_date_convert_to_seconds(date - 2.5h) = ", xios_date_convert_to_seconds(date - 2.5 * xios_hour) 
    113114 
    114   ni=0 ; lonvalue(:)=0 
    115   CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue=lonvalue) 
     115  ni=0 ; lonvalue(:)=0; lon(:,:)=0 
     116  CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue_2D=lon) 
    116117 
    117118  print *,"ni",ni 
    118   print *,"lonvalue",lonvalue ; 
     119  print *,"lonvalue",lon; 
    119120 
    120121  CALL xios_is_defined_field_attr("field_A",enabled=ok) 
  • XIOS/trunk/src/test/test_complete.f90

    r655 r664  
    2525  DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo 
    2626  DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm) 
    27   DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A_atm(:,:,:), field_A_srf(:,:), lonvalue(:) 
     27  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A_atm(:,:,:), field_A_srf(:,:), lonvalue(:,:) 
    2828  INTEGER, ALLOCATABLE :: kindex(:) 
    2929  INTEGER :: ni,ibegin,iend,nj,jbegin,jend 
     
    7171  iend=ibegin+ni-1 ; jend=jbegin+nj-1 
    7272 
    73   ALLOCATE(lon(ni,nj),lat(ni,nj),field_A_atm(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj)) 
     73  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A_atm(0:ni+1,-1:nj+2,llm),lonvalue(ni,nj)) 
    7474  lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1) 
    7575  lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1) 
     
    8989  CALL xios_set_axis_attr("axis_atm",size=llm ,value=lval) ; 
    9090 
    91   CALL xios_set_domain_attr("domain_atm",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj) 
     91  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') 
    9292  CALL xios_set_domain_attr("domain_atm",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4) 
    93   CALL xios_set_domain_attr("domain_atm",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/))) 
     93  CALL xios_set_domain_attr("domain_atm",lonvalue_2D=lon,latvalue_2D=lat) 
    9494 
    9595  CALL xios_set_domain_attr("domain_atm_zoom",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj) 
    9696  CALL xios_set_domain_attr("domain_atm_zoom",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4) 
    97   CALL xios_set_domain_attr("domain_atm_zoom",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/))) 
     97  CALL xios_set_domain_attr("domain_atm_zoom",lonvalue_2D=lon,latvalue_2D=lat) 
    9898!  CALL xios_set_domain_attr("domain_atm_zoom",zoom_ibegin=39, zoom_ni=20, zoom_jbegin=39, zoom_nj=5) 
    9999 
     
    124124!!! Recupration des valeurs des longitudes et de taille des domaines locaux (pour test de fonctionnalité) 
    125125 
    126   ni=0 ; lonvalue(:)=0 
    127   CALL xios_get_domain_attr("domain_atm",ni=ni,lonvalue=lonvalue) 
     126  ni=0 ; lonvalue(:,:)=0 
     127  CALL xios_get_domain_attr("domain_atm",ni=ni,lonvalue_2D=lonvalue) 
    128128 
    129129  PRINT *,"ni",ni 
    130   PRINT *,"lonvalue",lonvalue ; 
     130  PRINT *,"lonvalue",lonvalue; 
    131131 
    132132!!! Fin de la definition du contexte 
     
    177177 
    178178  CALL xios_set_axis_attr("axis_srf",size=llm ,value=lval) ; 
    179   CALL xios_set_domain_attr("domain_srf",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj) 
     179  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) 
    181181  CALL xios_set_domain_attr("domain_srf",data_n_index=nb_pt, data_i_index=kindex) 
    182   CALL xios_set_domain_attr("domain_srf",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/))) 
     182  CALL xios_set_domain_attr("domain_srf",lonvalue_2D=lon,latvalue_2D=lat) 
    183183 
    184184!!! Création d un nouveau champ 
     
    204204!!! Recupration des valeurs des longitudes et de taille des domaines locaux (pour test de fonctionnalité) 
    205205 
    206   ni=0 ; lonvalue(:)=0 
    207   CALL xios_get_domain_attr("domain_srf",ni=ni,lonvalue=lonvalue) 
     206  ni=0 ; lonvalue(:,:)=0 
     207  CALL xios_get_domain_attr("domain_srf",ni=ni,lonvalue_2D=lonvalue) 
    208208 
    209209  PRINT *,"ni",ni 
  • XIOS/trunk/src/test/test_new_features.f90

    r659 r664  
    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) 
    134   CALL xios_set_domain_attr("domain_A",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/))) 
     134  CALL xios_set_domain_attr("domain_A",lonvalue_2D=lon,latvalue_2D=lat) 
    135135 
    136136  CALL xios_set_domain_attr("domain_A_transformed", ni_glo=niDomGlo, nj_glo=njDomGlo, & 
    137137                                                    ibegin=ibeginDomInterp, ni=niDomInterp, jbegin=jbeginDomInterp, nj=njDomInterp) 
    138   CALL xios_set_domain_attr("domain_A_transformed", lonvalue=RESHAPE(lontransformed,(/niDomInterp*njDomInterp/)), & 
    139                                                     latvalue=RESHAPE(lattransformed,(/niDomInterp*njDomInterp/))) 
     138  CALL xios_set_domain_attr("domain_A_transformed", lonvalue_2D=lontransformed, & 
     139                                                    latvalue_2D=lattransformed) 
    140140 
    141141  CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.) 
     
    172172 
    173173  ni=0 ; lonvalue(:)=0 
    174   CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue=lonvalue) 
     174  CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue_1D=lonvalue) 
    175175 
    176176!  print *,"ni",ni 
  • XIOS/trunk/src/test/test_remap.f90

    • Property svn:executable set to *
    r661 r664  
    113113 
    114114  CALL xios_set_domain_attr("src_domain", ni_glo=src_ni_glo, ibegin=src_ibegin, ni=src_ni, type="unstructured") 
    115   CALL xios_set_domain_attr("src_domain", lonvalue=src_lon, latvalue=src_lat, & 
    116                             bounds_lon=src_boundslon, bounds_lat=src_boundslat, nvertex=src_nvertex) 
     115  CALL xios_set_domain_attr("src_domain",lonvalue_1D=src_lon,latvalue_1D=src_lat, bounds_lon_1D=src_boundslon, bounds_lat_1D=src_boundslat, nvertex=src_nvertex) 
     116                             
    117117  CALL xios_set_domain_attr("dst_domain", ni_glo=dst_ni_glo, ibegin=dst_ibegin, ni=dst_ni, type="unstructured") 
    118   CALL xios_set_domain_attr("dst_domain", lonvalue=dst_lon, latvalue=dst_lat, & 
    119                             bounds_lon=dst_boundslon, bounds_lat=dst_boundslat, nvertex=dst_nvertex) 
     118  CALL xios_set_domain_attr("dst_domain",lonvalue_1D=dst_lon,latvalue_1D=dst_lat, bounds_lon_1D=dst_boundslon, bounds_lat_1D=dst_boundslat, nvertex=dst_nvertex) 
     119                             
    120120  
    121121  dtime%second = 3600 
  • XIOS/trunk/src/test/test_unstruct_complete.f90

    r660 r664  
    203203  CALL xios_set_domain_attr("domain_srf", type='unstructured', data_dim=1, data_ni=data_n_index, & 
    204204                                          data_n_index=data_n_index, data_i_index=data_i_index) 
    205   CALL xios_set_domain_attr("domain_srf", lonvalue=lon, latvalue=lat) 
    206   CALL xios_set_domain_attr("domain_srf", nvertex=4, bounds_lon=bounds_lon, bounds_lat=bounds_lat) 
     205  CALL xios_set_domain_attr("domain_srf", lonvalue_1D=lon, latvalue_1D=lat) 
     206  CALL xios_set_domain_attr("domain_srf", nvertex=4, bounds_lon_1D=bounds_lon, bounds_lat_1D=bounds_lat) 
    207207 
    208208 
  • XIOS/trunk/src/transformation/domain_algorithm_zoom.cpp

    r631 r664  
    118118      globalIndexMask = (j+jBeginMask) * niGlob + (i + iBeginMask); 
    119119      if (transMap.find(globalIndexMask) == ite) 
    120         (domainDest_->mask)(i,j) = false; 
     120        (domainDest_->mask_1d)(i+j*niMask) = false; 
    121121    } 
    122122  } 
Note: See TracChangeset for help on using the changeset viewer.