Changeset 1201


Ignore:
Timestamp:
07/07/17 18:17:49 (4 years ago)
Author:
oabramkina
Message:

Two server levels: merging trunk r1200 (except for non-contiguous zoom) into dev. Tested on Curie. Todo: non-contiguous zoom.

Location:
XIOS/dev/dev_olga/src
Files:
48 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/dev_olga/src/buffer_client.cpp

    r1130 r1201  
    1212  size_t CClientBuffer::maxRequestSize = 0; 
    1313 
    14   CClientBuffer::CClientBuffer(MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize maxBufferedEvents) 
     14  CClientBuffer::CClientBuffer(MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents) 
    1515    : interComm(interComm) 
    1616    , serverRank(serverRank) 
    1717    , bufferSize(bufferSize) 
     18    , estimatedMaxEventSize(estimatedMaxEventSize) 
     19    , maxEventSize(0) 
    1820    , current(0) 
    1921    , count(0) 
     
    4244  bool CClientBuffer::isBufferFree(int size) 
    4345  { 
    44     if (size > maxRequestSize) maxRequestSize = size; 
    45  
    4646    if (size > bufferSize) 
    4747      ERROR("bool CClientBuffer::isBufferFree(int size)", 
    4848            << "The requested size (" << size << " bytes) is too big to fit the buffer (" << bufferSize << " bytes), please increase the client buffer size." << endl); 
     49 
     50    if (size > maxEventSize) 
     51    { 
     52      maxEventSize = size; 
     53 
     54      if (size > estimatedMaxEventSize) 
     55        error(0) << "WARNING: Unexpected event of size " << size << " for server " << serverRank 
     56                 << " (estimated max event size = " << estimatedMaxEventSize << ")" << std::endl; 
     57 
     58      if (size > maxRequestSize) maxRequestSize = size; 
     59    } 
     60 
    4961 
    5062    return (size <= remain() && bufferedEvents < maxBufferedEvents); 
  • XIOS/dev/dev_olga/src/buffer_client.hpp

    r917 r1201  
    1414      static size_t maxRequestSize; 
    1515 
    16       CClientBuffer(MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize maxBufferedEvents); 
     16      CClientBuffer(MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents); 
    1717      ~CClientBuffer(); 
    1818 
     
    2929      int count; 
    3030      int bufferedEvents; 
     31      int maxEventSize; 
    3132      const int maxBufferedEvents; 
    3233      const int bufferSize; 
     34      const int estimatedMaxEventSize; 
    3335      const int serverRank; 
    3436      bool pending; 
  • XIOS/dev/dev_olga/src/config/axis_attribute_private.conf

    r1099 r1201  
    11DECLARE_ATTRIBUTE_PRIVATE(int, global_zoom_begin) 
    22DECLARE_ATTRIBUTE_PRIVATE(int, global_zoom_n) 
    3  
     3DECLARE_ARRAY_PRIVATE(int,  1, global_zoom_index) 
    44DECLARE_ATTRIBUTE_PRIVATE(int, zoom_begin) 
    55DECLARE_ATTRIBUTE_PRIVATE(int, zoom_n) 
  • XIOS/dev/dev_olga/src/config/field_attribute.conf

    r1021 r1201  
    1616DECLARE_ATTRIBUTE(bool,      read_access) 
    1717DECLARE_ATTRIBUTE(bool,      indexed_output) 
     18DECLARE_ATTRIBUTE(bool,      check_if_active) 
    1819 
    1920DECLARE_ATTRIBUTE(StdString, domain_ref) 
  • XIOS/dev/dev_olga/src/config/file_attribute.conf

    r1158 r1201  
    1010DECLARE_ATTRIBUTE(CDuration, split_freq) 
    1111DECLARE_ATTRIBUTE(StdString, split_freq_format) 
     12DECLARE_ATTRIBUTE(CDuration, split_start_offset) 
     13DECLARE_ATTRIBUTE(CDuration, split_end_offset) 
     14DECLARE_ATTRIBUTE(string,     split_last_date) 
    1215DECLARE_ATTRIBUTE(bool,      enabled) 
    1316DECLARE_ENUM2(type,          one_file, multiple_file) 
  • XIOS/dev/dev_olga/src/config/zoom_axis_attribute.conf

    r787 r1201  
    22DECLARE_ATTRIBUTE(int,       begin) 
    33DECLARE_ATTRIBUTE(int,       n) 
     4DECLARE_ARRAY(int    ,1    , index) 
  • XIOS/dev/dev_olga/src/context_client.cpp

    r1194 r1201  
    246246   void CContextClient::newBuffer(int rank) 
    247247   { 
    248      if (!mapBufferSize_.count(rank)) 
    249      { 
    250 //       error(0) << "WARNING: Unexpected request for buffer to communicate with server " << rank << std::endl; 
    251        mapBufferSize_[rank] = CXios::minBufferSize; 
    252      } 
    253      CClientBuffer* buffer = buffers[rank] = new CClientBuffer(interComm, rank, mapBufferSize_[rank], maxBufferedEvents); 
    254      // Notify the server 
    255      CBufferOut* bufOut = buffer->getBuffer(sizeof(StdSize)); 
    256      bufOut->put(mapBufferSize_[rank]); // Stupid C++ 
    257      buffer->checkBuffer(); 
     248      if (!mapBufferSize_.count(rank)) 
     249      { 
     250        error(0) << "WARNING: Unexpected request for buffer to communicate with server " << rank << std::endl; 
     251        mapBufferSize_[rank] = CXios::minBufferSize; 
     252        maxEventSizes[rank] = CXios::minBufferSize; 
     253      } 
     254      CClientBuffer* buffer = buffers[rank] = new CClientBuffer(interComm, rank, mapBufferSize_[rank], maxEventSizes[rank], maxBufferedEvents); 
     255      // Notify the server 
     256      CBufferOut* bufOut = buffer->getBuffer(sizeof(StdSize)); 
     257      bufOut->put(mapBufferSize_[rank]); // Stupid C++ 
     258      buffer->checkBuffer(); 
    258259   } 
    259260 
     
    304305   { 
    305306     mapBufferSize_ = mapSize; 
     307     maxEventSizes = maxEventSize; 
    306308 
    307309     // Compute the maximum number of events that can be safely buffered. 
     
    315317 
    316318     if (minBufferSizeEventSizeRatio < 1.0) 
     319     { 
    317320       ERROR("void CContextClient::setBufferSize(const std::map<int,StdSize>& mapSize, const std::map<int,StdSize>& maxEventSize)", 
    318321             << "The buffer sizes and the maximum events sizes are incoherent."); 
     322     } 
     323     else if (minBufferSizeEventSizeRatio == std::numeric_limits<double>::max()) 
     324       minBufferSizeEventSizeRatio = 1.0; // In this case, maxBufferedEvents will never be used but we want to avoid any floating point exception 
    319325 
    320326     maxBufferedEvents = size_t(2 * minBufferSizeEventSizeRatio) // there is room for two local buffers on the server 
  • XIOS/dev/dev_olga/src/context_client.hpp

    r1194 r1201  
    7676      //! Mapping of server and buffer size for each connection to server 
    7777      std::map<int,StdSize> mapBufferSize_; 
     78      //! Maximum event sizes estimated for each connection to server 
     79      std::map<int,StdSize> maxEventSizes; 
    7880      //! Maximum number of events that can be buffered 
    7981      StdSize maxBufferedEvents; 
  • XIOS/dev/dev_olga/src/distribution_server.hpp

    r1158 r1201  
    2323  public: 
    2424    /** Default constructor */ 
     25    CDistributionServer(int rank, int dims, const CArray<size_t,1>& globalIndex = CArray<size_t,1>()); 
    2526    CDistributionServer(int rank, const std::vector<int>& nZoomBeginServer, 
     27                        const std::vector<int>& nZoomSizeServer, const std::vector<int>& nGlobal); 
     28    CDistributionServer(int rank, const std::vector<int>& nZoomBeginServer, 
     29                        const std::vector<int>& nZoomSizeServer, 
     30                        const std::vector<int>& nZoomBeginGlobal, 
     31                        const std::vector<int>& nGlobal); 
     32 
     33    CDistributionServer(int rank,  
     34                        const std::vector<CArray<int,1> >& globalIndexElements, 
     35                        const CArray<int,1>& elementOrder, 
     36                        const std::vector<int>& nZoomBeginServer, 
    2637                        const std::vector<int>& nZoomSizeServer, 
    2738                        const std::vector<int>& nZoomBeginGlobal, 
     
    5162    std::vector<int> nZoomSize_; 
    5263    std::vector<int> nZoomBegin_; 
     64 
    5365}; 
    5466 
  • XIOS/dev/dev_olga/src/filter/file_writer_filter.cpp

    r1158 r1201  
    1717  void CFileWriterFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    1818  { 
    19     bool ignoreMissingValue = (!field->detect_missing_value.isEmpty() &&  
    20                                !field->default_value.isEmpty() &&  
    21                                field->detect_missing_value == true); 
    22     if (ignoreMissingValue) 
     19    CDataPacketPtr packet = data[0]; 
     20 
     21    const bool detectMissingValue = (!field->detect_missing_value.isEmpty() 
     22                                      && !field->default_value.isEmpty() 
     23                                      && field->detect_missing_value == true); 
     24    if (detectMissingValue) 
    2325    { 
    24       double missingValue = field->default_value; 
    25       size_t nbData = data[0]->data.numElements(); 
     26      const double missingValue = field->default_value; 
     27      const size_t nbData = packet->data.numElements(); 
    2628      for (size_t idx = 0; idx < nbData; ++idx) 
    2729      { 
    28         if (NumTraits<double>::isnan(data[0]->data(idx))) 
    29           data[0]->data(idx) = missingValue; 
     30        if (NumTraits<double>::isnan(packet->data(idx))) 
     31          packet->data(idx) = missingValue; 
    3032      } 
    31     }     
     33    } 
    3234 
    33     field->sendUpdateData(data[0]->data); 
     35    field->sendUpdateData(packet->data); 
    3436  } 
    3537 
  • XIOS/dev/dev_olga/src/filter/source_filter.cpp

    r1158 r1201  
    3737    if (hasMissingValue) 
    3838    { 
    39       double nanValue = std::numeric_limits<double>::quiet_NaN(); 
    40       size_t nbData = packet->data.numElements(); 
     39      const double nanValue = std::numeric_limits<double>::quiet_NaN(); 
     40      const size_t nbData = packet->data.numElements(); 
    4141      for (size_t idx = 0; idx < nbData; ++idx) 
    4242      { 
     
    8282    } 
    8383 
     84    // Convert missing values to NaN 
     85    if (hasMissingValue) 
     86    { 
     87      const double nanValue = std::numeric_limits<double>::quiet_NaN(); 
     88      const size_t nbData = packet->data.numElements(); 
     89      for (size_t idx = 0; idx < nbData; ++idx) 
     90      { 
     91        if (defaultValue == packet->data(idx)) 
     92          packet->data(idx) = nanValue; 
     93      } 
     94    } 
     95 
    8496    onOutputReady(packet); 
    8597  } 
  • XIOS/dev/dev_olga/src/filter/source_filter.hpp

    r1158 r1201  
    6262      CGrid* grid; //!< The grid attached to the data the filter can accept 
    6363      const CDuration offset; //!< The offset applied to the timestamp of all packets 
    64       bool hasMissingValue; 
    65       double defaultValue; 
     64      const bool hasMissingValue; 
     65      const double defaultValue; 
    6666  }; // class CSourceFilter 
    6767} // namespace xios 
  • XIOS/dev/dev_olga/src/filter/store_filter.cpp

    r1158 r1201  
    66namespace xios 
    77{ 
    8   CStoreFilter::CStoreFilter(CGarbageCollector& gc, CContext* context, CGrid* grid) 
     8  CStoreFilter::CStoreFilter(CGarbageCollector& gc, CContext* context, CGrid* grid, 
     9                             bool detectMissingValues /*= false*/, double missingValue /*= 0.0*/) 
    910    : CInputPin(gc, 1) 
    1011    , gc(gc) 
    1112    , context(context) 
    1213    , grid(grid) 
     14    , detectMissingValues(detectMissingValues) 
     15    , missingValue(missingValue) 
    1316  { 
    1417    if (!context) 
     
    7578  void CStoreFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    7679  { 
    77     packets.insert(std::make_pair(data[0]->timestamp, data[0])); 
     80    CDataPacketPtr packet = data[0]; 
     81 
     82    packets.insert(std::make_pair(packet->timestamp, packet)); 
    7883    // The packet is always destroyed by the garbage collector 
    7984    // so we register but never unregister 
    80     gc.registerObject(this, data[0]->timestamp); 
     85    gc.registerObject(this, packet->timestamp); 
     86 
     87    if (detectMissingValues) 
     88    { 
     89      const size_t nbData = packet->data.numElements(); 
     90      for (size_t idx = 0; idx < nbData; ++idx) 
     91      { 
     92        if (NumTraits<double>::isnan(packet->data(idx))) 
     93          packet->data(idx) = missingValue; 
     94      } 
     95    } 
    8196  } 
    8297 
  • XIOS/dev/dev_olga/src/filter/store_filter.hpp

    r1158 r1201  
    2222       * \param context the context to which the data belongs 
    2323       * \param grid the grid to which the data is attached 
     24       * \param detectMissingValues whether missing values should be detected 
     25       * \param missingValue the value to use to replace missing values 
    2426       */ 
    25       CStoreFilter(CGarbageCollector& gc, CContext* context, CGrid* grid); 
     27      CStoreFilter(CGarbageCollector& gc, CContext* context, CGrid* grid, 
     28                   bool detectMissingValues = false, double missingValue = 0.0); 
    2629 
    2730      /*! 
     
    7578      CContext* context; //!< The context to which the data belongs 
    7679      CGrid* grid; //!< The grid attached to the data the filter can accept 
     80      const bool detectMissingValues; //!< Whether missing values should be detected 
     81      const double missingValue; //!< The value to use to replace missing values 
    7782      std::map<Time, CDataPacketPtr> packets; //<! The stored packets 
    7883  }; // class CStoreFilter 
  • XIOS/dev/dev_olga/src/filter/temporal_filter.hpp

    r1158 r1201  
    4848 
    4949    private: 
     50      // Warning the declaration order matters here, double-check the constructor before changing it 
     51      CArray<double, 1> tmpData; //!< The array of data used for temporary storage 
    5052      const boost::scoped_ptr<func::CFunctor> functor; //!< The functor corresponding to the temporal operation 
    51       CArray<double, 1> tmpData; //!< The array of data used for temporary storage 
     53      const bool isOnceOperation; //!< True if the operation should be computed just once 
     54      const bool isInstantOperation; //!< True if the operation is instant 
    5255      const CDuration samplingFreq; //!< The sampling frequency, i.e. the frequency at which the input data will be used 
    5356      const CDuration samplingOffset; //!< The sampling offset, i.e. the offset after which the input data will be used 
     
    5659      CDate nextOperationDate; //!< The date of the next operation 
    5760      bool isFirstOperation; //!< True before the first operation was been computed 
    58       const bool isOnceOperation; //!< True if the operation should be computed just once 
    59       const bool isInstantOperation; //!< True if the operation is instant 
    6061  }; // class CTemporalFilter 
    6162} // namespace xios 
  • XIOS/dev/dev_olga/src/interface/c_attr/icfield_attr.cpp

    r1021 r1201  
    119119 
    120120 
     121  void cxios_set_field_check_if_active(field_Ptr field_hdl, bool check_if_active) 
     122  { 
     123    CTimer::get("XIOS").resume(); 
     124    field_hdl->check_if_active.setValue(check_if_active); 
     125    CTimer::get("XIOS").suspend(); 
     126  } 
     127 
     128  void cxios_get_field_check_if_active(field_Ptr field_hdl, bool* check_if_active) 
     129  { 
     130    CTimer::get("XIOS").resume(); 
     131    *check_if_active = field_hdl->check_if_active.getInheritedValue(); 
     132    CTimer::get("XIOS").suspend(); 
     133  } 
     134 
     135  bool cxios_is_defined_field_check_if_active(field_Ptr field_hdl) 
     136  { 
     137     CTimer::get("XIOS").resume(); 
     138     bool isDefined = field_hdl->check_if_active.hasInheritedValue(); 
     139     CTimer::get("XIOS").suspend(); 
     140     return isDefined; 
     141  } 
     142 
     143 
    121144  void cxios_set_field_compression_level(field_Ptr field_hdl, int compression_level) 
    122145  { 
  • XIOS/dev/dev_olga/src/interface/c_attr/icfieldgroup_attr.cpp

    r1021 r1201  
    119119 
    120120 
     121  void cxios_set_fieldgroup_check_if_active(fieldgroup_Ptr fieldgroup_hdl, bool check_if_active) 
     122  { 
     123    CTimer::get("XIOS").resume(); 
     124    fieldgroup_hdl->check_if_active.setValue(check_if_active); 
     125    CTimer::get("XIOS").suspend(); 
     126  } 
     127 
     128  void cxios_get_fieldgroup_check_if_active(fieldgroup_Ptr fieldgroup_hdl, bool* check_if_active) 
     129  { 
     130    CTimer::get("XIOS").resume(); 
     131    *check_if_active = fieldgroup_hdl->check_if_active.getInheritedValue(); 
     132    CTimer::get("XIOS").suspend(); 
     133  } 
     134 
     135  bool cxios_is_defined_fieldgroup_check_if_active(fieldgroup_Ptr fieldgroup_hdl) 
     136  { 
     137     CTimer::get("XIOS").resume(); 
     138     bool isDefined = fieldgroup_hdl->check_if_active.hasInheritedValue(); 
     139     CTimer::get("XIOS").suspend(); 
     140     return isDefined; 
     141  } 
     142 
     143 
    121144  void cxios_set_fieldgroup_compression_level(fieldgroup_Ptr fieldgroup_hdl, int compression_level) 
    122145  { 
  • XIOS/dev/dev_olga/src/interface/c_attr/icfile_attr.cpp

    r1158 r1201  
    9090 
    9191 
     92  void cxios_set_file_convention_str(file_Ptr file_hdl, const char * convention_str, int convention_str_size) 
     93  { 
     94    std::string convention_str_str; 
     95    if (!cstr2string(convention_str, convention_str_size, convention_str_str)) return; 
     96    CTimer::get("XIOS").resume(); 
     97    file_hdl->convention_str.setValue(convention_str_str); 
     98    CTimer::get("XIOS").suspend(); 
     99  } 
     100 
     101  void cxios_get_file_convention_str(file_Ptr file_hdl, char * convention_str, int convention_str_size) 
     102  { 
     103    CTimer::get("XIOS").resume(); 
     104    if (!string_copy(file_hdl->convention_str.getInheritedValue(), convention_str, convention_str_size)) 
     105      ERROR("void cxios_get_file_convention_str(file_Ptr file_hdl, char * convention_str, int convention_str_size)", << "Input string is too short"); 
     106    CTimer::get("XIOS").suspend(); 
     107  } 
     108 
     109  bool cxios_is_defined_file_convention_str(file_Ptr file_hdl) 
     110  { 
     111     CTimer::get("XIOS").resume(); 
     112     bool isDefined = file_hdl->convention_str.hasInheritedValue(); 
     113     CTimer::get("XIOS").suspend(); 
     114     return isDefined; 
     115  } 
     116 
     117 
    92118  void cxios_set_file_cyclic(file_Ptr file_hdl, bool cyclic) 
    93119  { 
  • XIOS/dev/dev_olga/src/interface/c_attr/icfilegroup_attr.cpp

    r1158 r1201  
    9090 
    9191 
     92  void cxios_set_filegroup_convention_str(filegroup_Ptr filegroup_hdl, const char * convention_str, int convention_str_size) 
     93  { 
     94    std::string convention_str_str; 
     95    if (!cstr2string(convention_str, convention_str_size, convention_str_str)) return; 
     96    CTimer::get("XIOS").resume(); 
     97    filegroup_hdl->convention_str.setValue(convention_str_str); 
     98    CTimer::get("XIOS").suspend(); 
     99  } 
     100 
     101  void cxios_get_filegroup_convention_str(filegroup_Ptr filegroup_hdl, char * convention_str, int convention_str_size) 
     102  { 
     103    CTimer::get("XIOS").resume(); 
     104    if (!string_copy(filegroup_hdl->convention_str.getInheritedValue(), convention_str, convention_str_size)) 
     105      ERROR("void cxios_get_filegroup_convention_str(filegroup_Ptr filegroup_hdl, char * convention_str, int convention_str_size)", << "Input string is too short"); 
     106    CTimer::get("XIOS").suspend(); 
     107  } 
     108 
     109  bool cxios_is_defined_filegroup_convention_str(filegroup_Ptr filegroup_hdl) 
     110  { 
     111     CTimer::get("XIOS").resume(); 
     112     bool isDefined = filegroup_hdl->convention_str.hasInheritedValue(); 
     113     CTimer::get("XIOS").suspend(); 
     114     return isDefined; 
     115  } 
     116 
     117 
    92118  void cxios_set_filegroup_cyclic(filegroup_Ptr filegroup_hdl, bool cyclic) 
    93119  { 
  • XIOS/dev/dev_olga/src/interface/c_attr/icinterpolate_domain_attr.cpp

    r1158 r1201  
    6262     CTimer::get("XIOS").resume(); 
    6363     bool isDefined = interpolate_domain_hdl->order.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
     69  void cxios_set_interpolate_domain_quantity(interpolate_domain_Ptr interpolate_domain_hdl, bool quantity) 
     70  { 
     71    CTimer::get("XIOS").resume(); 
     72    interpolate_domain_hdl->quantity.setValue(quantity); 
     73    CTimer::get("XIOS").suspend(); 
     74  } 
     75 
     76  void cxios_get_interpolate_domain_quantity(interpolate_domain_Ptr interpolate_domain_hdl, bool* quantity) 
     77  { 
     78    CTimer::get("XIOS").resume(); 
     79    *quantity = interpolate_domain_hdl->quantity.getInheritedValue(); 
     80    CTimer::get("XIOS").suspend(); 
     81  } 
     82 
     83  bool cxios_is_defined_interpolate_domain_quantity(interpolate_domain_Ptr interpolate_domain_hdl) 
     84  { 
     85     CTimer::get("XIOS").resume(); 
     86     bool isDefined = interpolate_domain_hdl->quantity.hasInheritedValue(); 
    6487     CTimer::get("XIOS").suspend(); 
    6588     return isDefined; 
  • XIOS/dev/dev_olga/src/interface/c_attr/iczoom_axis_attr.cpp

    r787 r1201  
    4141 
    4242 
     43  void cxios_set_zoom_axis_index(zoom_axis_Ptr zoom_axis_hdl, int* index, int* extent) 
     44  { 
     45    CTimer::get("XIOS").resume(); 
     46    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData); 
     47    zoom_axis_hdl->index.reference(tmp.copy()); 
     48     CTimer::get("XIOS").suspend(); 
     49  } 
     50 
     51  void cxios_get_zoom_axis_index(zoom_axis_Ptr zoom_axis_hdl, int* index, int* extent) 
     52  { 
     53    CTimer::get("XIOS").resume(); 
     54    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData); 
     55    tmp=zoom_axis_hdl->index.getInheritedValue(); 
     56     CTimer::get("XIOS").suspend(); 
     57  } 
     58 
     59  bool cxios_is_defined_zoom_axis_index(zoom_axis_Ptr zoom_axis_hdl) 
     60  { 
     61     CTimer::get("XIOS").resume(); 
     62     bool isDefined = zoom_axis_hdl->index.hasInheritedValue(); 
     63     CTimer::get("XIOS").suspend(); 
     64     return isDefined; 
     65  } 
     66 
     67 
    4368  void cxios_set_zoom_axis_n(zoom_axis_Ptr zoom_axis_hdl, int n) 
    4469  { 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/field_interface_attr.F90

    r1021 r1201  
    9292 
    9393 
     94    SUBROUTINE cxios_set_field_check_if_active(field_hdl, check_if_active) BIND(C) 
     95      USE ISO_C_BINDING 
     96      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     97      LOGICAL (KIND=C_BOOL)      , VALUE :: check_if_active 
     98    END SUBROUTINE cxios_set_field_check_if_active 
     99 
     100    SUBROUTINE cxios_get_field_check_if_active(field_hdl, check_if_active) BIND(C) 
     101      USE ISO_C_BINDING 
     102      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     103      LOGICAL (KIND=C_BOOL)             :: check_if_active 
     104    END SUBROUTINE cxios_get_field_check_if_active 
     105 
     106    FUNCTION cxios_is_defined_field_check_if_active(field_hdl) BIND(C) 
     107      USE ISO_C_BINDING 
     108      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_check_if_active 
     109      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     110    END FUNCTION cxios_is_defined_field_check_if_active 
     111 
     112 
    94113    SUBROUTINE cxios_set_field_compression_level(field_hdl, compression_level) BIND(C) 
    95114      USE ISO_C_BINDING 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/fieldgroup_interface_attr.F90

    r1021 r1201  
    9292 
    9393 
     94    SUBROUTINE cxios_set_fieldgroup_check_if_active(fieldgroup_hdl, check_if_active) BIND(C) 
     95      USE ISO_C_BINDING 
     96      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     97      LOGICAL (KIND=C_BOOL)      , VALUE :: check_if_active 
     98    END SUBROUTINE cxios_set_fieldgroup_check_if_active 
     99 
     100    SUBROUTINE cxios_get_fieldgroup_check_if_active(fieldgroup_hdl, check_if_active) BIND(C) 
     101      USE ISO_C_BINDING 
     102      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     103      LOGICAL (KIND=C_BOOL)             :: check_if_active 
     104    END SUBROUTINE cxios_get_fieldgroup_check_if_active 
     105 
     106    FUNCTION cxios_is_defined_fieldgroup_check_if_active(fieldgroup_hdl) BIND(C) 
     107      USE ISO_C_BINDING 
     108      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_check_if_active 
     109      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     110    END FUNCTION cxios_is_defined_fieldgroup_check_if_active 
     111 
     112 
    94113    SUBROUTINE cxios_set_fieldgroup_compression_level(fieldgroup_hdl, compression_level) BIND(C) 
    95114      USE ISO_C_BINDING 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/file_interface_attr.F90

    r1158 r1201  
    6969 
    7070 
     71    SUBROUTINE cxios_set_file_convention_str(file_hdl, convention_str, convention_str_size) BIND(C) 
     72      USE ISO_C_BINDING 
     73      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     74      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: convention_str 
     75      INTEGER  (kind = C_INT)     , VALUE        :: convention_str_size 
     76    END SUBROUTINE cxios_set_file_convention_str 
     77 
     78    SUBROUTINE cxios_get_file_convention_str(file_hdl, convention_str, convention_str_size) BIND(C) 
     79      USE ISO_C_BINDING 
     80      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     81      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: convention_str 
     82      INTEGER  (kind = C_INT)     , VALUE        :: convention_str_size 
     83    END SUBROUTINE cxios_get_file_convention_str 
     84 
     85    FUNCTION cxios_is_defined_file_convention_str(file_hdl) BIND(C) 
     86      USE ISO_C_BINDING 
     87      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_convention_str 
     88      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     89    END FUNCTION cxios_is_defined_file_convention_str 
     90 
     91 
    7192    SUBROUTINE cxios_set_file_cyclic(file_hdl, cyclic) BIND(C) 
    7293      USE ISO_C_BINDING 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/filegroup_interface_attr.F90

    r1158 r1201  
    6969 
    7070 
     71    SUBROUTINE cxios_set_filegroup_convention_str(filegroup_hdl, convention_str, convention_str_size) BIND(C) 
     72      USE ISO_C_BINDING 
     73      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     74      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: convention_str 
     75      INTEGER  (kind = C_INT)     , VALUE        :: convention_str_size 
     76    END SUBROUTINE cxios_set_filegroup_convention_str 
     77 
     78    SUBROUTINE cxios_get_filegroup_convention_str(filegroup_hdl, convention_str, convention_str_size) BIND(C) 
     79      USE ISO_C_BINDING 
     80      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     81      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: convention_str 
     82      INTEGER  (kind = C_INT)     , VALUE        :: convention_str_size 
     83    END SUBROUTINE cxios_get_filegroup_convention_str 
     84 
     85    FUNCTION cxios_is_defined_filegroup_convention_str(filegroup_hdl) BIND(C) 
     86      USE ISO_C_BINDING 
     87      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_convention_str 
     88      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     89    END FUNCTION cxios_is_defined_filegroup_convention_str 
     90 
     91 
    7192    SUBROUTINE cxios_set_filegroup_cyclic(filegroup_hdl, cyclic) BIND(C) 
    7293      USE ISO_C_BINDING 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/ifield_attr.F90

    r1021 r1201  
    1212 
    1313  SUBROUTINE xios(set_field_attr)  & 
    14     ( field_id, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    15     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    16     , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    17     , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     14    ( field_id, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     15    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     16    , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     17    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     18     ) 
    1819 
    1920    IMPLICIT NONE 
     
    2425      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods 
    2526      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods_mode 
     27      LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active 
     28      LOGICAL (KIND=C_BOOL) :: check_if_active_tmp 
    2629      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
    2730      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value 
     
    5962      (field_id,field_hdl) 
    6063      CALL xios(set_field_attr_hdl_)   & 
    61       ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    62       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    63       , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    64       , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     64      ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     65      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     66      , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     67      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     68       ) 
    6569 
    6670  END SUBROUTINE xios(set_field_attr) 
    6771 
    6872  SUBROUTINE xios(set_field_attr_hdl)  & 
    69     ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    70     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    71     , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    72     , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     73    ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     74    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     75    , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     76    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     77     ) 
    7378 
    7479    IMPLICIT NONE 
     
    7883      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods 
    7984      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods_mode 
     85      LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active 
     86      LOGICAL (KIND=C_BOOL) :: check_if_active_tmp 
    8087      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
    8188      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value 
     
    111118 
    112119      CALL xios(set_field_attr_hdl_)  & 
    113       ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    114       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    115       , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    116       , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     120      ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     121      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     122      , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     123      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     124       ) 
    117125 
    118126  END SUBROUTINE xios(set_field_attr_hdl) 
    119127 
    120128  SUBROUTINE xios(set_field_attr_hdl_)   & 
    121     ( field_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, compression_level_, default_value_  & 
    122     , detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_, freq_offset_, freq_op_, grid_path_  & 
    123     , grid_ref_, indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_  & 
    124     , scale_factor_, standard_name_, ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_  & 
    125     ) 
     129    ( field_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, check_if_active_, compression_level_  & 
     130    , default_value_, detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_, freq_offset_  & 
     131    , freq_op_, grid_path_, grid_ref_, indexed_output_, level_, long_name_, name_, operation_, prec_  & 
     132    , read_access_, scalar_ref_, scale_factor_, standard_name_, ts_enabled_, ts_split_freq_, unit_  & 
     133    , valid_max_, valid_min_ ) 
    126134 
    127135    IMPLICIT NONE 
     
    131139      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods_ 
    132140      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods_mode_ 
     141      LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active_ 
     142      LOGICAL (KIND=C_BOOL) :: check_if_active__tmp 
    133143      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_ 
    134144      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value_ 
     
    183193      ENDIF 
    184194 
     195      IF (PRESENT(check_if_active_)) THEN 
     196        check_if_active__tmp = check_if_active_ 
     197        CALL cxios_set_field_check_if_active & 
     198      (field_hdl%daddr, check_if_active__tmp) 
     199      ENDIF 
     200 
    185201      IF (PRESENT(compression_level_)) THEN 
    186202        CALL cxios_set_field_compression_level & 
     
    321337 
    322338  SUBROUTINE xios(get_field_attr)  & 
    323     ( field_id, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    324     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    325     , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    326     , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     339    ( field_id, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     340    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     341    , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     342    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     343     ) 
    327344 
    328345    IMPLICIT NONE 
     
    333350      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods 
    334351      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods_mode 
     352      LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active 
     353      LOGICAL (KIND=C_BOOL) :: check_if_active_tmp 
    335354      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
    336355      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value 
     
    368387      (field_id,field_hdl) 
    369388      CALL xios(get_field_attr_hdl_)   & 
    370       ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    371       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    372       , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    373       , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     389      ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     390      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     391      , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     392      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     393       ) 
    374394 
    375395  END SUBROUTINE xios(get_field_attr) 
    376396 
    377397  SUBROUTINE xios(get_field_attr_hdl)  & 
    378     ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    379     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    380     , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    381     , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     398    ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     399    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     400    , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     401    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     402     ) 
    382403 
    383404    IMPLICIT NONE 
     
    387408      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods 
    388409      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods_mode 
     410      LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active 
     411      LOGICAL (KIND=C_BOOL) :: check_if_active_tmp 
    389412      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
    390413      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value 
     
    420443 
    421444      CALL xios(get_field_attr_hdl_)  & 
    422       ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    423       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    424       , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    425       , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     445      ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     446      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     447      , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     448      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     449       ) 
    426450 
    427451  END SUBROUTINE xios(get_field_attr_hdl) 
    428452 
    429453  SUBROUTINE xios(get_field_attr_hdl_)   & 
    430     ( field_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, compression_level_, default_value_  & 
    431     , detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_, freq_offset_, freq_op_, grid_path_  & 
    432     , grid_ref_, indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_  & 
    433     , scale_factor_, standard_name_, ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_  & 
    434     ) 
     454    ( field_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, check_if_active_, compression_level_  & 
     455    , default_value_, detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_, freq_offset_  & 
     456    , freq_op_, grid_path_, grid_ref_, indexed_output_, level_, long_name_, name_, operation_, prec_  & 
     457    , read_access_, scalar_ref_, scale_factor_, standard_name_, ts_enabled_, ts_split_freq_, unit_  & 
     458    , valid_max_, valid_min_ ) 
    435459 
    436460    IMPLICIT NONE 
     
    440464      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods_ 
    441465      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods_mode_ 
     466      LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active_ 
     467      LOGICAL (KIND=C_BOOL) :: check_if_active__tmp 
    442468      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_ 
    443469      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value_ 
     
    492518      ENDIF 
    493519 
     520      IF (PRESENT(check_if_active_)) THEN 
     521        CALL cxios_get_field_check_if_active & 
     522      (field_hdl%daddr, check_if_active__tmp) 
     523        check_if_active_ = check_if_active__tmp 
     524      ENDIF 
     525 
    494526      IF (PRESENT(compression_level_)) THEN 
    495527        CALL cxios_get_field_compression_level & 
     
    630662 
    631663  SUBROUTINE xios(is_defined_field_attr)  & 
    632     ( field_id, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    633     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    634     , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    635     , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     664    ( field_id, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     665    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     666    , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     667    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     668     ) 
    636669 
    637670    IMPLICIT NONE 
     
    646679      LOGICAL, OPTIONAL, INTENT(OUT) :: cell_methods_mode 
    647680      LOGICAL(KIND=C_BOOL) :: cell_methods_mode_tmp 
     681      LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active 
     682      LOGICAL(KIND=C_BOOL) :: check_if_active_tmp 
    648683      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level 
    649684      LOGICAL(KIND=C_BOOL) :: compression_level_tmp 
     
    702737      (field_id,field_hdl) 
    703738      CALL xios(is_defined_field_attr_hdl_)   & 
    704       ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    705       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    706       , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    707       , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     739      ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     740      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     741      , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     742      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     743       ) 
    708744 
    709745  END SUBROUTINE xios(is_defined_field_attr) 
    710746 
    711747  SUBROUTINE xios(is_defined_field_attr_hdl)  & 
    712     ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    713     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    714     , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    715     , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     748    ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     749    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     750    , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     751    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     752     ) 
    716753 
    717754    IMPLICIT NONE 
     
    725762      LOGICAL, OPTIONAL, INTENT(OUT) :: cell_methods_mode 
    726763      LOGICAL(KIND=C_BOOL) :: cell_methods_mode_tmp 
     764      LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active 
     765      LOGICAL(KIND=C_BOOL) :: check_if_active_tmp 
    727766      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level 
    728767      LOGICAL(KIND=C_BOOL) :: compression_level_tmp 
     
    779818 
    780819      CALL xios(is_defined_field_attr_hdl_)  & 
    781       ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    782       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    783       , grid_ref, indexed_output, level, long_name, name, operation, prec, read_access, scalar_ref  & 
    784       , scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
     820      ( field_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     821      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     822      , grid_path, grid_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     823      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
     824       ) 
    785825 
    786826  END SUBROUTINE xios(is_defined_field_attr_hdl) 
    787827 
    788828  SUBROUTINE xios(is_defined_field_attr_hdl_)   & 
    789     ( field_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, compression_level_, default_value_  & 
    790     , detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_, freq_offset_, freq_op_, grid_path_  & 
    791     , grid_ref_, indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_  & 
    792     , scale_factor_, standard_name_, ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_  & 
    793     ) 
     829    ( field_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, check_if_active_, compression_level_  & 
     830    , default_value_, detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_, freq_offset_  & 
     831    , freq_op_, grid_path_, grid_ref_, indexed_output_, level_, long_name_, name_, operation_, prec_  & 
     832    , read_access_, scalar_ref_, scale_factor_, standard_name_, ts_enabled_, ts_split_freq_, unit_  & 
     833    , valid_max_, valid_min_ ) 
    794834 
    795835    IMPLICIT NONE 
     
    803843      LOGICAL, OPTIONAL, INTENT(OUT) :: cell_methods_mode_ 
    804844      LOGICAL(KIND=C_BOOL) :: cell_methods_mode__tmp 
     845      LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active_ 
     846      LOGICAL(KIND=C_BOOL) :: check_if_active__tmp 
    805847      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level_ 
    806848      LOGICAL(KIND=C_BOOL) :: compression_level__tmp 
     
    880922      ENDIF 
    881923 
     924      IF (PRESENT(check_if_active_)) THEN 
     925        check_if_active__tmp = cxios_is_defined_field_check_if_active & 
     926      (field_hdl%daddr) 
     927        check_if_active_ = check_if_active__tmp 
     928      ENDIF 
     929 
    882930      IF (PRESENT(compression_level_)) THEN 
    883931        compression_level__tmp = cxios_is_defined_field_compression_level & 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/ifieldgroup_attr.F90

    r1021 r1201  
    1212 
    1313  SUBROUTINE xios(set_fieldgroup_attr)  & 
    14     ( fieldgroup_id, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    15     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    16     , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     14    ( fieldgroup_id, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     15    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     16    , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    1717    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    1818     ) 
     
    2525      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods 
    2626      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods_mode 
     27      LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active 
     28      LOGICAL (KIND=C_BOOL) :: check_if_active_tmp 
    2729      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
    2830      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value 
     
    6163      (fieldgroup_id,fieldgroup_hdl) 
    6264      CALL xios(set_fieldgroup_attr_hdl_)   & 
    63       ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    64       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    65       , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     65      ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     66      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     67      , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    6668      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    6769       ) 
     
    7072 
    7173  SUBROUTINE xios(set_fieldgroup_attr_hdl)  & 
    72     ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    73     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    74     , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     74    ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     75    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     76    , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    7577    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    7678     ) 
     
    8284      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods 
    8385      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods_mode 
     86      LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active 
     87      LOGICAL (KIND=C_BOOL) :: check_if_active_tmp 
    8488      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
    8589      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value 
     
    116120 
    117121      CALL xios(set_fieldgroup_attr_hdl_)  & 
    118       ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    119       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    120       , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     122      ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     123      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     124      , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    121125      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    122126       ) 
     
    125129 
    126130  SUBROUTINE xios(set_fieldgroup_attr_hdl_)   & 
    127     ( fieldgroup_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, compression_level_  & 
    128     , default_value_, detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_, freq_offset_  & 
    129     , freq_op_, grid_path_, grid_ref_, group_ref_, indexed_output_, level_, long_name_, name_, operation_  & 
    130     , prec_, read_access_, scalar_ref_, scale_factor_, standard_name_, ts_enabled_, ts_split_freq_  & 
    131     , unit_, valid_max_, valid_min_ ) 
     131    ( fieldgroup_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, check_if_active_  & 
     132    , compression_level_, default_value_, detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_  & 
     133    , freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_, indexed_output_, level_, long_name_  & 
     134    , name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_, ts_enabled_  & 
     135    , ts_split_freq_, unit_, valid_max_, valid_min_ ) 
    132136 
    133137    IMPLICIT NONE 
     
    137141      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods_ 
    138142      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: cell_methods_mode_ 
     143      LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active_ 
     144      LOGICAL (KIND=C_BOOL) :: check_if_active__tmp 
    139145      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_ 
    140146      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value_ 
     
    190196      ENDIF 
    191197 
     198      IF (PRESENT(check_if_active_)) THEN 
     199        check_if_active__tmp = check_if_active_ 
     200        CALL cxios_set_fieldgroup_check_if_active & 
     201      (fieldgroup_hdl%daddr, check_if_active__tmp) 
     202      ENDIF 
     203 
    192204      IF (PRESENT(compression_level_)) THEN 
    193205        CALL cxios_set_fieldgroup_compression_level & 
     
    333345 
    334346  SUBROUTINE xios(get_fieldgroup_attr)  & 
    335     ( fieldgroup_id, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    336     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    337     , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     347    ( fieldgroup_id, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     348    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     349    , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    338350    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    339351     ) 
     
    346358      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods 
    347359      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods_mode 
     360      LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active 
     361      LOGICAL (KIND=C_BOOL) :: check_if_active_tmp 
    348362      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
    349363      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value 
     
    382396      (fieldgroup_id,fieldgroup_hdl) 
    383397      CALL xios(get_fieldgroup_attr_hdl_)   & 
    384       ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    385       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    386       , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     398      ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     399      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     400      , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    387401      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    388402       ) 
     
    391405 
    392406  SUBROUTINE xios(get_fieldgroup_attr_hdl)  & 
    393     ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    394     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    395     , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     407    ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     408    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     409    , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    396410    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    397411     ) 
     
    403417      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods 
    404418      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods_mode 
     419      LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active 
     420      LOGICAL (KIND=C_BOOL) :: check_if_active_tmp 
    405421      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
    406422      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value 
     
    437453 
    438454      CALL xios(get_fieldgroup_attr_hdl_)  & 
    439       ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    440       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    441       , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     455      ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     456      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     457      , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    442458      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    443459       ) 
     
    446462 
    447463  SUBROUTINE xios(get_fieldgroup_attr_hdl_)   & 
    448     ( fieldgroup_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, compression_level_  & 
    449     , default_value_, detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_, freq_offset_  & 
    450     , freq_op_, grid_path_, grid_ref_, group_ref_, indexed_output_, level_, long_name_, name_, operation_  & 
    451     , prec_, read_access_, scalar_ref_, scale_factor_, standard_name_, ts_enabled_, ts_split_freq_  & 
    452     , unit_, valid_max_, valid_min_ ) 
     464    ( fieldgroup_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, check_if_active_  & 
     465    , compression_level_, default_value_, detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_  & 
     466    , freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_, indexed_output_, level_, long_name_  & 
     467    , name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_, ts_enabled_  & 
     468    , ts_split_freq_, unit_, valid_max_, valid_min_ ) 
    453469 
    454470    IMPLICIT NONE 
     
    458474      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods_ 
    459475      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: cell_methods_mode_ 
     476      LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active_ 
     477      LOGICAL (KIND=C_BOOL) :: check_if_active__tmp 
    460478      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_ 
    461479      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value_ 
     
    511529      ENDIF 
    512530 
     531      IF (PRESENT(check_if_active_)) THEN 
     532        CALL cxios_get_fieldgroup_check_if_active & 
     533      (fieldgroup_hdl%daddr, check_if_active__tmp) 
     534        check_if_active_ = check_if_active__tmp 
     535      ENDIF 
     536 
    513537      IF (PRESENT(compression_level_)) THEN 
    514538        CALL cxios_get_fieldgroup_compression_level & 
     
    654678 
    655679  SUBROUTINE xios(is_defined_fieldgroup_attr)  & 
    656     ( fieldgroup_id, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    657     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    658     , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     680    ( fieldgroup_id, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     681    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     682    , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    659683    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    660684     ) 
     
    671695      LOGICAL, OPTIONAL, INTENT(OUT) :: cell_methods_mode 
    672696      LOGICAL(KIND=C_BOOL) :: cell_methods_mode_tmp 
     697      LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active 
     698      LOGICAL(KIND=C_BOOL) :: check_if_active_tmp 
    673699      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level 
    674700      LOGICAL(KIND=C_BOOL) :: compression_level_tmp 
     
    729755      (fieldgroup_id,fieldgroup_hdl) 
    730756      CALL xios(is_defined_fieldgroup_attr_hdl_)   & 
    731       ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    732       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    733       , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     757      ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     758      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     759      , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    734760      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    735761       ) 
     
    738764 
    739765  SUBROUTINE xios(is_defined_fieldgroup_attr_hdl)  & 
    740     ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    741     , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    742     , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     766    ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     767    , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     768    , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    743769    , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    744770     ) 
     
    754780      LOGICAL, OPTIONAL, INTENT(OUT) :: cell_methods_mode 
    755781      LOGICAL(KIND=C_BOOL) :: cell_methods_mode_tmp 
     782      LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active 
     783      LOGICAL(KIND=C_BOOL) :: check_if_active_tmp 
    756784      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level 
    757785      LOGICAL(KIND=C_BOOL) :: compression_level_tmp 
     
    810838 
    811839      CALL xios(is_defined_fieldgroup_attr_hdl_)  & 
    812       ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, compression_level, default_value  & 
    813       , detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op, grid_path  & 
    814       , grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
     840      ( fieldgroup_hdl, add_offset, axis_ref, cell_methods, cell_methods_mode, check_if_active, compression_level  & 
     841      , default_value, detect_missing_value, domain_ref, enabled, expr, field_ref, freq_offset, freq_op  & 
     842      , grid_path, grid_ref, group_ref, indexed_output, level, long_name, name, operation, prec, read_access  & 
    815843      , scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq, unit, valid_max, valid_min  & 
    816844       ) 
     
    819847 
    820848  SUBROUTINE xios(is_defined_fieldgroup_attr_hdl_)   & 
    821     ( fieldgroup_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, compression_level_  & 
    822     , default_value_, detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_, freq_offset_  & 
    823     , freq_op_, grid_path_, grid_ref_, group_ref_, indexed_output_, level_, long_name_, name_, operation_  & 
    824     , prec_, read_access_, scalar_ref_, scale_factor_, standard_name_, ts_enabled_, ts_split_freq_  & 
    825     , unit_, valid_max_, valid_min_ ) 
     849    ( fieldgroup_hdl, add_offset_, axis_ref_, cell_methods_, cell_methods_mode_, check_if_active_  & 
     850    , compression_level_, default_value_, detect_missing_value_, domain_ref_, enabled_, expr_, field_ref_  & 
     851    , freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_, indexed_output_, level_, long_name_  & 
     852    , name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_, ts_enabled_  & 
     853    , ts_split_freq_, unit_, valid_max_, valid_min_ ) 
    826854 
    827855    IMPLICIT NONE 
     
    835863      LOGICAL, OPTIONAL, INTENT(OUT) :: cell_methods_mode_ 
    836864      LOGICAL(KIND=C_BOOL) :: cell_methods_mode__tmp 
     865      LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active_ 
     866      LOGICAL(KIND=C_BOOL) :: check_if_active__tmp 
    837867      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level_ 
    838868      LOGICAL(KIND=C_BOOL) :: compression_level__tmp 
     
    914944      ENDIF 
    915945 
     946      IF (PRESENT(check_if_active_)) THEN 
     947        check_if_active__tmp = cxios_is_defined_fieldgroup_check_if_active & 
     948      (fieldgroup_hdl%daddr) 
     949        check_if_active_ = check_if_active__tmp 
     950      ENDIF 
     951 
    916952      IF (PRESENT(compression_level_)) THEN 
    917953        compression_level__tmp = cxios_is_defined_fieldgroup_compression_level & 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/ifile_attr.F90

    r1158 r1201  
    1212 
    1313  SUBROUTINE xios(set_file_attr)  & 
    14     ( file_id, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    15     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    16     , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    17     , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     14    ( file_id, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     15    , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     16    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     17    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    1818 
    1919    IMPLICIT NONE 
     
    2424      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
    2525      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention 
     26      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention_str 
    2627      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic 
    2728      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
     
    5556      (file_id,file_hdl) 
    5657      CALL xios(set_file_attr_hdl_)   & 
    57       ( file_hdl, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    58       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    59       , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    60       , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     58      ( file_hdl, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     59      , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     60      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     61      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    6162 
    6263  END SUBROUTINE xios(set_file_attr) 
    6364 
    6465  SUBROUTINE xios(set_file_attr_hdl)  & 
    65     ( file_hdl, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    66     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    67     , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    68     , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     66    ( file_hdl, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     67    , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     68    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     69    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    6970 
    7071    IMPLICIT NONE 
     
    7475      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
    7576      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention 
     77      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention_str 
    7678      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic 
    7779      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
     
    103105 
    104106      CALL xios(set_file_attr_hdl_)  & 
    105       ( file_hdl, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    106       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    107       , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    108       , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     107      ( file_hdl, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     108      , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     109      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     110      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    109111 
    110112  END SUBROUTINE xios(set_file_attr_hdl) 
    111113 
    112114  SUBROUTINE xios(set_file_attr_hdl_)   & 
    113     ( file_hdl, append_, compression_level_, convention_, cyclic_, description_, enabled_, format_  & 
    114     , min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_  & 
    115     , split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_, time_stamp_format_  & 
    116     , time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_, uuid_name_ ) 
     115    ( file_hdl, append_, compression_level_, convention_, convention_str_, cyclic_, description_  & 
     116    , enabled_, format_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_  & 
     117    , record_offset_, split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_  & 
     118    , time_stamp_format_, time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_  & 
     119    , uuid_name_ ) 
    117120 
    118121    IMPLICIT NONE 
     
    122125      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_ 
    123126      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention_ 
     127      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention_str_ 
    124128      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic_ 
    125129      LOGICAL (KIND=C_BOOL) :: cyclic__tmp 
     
    166170      ENDIF 
    167171 
     172      IF (PRESENT(convention_str_)) THEN 
     173        CALL cxios_set_file_convention_str & 
     174      (file_hdl%daddr, convention_str_, len(convention_str_)) 
     175      ENDIF 
     176 
    168177      IF (PRESENT(cyclic_)) THEN 
    169178        cyclic__tmp = cyclic_ 
     
    296305 
    297306  SUBROUTINE xios(get_file_attr)  & 
    298     ( file_id, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    299     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    300     , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    301     , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     307    ( file_id, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     308    , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     309    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     310    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    302311 
    303312    IMPLICIT NONE 
     
    308317      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
    309318      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention 
     319      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention_str 
    310320      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic 
    311321      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
     
    339349      (file_id,file_hdl) 
    340350      CALL xios(get_file_attr_hdl_)   & 
    341       ( file_hdl, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    342       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    343       , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    344       , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     351      ( file_hdl, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     352      , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     353      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     354      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    345355 
    346356  END SUBROUTINE xios(get_file_attr) 
    347357 
    348358  SUBROUTINE xios(get_file_attr_hdl)  & 
    349     ( file_hdl, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    350     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    351     , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    352     , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     359    ( file_hdl, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     360    , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     361    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     362    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    353363 
    354364    IMPLICIT NONE 
     
    358368      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
    359369      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention 
     370      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention_str 
    360371      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic 
    361372      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
     
    387398 
    388399      CALL xios(get_file_attr_hdl_)  & 
    389       ( file_hdl, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    390       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    391       , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    392       , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     400      ( file_hdl, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     401      , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     402      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     403      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    393404 
    394405  END SUBROUTINE xios(get_file_attr_hdl) 
    395406 
    396407  SUBROUTINE xios(get_file_attr_hdl_)   & 
    397     ( file_hdl, append_, compression_level_, convention_, cyclic_, description_, enabled_, format_  & 
    398     , min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_  & 
    399     , split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_, time_stamp_format_  & 
    400     , time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_, uuid_name_ ) 
     408    ( file_hdl, append_, compression_level_, convention_, convention_str_, cyclic_, description_  & 
     409    , enabled_, format_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_  & 
     410    , record_offset_, split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_  & 
     411    , time_stamp_format_, time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_  & 
     412    , uuid_name_ ) 
    401413 
    402414    IMPLICIT NONE 
     
    406418      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_ 
    407419      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention_ 
     420      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention_str_ 
    408421      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic_ 
    409422      LOGICAL (KIND=C_BOOL) :: cyclic__tmp 
     
    450463      ENDIF 
    451464 
     465      IF (PRESENT(convention_str_)) THEN 
     466        CALL cxios_get_file_convention_str & 
     467      (file_hdl%daddr, convention_str_, len(convention_str_)) 
     468      ENDIF 
     469 
    452470      IF (PRESENT(cyclic_)) THEN 
    453471        CALL cxios_get_file_cyclic & 
     
    580598 
    581599  SUBROUTINE xios(is_defined_file_attr)  & 
    582     ( file_id, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    583     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    584     , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    585     , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     600    ( file_id, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     601    , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     602    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     603    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    586604 
    587605    IMPLICIT NONE 
     
    594612      LOGICAL, OPTIONAL, INTENT(OUT) :: convention 
    595613      LOGICAL(KIND=C_BOOL) :: convention_tmp 
     614      LOGICAL, OPTIONAL, INTENT(OUT) :: convention_str 
     615      LOGICAL(KIND=C_BOOL) :: convention_str_tmp 
    596616      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic 
    597617      LOGICAL(KIND=C_BOOL) :: cyclic_tmp 
     
    648668      (file_id,file_hdl) 
    649669      CALL xios(is_defined_file_attr_hdl_)   & 
    650       ( file_hdl, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    651       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    652       , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    653       , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     670      ( file_hdl, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     671      , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     672      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     673      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    654674 
    655675  END SUBROUTINE xios(is_defined_file_attr) 
    656676 
    657677  SUBROUTINE xios(is_defined_file_attr_hdl)  & 
    658     ( file_hdl, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    659     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    660     , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    661     , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     678    ( file_hdl, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     679    , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     680    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     681    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    662682 
    663683    IMPLICIT NONE 
     
    669689      LOGICAL, OPTIONAL, INTENT(OUT) :: convention 
    670690      LOGICAL(KIND=C_BOOL) :: convention_tmp 
     691      LOGICAL, OPTIONAL, INTENT(OUT) :: convention_str 
     692      LOGICAL(KIND=C_BOOL) :: convention_str_tmp 
    671693      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic 
    672694      LOGICAL(KIND=C_BOOL) :: cyclic_tmp 
     
    721743 
    722744      CALL xios(is_defined_file_attr_hdl_)  & 
    723       ( file_hdl, append, compression_level, convention, cyclic, description, enabled, format, min_digits  & 
    724       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    725       , split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  & 
    726       , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     745      ( file_hdl, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     746      , format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     747      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     748      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    727749 
    728750  END SUBROUTINE xios(is_defined_file_attr_hdl) 
    729751 
    730752  SUBROUTINE xios(is_defined_file_attr_hdl_)   & 
    731     ( file_hdl, append_, compression_level_, convention_, cyclic_, description_, enabled_, format_  & 
    732     , min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_  & 
    733     , split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_, time_stamp_format_  & 
    734     , time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_, uuid_name_ ) 
     753    ( file_hdl, append_, compression_level_, convention_, convention_str_, cyclic_, description_  & 
     754    , enabled_, format_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_  & 
     755    , record_offset_, split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_  & 
     756    , time_stamp_format_, time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_  & 
     757    , uuid_name_ ) 
    735758 
    736759    IMPLICIT NONE 
     
    742765      LOGICAL, OPTIONAL, INTENT(OUT) :: convention_ 
    743766      LOGICAL(KIND=C_BOOL) :: convention__tmp 
     767      LOGICAL, OPTIONAL, INTENT(OUT) :: convention_str_ 
     768      LOGICAL(KIND=C_BOOL) :: convention_str__tmp 
    744769      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic_ 
    745770      LOGICAL(KIND=C_BOOL) :: cyclic__tmp 
     
    811836      ENDIF 
    812837 
     838      IF (PRESENT(convention_str_)) THEN 
     839        convention_str__tmp = cxios_is_defined_file_convention_str & 
     840      (file_hdl%daddr) 
     841        convention_str_ = convention_str__tmp 
     842      ENDIF 
     843 
    813844      IF (PRESENT(cyclic_)) THEN 
    814845        cyclic__tmp = cxios_is_defined_file_cyclic & 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/ifilegroup_attr.F90

    r1158 r1201  
    1212 
    1313  SUBROUTINE xios(set_filegroup_attr)  & 
    14     ( filegroup_id, append, compression_level, convention, cyclic, description, enabled, format  & 
    15     , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    16     , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     14    ( filegroup_id, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     15    , format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  & 
     16    , record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    1717    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    1818 
     
    2424      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
    2525      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention 
     26      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention_str 
    2627      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic 
    2728      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
     
    5657      (filegroup_id,filegroup_hdl) 
    5758      CALL xios(set_filegroup_attr_hdl_)   & 
    58       ( filegroup_hdl, append, compression_level, convention, cyclic, description, enabled, format  & 
    59       , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    60       , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    61       , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     59      ( filegroup_hdl, append, compression_level, convention, convention_str, cyclic, description  & 
     60      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  & 
     61      , par_access, record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name  & 
     62      , time_stamp_format, time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name  & 
     63       ) 
    6264 
    6365  END SUBROUTINE xios(set_filegroup_attr) 
    6466 
    6567  SUBROUTINE xios(set_filegroup_attr_hdl)  & 
    66     ( filegroup_hdl, append, compression_level, convention, cyclic, description, enabled, format  & 
    67     , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    68     , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    69     , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     68    ( filegroup_hdl, append, compression_level, convention, convention_str, cyclic, description  & 
     69    , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  & 
     70    , par_access, record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name  & 
     71    , time_stamp_format, time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name  & 
     72     ) 
    7073 
    7174    IMPLICIT NONE 
     
    7578      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
    7679      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention 
     80      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention_str 
    7781      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic 
    7882      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
     
    105109 
    106110      CALL xios(set_filegroup_attr_hdl_)  & 
    107       ( filegroup_hdl, append, compression_level, convention, cyclic, description, enabled, format  & 
    108       , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    109       , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    110       , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     111      ( filegroup_hdl, append, compression_level, convention, convention_str, cyclic, description  & 
     112      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  & 
     113      , par_access, record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name  & 
     114      , time_stamp_format, time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name  & 
     115       ) 
    111116 
    112117  END SUBROUTINE xios(set_filegroup_attr_hdl) 
    113118 
    114119  SUBROUTINE xios(set_filegroup_attr_hdl_)   & 
    115     ( filegroup_hdl, append_, compression_level_, convention_, cyclic_, description_, enabled_, format_  & 
    116     , group_ref_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_  & 
    117     , record_offset_, split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_  & 
     120    ( filegroup_hdl, append_, compression_level_, convention_, convention_str_, cyclic_, description_  & 
     121    , enabled_, format_, group_ref_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_  & 
     122    , par_access_, record_offset_, split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_  & 
    118123    , time_stamp_format_, time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_  & 
    119124    , uuid_name_ ) 
     
    125130      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_ 
    126131      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention_ 
     132      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: convention_str_ 
    127133      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic_ 
    128134      LOGICAL (KIND=C_BOOL) :: cyclic__tmp 
     
    170176      ENDIF 
    171177 
     178      IF (PRESENT(convention_str_)) THEN 
     179        CALL cxios_set_filegroup_convention_str & 
     180      (filegroup_hdl%daddr, convention_str_, len(convention_str_)) 
     181      ENDIF 
     182 
    172183      IF (PRESENT(cyclic_)) THEN 
    173184        cyclic__tmp = cyclic_ 
     
    305316 
    306317  SUBROUTINE xios(get_filegroup_attr)  & 
    307     ( filegroup_id, append, compression_level, convention, cyclic, description, enabled, format  & 
    308     , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    309     , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     318    ( filegroup_id, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     319    , format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  & 
     320    , record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    310321    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    311322 
     
    317328      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
    318329      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention 
     330      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention_str 
    319331      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic 
    320332      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
     
    349361      (filegroup_id,filegroup_hdl) 
    350362      CALL xios(get_filegroup_attr_hdl_)   & 
    351       ( filegroup_hdl, append, compression_level, convention, cyclic, description, enabled, format  & 
    352       , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    353       , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    354       , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     363      ( filegroup_hdl, append, compression_level, convention, convention_str, cyclic, description  & 
     364      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  & 
     365      , par_access, record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name  & 
     366      , time_stamp_format, time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name  & 
     367       ) 
    355368 
    356369  END SUBROUTINE xios(get_filegroup_attr) 
    357370 
    358371  SUBROUTINE xios(get_filegroup_attr_hdl)  & 
    359     ( filegroup_hdl, append, compression_level, convention, cyclic, description, enabled, format  & 
    360     , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    361     , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    362     , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     372    ( filegroup_hdl, append, compression_level, convention, convention_str, cyclic, description  & 
     373    , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  & 
     374    , par_access, record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name  & 
     375    , time_stamp_format, time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name  & 
     376     ) 
    363377 
    364378    IMPLICIT NONE 
     
    368382      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
    369383      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention 
     384      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention_str 
    370385      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic 
    371386      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
     
    398413 
    399414      CALL xios(get_filegroup_attr_hdl_)  & 
    400       ( filegroup_hdl, append, compression_level, convention, cyclic, description, enabled, format  & 
    401       , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    402       , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    403       , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     415      ( filegroup_hdl, append, compression_level, convention, convention_str, cyclic, description  & 
     416      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  & 
     417      , par_access, record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name  & 
     418      , time_stamp_format, time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name  & 
     419       ) 
    404420 
    405421  END SUBROUTINE xios(get_filegroup_attr_hdl) 
    406422 
    407423  SUBROUTINE xios(get_filegroup_attr_hdl_)   & 
    408     ( filegroup_hdl, append_, compression_level_, convention_, cyclic_, description_, enabled_, format_  & 
    409     , group_ref_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_  & 
    410     , record_offset_, split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_  & 
     424    ( filegroup_hdl, append_, compression_level_, convention_, convention_str_, cyclic_, description_  & 
     425    , enabled_, format_, group_ref_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_  & 
     426    , par_access_, record_offset_, split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_  & 
    411427    , time_stamp_format_, time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_  & 
    412428    , uuid_name_ ) 
     
    418434      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_ 
    419435      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention_ 
     436      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: convention_str_ 
    420437      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic_ 
    421438      LOGICAL (KIND=C_BOOL) :: cyclic__tmp 
     
    463480      ENDIF 
    464481 
     482      IF (PRESENT(convention_str_)) THEN 
     483        CALL cxios_get_filegroup_convention_str & 
     484      (filegroup_hdl%daddr, convention_str_, len(convention_str_)) 
     485      ENDIF 
     486 
    465487      IF (PRESENT(cyclic_)) THEN 
    466488        CALL cxios_get_filegroup_cyclic & 
     
    598620 
    599621  SUBROUTINE xios(is_defined_filegroup_attr)  & 
    600     ( filegroup_id, append, compression_level, convention, cyclic, description, enabled, format  & 
    601     , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    602     , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
     622    ( filegroup_id, append, compression_level, convention, convention_str, cyclic, description, enabled  & 
     623    , format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  & 
     624    , record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    603625    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
    604626 
     
    612634      LOGICAL, OPTIONAL, INTENT(OUT) :: convention 
    613635      LOGICAL(KIND=C_BOOL) :: convention_tmp 
     636      LOGICAL, OPTIONAL, INTENT(OUT) :: convention_str 
     637      LOGICAL(KIND=C_BOOL) :: convention_str_tmp 
    614638      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic 
    615639      LOGICAL(KIND=C_BOOL) :: cyclic_tmp 
     
    668692      (filegroup_id,filegroup_hdl) 
    669693      CALL xios(is_defined_filegroup_attr_hdl_)   & 
    670       ( filegroup_hdl, append, compression_level, convention, cyclic, description, enabled, format  & 
    671       , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    672       , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    673       , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     694      ( filegroup_hdl, append, compression_level, convention, convention_str, cyclic, description  & 
     695      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  & 
     696      , par_access, record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name  & 
     697      , time_stamp_format, time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name  & 
     698       ) 
    674699 
    675700  END SUBROUTINE xios(is_defined_filegroup_attr) 
    676701 
    677702  SUBROUTINE xios(is_defined_filegroup_attr_hdl)  & 
    678     ( filegroup_hdl, append, compression_level, convention, cyclic, description, enabled, format  & 
    679     , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    680     , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    681     , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     703    ( filegroup_hdl, append, compression_level, convention, convention_str, cyclic, description  & 
     704    , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  & 
     705    , par_access, record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name  & 
     706    , time_stamp_format, time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name  & 
     707     ) 
    682708 
    683709    IMPLICIT NONE 
     
    689715      LOGICAL, OPTIONAL, INTENT(OUT) :: convention 
    690716      LOGICAL(KIND=C_BOOL) :: convention_tmp 
     717      LOGICAL, OPTIONAL, INTENT(OUT) :: convention_str 
     718      LOGICAL(KIND=C_BOOL) :: convention_str_tmp 
    691719      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic 
    692720      LOGICAL(KIND=C_BOOL) :: cyclic_tmp 
     
    743771 
    744772      CALL xios(is_defined_filegroup_attr_hdl_)  & 
    745       ( filegroup_hdl, append, compression_level, convention, cyclic, description, enabled, format  & 
    746       , group_ref, min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
    747       , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, time_stamp_format  & 
    748       , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name ) 
     773      ( filegroup_hdl, append, compression_level, convention, convention_str, cyclic, description  & 
     774      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  & 
     775      , par_access, record_offset, split_freq, split_freq_format, sync_freq, time_counter, time_counter_name  & 
     776      , time_stamp_format, time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name  & 
     777       ) 
    749778 
    750779  END SUBROUTINE xios(is_defined_filegroup_attr_hdl) 
    751780 
    752781  SUBROUTINE xios(is_defined_filegroup_attr_hdl_)   & 
    753     ( filegroup_hdl, append_, compression_level_, convention_, cyclic_, description_, enabled_, format_  & 
    754     , group_ref_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_  & 
    755     , record_offset_, split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_  & 
     782    ( filegroup_hdl, append_, compression_level_, convention_, convention_str_, cyclic_, description_  & 
     783    , enabled_, format_, group_ref_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_  & 
     784    , par_access_, record_offset_, split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_  & 
    756785    , time_stamp_format_, time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_  & 
    757786    , uuid_name_ ) 
     
    765794      LOGICAL, OPTIONAL, INTENT(OUT) :: convention_ 
    766795      LOGICAL(KIND=C_BOOL) :: convention__tmp 
     796      LOGICAL, OPTIONAL, INTENT(OUT) :: convention_str_ 
     797      LOGICAL(KIND=C_BOOL) :: convention_str__tmp 
    767798      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic_ 
    768799      LOGICAL(KIND=C_BOOL) :: cyclic__tmp 
     
    836867      ENDIF 
    837868 
     869      IF (PRESENT(convention_str_)) THEN 
     870        convention_str__tmp = cxios_is_defined_filegroup_convention_str & 
     871      (filegroup_hdl%daddr) 
     872        convention_str_ = convention_str__tmp 
     873      ENDIF 
     874 
    838875      IF (PRESENT(cyclic_)) THEN 
    839876        cyclic__tmp = cxios_is_defined_filegroup_cyclic & 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/iinterpolate_domain_attr.F90

    r1158 r1201  
    1212 
    1313  SUBROUTINE xios(set_interpolate_domain_attr)  & 
    14     ( interpolate_domain_id, mode, order, renormalize, weight_filename, write_weight ) 
     14    ( interpolate_domain_id, mode, order, quantity, renormalize, weight_filename, write_weight ) 
    1515 
    1616    IMPLICIT NONE 
     
    1919      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: mode 
    2020      INTEGER  , OPTIONAL, INTENT(IN) :: order 
     21      LOGICAL  , OPTIONAL, INTENT(IN) :: quantity 
     22      LOGICAL (KIND=C_BOOL) :: quantity_tmp 
    2123      LOGICAL  , OPTIONAL, INTENT(IN) :: renormalize 
    2224      LOGICAL (KIND=C_BOOL) :: renormalize_tmp 
     
    2830      (interpolate_domain_id,interpolate_domain_hdl) 
    2931      CALL xios(set_interpolate_domain_attr_hdl_)   & 
    30       ( interpolate_domain_hdl, mode, order, renormalize, weight_filename, write_weight ) 
     32      ( interpolate_domain_hdl, mode, order, quantity, renormalize, weight_filename, write_weight  & 
     33       ) 
    3134 
    3235  END SUBROUTINE xios(set_interpolate_domain_attr) 
    3336 
    3437  SUBROUTINE xios(set_interpolate_domain_attr_hdl)  & 
    35     ( interpolate_domain_hdl, mode, order, renormalize, weight_filename, write_weight ) 
     38    ( interpolate_domain_hdl, mode, order, quantity, renormalize, weight_filename, write_weight  & 
     39     ) 
    3640 
    3741    IMPLICIT NONE 
     
    3943      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: mode 
    4044      INTEGER  , OPTIONAL, INTENT(IN) :: order 
     45      LOGICAL  , OPTIONAL, INTENT(IN) :: quantity 
     46      LOGICAL (KIND=C_BOOL) :: quantity_tmp 
    4147      LOGICAL  , OPTIONAL, INTENT(IN) :: renormalize 
    4248      LOGICAL (KIND=C_BOOL) :: renormalize_tmp 
     
    4652 
    4753      CALL xios(set_interpolate_domain_attr_hdl_)  & 
    48       ( interpolate_domain_hdl, mode, order, renormalize, weight_filename, write_weight ) 
     54      ( interpolate_domain_hdl, mode, order, quantity, renormalize, weight_filename, write_weight  & 
     55       ) 
    4956 
    5057  END SUBROUTINE xios(set_interpolate_domain_attr_hdl) 
    5158 
    5259  SUBROUTINE xios(set_interpolate_domain_attr_hdl_)   & 
    53     ( interpolate_domain_hdl, mode_, order_, renormalize_, weight_filename_, write_weight_ ) 
     60    ( interpolate_domain_hdl, mode_, order_, quantity_, renormalize_, weight_filename_, write_weight_  & 
     61     ) 
    5462 
    5563    IMPLICIT NONE 
     
    5765      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: mode_ 
    5866      INTEGER  , OPTIONAL, INTENT(IN) :: order_ 
     67      LOGICAL  , OPTIONAL, INTENT(IN) :: quantity_ 
     68      LOGICAL (KIND=C_BOOL) :: quantity__tmp 
    5969      LOGICAL  , OPTIONAL, INTENT(IN) :: renormalize_ 
    6070      LOGICAL (KIND=C_BOOL) :: renormalize__tmp 
     
    7383      ENDIF 
    7484 
     85      IF (PRESENT(quantity_)) THEN 
     86        quantity__tmp = quantity_ 
     87        CALL cxios_set_interpolate_domain_quantity & 
     88      (interpolate_domain_hdl%daddr, quantity__tmp) 
     89      ENDIF 
     90 
    7591      IF (PRESENT(renormalize_)) THEN 
    7692        renormalize__tmp = renormalize_ 
     
    93109 
    94110  SUBROUTINE xios(get_interpolate_domain_attr)  & 
    95     ( interpolate_domain_id, mode, order, renormalize, weight_filename, write_weight ) 
     111    ( interpolate_domain_id, mode, order, quantity, renormalize, weight_filename, write_weight ) 
    96112 
    97113    IMPLICIT NONE 
     
    100116      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: mode 
    101117      INTEGER  , OPTIONAL, INTENT(OUT) :: order 
     118      LOGICAL  , OPTIONAL, INTENT(OUT) :: quantity 
     119      LOGICAL (KIND=C_BOOL) :: quantity_tmp 
    102120      LOGICAL  , OPTIONAL, INTENT(OUT) :: renormalize 
    103121      LOGICAL (KIND=C_BOOL) :: renormalize_tmp 
     
    109127      (interpolate_domain_id,interpolate_domain_hdl) 
    110128      CALL xios(get_interpolate_domain_attr_hdl_)   & 
    111       ( interpolate_domain_hdl, mode, order, renormalize, weight_filename, write_weight ) 
     129      ( interpolate_domain_hdl, mode, order, quantity, renormalize, weight_filename, write_weight  & 
     130       ) 
    112131 
    113132  END SUBROUTINE xios(get_interpolate_domain_attr) 
    114133 
    115134  SUBROUTINE xios(get_interpolate_domain_attr_hdl)  & 
    116     ( interpolate_domain_hdl, mode, order, renormalize, weight_filename, write_weight ) 
     135    ( interpolate_domain_hdl, mode, order, quantity, renormalize, weight_filename, write_weight  & 
     136     ) 
    117137 
    118138    IMPLICIT NONE 
     
    120140      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: mode 
    121141      INTEGER  , OPTIONAL, INTENT(OUT) :: order 
     142      LOGICAL  , OPTIONAL, INTENT(OUT) :: quantity 
     143      LOGICAL (KIND=C_BOOL) :: quantity_tmp 
    122144      LOGICAL  , OPTIONAL, INTENT(OUT) :: renormalize 
    123145      LOGICAL (KIND=C_BOOL) :: renormalize_tmp 
     
    127149 
    128150      CALL xios(get_interpolate_domain_attr_hdl_)  & 
    129       ( interpolate_domain_hdl, mode, order, renormalize, weight_filename, write_weight ) 
     151      ( interpolate_domain_hdl, mode, order, quantity, renormalize, weight_filename, write_weight  & 
     152       ) 
    130153 
    131154  END SUBROUTINE xios(get_interpolate_domain_attr_hdl) 
    132155 
    133156  SUBROUTINE xios(get_interpolate_domain_attr_hdl_)   & 
    134     ( interpolate_domain_hdl, mode_, order_, renormalize_, weight_filename_, write_weight_ ) 
     157    ( interpolate_domain_hdl, mode_, order_, quantity_, renormalize_, weight_filename_, write_weight_  & 
     158     ) 
    135159 
    136160    IMPLICIT NONE 
     
    138162      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: mode_ 
    139163      INTEGER  , OPTIONAL, INTENT(OUT) :: order_ 
     164      LOGICAL  , OPTIONAL, INTENT(OUT) :: quantity_ 
     165      LOGICAL (KIND=C_BOOL) :: quantity__tmp 
    140166      LOGICAL  , OPTIONAL, INTENT(OUT) :: renormalize_ 
    141167      LOGICAL (KIND=C_BOOL) :: renormalize__tmp 
     
    154180      ENDIF 
    155181 
     182      IF (PRESENT(quantity_)) THEN 
     183        CALL cxios_get_interpolate_domain_quantity & 
     184      (interpolate_domain_hdl%daddr, quantity__tmp) 
     185        quantity_ = quantity__tmp 
     186      ENDIF 
     187 
    156188      IF (PRESENT(renormalize_)) THEN 
    157189        CALL cxios_get_interpolate_domain_renormalize & 
     
    174206 
    175207  SUBROUTINE xios(is_defined_interpolate_domain_attr)  & 
    176     ( interpolate_domain_id, mode, order, renormalize, weight_filename, write_weight ) 
     208    ( interpolate_domain_id, mode, order, quantity, renormalize, weight_filename, write_weight ) 
    177209 
    178210    IMPLICIT NONE 
     
    183215      LOGICAL, OPTIONAL, INTENT(OUT) :: order 
    184216      LOGICAL(KIND=C_BOOL) :: order_tmp 
     217      LOGICAL, OPTIONAL, INTENT(OUT) :: quantity 
     218      LOGICAL(KIND=C_BOOL) :: quantity_tmp 
    185219      LOGICAL, OPTIONAL, INTENT(OUT) :: renormalize 
    186220      LOGICAL(KIND=C_BOOL) :: renormalize_tmp 
     
    193227      (interpolate_domain_id,interpolate_domain_hdl) 
    194228      CALL xios(is_defined_interpolate_domain_attr_hdl_)   & 
    195       ( interpolate_domain_hdl, mode, order, renormalize, weight_filename, write_weight ) 
     229      ( interpolate_domain_hdl, mode, order, quantity, renormalize, weight_filename, write_weight  & 
     230       ) 
    196231 
    197232  END SUBROUTINE xios(is_defined_interpolate_domain_attr) 
    198233 
    199234  SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl)  & 
    200     ( interpolate_domain_hdl, mode, order, renormalize, weight_filename, write_weight ) 
     235    ( interpolate_domain_hdl, mode, order, quantity, renormalize, weight_filename, write_weight  & 
     236     ) 
    201237 
    202238    IMPLICIT NONE 
     
    206242      LOGICAL, OPTIONAL, INTENT(OUT) :: order 
    207243      LOGICAL(KIND=C_BOOL) :: order_tmp 
     244      LOGICAL, OPTIONAL, INTENT(OUT) :: quantity 
     245      LOGICAL(KIND=C_BOOL) :: quantity_tmp 
    208246      LOGICAL, OPTIONAL, INTENT(OUT) :: renormalize 
    209247      LOGICAL(KIND=C_BOOL) :: renormalize_tmp 
     
    214252 
    215253      CALL xios(is_defined_interpolate_domain_attr_hdl_)  & 
    216       ( interpolate_domain_hdl, mode, order, renormalize, weight_filename, write_weight ) 
     254      ( interpolate_domain_hdl, mode, order, quantity, renormalize, weight_filename, write_weight  & 
     255       ) 
    217256 
    218257  END SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl) 
    219258 
    220259  SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl_)   & 
    221     ( interpolate_domain_hdl, mode_, order_, renormalize_, weight_filename_, write_weight_ ) 
     260    ( interpolate_domain_hdl, mode_, order_, quantity_, renormalize_, weight_filename_, write_weight_  & 
     261     ) 
    222262 
    223263    IMPLICIT NONE 
     
    227267      LOGICAL, OPTIONAL, INTENT(OUT) :: order_ 
    228268      LOGICAL(KIND=C_BOOL) :: order__tmp 
     269      LOGICAL, OPTIONAL, INTENT(OUT) :: quantity_ 
     270      LOGICAL(KIND=C_BOOL) :: quantity__tmp 
    229271      LOGICAL, OPTIONAL, INTENT(OUT) :: renormalize_ 
    230272      LOGICAL(KIND=C_BOOL) :: renormalize__tmp 
     
    246288      ENDIF 
    247289 
     290      IF (PRESENT(quantity_)) THEN 
     291        quantity__tmp = cxios_is_defined_interpolate_domain_quantity & 
     292      (interpolate_domain_hdl%daddr) 
     293        quantity_ = quantity__tmp 
     294      ENDIF 
     295 
    248296      IF (PRESENT(renormalize_)) THEN 
    249297        renormalize__tmp = cxios_is_defined_interpolate_domain_renormalize & 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/interpolate_domain_interface_attr.F90

    r1158 r1201  
    4848      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl 
    4949    END FUNCTION cxios_is_defined_interpolate_domain_order 
     50 
     51 
     52    SUBROUTINE cxios_set_interpolate_domain_quantity(interpolate_domain_hdl, quantity) BIND(C) 
     53      USE ISO_C_BINDING 
     54      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl 
     55      LOGICAL (KIND=C_BOOL)      , VALUE :: quantity 
     56    END SUBROUTINE cxios_set_interpolate_domain_quantity 
     57 
     58    SUBROUTINE cxios_get_interpolate_domain_quantity(interpolate_domain_hdl, quantity) BIND(C) 
     59      USE ISO_C_BINDING 
     60      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl 
     61      LOGICAL (KIND=C_BOOL)             :: quantity 
     62    END SUBROUTINE cxios_get_interpolate_domain_quantity 
     63 
     64    FUNCTION cxios_is_defined_interpolate_domain_quantity(interpolate_domain_hdl) BIND(C) 
     65      USE ISO_C_BINDING 
     66      LOGICAL(kind=C_BOOL) :: cxios_is_defined_interpolate_domain_quantity 
     67      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl 
     68    END FUNCTION cxios_is_defined_interpolate_domain_quantity 
    5069 
    5170 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/izoom_axis_attr.F90

    r966 r1201  
    1212 
    1313  SUBROUTINE xios(set_zoom_axis_attr)  & 
    14     ( zoom_axis_id, begin, n ) 
     14    ( zoom_axis_id, begin, index, n ) 
    1515 
    1616    IMPLICIT NONE 
     
    1818      CHARACTER(LEN=*), INTENT(IN) ::zoom_axis_id 
    1919      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
     20      INTEGER  , OPTIONAL, INTENT(IN) :: index(:) 
    2021      INTEGER  , OPTIONAL, INTENT(IN) :: n 
    2122 
     
    2324      (zoom_axis_id,zoom_axis_hdl) 
    2425      CALL xios(set_zoom_axis_attr_hdl_)   & 
    25       ( zoom_axis_hdl, begin, n ) 
     26      ( zoom_axis_hdl, begin, index, n ) 
    2627 
    2728  END SUBROUTINE xios(set_zoom_axis_attr) 
    2829 
    2930  SUBROUTINE xios(set_zoom_axis_attr_hdl)  & 
    30     ( zoom_axis_hdl, begin, n ) 
     31    ( zoom_axis_hdl, begin, index, n ) 
    3132 
    3233    IMPLICIT NONE 
    3334      TYPE(txios(zoom_axis)) , INTENT(IN) :: zoom_axis_hdl 
    3435      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
     36      INTEGER  , OPTIONAL, INTENT(IN) :: index(:) 
    3537      INTEGER  , OPTIONAL, INTENT(IN) :: n 
    3638 
    3739      CALL xios(set_zoom_axis_attr_hdl_)  & 
    38       ( zoom_axis_hdl, begin, n ) 
     40      ( zoom_axis_hdl, begin, index, n ) 
    3941 
    4042  END SUBROUTINE xios(set_zoom_axis_attr_hdl) 
    4143 
    4244  SUBROUTINE xios(set_zoom_axis_attr_hdl_)   & 
    43     ( zoom_axis_hdl, begin_, n_ ) 
     45    ( zoom_axis_hdl, begin_, index_, n_ ) 
    4446 
    4547    IMPLICIT NONE 
    4648      TYPE(txios(zoom_axis)) , INTENT(IN) :: zoom_axis_hdl 
    4749      INTEGER  , OPTIONAL, INTENT(IN) :: begin_ 
     50      INTEGER  , OPTIONAL, INTENT(IN) :: index_(:) 
    4851      INTEGER  , OPTIONAL, INTENT(IN) :: n_ 
    4952 
     
    5154        CALL cxios_set_zoom_axis_begin & 
    5255      (zoom_axis_hdl%daddr, begin_) 
     56      ENDIF 
     57 
     58      IF (PRESENT(index_)) THEN 
     59        CALL cxios_set_zoom_axis_index & 
     60      (zoom_axis_hdl%daddr, index_, SHAPE(index_)) 
    5361      ENDIF 
    5462 
     
    6169 
    6270  SUBROUTINE xios(get_zoom_axis_attr)  & 
    63     ( zoom_axis_id, begin, n ) 
     71    ( zoom_axis_id, begin, index, n ) 
    6472 
    6573    IMPLICIT NONE 
     
    6775      CHARACTER(LEN=*), INTENT(IN) ::zoom_axis_id 
    6876      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
     77      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:) 
    6978      INTEGER  , OPTIONAL, INTENT(OUT) :: n 
    7079 
     
    7281      (zoom_axis_id,zoom_axis_hdl) 
    7382      CALL xios(get_zoom_axis_attr_hdl_)   & 
    74       ( zoom_axis_hdl, begin, n ) 
     83      ( zoom_axis_hdl, begin, index, n ) 
    7584 
    7685  END SUBROUTINE xios(get_zoom_axis_attr) 
    7786 
    7887  SUBROUTINE xios(get_zoom_axis_attr_hdl)  & 
    79     ( zoom_axis_hdl, begin, n ) 
     88    ( zoom_axis_hdl, begin, index, n ) 
    8089 
    8190    IMPLICIT NONE 
    8291      TYPE(txios(zoom_axis)) , INTENT(IN) :: zoom_axis_hdl 
    8392      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
     93      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:) 
    8494      INTEGER  , OPTIONAL, INTENT(OUT) :: n 
    8595 
    8696      CALL xios(get_zoom_axis_attr_hdl_)  & 
    87       ( zoom_axis_hdl, begin, n ) 
     97      ( zoom_axis_hdl, begin, index, n ) 
    8898 
    8999  END SUBROUTINE xios(get_zoom_axis_attr_hdl) 
    90100 
    91101  SUBROUTINE xios(get_zoom_axis_attr_hdl_)   & 
    92     ( zoom_axis_hdl, begin_, n_ ) 
     102    ( zoom_axis_hdl, begin_, index_, n_ ) 
    93103 
    94104    IMPLICIT NONE 
    95105      TYPE(txios(zoom_axis)) , INTENT(IN) :: zoom_axis_hdl 
    96106      INTEGER  , OPTIONAL, INTENT(OUT) :: begin_ 
     107      INTEGER  , OPTIONAL, INTENT(OUT) :: index_(:) 
    97108      INTEGER  , OPTIONAL, INTENT(OUT) :: n_ 
    98109 
     
    100111        CALL cxios_get_zoom_axis_begin & 
    101112      (zoom_axis_hdl%daddr, begin_) 
     113      ENDIF 
     114 
     115      IF (PRESENT(index_)) THEN 
     116        CALL cxios_get_zoom_axis_index & 
     117      (zoom_axis_hdl%daddr, index_, SHAPE(index_)) 
    102118      ENDIF 
    103119 
     
    110126 
    111127  SUBROUTINE xios(is_defined_zoom_axis_attr)  & 
    112     ( zoom_axis_id, begin, n ) 
     128    ( zoom_axis_id, begin, index, n ) 
    113129 
    114130    IMPLICIT NONE 
     
    117133      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
    118134      LOGICAL(KIND=C_BOOL) :: begin_tmp 
     135      LOGICAL, OPTIONAL, INTENT(OUT) :: index 
     136      LOGICAL(KIND=C_BOOL) :: index_tmp 
    119137      LOGICAL, OPTIONAL, INTENT(OUT) :: n 
    120138      LOGICAL(KIND=C_BOOL) :: n_tmp 
     
    123141      (zoom_axis_id,zoom_axis_hdl) 
    124142      CALL xios(is_defined_zoom_axis_attr_hdl_)   & 
    125       ( zoom_axis_hdl, begin, n ) 
     143      ( zoom_axis_hdl, begin, index, n ) 
    126144 
    127145  END SUBROUTINE xios(is_defined_zoom_axis_attr) 
    128146 
    129147  SUBROUTINE xios(is_defined_zoom_axis_attr_hdl)  & 
    130     ( zoom_axis_hdl, begin, n ) 
     148    ( zoom_axis_hdl, begin, index, n ) 
    131149 
    132150    IMPLICIT NONE 
     
    134152      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
    135153      LOGICAL(KIND=C_BOOL) :: begin_tmp 
     154      LOGICAL, OPTIONAL, INTENT(OUT) :: index 
     155      LOGICAL(KIND=C_BOOL) :: index_tmp 
    136156      LOGICAL, OPTIONAL, INTENT(OUT) :: n 
    137157      LOGICAL(KIND=C_BOOL) :: n_tmp 
    138158 
    139159      CALL xios(is_defined_zoom_axis_attr_hdl_)  & 
    140       ( zoom_axis_hdl, begin, n ) 
     160      ( zoom_axis_hdl, begin, index, n ) 
    141161 
    142162  END SUBROUTINE xios(is_defined_zoom_axis_attr_hdl) 
    143163 
    144164  SUBROUTINE xios(is_defined_zoom_axis_attr_hdl_)   & 
    145     ( zoom_axis_hdl, begin_, n_ ) 
     165    ( zoom_axis_hdl, begin_, index_, n_ ) 
    146166 
    147167    IMPLICIT NONE 
     
    149169      LOGICAL, OPTIONAL, INTENT(OUT) :: begin_ 
    150170      LOGICAL(KIND=C_BOOL) :: begin__tmp 
     171      LOGICAL, OPTIONAL, INTENT(OUT) :: index_ 
     172      LOGICAL(KIND=C_BOOL) :: index__tmp 
    151173      LOGICAL, OPTIONAL, INTENT(OUT) :: n_ 
    152174      LOGICAL(KIND=C_BOOL) :: n__tmp 
     
    156178      (zoom_axis_hdl%daddr) 
    157179        begin_ = begin__tmp 
     180      ENDIF 
     181 
     182      IF (PRESENT(index_)) THEN 
     183        index__tmp = cxios_is_defined_zoom_axis_index & 
     184      (zoom_axis_hdl%daddr) 
     185        index_ = index__tmp 
    158186      ENDIF 
    159187 
  • XIOS/dev/dev_olga/src/interface/fortran_attr/zoom_axis_interface_attr.F90

    r787 r1201  
    2929 
    3030 
     31    SUBROUTINE cxios_set_zoom_axis_index(zoom_axis_hdl, index, extent) BIND(C) 
     32      USE ISO_C_BINDING 
     33      INTEGER (kind = C_INTPTR_T), VALUE       :: zoom_axis_hdl 
     34      INTEGER (KIND=C_INT)     , DIMENSION(*) :: index 
     35      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     36    END SUBROUTINE cxios_set_zoom_axis_index 
     37 
     38    SUBROUTINE cxios_get_zoom_axis_index(zoom_axis_hdl, index, extent) BIND(C) 
     39      USE ISO_C_BINDING 
     40      INTEGER (kind = C_INTPTR_T), VALUE       :: zoom_axis_hdl 
     41      INTEGER (KIND=C_INT)     , DIMENSION(*) :: index 
     42      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     43    END SUBROUTINE cxios_get_zoom_axis_index 
     44 
     45    FUNCTION cxios_is_defined_zoom_axis_index(zoom_axis_hdl) BIND(C) 
     46      USE ISO_C_BINDING 
     47      LOGICAL(kind=C_BOOL) :: cxios_is_defined_zoom_axis_index 
     48      INTEGER (kind = C_INTPTR_T), VALUE :: zoom_axis_hdl 
     49    END FUNCTION cxios_is_defined_zoom_axis_index 
     50 
     51 
    3152    SUBROUTINE cxios_set_zoom_axis_n(zoom_axis_hdl, n) BIND(C) 
    3253      USE ISO_C_BINDING 
  • XIOS/dev/dev_olga/src/io/nc4_data_input.cpp

    r1158 r1201  
    318318      if (SuperClassWriter::hasVariable(boundsLatName) || SuperClassWriter::hasVariable(boundsLonName))  
    319319        domain->nvertex.setValue(nbVertex); 
     320 
    320321      std::vector<StdSize> nBeginBndsLatLon(3), nSizeBndsLatLon(3); 
    321322      nBeginBndsLatLon[0] = 0; nSizeBndsLatLon[0] = domain->nj_glo.getValue(); 
  • XIOS/dev/dev_olga/src/io/onetcdf4.cpp

    r1158 r1201  
    536536       
    537537      template <> 
     538 
    538539      void CONetCDF4::writeData_(int grpid, int varid, 
    539540                                 const std::vector<StdSize>& sstart, 
  • XIOS/dev/dev_olga/src/node/axis.hpp

    r1158 r1201  
    123123        int zoom_begin_srv, zoom_end_srv, zoom_size_srv; 
    124124        int ni_srv, begin_srv, end_srv; 
     125        int global_zoom_begin_srv, global_zoom_end_srv, global_zoom_size_srv; 
    125126        CArray<double,1> value_srv; 
    126127        CArray<double,2> bound_srv; 
    127128        CArray<StdString,1> label_srv; 
     129        CArray<int,1> zoom_index_srv; 
    128130        bool hasValue; 
    129131        CArray<int,1> globalDimGrid; 
     
    144146         void computeConnectedServer(const std::vector<int>& globalDim, int orderPositionInGrid, 
    145147                                     CServerDistributionDescription::ServerDistributionType distType); 
     148         bool zoomByIndex(); 
    146149 
    147150         void sendNonDistributedAttributes(void); 
  • XIOS/dev/dev_olga/src/node/calendar_wrapper.cpp

    r1158 r1201  
    77namespace xios { 
    88 
    9   /// ////////////////////// Dfinitions ////////////////////// /// 
     9  /// ////////////////////// Définitions ////////////////////// /// 
    1010 
    1111  CCalendarWrapper::CCalendarWrapper(void) 
  • XIOS/dev/dev_olga/src/node/context.cpp

    r1194 r1201  
    291291   void CContext::setClientServerBuffer(CContextClient* contextClient) 
    292292   { 
    293      size_t minBufferSize = CXios::minBufferSize; 
     293      // Estimated minimum event size for small events (10 is an arbitrary constant just for safety) 
     294      const size_t minEventSize = CEventClient::headerSize + getIdServer().size() + 10 * sizeof(int); 
     295 
     296      // Ensure there is at least some room for 20 of such events in the buffers 
     297      size_t minBufferSize = std::max(CXios::minBufferSize, 20 * minEventSize); 
     298 
    294299#define DECLARE_NODE(Name_, name_)    \ 
    295300     if (minBufferSize < sizeof(C##Name_##Definition)) minBufferSize = sizeof(C##Name_##Definition); 
     
    299304#undef DECLARE_NODE_PAR 
    300305 
     306     // Compute the buffer sizes needed to send the attributes and data corresponding to fields 
    301307     std::map<int, StdSize> maxEventSize; 
    302308     std::map<int, StdSize> bufferSize = getAttributesBufferSize(maxEventSize, contextClient); 
     
    307313       if (it->second > bufferSize[it->first]) bufferSize[it->first] = it->second; 
    308314 
     315     // Apply the buffer size factor and check that we are above the minimum buffer size 
    309316     ite = bufferSize.end(); 
    310317     for (it = bufferSize.begin(); it != ite; ++it) 
     
    314321     } 
    315322 
    316      // We consider that the minimum buffer size is also the minimum event size 
    317      ite = maxEventSize.end(); 
    318      for (it = maxEventSize.begin(); it != ite; ++it) 
    319        if (it->second < minBufferSize) it->second = minBufferSize; 
    320  
     323     // Leaders will have to send some control events so ensure there is some room for those in the buffers 
    321324     if (contextClient->isServerLeader()) 
    322325     { 
    323326       const std::list<int>& ranks = contextClient->getRanksServerLeader(); 
    324327       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    325          if (!bufferSize.count(*itRank)) bufferSize[*itRank] = maxEventSize[*itRank] = minBufferSize; 
     328       { 
     329         if (!bufferSize.count(*itRank)) 
     330         { 
     331           bufferSize[*itRank] = minBufferSize; 
     332           maxEventSize[*itRank] = minEventSize; 
     333         } 
     334       } 
    326335     } 
    327336     contextClient->setBufferSize(bufferSize, maxEventSize); 
  • XIOS/dev/dev_olga/src/node/domain.cpp

    r1173 r1201  
    24632463    } 
    24642464     
     2465    i_index.resize(nbIndGlob); 
     2466    j_index.resize(nbIndGlob); 
     2467 
    24652468    globalLocalIndexMap_.rehash(std::ceil(nbIndGlob/globalLocalIndexMap_.max_load_factor())); 
    2466     i_index.resize(nbIndGlob); 
    2467     j_index.resize(nbIndGlob);     
    24682469    nbIndGlob = 0; 
    24692470    for (i = 0; i < nbReceived; ++i) 
     
    24732474      { 
    24742475         index = tmp(ind); 
    2475          if (0 == globalLocalIndexMap_.count(index)) 
    2476          { 
    2477            i_index(nbIndGlob) = index % ni_glo; 
    2478            j_index(nbIndGlob) = index / ni_glo; 
    2479            globalLocalIndexMap_[index] = nbIndGlob;   
    2480            ++nbIndGlob; 
    2481          }  
     2476         i_index(nbIndGlob) = index % ni_glo; 
     2477         j_index(nbIndGlob) = index / ni_glo; 
     2478         globalLocalIndexMap_[index] = nbIndGlob;   
     2479         ++nbIndGlob; 
    24822480      }  
    24832481    }  
    2484  
    2485     i_index.resizeAndPreserve(nbIndGlob); 
    2486     j_index.resizeAndPreserve(nbIndGlob); 
    24872482  } 
    24882483 
     
    26352630  void CDomain::recvMask(std::map<int, CBufferIn*>& rankBuffers) 
    26362631  { 
    2637     int nbReceived = rankBuffers.size(), i, ind, index, lInd; 
     2632    int nbReceived = rankBuffers.size(), i, ind, index; 
    26382633    if (nbReceived != recvClientRanks_.size()) 
    2639       ERROR("void CDomain::recvMask(std::map<int, CBufferIn*>& rankBuffers)", 
     2634      ERROR("void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers)", 
    26402635           << "The number of sending clients is not correct." 
    26412636           << "Expected number: " << recvClientRanks_.size() << " but received " << nbReceived); 
     
    26552650    } 
    26562651   
    2657     if (nbMaskInd != globalLocalIndexMap_.size()) 
    2658       info (0) << "If the domain " << this->getDomainOutputName() <<" does not have overlapped region between processes." 
    2659                << "Something shouble be wrong with mask index "<< std::endl; 
    2660  
    2661     nbMaskInd = globalLocalIndexMap_.size(); 
    26622652    mask_1d.resize(nbMaskInd); 
    2663      
     2653    nbMaskInd = 0; 
    26642654    for (i = 0; i < nbReceived; ++i) 
    26652655    { 
    2666       CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]]; 
    26672656      CArray<bool,1>& tmp = recvMaskValue[i]; 
    26682657      for (ind = 0; ind < tmp.numElements(); ++ind) 
    26692658      { 
    2670         lInd = globalLocalIndexMap_[size_t(tmpInd(ind))]; 
    2671         mask_1d(lInd) = tmp(ind); 
     2659        mask_1d(nbMaskInd) = tmp(ind);       
     2660        ++nbMaskInd; 
    26722661      } 
    26732662    }     
     
    27282717     
    27292718      if (nbLonInd != globalLocalIndexMap_.size()) 
    2730         info (0) << "If the domain " << this->getDomainOutputName() <<" does not have overlapped region between processes." 
    2731                  << "Something shouble be wrong with longitude index "<< std::endl; 
    2732  
    2733       nbLonInd = globalLocalIndexMap_.size(); 
     2719        info (0) << "Something wrong with longitude index "<< std::endl; 
     2720 
    27342721      lonvalue.resize(nbLonInd); 
    27352722      if (hasBounds) 
     
    28122799     
    28132800      if (nbLatInd != globalLocalIndexMap_.size()) 
    2814         info (0) << "If the domain " << this->getDomainOutputName() <<" does not have overlapped region between processes." 
    2815                 << "Something shouble be wrong with latitude index "<< std::endl; 
    2816  
    2817       nbLatInd = globalLocalIndexMap_.size(); 
     2801        info (0) << "Something wrong with latitude index "<< std::endl; 
     2802 
    28182803      latvalue.resize(nbLatInd); 
    28192804      if (hasBounds) 
     
    28852870    } 
    28862871 
     2872    int nbAreaInd = 0; 
     2873    for (i = 0; i < nbReceived; ++i) 
     2874    {       
     2875      nbAreaInd += recvAreaValue[i].numElements(); 
     2876    } 
     2877   
     2878    if (nbAreaInd != globalLocalIndexMap_.size()) 
     2879      info (0) << "Something wrong with latitude index "<< std::endl; 
     2880 
    28872881    if (hasArea) 
    28882882    { 
    2889       int nbAreaInd = 0; 
    2890       for (i = 0; i < nbReceived; ++i) 
    2891       {       
    2892         nbAreaInd += recvAreaValue[i].numElements(); 
    2893       } 
    2894  
    2895       if (nbAreaInd != globalLocalIndexMap_.size()) 
    2896         info (0) << "If the domain " << this->getDomainOutputName() <<" does not have overlapped region between processes." 
    2897                  << "Something shouble be wrong with area index "<< std::endl; 
    2898  
    2899       nbAreaInd = globalLocalIndexMap_.size(); 
    29002883      areavalue.resize(nbAreaInd); 
    29012884      nbAreaInd = 0;       
     
    30052988      { 
    30062989         lInd = globalLocalIndexMap_[size_t(tmpInd(ind))]; 
    3007          dataIIndex(lInd) = (-1 == dataIIndex(lInd)) ? tmpI(ind) : dataIIndex(lInd); // Only fill in dataIndex if there is no data 
    3008          dataJIndex(lInd) = (-1 == dataJIndex(lInd)) ? tmpJ(ind) : dataJIndex(lInd);          
     2990         dataIIndex(lInd) = tmpI(ind); 
     2991         dataJIndex(lInd) = tmpJ(ind);          
    30092992      }  
    30102993    } 
  • XIOS/dev/dev_olga/src/node/field.cpp

    r1166 r1201  
    131131 
    132132    CContext* context = CContext::getCurrent(); 
    133       CContextClient* client = (!context->hasServer) ? context->client : this->file->getContextClient(); 
    134  
    135       CEventClient event(getType(), EVENT_ID_UPDATE_DATA); 
    136  
    137       map<int, CArray<int,1> >::iterator it; 
    138       list<CMessage> list_msg; 
    139       list<CArray<double,1> > list_data; 
    140  
    141       if (!grid->doGridHaveDataDistributed()) 
     133    CContextClient* client = (!context->hasServer) ? context->client : this->file->getContextClient(); 
     134 
     135    CEventClient event(getType(), EVENT_ID_UPDATE_DATA); 
     136 
     137    map<int, CArray<int,1> >::iterator it; 
     138    list<CMessage> list_msg; 
     139    list<CArray<double,1> > list_data; 
     140 
     141    if (!grid->doGridHaveDataDistributed()) 
     142    { 
     143       if (client->isServerLeader()) 
     144       { 
     145          for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++) 
     146          { 
     147            int rank = it->first; 
     148            CArray<int,1>& index = it->second; 
     149 
     150            list_msg.push_back(CMessage()); 
     151            list_data.push_back(CArray<double,1>(index.numElements())); 
     152 
     153            CArray<double,1>& data_tmp = list_data.back(); 
     154            for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n)); 
     155 
     156            list_msg.back() << getId() << data_tmp; 
     157            event.push(rank, 1, list_msg.back()); 
     158          } 
     159          client->sendEvent(event); 
     160        } 
     161      else client->sendEvent(event); 
     162    } 
     163    else 
     164    { 
     165      for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++) 
    142166      { 
    143          if (client->isServerLeader()) 
    144          { 
    145             for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++) 
    146             { 
    147               int rank = it->first; 
    148               CArray<int,1>& index = it->second; 
    149  
    150               list_msg.push_back(CMessage()); 
    151               list_data.push_back(CArray<double,1>(index.numElements())); 
    152  
    153               CArray<double,1>& data_tmp = list_data.back(); 
    154               for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n)); 
    155  
    156               list_msg.back() << getId() << data_tmp; 
    157               event.push(rank, 1, list_msg.back()); 
    158             } 
    159             client->sendEvent(event); 
    160          } 
    161          else client->sendEvent(event); 
    162       } 
    163       else 
    164       { 
    165         for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++) 
    166         { 
    167           int rank = it->first; 
    168           CArray<int,1>& index = it->second; 
    169  
    170           list_msg.push_back(CMessage()); 
    171           list_data.push_back(CArray<double,1>(index.numElements())); 
    172  
    173           CArray<double,1>& data_tmp = list_data.back(); 
    174           for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n)); 
    175  
    176           list_msg.back() << getId() << data_tmp; 
    177           event.push(rank, grid->nbSenders[0][rank], list_msg.back()); 
    178         } 
    179         client->sendEvent(event); 
    180       }     
     167        int rank = it->first; 
     168        CArray<int,1>& index = it->second; 
     169 
     170        list_msg.push_back(CMessage()); 
     171        list_data.push_back(CArray<double,1>(index.numElements())); 
     172 
     173        CArray<double,1>& data_tmp = list_data.back(); 
     174        for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n)); 
     175 
     176        list_msg.back() << getId() << data_tmp; 
     177        event.push(rank, grid->nbSenders[0][rank], list_msg.back()); 
     178      } 
     179      client->sendEvent(event); 
     180    } 
    181181 
    182182    CTimer::get("Field : send data").suspend(); 
     
    276276  { 
    277277    CContext* context = CContext::getCurrent(); 
     278//    CContextClient* client = context->client; 
    278279    CContextClient* client = (!context->hasServer) ? context->client : this->file->getContextClient(); 
    279  
    280280 
    281281    lastDataRequestedFromServer = tsDataRequested; 
     
    336336    CContext* context = CContext::getCurrent(); 
    337337    CContextClient* client = context->client; 
     338//    CContextClient* client = (!context->hasServer) ? context->client : this->file->getContextClient(); 
    338339 
    339340    CEventClient event(getType(), EVENT_ID_READ_DATA_READY); 
     
    854855   {      
    855856    if (!isReferenceSolvedAndTransformed) solveAllEnabledFieldsAndTransform(); 
     857 
     858     const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     859     const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
     860 
    856861     CContext* context = CContext::getCurrent(); 
    857862     bool hasWriterServer = context->hasServer && !context->hasClient; 
     
    906911             if (grid && grid != gridRef && grid->hasTransform()) 
    907912             { 
    908                bool hasMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    909                double defaultValue  = hasMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
    910                std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, hasMissingValue, defaultValue); 
     913                 std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, detectMissingValues, defaultValue);  
    911914 
    912915               filter->connectOutput(filters.first, 0); 
     
    924927           instantDataFilter = serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, 
    925928                                                                                                       freq_offset.isEmpty() ? NoneDu : freq_offset, 
    926                                                                                                        true)); 
     929                                                                                                       true, 
     930                                                                                                       detectMissingValues, defaultValue)); 
    927931         else // The data might be passed from the model 
    928932         { 
    929             bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    930             double defaultValue  = ignoreMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
     933            if (check_if_active.isEmpty()) check_if_active = false;  
    931934            instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, NoneDu, false, 
    932                                                                                                         ignoreMissingValue, defaultValue)); 
     935                                                                                                        detectMissingValues, defaultValue)); 
    933936         } 
    934937       } 
     
    937940       if (enableOutput && !storeFilter && !fileWriterFilter) 
    938941       { 
    939          if (!read_access.isEmpty() && read_access) 
    940          { 
    941            storeFilter = boost::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid)); 
    942            instantDataFilter->connectOutput(storeFilter, 0); 
    943          } 
    944  
    945          if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write)) 
    946          { 
    947            fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this)); 
    948            getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0); 
    949          } 
     942         storeFilter = boost::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid, 
     943                                                                        detectMissingValues, defaultValue)); 
     944         instantDataFilter->connectOutput(storeFilter, 0); 
     945       } 
     946 
     947       if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write)) 
     948       { 
     949         fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this)); 
     950         getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0); 
    950951       } 
    951952     } 
     
    10011002     if (!selfReferenceFilter) 
    10021003     { 
     1004       const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     1005       const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
     1006 
    10031007       if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read) 
    10041008       { 
     
    10061010           serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, 
    10071011                                                                                   freq_offset.isEmpty() ? NoneDu : freq_offset, 
    1008                                                                                    true)); 
     1012                                                                                   true, 
     1013                                                                                   detectMissingValues, defaultValue)); 
     1014 
    10091015         selfReferenceFilter = serverSourceFilter; 
    10101016       } 
     
    10191025         if (!clientSourceFilter) 
    10201026         { 
    1021            bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    1022            double defaultValue  = ignoreMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);  
     1027           if (check_if_active.isEmpty()) check_if_active = false; 
    10231028           clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, NoneDu, false, 
    1024                                                                                    ignoreMissingValue, defaultValue)); 
     1029                                                                                   detectMissingValues, defaultValue)); 
    10251030         } 
    10261031 
     
    10561061         freq_offset.setValue(NoneDu); 
    10571062 
    1058        const bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    1059  
     1063       const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     1064        
    10601065       boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
    10611066                                                                             CContext::getCurrent()->getCalendar()->getInitDate(), 
    10621067                                                                             freq_op, freq_offset, outFreq, 
    1063                                                                              ignoreMissingValue, ignoreMissingValue ? default_value : 0.0)); 
     1068                                                                             detectMissingValues, detectMissingValues ? default_value : 0.0)); 
    10641069       instantDataFilter->connectOutput(temporalFilter, 0); 
    10651070 
     
    10961101       if (freq_offset.isEmpty()) freq_offset.setValue(NoneDu); 
    10971102 
    1098        const bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     1103       const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    10991104 
    11001105       boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
    11011106                                                                             CContext::getCurrent()->getCalendar()->getInitDate(), 
    11021107                                                                             freq_op, freq_offset, outFreq, 
    1103                                                                              ignoreMissingValue, ignoreMissingValue ? default_value : 0.0)); 
     1108                                                                             detectMissingValues, detectMissingValues ? default_value : 0.0)); 
    11041109       selfReferenceFilter->connectOutput(temporalFilter, 0); 
    11051110       return temporalFilter ; 
  • XIOS/dev/dev_olga/src/node/field_impl.hpp

    r1021 r1201  
    1919  { 
    2020    if (clientSourceFilter) 
    21       clientSourceFilter->streamData(CContext::getCurrent()->getCalendar()->getCurrentDate(), _data); 
     21    { 
     22      if (check_if_active.isEmpty() || (!check_if_active.isEmpty() && (!check_if_active) || isActive(true))) 
     23        clientSourceFilter->streamData(CContext::getCurrent()->getCalendar()->getCurrentDate(), _data); 
     24    } 
    2225    else if (instantDataFilter) 
    2326      ERROR("void CField::setData(const CArray<double, N>& _data)", 
  • XIOS/dev/dev_olga/src/node/file.cpp

    r1158 r1201  
    425425         if (!split_freq.isEmpty()) 
    426426         { 
    427            CDate splitEnd = lastSplit + split_freq - 1 * Second; 
     427           CDate split_start ; 
     428           CDate splitEnd ; 
     429           if (!split_start_offset.isEmpty()) split_start=lastSplit + split_start_offset ; 
     430           else split_start=lastSplit ; 
     431 
     432           splitEnd = lastSplit + split_freq ; 
     433           if (!split_last_date.isEmpty()) 
     434           { 
     435             CDate splitLastDate=CDate::FromString(split_last_date,*CContext::getCurrent()->getCalendar()) ; 
     436             if( splitLastDate < splitEnd)  splitEnd=splitLastDate ; 
     437           } 
     438             
     439           if (!split_end_offset.isEmpty()) splitEnd = splitEnd + split_end_offset; 
     440           else splitEnd = splitEnd - 1 * Second; 
    428441 
    429442           string splitFormat; 
     
    440453 
    441454           oss << firstPart ; 
    442            if (hasStartDate) oss << lastSplit.getStr(splitFormat) ; 
     455           if (hasStartDate) oss << split_start.getStr(splitFormat) ; 
    443456           oss << middlePart ; 
    444457           if (hasEndDate) oss << splitEnd.getStr(splitFormat); 
  • XIOS/dev/dev_olga/src/node/grid.cpp

    r1178 r1201  
    287287     nbSrvPools = 1;   
    288288     for (int p = 0; p < nbSrvPools; ++p) 
    289      {     
    290        if (context->hasClient && this->isChecked && doSendingIndex && !isIndexSent)  
    291        {  
    292          if (isScalarGrid()) 
    293            sendIndexScalarGrid(); 
    294          else 
    295            sendIndex(); 
    296          this->isIndexSent = true;  
     289     {        
     290       if (isScalarGrid()) 
     291       {   
     292          if (context->hasClient) 
     293            if (this->isChecked && doSendingIndex && !isIndexSent) { sendIndexScalarGrid(); this->isIndexSent = true; } 
     294 
     295          if (this->isChecked) continue; 
     296   
     297          if (context->hasClient) 
     298          { 
     299            this->computeIndexScalarGrid(); 
     300          } 
     301   
     302         if (!(this->hasTransform() && !this->isTransformed())) 
     303          this->isChecked = true; 
     304         continue; 
    297305       } 
    298306 
    299        // Not sure about this 
    300        //if (!(this->hasTransform() && !this->isTransformed())) 
    301        // this->isChecked = true; 
    302        //return; 
     307       if (context->hasClient) 
     308       { 
     309         if (this->isChecked && doSendingIndex && !isIndexSent) 
     310            {sendIndex(); this->isIndexSent = true;} 
     311       } 
    303312     } 
    304313     
     
    537546      if (computedWrittenIndex_) return; 
    538547      computedWrittenIndex_ = true; 
    539  
    540       if (isScalarGrid()) 
    541       { 
    542         size_t nbWritten = 1; 
    543         int writtenIndex = 0; 
    544  
    545         localIndexToWriteOnClient.resize(nbWritten);   
    546         localIndexToWriteOnServer.resize(nbWritten); 
    547         localIndexToWriteOnServer(0) = writtenIndex; 
    548         localIndexToWriteOnClient(0) = writtenIndex; 
    549          
    550         return; 
    551       } 
    552548 
    553549      size_t nbWritten = 0, indGlo; 
     
    750746   { 
    751747     CContext* context = CContext::getCurrent(); 
    752      if (isScalarGrid()) 
     748     computeClientIndex(); 
     749     if (context->hasClient) 
    753750     { 
    754        computeClientIndexScalarGrid(); 
    755        if (context->hasClient) 
    756        { 
    757          computeConnectedClientsScalarGrid(); 
    758        } 
    759      } 
    760      else 
    761      { 
    762        computeClientIndex(); 
    763        if (context->hasClient) 
    764        { 
    765          computeConnectedClients(); 
    766        } 
     751       computeConnectedClients(); 
    767752     } 
    768753   } 
     
    11861171   } 
    11871172 
    1188   void CGrid::computeClientIndexScalarGrid() 
    1189   { 
    1190     CContext* context = CContext::getCurrent();     
    1191     int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 1) : 1; // This should be changed soon 
    1192     for (int p = 0; p < nbSrvPools; ++p) 
    1193     { 
    1194       CContextClient* client = (context->hasServer) ? (context->hasClient ? context->clientPrimServer[p] : context->client)  
    1195                                                     : context->client; 
    1196  
    1197       storeIndex_client.resize(1); 
    1198       storeIndex_client(0) = 0;       
    1199  
    1200       if (0 != serverDistribution_) 
    1201       { 
    1202         map<int, CArray<size_t, 1> >::iterator itb = outGlobalIndexFromClient.begin(), 
    1203                                                ite = outGlobalIndexFromClient.end(), it; 
    1204         for (it = itb; it != ite; ++it) 
    1205         { 
    1206           int rank = it->first; 
    1207           CArray<size_t,1>& globalIndex = outGlobalIndexFromClient[rank]; 
    1208           outLocalIndexStoreOnClient.insert(make_pair(rank, CArray<size_t,1>(globalIndex.numElements()))); 
    1209           CArray<size_t,1>& localIndex = outLocalIndexStoreOnClient[rank]; 
    1210           if (1 != globalIndex.numElements()) 
    1211             ERROR("void CGrid::computeClientIndexScalarGrid()", 
    1212               << "Something wrong happened. " 
    1213               << "Number of received global index on scalar grid should equal to 1"  
    1214               << "Number of received global index " << globalIndex.numElements() << "."); 
    1215  
    1216           localIndex(0) = globalIndex(0); 
    1217         } 
    1218       } 
    1219     } 
    1220   } 
    1221  
    1222   void CGrid::computeConnectedClientsScalarGrid() 
     1173  void CGrid::computeIndexScalarGrid() 
    12231174  { 
    12241175    CContext* context = CContext::getCurrent();     
     
    12301181    for (int p = 0; p < nbSrvPools; ++p) 
    12311182    { 
    1232       CContextClient* client = (context->hasServer) ? (context->hasClient ? context->clientPrimServer[p] : context->client)  
    1233                                                     : context->client; 
     1183      CContextClient* client = context->hasServer ? context->clientPrimServer[p] : context->client; 
     1184 
     1185      storeIndex_client.resize(1); 
     1186      storeIndex_client(0) = 0; 
    12341187 
    12351188      connectedServerRank_[p].clear(); 
    12361189 
    1237       if (client->isServerLeader()) 
    1238       { 
    1239         const std::list<int>& ranks = client->getRanksServerLeader(); 
    1240         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1241         { 
    1242           int rank = *itRank; 
    1243           int nb = 1; 
     1190      if (0 == client->clientRank) 
     1191      { 
     1192        for (int rank = 0; rank < client->serverSize; ++rank) 
     1193        { 
    12441194          connectedServerRank_[p].push_back(rank); 
    1245           connectedDataSize_[p][rank] = nb; 
    1246           nbSenders[p][rank] = nb; 
    1247         } 
    1248       } 
    1249       else 
    1250       { 
    1251         const std::list<int>& ranks = client->getRanksServerNotLeader(); 
    1252         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1253         { 
    1254           int rank = *itRank; 
    1255           int nb = 1; 
    1256           connectedServerRank_[p].push_back(rank); 
    1257           connectedDataSize_[p][rank] = nb; 
    1258           nbSenders[p][rank] = nb; 
    1259         }         
    1260       } 
    1261  
     1195          connectedDataSize_[p][rank] = 1; 
     1196          nbSenders[p][rank] = 1; 
     1197        } 
     1198      } 
    12621199      isDataDistributed_ = false; 
    12631200    } 
  • XIOS/dev/dev_olga/src/node/grid.hpp

    r1178 r1201  
    278278        void computeClientIndex(); 
    279279        void computeConnectedClients(); 
    280         void computeClientIndexScalarGrid(); 
    281         void computeConnectedClientsScalarGrid();         
    282280 
    283281      private: 
  • XIOS/dev/dev_olga/src/node/zoom_axis.cpp

    r836 r1201  
    4646    axisGlobalSize   = axisDest->n_glo.getValue(); 
    4747 
    48     begin = (this->begin.isEmpty()) ?  0 : this->begin.getValue(); 
    49     n     = (this->n.isEmpty()) ?  axisGlobalSize : this->n.getValue(); 
    50     end   = begin+n-1; 
     48    bool zoomByIndex = !this->index.isEmpty() && (0 != this->index.numElements()); 
     49 
     50    if (zoomByIndex) 
     51    { 
     52      begin = min(this->index); 
     53      end   = max(this->index); 
     54      n     = end - begin + 1; 
     55    } 
     56    else 
     57    { 
     58      begin = (this->begin.isEmpty()) ?  0 : this->begin.getValue(); 
     59      n     = (this->n.isEmpty()) ?  axisGlobalSize : this->n.getValue(); 
     60      end   = begin+n-1; 
     61    } 
    5162 
    5263    if (begin < 0 || begin > axisGlobalSize - 1 || end < 0 || end > axisGlobalSize - 1 
     
    5566            << "One or more attributes among 'begin' (" << begin << "), 'end' (" << end << "), 'n' (" << n << ") " 
    5667            << "of axis transformation [ id = '" << axisDest->getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified"); 
     68     
     69    if (zoomByIndex && (!this->begin.isEmpty() || !this->n.isEmpty())) 
     70      ERROR("CZoomAxis::checkValid(CAxis* axisDest)", 
     71            << "Only one type of zoom is accepted. Define zoom by index with global_zoom_index or define zoom with begin and n. " 
     72            << "Axis transformation [ id = '" << axisDest->getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified"); 
    5773 
    5874    this->begin.setValue(begin); 
  • XIOS/dev/dev_olga/src/server.cpp

    r1184 r1201  
    484484         } 
    485485 
    486 //         for(int i=1;i<size;i++) 
    487 //         { 
    488 //            MPI_Isend(buff,count,MPI_CHAR,i,2,intraComm,&requests[i-1]) ; 
    489 //         } 
    490 //         MPI_Waitall(size-1,requests,status) ; 
    491 //         registerContext(buff,count,it->second.leaderRank) ; 
    492  
    493486         recvContextId.erase(it) ; 
    494487         delete [] requests ; 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_zoom.hpp

    r1144 r1201  
    4848  StdSize zoomSize_; 
    4949 
     50  std::vector<int> zoomIndex_; 
     51 
    5052private: 
    5153 
  • XIOS/dev/dev_olga/src/transformation/generic_algorithm_transformation.cpp

    r1173 r1201  
    4949    } 
    5050 
     51    // If all data source are nan then data destination must be nan 
    5152    for (int idx = 0; idx < nbLocalIndex; ++idx) 
    5253    { 
Note: See TracChangeset for help on using the changeset viewer.