Changeset 286


Ignore:
Timestamp:
10/21/11 19:01:35 (11 years ago)
Author:
ymipsl
Message:

reprise en main de la version de H. Ozdoba. Correction de différentes erreurs de conception et bug.
Version NEMO operationnel en client/server, interoperabilita avec OASIS, reconstition de fichiers via netcdf4/HDF5

YM

Location:
XMLIO_V2/dev/common/src/xmlio
Files:
15 added
9 deleted
63 edited

Legend:

Unmodified
Added
Removed
  • XMLIO_V2/dev/common/src/xmlio/buffer.hpp

    r219 r286  
    4242 
    4343            StdSize getNextDataPosition(StdSize position); 
    44  
     44            static inline StdSize getDataHeaderSize(void) { return sizeof(CBufferDataType) + 2 * sizeof(StdSize) + sizeof(bool) ; } 
    4545         //-------------------------------------------------------------- 
    4646 
  • XMLIO_V2/dev/common/src/xmlio/buffer_impl.hpp

    r274 r286  
    8282         if (this->size < (position + this->getRequestedSize(data))) 
    8383            ERROR("CBuffer::setDataArray<T>(data, size, position)", 
    84                    << " Buffer size <  size + position !"); 
     84                   << " Buffer size <  size + position !  :  "<<this->size<<" < "<<this->getRequestedSize(data)<<" + "<<position); 
    8585         CBufferData bufdata; 
    8686         bufdata.type     = this->getBufferDataType<T>(); 
  • XMLIO_V2/dev/common/src/xmlio/buffer_list.cpp

    r219 r286  
    66   { 
    77      /// ////////////////////// Définitions ////////////////////// /// 
    8       CBufferList::CBufferList(MPIComm com_client_server) 
     8      CBufferList::CBufferList(MPI_Comm com_client_server) 
    99         : SuperClass(CMPIManager::GetCommSize(com_client_server) - 1) 
    1010         , com_client_server(com_client_server) 
  • XMLIO_V2/dev/common/src/xmlio/buffer_list.hpp

    r219 r286  
    2525 
    2626            /// Construteurs /// 
    27             CBufferList(MPIComm com_client_server = CMPIManager::GetCommWorld()); 
     27            CBufferList(MPI_Comm com_client_server = CMPIManager::GetCommWorld()); 
    2828            CBufferList(const CBufferList & buffer_list);         // Not implemented yet. 
    2929            CBufferList(const CBufferList * const buffer_list);   // Not implemented yet. 
     
    4545         private : 
    4646 
    47             MPIComm com_client_server; 
     47            MPI_Comm com_client_server; 
    4848            StdSize nbbuffer; 
    4949 
  • XMLIO_V2/dev/common/src/xmlio/buffer_pair.cpp

    r268 r286  
    88   { 
    99      /// ////////////////////// Définitions ////////////////////// /// 
    10       CBufferPair::CBufferPair(MPIComm com_client_server) 
     10      CBufferPair::CBufferPair(MPI_Comm com_client_server) 
    1111         : com_client_server(com_client_server)  
    1212         , first(BUFFER_CLIENT_SIZE), second(BUFFER_CLIENT_SIZE) 
  • XMLIO_V2/dev/common/src/xmlio/buffer_pair.hpp

    r268 r286  
    2323 
    2424            /// Construteurs /// 
    25             CBufferPair(MPIComm com_client_server = CMPIManager::GetCommWorld()); 
     25            CBufferPair(MPI_Comm com_client_server = CMPIManager::GetCommWorld()); 
    2626            CBufferPair(const CBufferPair & buffer_pair);       // Not implemented yet. 
    2727            CBufferPair(const CBufferPair * const buffer_pair); // Not implemented yet. 
     
    5252 
    5353            /// Propriétés privées /// 
    54             MPIComm com_client_server; 
     54            MPI_Comm com_client_server; 
    5555            CLinearBuffer first, second; 
    5656            MPI_Request first_request, second_request; 
  • XMLIO_V2/dev/common/src/xmlio/calendar.cpp

    r266 r286  
    5454      CDate & CCalendar::update(int step) 
    5555      {  
    56          std::cout << "step : " << step << std::endl; 
     56         std::cout << "step : " << step <<" timestep "<<this->timestep << std::endl; 
     57//         std::cout << "date before : " << this->getCurrentDate() <<" date after "<<this->getInitDate() + step * this->timestep << std::endl; 
    5758         return (this->getCurrentDate() = this->getInitDate() + step * this->timestep); 
    5859      } 
  • XMLIO_V2/dev/common/src/xmlio/client.cpp

    r278 r286  
    88   /// ////////////////////// Définitions ////////////////////// /// 
    99    
    10    CClient::CClient(MPIComm comm_client_server) 
     10   CClient::CClient(MPI_Comm comm_client_server) 
    1111      : bpair(comm_client_server) 
    1212   {  
     
    2525   ///-------------------------------------------------------------- 
    2626 
    27    boost::shared_ptr<CClient> CClient::CreateClient(MPIComm comm_client_server) 
     27   boost::shared_ptr<CClient> CClient::CreateClient(MPI_Comm comm_client_server) 
    2828   { 
    2929      if (CClient::Client.get() == NULL) 
     
    6767      // Pas d'argument à ajouter. 
    6868      this->bpair.sendCurrentBuffer(); 
    69       comm::CMPIManager::Barrier(); 
     69      comm::CMPIManager::Barrier(CMPIManager::GetCommClientServer()); 
    7070   } 
    7171    
     
    8585   void CClient::updateCalendar(long int timestep) 
    8686   { 
    87       this->bpair.prepareRequest(1, 1, &timestep, 
     87       this->bpair.prepareRequest(1, 1, &timestep, 
    8888                                       CLinearBuffer::NULL_ARG, 
    8989                                       CLinearBuffer::NULL_ARG, 
  • XMLIO_V2/dev/common/src/xmlio/client.hpp

    r278 r286  
    1818      public : 
    1919 
    20          static boost::shared_ptr<CClient> CreateClient(MPIComm comm_client_server); 
     20         static boost::shared_ptr<CClient> CreateClient(MPI_Comm comm_client_server); 
    2121         static boost::shared_ptr<CClient> GetClient(void); 
    2222                 
     
    5050 
    5151         /// Constructeurs /// 
    52          CClient(MPIComm comm_client_server); 
     52         CClient(MPI_Comm comm_client_server); 
    5353       
    5454         /// Propriété privée /// 
  • XMLIO_V2/dev/common/src/xmlio/config/file_attribute.conf

    r266 r286  
    88 
    99DECLARE_ATTRIBUTE(bool,      enabled) 
     10DECLARE_ATTRIBUTE(StdString,      type) 
    1011 
    1112// DECLARE_ATTRIBUTE_DEF(bool, enabled, true) 
  • XMLIO_V2/dev/common/src/xmlio/config/properties.conf

    r219 r286  
    99 
    1010/// Output config /// 
    11 DECLARE_PROPERTY  (StdString, NETCDF_OUTPUT,  "MULTI_FILE") // (ONE_FILE, TWO_FILE, MULTI_FILE) 
     11//DECLARE_PROPERTY  (StdString, NETCDF_OUTPUT,  "MULTI_FILE") // (ONE_FILE, TWO_FILE, MULTI_FILE) 
     12DECLARE_PROPERTY  (StdString, NETCDF_OUTPUT,  "ONE_FILE") // (ONE_FILE, TWO_FILE, MULTI_FILE) 
    1213DECLARE_PROPERTY  (StdString, FILE_SUFFIX,    "_node"   ) 
    1314DECLARE_PROPERTY  (StdString, FILE_EXTENSION, ".nc"     ) 
     
    1819 
    1920/// Buffer Size /// 
    20 DECLARE_PROPERTY (StdSize, BUFFER_CLIENT_SIZE,  1E6) // 1 Mo 
    21 DECLARE_PROPERTY (StdSize, BUFFER_SERVER_SIZE, 10E6) // 10 Mo 
     21DECLARE_PROPERTY (StdSize, BUFFER_CLIENT_SIZE,  100E6) // 100 Mo 
     22DECLARE_PROPERTY (StdSize, BUFFER_SERVER_SIZE, 1000E6) // 1000 Mo 
    2223 
    2324 
  • XMLIO_V2/dev/common/src/xmlio/data_output.cpp

    r274 r286  
    4242      { 
    4343         this->writeFile_(file); 
     44      } 
     45 
     46      void CDataOutput::closeFile(void) 
     47      { 
     48         this->closeFile_(); 
    4449      } 
    4550 
     
    9297            CObjectFactory::GetObject<CDomain>(grid->domain_ref.getValue()); 
    9398             
    94          if (domain->isEmpty()) return; 
     99//         if (domain->isEmpty()) return; 
    95100         this->writeFieldData_(field); 
    96101      } 
  • XMLIO_V2/dev/common/src/xmlio/data_output.hpp

    r219 r286  
    2525            /// Ecriture /// 
    2626            void writeFile     (const boost::shared_ptr<tree::CFile>  file); 
     27            void closeFile     (void); 
    2728            void writeField    (const boost::shared_ptr<tree::CField> field); 
    2829            void writeFieldGrid(const boost::shared_ptr<tree::CField> field); 
     
    4344 
    4445            virtual void writeFile_       (const boost::shared_ptr<tree::CFile>     file)   = 0; 
     46            virtual void closeFile_       (void)                                            = 0; 
    4547            virtual void writeField_      (const boost::shared_ptr<tree::CField>    field)  = 0; 
    4648            virtual void writeFieldData_  (const boost::shared_ptr<tree::CField>    field)  = 0; 
  • XMLIO_V2/dev/common/src/xmlio/data_treatment.cpp

    r278 r286  
    5151         this->currentContext->getCalendar()->setTimeStep(duration); 
    5252         this->currentContext->timestep.setValue(duration.toString()); 
    53          std::cout << "timestep :" << duration << std::endl; 
    5453         if (CXIOSManager::GetStatus() == CXIOSManager::LOC_CLIENT) 
    5554         { // Mise à jour cÃŽté serveur 
     
    5958      } 
    6059 
     60      void CDataTreatment::finalize(void) 
     61      { 
     62         // Mise à jour cÃŽté client 
     63         if (CXIOSManager::GetStatus() == CXIOSManager::LOC_CLIENT) 
     64         { // Mise à jour cÃŽté serveur 
     65            boost::shared_ptr<comm::CClient> client = comm::CClient::GetClient(); 
     66            client->finalize(); 
     67         } 
     68         else closeAllFile() ; 
     69      } 
     70 
     71      void CDataTreatment::closeAllFile(void ) 
     72      { 
     73         std::vector<boost::shared_ptr<CFile> >::const_iterator 
     74            it = this->enabledFiles.begin(), end = this->enabledFiles.end(); 
     75          
     76         for (; it != end; it++) 
     77         { 
     78            (*it)->close(); 
     79         } 
     80      } 
    6181      //---------------------------------------------------------------- 
    6282       
     
    7797            boost::shared_ptr<CField> field = *it; 
    7898            boost::shared_ptr<CFile>  file  = field->getRelFile(); 
     99             
    79100            if (file->getId().compare(fileId) == 0) 
    80101            { 
  • XMLIO_V2/dev/common/src/xmlio/data_treatment.hpp

    r278 r286  
    1010#include "client.hpp" 
    1111#include "xios_manager.hpp" 
     12#include <mpi.h> 
    1213 
    1314namespace xmlioserver 
     
    4546            void update_calendar(int step); 
    4647            void set_timestep(const date::CDuration & duration); 
     48            void finalize(void) ; 
     49             
     50            /// Création des sorties /// 
     51            template <class T> void createDataOutput(MPI_Comm comm_server = CXIOSManager::Comm_Server); 
    4752 
    48             /// Création des sorties /// 
    49             template <class T> void createDataOutput(comm::MPIComm comm_server = CXIOSManager::Comm_Server); 
    50  
     53            
    5154            /// Destructeur /// 
    5255            ~CDataTreatment(void); 
     
    5659            /// Traitements /// 
    5760            void doTreatment(void); 
     61            void closeAllFile(void ) ; 
    5862 
    5963            void findAllEnabledFields(void); 
     
    6670            boost::shared_ptr<CContext> currentContext; 
    6771            std::vector<boost::shared_ptr<CFile> > enabledFiles; 
    68  
     72      
    6973      }; // CDataTreatment 
    7074 
     
    7276 
    7377      template <class T> 
    74          void CDataTreatment::createDataOutput(comm::MPIComm comm_server ) 
     78         void CDataTreatment::createDataOutput(MPI_Comm comm_server ) 
    7579      { 
    7680         std::vector<boost::shared_ptr<CFile> >::const_iterator 
     
    9094            if (!file->name_suffix.isEmpty()) 
    9195                oss << file->name_suffix.getValue(); 
    92             if (comm::CMPIManager::GetCommSize(comm_server) > 1) 
    93                      oss << "." << comm::CMPIManager::GetCommRank(comm_server); 
    94                  oss << ".nc"; 
    95             boost::shared_ptr<io::CDataOutput> dout(new T(oss.str(), false)); 
     96 
     97            bool multifile=true ; 
     98            if (!file->type.isEmpty()) 
     99            { 
     100              StdString str=file->type.getValue() ;  
     101              if (str.compare("one_file")==0) multifile=false ; 
     102              else if (str.compare("multi_file")==0) multifile=true ; 
     103              else ERROR("void CDataTreatment::createDataOutput(MPI_Comm comm_server)", 
     104                         "incorrect file <type> attribut : must be <multi_file> or <one_file>, " 
     105                        <<"having : <"<<str<<">") ; 
     106            }  
     107            if (multifile)  
     108            { 
     109              if (comm::CMPIManager::GetCommSize(comm_server) > 1) 
     110                       oss << "_" << comm::CMPIManager::GetCommRank(comm_server); 
     111            } 
     112            oss << ".nc"; 
     113 
     114            boost::shared_ptr<io::CDataOutput> dout(new T(oss.str(), false,comm_server,multifile)); 
    96115            file->initializeDataOutput(dout); 
    97116         } 
     
    135154               {  
    136155                   boost::shared_ptr<comm::CClient> client = comm::CClient::GetClient(); 
    137                    client->sendData(fieldId, file->getId(), field->getData()); 
     156//                   std::cout<<"--> sendData :: fieldId : "<<fieldId<<", fileId : "<<file->getId()<<std::endl ; 
     157//                   client->sendData(fieldId, file->getId(), field->getData()); 
     158                   client->sendData(field->getId(), file->getId(), field->getData()); 
    138159               } 
    139160               else 
  • XMLIO_V2/dev/common/src/xmlio/fortran/axis_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55      
    6       SUBROUTINE xios_set_axis_name(axis_hdl, name, name_size) BIND(C) 
     6      SUBROUTINE cxios_set_axis_name(axis_hdl, name, name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER  (kind = C_INTPTR_T), VALUE        :: axis_hdl 
    99         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    1010         INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_axis_name 
     11      END SUBROUTINE cxios_set_axis_name 
    1212 
    13       SUBROUTINE xios_set_axis_standard_name(axis_hdl, standard_name, standard_name_size) BIND(C) 
     13      SUBROUTINE cxios_set_axis_standard_name(axis_hdl, standard_name, standard_name_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER  (kind = C_INTPTR_T), VALUE        :: axis_hdl 
    1616         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    1717         INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE xios_set_axis_standard_name 
     18      END SUBROUTINE cxios_set_axis_standard_name 
    1919 
    20       SUBROUTINE xios_set_axis_long_name(axis_hdl, long_name, long_name_size) BIND(C) 
     20      SUBROUTINE cxios_set_axis_long_name(axis_hdl, long_name, long_name_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER  (kind = C_INTPTR_T), VALUE       :: axis_hdl 
    2323         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name 
    2424         INTEGER  (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE xios_set_axis_long_name 
     25      END SUBROUTINE cxios_set_axis_long_name 
    2626 
    27       SUBROUTINE xios_set_axis_unit(axis_hdl, unit, unit_size) BIND(C) 
     27      SUBROUTINE cxios_set_axis_unit(axis_hdl, unit, unit_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE       :: axis_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: unit_size 
    32       END SUBROUTINE xios_set_axis_unit 
     32      END SUBROUTINE cxios_set_axis_unit 
    3333 
    34       SUBROUTINE xios_set_axis_size(axis_hdl, size) BIND(C) 
     34      SUBROUTINE cxios_set_axis_size(axis_hdl, size) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    3737         INTEGER (kind = C_INT)     , VALUE :: size 
    38       END SUBROUTINE xios_set_axis_size 
     38      END SUBROUTINE cxios_set_axis_size 
    3939 
    40       SUBROUTINE xios_set_axis_zvalue(axis_hdl, zvalue, zvalue_extent1) BIND(C) 
     40      SUBROUTINE cxios_set_axis_zvalue(axis_hdl, zvalue, zvalue_extent1) BIND(C) 
    4141         USE ISO_C_BINDING 
    4242         INTEGER (kind = C_INTPTR_T), VALUE        :: axis_hdl 
    4343         REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: zvalue 
    4444         INTEGER (kind = C_INT)     , VALUE        :: zvalue_extent1 
    45       END SUBROUTINE xios_set_axis_zvalue 
     45      END SUBROUTINE cxios_set_axis_zvalue 
    4646       
    47       SUBROUTINE xios_axis_handle_create(ret, idt, idt_size) BIND(C) 
     47      SUBROUTINE cxios_axis_handle_create(ret, idt, idt_size) BIND(C) 
    4848         USE ISO_C_BINDING 
    4949         INTEGER  (kind = C_INTPTR_T)               :: ret 
    5050         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    5151         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    52       END SUBROUTINE xios_axis_handle_create 
     52      END SUBROUTINE cxios_axis_handle_create 
    5353 
    54       SUBROUTINE xios_axis_valid_id(ret, idt, idt_size) BIND(C) 
     54      SUBROUTINE cxios_axis_valid_id(ret, idt, idt_size) BIND(C) 
    5555         USE ISO_C_BINDING 
    5656         LOGICAL  (kind = C_BOOL)                   :: ret 
    5757         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    5858         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    59       END SUBROUTINE xios_axis_valid_id 
     59      END SUBROUTINE cxios_axis_valid_id 
    6060 
    6161   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/axisgroup_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55      
    6       SUBROUTINE xios_set_axisgroup_name(axisgroup_hdl, name, name_size) BIND(C) 
     6      SUBROUTINE cxios_set_axisgroup_name(axisgroup_hdl, name, name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER  (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    99         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    1010         INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_axisgroup_name 
     11      END SUBROUTINE cxios_set_axisgroup_name 
    1212 
    13       SUBROUTINE xios_set_axisgroup_standard_name(axisgroup_hdl, standard_name, standard_name_size) BIND(C) 
     13      SUBROUTINE cxios_set_axisgroup_standard_name(axisgroup_hdl, standard_name, standard_name_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER  (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    1616         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    1717         INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE xios_set_axisgroup_standard_name 
     18      END SUBROUTINE cxios_set_axisgroup_standard_name 
    1919 
    20       SUBROUTINE xios_set_axisgroup_long_name(axisgroup_hdl, long_name, long_name_size) BIND(C) 
     20      SUBROUTINE cxios_set_axisgroup_long_name(axisgroup_hdl, long_name, long_name_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER  (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    2323         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name 
    2424         INTEGER  (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE xios_set_axisgroup_long_name 
     25      END SUBROUTINE cxios_set_axisgroup_long_name 
    2626 
    27       SUBROUTINE xios_set_axisgroup_unit(axisgroup_hdl, unit, unit_size) BIND(C) 
     27      SUBROUTINE cxios_set_axisgroup_unit(axisgroup_hdl, unit, unit_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: unit_size 
    32       END SUBROUTINE xios_set_axisgroup_unit 
     32      END SUBROUTINE cxios_set_axisgroup_unit 
    3333 
    34       SUBROUTINE xios_set_axisgroup_size(axisgroup_hdl, size) BIND(C) 
     34      SUBROUTINE cxios_set_axisgroup_size(axisgroup_hdl, size) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    3737         INTEGER (kind = C_INT)     , VALUE :: size 
    38       END SUBROUTINE xios_set_axisgroup_size 
     38      END SUBROUTINE cxios_set_axisgroup_size 
    3939 
    40       SUBROUTINE xios_set_axisgroup_zvalue(axisgroup_hdl, zvalue, zvalue_extent1) BIND(C) 
     40      SUBROUTINE cxios_set_axisgroup_zvalue(axisgroup_hdl, zvalue, zvalue_extent1) BIND(C) 
    4141         USE ISO_C_BINDING 
    4242         INTEGER (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    4343         REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: zvalue 
    4444         INTEGER (kind = C_INT)     , VALUE        :: zvalue_extent1 
    45       END SUBROUTINE xios_set_axisgroup_zvalue 
     45      END SUBROUTINE cxios_set_axisgroup_zvalue 
    4646   
    47       SUBROUTINE xios_axisgroup_handle_create(ret, idt, idt_size) BIND(C) 
     47      SUBROUTINE cxios_axisgroup_handle_create(ret, idt, idt_size) BIND(C) 
    4848         USE ISO_C_BINDING 
    4949         INTEGER  (kind = C_INTPTR_T)               :: ret 
    5050         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    5151         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    52       END SUBROUTINE xios_axisgroup_handle_create 
     52      END SUBROUTINE cxios_axisgroup_handle_create 
    5353 
    54       SUBROUTINE xios_axisgroup_valid_id(ret, idt, idt_size) BIND(C) 
     54      SUBROUTINE cxios_axisgroup_valid_id(ret, idt, idt_size) BIND(C) 
    5555         USE ISO_C_BINDING 
    5656         LOGICAL  (kind = C_BOOL)                   :: ret 
    5757         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    5858         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    59       END SUBROUTINE xios_axisgroup_valid_id 
     59      END SUBROUTINE cxios_axisgroup_valid_id 
    6060 
    6161   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/context_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55      
    6       SUBROUTINE xios_set_context_calendar_type(context_hdl, calendar_type ,calendar_type_size) BIND(C) 
     6      SUBROUTINE cxios_set_context_calendar_type(context_hdl, calendar_type ,calendar_type_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER  (kind = C_INTPTR_T), VALUE        :: context_hdl 
    99         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: calendar_type 
    1010         INTEGER  (kind = C_INT)     , VALUE        :: calendar_type_size 
    11       END SUBROUTINE xios_set_context_calendar_type 
     11      END SUBROUTINE cxios_set_context_calendar_type 
    1212 
    13       SUBROUTINE xios_set_context_start_date(context_hdl, start_date ,start_date_size) BIND(C) 
     13      SUBROUTINE cxios_set_context_start_date(context_hdl, start_date ,start_date_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER  (kind = C_INTPTR_T), VALUE        :: context_hdl 
    1616         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: start_date 
    1717         INTEGER  (kind = C_INT)     , VALUE        :: start_date_size 
    18       END SUBROUTINE xios_set_context_start_date 
     18      END SUBROUTINE cxios_set_context_start_date 
    1919 
    20       SUBROUTINE xios_set_context_output_dir(context_hdl, output_dir ,output_dir_size) BIND(C) 
     20      SUBROUTINE cxios_set_context_output_dir(context_hdl, output_dir ,output_dir_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER  (kind = C_INTPTR_T), VALUE        :: context_hdl 
    2323         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: output_dir 
    2424         INTEGER  (kind = C_INT)     , VALUE        :: output_dir_size 
    25       END SUBROUTINE xios_set_context_output_dir 
     25      END SUBROUTINE cxios_set_context_output_dir 
    2626       
    27       SUBROUTINE xios_context_handle_create(ret, idt, idt_size) BIND(C) 
     27      SUBROUTINE cxios_context_handle_create(ret, idt, idt_size) BIND(C) 
    2828         import C_CHAR, C_INTPTR_T, C_INT 
    2929         INTEGER  (kind = C_INTPTR_T)               :: ret 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    32       END SUBROUTINE xios_context_handle_create 
     32      END SUBROUTINE cxios_context_handle_create 
    3333       
    34       SUBROUTINE xios_context_set_current(context, withswap) BIND(C) 
     34      SUBROUTINE cxios_context_set_current(context, withswap) BIND(C) 
    3535         import C_BOOL, C_INT, C_INTPTR_T 
    3636         INTEGER (kind = C_INTPTR_T), VALUE :: context 
    3737         LOGICAL (kind = C_BOOL)    , VALUE :: withswap 
    38       END SUBROUTINE xios_context_set_current 
     38      END SUBROUTINE cxios_context_set_current 
    3939 
    40       SUBROUTINE xios_context_create(context, context_id, context_id_size, calendar_type, & 
     40      SUBROUTINE cxios_context_create(context, context_id, context_id_size, calendar_type, & 
    4141                                     year, month, day, hour, minute, second) BIND(C) 
    4242         USE ISO_C_BINDING 
     
    4545         INTEGER  (kind = C_INT)     , VALUE        :: context_id_size 
    4646         INTEGER  (kind = C_INT)     , VALUE        :: calendar_type, year, month, day, hour, minute, second 
    47       END SUBROUTINE xios_context_create 
     47      END SUBROUTINE cxios_context_create 
    4848 
    49       SUBROUTINE xios_context_valid_id(ret, idt, idt_size) BIND(C) 
     49      SUBROUTINE cxios_context_valid_id(ret, idt, idt_size) BIND(C) 
    5050         USE ISO_C_BINDING 
    5151         LOGICAL  (kind = C_BOOL)                   :: ret 
    5252         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    5353         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    54       END SUBROUTINE xios_context_valid_id 
     54      END SUBROUTINE cxios_context_valid_id 
    5555 
    5656   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/domain_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55        
    6       SUBROUTINE xios_set_domain_name(domain_hdl, name, name_size) BIND(C) 
     6      SUBROUTINE cxios_set_domain_name(domain_hdl, name, name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER  (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    99         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    1010         INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_domain_name 
    12  
    13       SUBROUTINE xios_set_domain_standard_name(domain_hdl, standard_name, standard_name_size) BIND(C) 
     11      END SUBROUTINE cxios_set_domain_name 
     12 
     13      SUBROUTINE cxios_set_domain_standard_name(domain_hdl, standard_name, standard_name_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER  (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    1616         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    1717         INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE xios_set_domain_standard_name 
    19  
    20       SUBROUTINE xios_set_domain_long_name(domain_hdl, long_name, long_name_size) BIND(C) 
     18      END SUBROUTINE cxios_set_domain_standard_name 
     19 
     20      SUBROUTINE cxios_set_domain_long_name(domain_hdl, long_name, long_name_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER  (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    2323         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name 
    2424         INTEGER  (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE xios_set_domain_long_name 
    26  
    27       SUBROUTINE xios_set_domain_domain_group_ref(domain_hdl, domain_group_ref, domain_group_ref_size) BIND(C) 
     25      END SUBROUTINE cxios_set_domain_long_name 
     26 
     27      SUBROUTINE cxios_set_domain_domain_group_ref(domain_hdl, domain_group_ref, domain_group_ref_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: domain_group_ref 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: domain_group_ref_size 
    32       END SUBROUTINE xios_set_domain_domain_group_ref 
    33  
    34       SUBROUTINE xios_set_domain_ni_glo(domain_hdl, ni_glo) BIND(C) 
     32      END SUBROUTINE cxios_set_domain_domain_group_ref 
     33 
     34      SUBROUTINE cxios_set_domain_ni_glo(domain_hdl, ni_glo) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    3737         INTEGER (kind = C_INT)     , VALUE :: ni_glo 
    38       END SUBROUTINE xios_set_domain_ni_glo 
    39  
    40       SUBROUTINE xios_set_domain_nj_glo(domain_hdl, nj_glo) BIND(C) 
     38      END SUBROUTINE cxios_set_domain_ni_glo 
     39 
     40      SUBROUTINE cxios_set_domain_nj_glo(domain_hdl, nj_glo) BIND(C) 
    4141         USE ISO_C_BINDING 
    4242         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    4343         INTEGER (kind = C_INT)     , VALUE :: nj_glo 
    44       END SUBROUTINE xios_set_domain_nj_glo 
    45  
    46       SUBROUTINE xios_set_domain_ibegin(domain_hdl, ibegin) BIND(C) 
     44      END SUBROUTINE cxios_set_domain_nj_glo 
     45 
     46      SUBROUTINE cxios_set_domain_ibegin(domain_hdl, ibegin) BIND(C) 
    4747         USE ISO_C_BINDING 
    4848         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    4949         INTEGER (kind = C_INT)     , VALUE :: ibegin 
    50       END SUBROUTINE xios_set_domain_ibegin 
    51  
    52       SUBROUTINE xios_set_domain_iend(domain_hdl, iend) BIND(C) 
     50      END SUBROUTINE cxios_set_domain_ibegin 
     51 
     52      SUBROUTINE cxios_set_domain_iend(domain_hdl, iend) BIND(C) 
    5353         USE ISO_C_BINDING 
    5454         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    5555         INTEGER (kind = C_INT)     , VALUE :: iend 
    56       END SUBROUTINE xios_set_domain_iend 
    57  
    58       SUBROUTINE xios_set_domain_ni(domain_hdl, ni) BIND(C) 
     56      END SUBROUTINE cxios_set_domain_iend 
     57 
     58      SUBROUTINE cxios_set_domain_ni(domain_hdl, ni) BIND(C) 
    5959         USE ISO_C_BINDING 
    6060         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    6161         INTEGER (kind = C_INT)     , VALUE :: ni 
    62       END SUBROUTINE xios_set_domain_ni 
    63  
    64       SUBROUTINE xios_set_domain_jbegin(domain_hdl, jbegin) BIND(C) 
     62      END SUBROUTINE cxios_set_domain_ni 
     63 
     64      SUBROUTINE cxios_set_domain_jbegin(domain_hdl, jbegin) BIND(C) 
    6565         USE ISO_C_BINDING 
    6666         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    6767         INTEGER (kind = C_INT)     , VALUE :: jbegin 
    68       END SUBROUTINE xios_set_domain_jbegin 
    69  
    70       SUBROUTINE xios_set_domain_jend(domain_hdl, jend) BIND(C) 
     68      END SUBROUTINE cxios_set_domain_jbegin 
     69 
     70      SUBROUTINE cxios_set_domain_jend(domain_hdl, jend) BIND(C) 
    7171         USE ISO_C_BINDING 
    7272         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    7373         INTEGER (kind = C_INT)     , VALUE :: jend 
    74       END SUBROUTINE xios_set_domain_jend 
    75  
    76       SUBROUTINE xios_set_domain_nj(domain_hdl, nj) BIND(C) 
     74      END SUBROUTINE cxios_set_domain_jend 
     75 
     76      SUBROUTINE cxios_set_domain_nj(domain_hdl, nj) BIND(C) 
    7777         USE ISO_C_BINDING 
    7878         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    7979         INTEGER (kind = C_INT)     , VALUE :: nj 
    80       END SUBROUTINE xios_set_domain_nj 
    81  
    82       SUBROUTINE xios_set_domain_mask(domain_hdl, mask, mask_extent1, mask_extent2) BIND(C) 
     80      END SUBROUTINE cxios_set_domain_nj 
     81 
     82      SUBROUTINE cxios_set_domain_mask(domain_hdl, mask, mask_extent1, mask_extent2) BIND(C) 
    8383         USE ISO_C_BINDING 
    8484         INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
     
    8686         INTEGER (kind = C_INT)     , VALUE        :: mask_extent1 
    8787         INTEGER (kind = C_INT)     , VALUE        :: mask_extent2 
    88       END SUBROUTINE xios_set_domain_mask 
    89  
    90       SUBROUTINE xios_set_domain_data_dim(domain_hdl, data_dim) BIND(C) 
     88      END SUBROUTINE cxios_set_domain_mask 
     89 
     90      SUBROUTINE cxios_set_domain_data_dim(domain_hdl, data_dim) BIND(C) 
    9191         USE ISO_C_BINDING 
    9292         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    9393         INTEGER (kind = C_INT)     , VALUE :: data_dim 
    94       END SUBROUTINE xios_set_domain_data_dim 
    95  
    96       SUBROUTINE xios_set_domain_data_ni(domain_hdl, data_ni) BIND(C) 
     94      END SUBROUTINE cxios_set_domain_data_dim 
     95 
     96      SUBROUTINE cxios_set_domain_data_ni(domain_hdl, data_ni) BIND(C) 
    9797         USE ISO_C_BINDING 
    9898         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    9999         INTEGER (kind = C_INT)     , VALUE :: data_ni 
    100       END SUBROUTINE xios_set_domain_data_ni 
    101  
    102       SUBROUTINE xios_set_domain_data_nj(domain_hdl, data_nj) BIND(C) 
     100      END SUBROUTINE cxios_set_domain_data_ni 
     101 
     102      SUBROUTINE cxios_set_domain_data_nj(domain_hdl, data_nj) BIND(C) 
    103103         USE ISO_C_BINDING 
    104104         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    105105         INTEGER (kind = C_INT)     , VALUE :: data_nj 
    106       END SUBROUTINE xios_set_domain_data_nj 
    107  
    108       SUBROUTINE xios_set_domain_data_ibegin(domain_hdl, data_ibegin) BIND(C) 
     106      END SUBROUTINE cxios_set_domain_data_nj 
     107 
     108      SUBROUTINE cxios_set_domain_data_ibegin(domain_hdl, data_ibegin) BIND(C) 
    109109         USE ISO_C_BINDING 
    110110         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    111111         INTEGER (kind = C_INT)     , VALUE :: data_ibegin 
    112       END SUBROUTINE xios_set_domain_data_ibegin 
    113  
    114       SUBROUTINE xios_set_domain_data_jbegin(domain_hdl, data_jbegin) BIND(C) 
     112      END SUBROUTINE cxios_set_domain_data_ibegin 
     113 
     114      SUBROUTINE cxios_set_domain_data_jbegin(domain_hdl, data_jbegin) BIND(C) 
    115115         USE ISO_C_BINDING 
    116116         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    117117         INTEGER (kind = C_INT)     , VALUE :: data_jbegin 
    118       END SUBROUTINE xios_set_domain_data_jbegin 
    119  
    120       SUBROUTINE xios_set_domain_zoom_ni(domain_hdl, zoom_ni) BIND(C) 
     118      END SUBROUTINE cxios_set_domain_data_jbegin 
     119 
     120      SUBROUTINE cxios_set_domain_zoom_ni(domain_hdl, zoom_ni) BIND(C) 
    121121         USE ISO_C_BINDING 
    122122         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    123123         INTEGER (kind = C_INT)     , VALUE :: zoom_ni 
    124       END SUBROUTINE xios_set_domain_zoom_ni 
    125  
    126       SUBROUTINE xios_set_domain_zoom_nj(domain_hdl, zoom_nj) BIND(C) 
     124      END SUBROUTINE cxios_set_domain_zoom_ni 
     125 
     126      SUBROUTINE cxios_set_domain_zoom_nj(domain_hdl, zoom_nj) BIND(C) 
    127127         USE ISO_C_BINDING 
    128128         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    129129         INTEGER (kind = C_INT)     , VALUE :: zoom_nj 
    130       END SUBROUTINE xios_set_domain_zoom_nj 
    131  
    132       SUBROUTINE xios_set_domain_zoom_ibegin(domain_hdl, zoom_ibegin) BIND(C) 
     130      END SUBROUTINE cxios_set_domain_zoom_nj 
     131 
     132      SUBROUTINE cxios_set_domain_zoom_ibegin(domain_hdl, zoom_ibegin) BIND(C) 
    133133         USE ISO_C_BINDING 
    134134         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    135135         INTEGER (kind = C_INT)     , VALUE :: zoom_ibegin 
    136       END SUBROUTINE xios_set_domain_zoom_ibegin 
    137  
    138       SUBROUTINE xios_set_domain_zoom_jbegin(domain_hdl, zoom_jbegin) BIND(C) 
     136      END SUBROUTINE cxios_set_domain_zoom_ibegin 
     137 
     138      SUBROUTINE cxios_set_domain_zoom_jbegin(domain_hdl, zoom_jbegin) BIND(C) 
    139139         USE ISO_C_BINDING 
    140140         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    141141         INTEGER (kind = C_INT)     , VALUE :: zoom_jbegin 
    142       END SUBROUTINE xios_set_domain_zoom_jbegin 
    143  
    144       SUBROUTINE xios_set_domain_zoom_ni_loc(domain_hdl, zoom_ni_loc) BIND(C) 
     142      END SUBROUTINE cxios_set_domain_zoom_jbegin 
     143 
     144      SUBROUTINE cxios_set_domain_zoom_ni_loc(domain_hdl, zoom_ni_loc) BIND(C) 
    145145         USE ISO_C_BINDING 
    146146         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    147147         INTEGER (kind = C_INT)     , VALUE :: zoom_ni_loc 
    148       END SUBROUTINE xios_set_domain_zoom_ni_loc 
    149  
    150       SUBROUTINE xios_set_domain_zoom_nj_loc(domain_hdl, zoom_nj_loc) BIND(C) 
     148      END SUBROUTINE cxios_set_domain_zoom_ni_loc 
     149 
     150      SUBROUTINE cxios_set_domain_zoom_nj_loc(domain_hdl, zoom_nj_loc) BIND(C) 
    151151         USE ISO_C_BINDING 
    152152         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    153153         INTEGER (kind = C_INT)     , VALUE :: zoom_nj_loc 
    154       END SUBROUTINE xios_set_domain_zoom_nj_loc 
    155  
    156       SUBROUTINE xios_set_domain_zoom_ibegin_loc(domain_hdl, zoom_ibegin_loc) BIND(C) 
     154      END SUBROUTINE cxios_set_domain_zoom_nj_loc 
     155 
     156      SUBROUTINE cxios_set_domain_zoom_ibegin_loc(domain_hdl, zoom_ibegin_loc) BIND(C) 
    157157         USE ISO_C_BINDING 
    158158         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    159159         INTEGER (kind = C_INT)     , VALUE :: zoom_ibegin_loc 
    160       END SUBROUTINE xios_set_domain_zoom_ibegin_loc 
    161  
    162       SUBROUTINE xios_set_domain_zoom_jbegin_loc(domain_hdl, zoom_jbegin_loc) BIND(C) 
     160      END SUBROUTINE cxios_set_domain_zoom_ibegin_loc 
     161 
     162      SUBROUTINE cxios_set_domain_zoom_jbegin_loc(domain_hdl, zoom_jbegin_loc) BIND(C) 
    163163         USE ISO_C_BINDING 
    164164         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    165165         INTEGER (kind = C_INT)     , VALUE :: zoom_jbegin_loc 
    166       END SUBROUTINE xios_set_domain_zoom_jbegin_loc 
    167  
    168       SUBROUTINE xios_set_domain_data_n_index(domain_hdl, data_n_index) BIND(C) 
     166      END SUBROUTINE cxios_set_domain_zoom_jbegin_loc 
     167 
     168      SUBROUTINE cxios_set_domain_data_n_index(domain_hdl, data_n_index) BIND(C) 
    169169         USE ISO_C_BINDING 
    170170         INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    171171         INTEGER (kind = C_INT)     , VALUE :: data_n_index 
    172       END SUBROUTINE xios_set_domain_data_n_index 
    173  
    174       SUBROUTINE xios_set_domain_data_i_index(domain_hdl, data_i_index, data_i_index_extent1) BIND(C) 
     172      END SUBROUTINE cxios_set_domain_data_n_index 
     173 
     174      SUBROUTINE cxios_set_domain_data_i_index(domain_hdl, data_i_index, data_i_index_extent1) BIND(C) 
    175175         USE ISO_C_BINDING 
    176176         INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    177177         INTEGER (kind = C_INT)     , DIMENSION(*) :: data_i_index 
    178178         INTEGER (kind = C_INT)     , VALUE        :: data_i_index_extent1 
    179       END SUBROUTINE xios_set_domain_data_i_index 
    180  
    181       SUBROUTINE xios_set_domain_data_j_index(domain_hdl, data_j_index, data_j_index_extent1) BIND(C) 
     179      END SUBROUTINE cxios_set_domain_data_i_index 
     180 
     181      SUBROUTINE cxios_set_domain_data_j_index(domain_hdl, data_j_index, data_j_index_extent1) BIND(C) 
    182182         USE ISO_C_BINDING 
    183183         INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    184184         INTEGER (kind = C_INT)     , DIMENSION(*) :: data_j_index 
    185185         INTEGER (kind = C_INT)     , VALUE        :: data_j_index_extent1 
    186       END SUBROUTINE xios_set_domain_data_j_index 
    187  
    188       SUBROUTINE xios_set_domain_lonvalue(domain_hdl, lonvalue, lonvalue_extent1) BIND(C) 
     186      END SUBROUTINE cxios_set_domain_data_j_index 
     187 
     188      SUBROUTINE cxios_set_domain_lonvalue(domain_hdl, lonvalue, lonvalue_extent1) BIND(C) 
    189189         USE ISO_C_BINDING 
    190190         INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    191191         REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: lonvalue 
    192192         INTEGER (kind = C_INT)     , VALUE        :: lonvalue_extent1 
    193       END SUBROUTINE xios_set_domain_lonvalue 
    194  
    195       SUBROUTINE xios_set_domain_latvalue(domain_hdl, latvalue, latvalue_extent1) BIND(C) 
     193      END SUBROUTINE cxios_set_domain_lonvalue 
     194 
     195      SUBROUTINE cxios_set_domain_latvalue(domain_hdl, latvalue, latvalue_extent1) BIND(C) 
    196196         USE ISO_C_BINDING 
    197197         INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    198198         REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: latvalue 
    199199         INTEGER (kind = C_INT)     , VALUE        :: latvalue_extent1 
    200       END SUBROUTINE xios_set_domain_latvalue 
    201         
    202       SUBROUTINE xios_domain_handle_create(ret, idt, idt_size) BIND(C) 
     200      END SUBROUTINE cxios_set_domain_latvalue 
     201        
     202      SUBROUTINE cxios_domain_handle_create(ret, idt, idt_size) BIND(C) 
    203203         USE ISO_C_BINDING 
    204204         INTEGER  (kind = C_INTPTR_T)               :: ret 
    205205         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    206206         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    207       END SUBROUTINE xios_domain_handle_create 
    208  
    209       SUBROUTINE xios_domain_valid_id(ret, idt, idt_size) BIND(C) 
     207      END SUBROUTINE cxios_domain_handle_create 
     208 
     209      SUBROUTINE cxios_domain_valid_id(ret, idt, idt_size) BIND(C) 
    210210         USE ISO_C_BINDING 
    211211         LOGICAL  (kind = C_BOOL)                   :: ret 
    212212         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    213213         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    214       END SUBROUTINE xios_domain_valid_id 
     214      END SUBROUTINE cxios_domain_valid_id 
    215215 
    216216   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/domaingroup_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55        
    6       SUBROUTINE xios_set_domaingroup_name(domaingroup_hdl, name, name_size) BIND(C) 
     6      SUBROUTINE cxios_set_domaingroup_name(domaingroup_hdl, name, name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER  (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    99         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    1010         INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_domaingroup_name 
    12  
    13       SUBROUTINE xios_set_domaingroup_standard_name(domaingroup_hdl, standard_name, standard_name_size) BIND(C) 
     11      END SUBROUTINE cxios_set_domaingroup_name 
     12 
     13      SUBROUTINE cxios_set_domaingroup_standard_name(domaingroup_hdl, standard_name, standard_name_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER  (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    1616         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    1717         INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE xios_set_domaingroup_standard_name 
    19  
    20       SUBROUTINE xios_set_domaingroup_long_name(domaingroup_hdl, long_name, long_name_size) BIND(C) 
     18      END SUBROUTINE cxios_set_domaingroup_standard_name 
     19 
     20      SUBROUTINE cxios_set_domaingroup_long_name(domaingroup_hdl, long_name, long_name_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER  (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    2323         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name 
    2424         INTEGER  (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE xios_set_domaingroup_long_name 
    26  
    27       SUBROUTINE xios_set_domaingroup_domain_group_ref(domaingroup_hdl, domain_group_ref, domain_group_ref_size) BIND(C) 
     25      END SUBROUTINE cxios_set_domaingroup_long_name 
     26 
     27      SUBROUTINE cxios_set_domaingroup_domain_group_ref(domaingroup_hdl, domain_group_ref, domain_group_ref_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: domain_group_ref 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: domain_group_ref_size 
    32       END SUBROUTINE xios_set_domaingroup_domain_group_ref 
    33  
    34       SUBROUTINE xios_set_domaingroup_ni_glo(domaingroup_hdl, ni_glo) BIND(C) 
     32      END SUBROUTINE cxios_set_domaingroup_domain_group_ref 
     33 
     34      SUBROUTINE cxios_set_domaingroup_ni_glo(domaingroup_hdl, ni_glo) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    3737         INTEGER (kind = C_INT)     , VALUE :: ni_glo 
    38       END SUBROUTINE xios_set_domaingroup_ni_glo 
    39  
    40       SUBROUTINE xios_set_domaingroup_nj_glo(domaingroup_hdl, nj_glo) BIND(C) 
     38      END SUBROUTINE cxios_set_domaingroup_ni_glo 
     39 
     40      SUBROUTINE cxios_set_domaingroup_nj_glo(domaingroup_hdl, nj_glo) BIND(C) 
    4141         USE ISO_C_BINDING 
    4242         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    4343         INTEGER (kind = C_INT)     , VALUE :: nj_glo 
    44       END SUBROUTINE xios_set_domaingroup_nj_glo 
    45  
    46       SUBROUTINE xios_set_domaingroup_ibegin(domaingroup_hdl, ibegin) BIND(C) 
     44      END SUBROUTINE cxios_set_domaingroup_nj_glo 
     45 
     46      SUBROUTINE cxios_set_domaingroup_ibegin(domaingroup_hdl, ibegin) BIND(C) 
    4747         USE ISO_C_BINDING 
    4848         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    4949         INTEGER (kind = C_INT)     , VALUE :: ibegin 
    50       END SUBROUTINE xios_set_domaingroup_ibegin 
    51  
    52       SUBROUTINE xios_set_domaingroup_iend(domaingroup_hdl, iend) BIND(C) 
     50      END SUBROUTINE cxios_set_domaingroup_ibegin 
     51 
     52      SUBROUTINE cxios_set_domaingroup_iend(domaingroup_hdl, iend) BIND(C) 
    5353         USE ISO_C_BINDING 
    5454         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    5555         INTEGER (kind = C_INT)     , VALUE :: iend 
    56       END SUBROUTINE xios_set_domaingroup_iend 
    57  
    58       SUBROUTINE xios_set_domaingroup_ni(domaingroup_hdl, ni) BIND(C) 
     56      END SUBROUTINE cxios_set_domaingroup_iend 
     57 
     58      SUBROUTINE cxios_set_domaingroup_ni(domaingroup_hdl, ni) BIND(C) 
    5959         USE ISO_C_BINDING 
    6060         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    6161         INTEGER (kind = C_INT)     , VALUE :: ni 
    62       END SUBROUTINE xios_set_domaingroup_ni 
    63  
    64       SUBROUTINE xios_set_domaingroup_jbegin(domaingroup_hdl, jbegin) BIND(C) 
     62      END SUBROUTINE cxios_set_domaingroup_ni 
     63 
     64      SUBROUTINE cxios_set_domaingroup_jbegin(domaingroup_hdl, jbegin) BIND(C) 
    6565         USE ISO_C_BINDING 
    6666         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    6767         INTEGER (kind = C_INT)     , VALUE :: jbegin 
    68       END SUBROUTINE xios_set_domaingroup_jbegin 
    69  
    70       SUBROUTINE xios_set_domaingroup_jend(domaingroup_hdl, jend) BIND(C) 
     68      END SUBROUTINE cxios_set_domaingroup_jbegin 
     69 
     70      SUBROUTINE cxios_set_domaingroup_jend(domaingroup_hdl, jend) BIND(C) 
    7171         USE ISO_C_BINDING 
    7272         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    7373         INTEGER (kind = C_INT)     , VALUE :: jend 
    74       END SUBROUTINE xios_set_domaingroup_jend 
    75  
    76       SUBROUTINE xios_set_domaingroup_nj(domaingroup_hdl, nj) BIND(C) 
     74      END SUBROUTINE cxios_set_domaingroup_jend 
     75 
     76      SUBROUTINE cxios_set_domaingroup_nj(domaingroup_hdl, nj) BIND(C) 
    7777         USE ISO_C_BINDING 
    7878         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    7979         INTEGER (kind = C_INT)     , VALUE :: nj 
    80       END SUBROUTINE xios_set_domaingroup_nj 
    81  
    82       SUBROUTINE xios_set_domaingroup_mask(domaingroup_hdl, mask, mask_extent1, mask_extent2) BIND(C) 
     80      END SUBROUTINE cxios_set_domaingroup_nj 
     81 
     82      SUBROUTINE cxios_set_domaingroup_mask(domaingroup_hdl, mask, mask_extent1, mask_extent2) BIND(C) 
    8383         USE ISO_C_BINDING 
    8484         INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
     
    8686         INTEGER (kind = C_INT)     , VALUE        :: mask_extent1 
    8787         INTEGER (kind = C_INT)     , VALUE        :: mask_extent2 
    88       END SUBROUTINE xios_set_domaingroup_mask 
    89  
    90       SUBROUTINE xios_set_domaingroup_data_dim(domaingroup_hdl, data_dim) BIND(C) 
     88      END SUBROUTINE cxios_set_domaingroup_mask 
     89 
     90      SUBROUTINE cxios_set_domaingroup_data_dim(domaingroup_hdl, data_dim) BIND(C) 
    9191         USE ISO_C_BINDING 
    9292         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    9393         INTEGER (kind = C_INT)     , VALUE :: data_dim 
    94       END SUBROUTINE xios_set_domaingroup_data_dim 
    95  
    96       SUBROUTINE xios_set_domaingroup_data_ni(domaingroup_hdl, data_ni) BIND(C) 
     94      END SUBROUTINE cxios_set_domaingroup_data_dim 
     95 
     96      SUBROUTINE cxios_set_domaingroup_data_ni(domaingroup_hdl, data_ni) BIND(C) 
    9797         USE ISO_C_BINDING 
    9898         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    9999         INTEGER (kind = C_INT)     , VALUE :: data_ni 
    100       END SUBROUTINE xios_set_domaingroup_data_ni 
    101  
    102       SUBROUTINE xios_set_domaingroup_data_nj(domaingroup_hdl, data_nj) BIND(C) 
     100      END SUBROUTINE cxios_set_domaingroup_data_ni 
     101 
     102      SUBROUTINE cxios_set_domaingroup_data_nj(domaingroup_hdl, data_nj) BIND(C) 
    103103         USE ISO_C_BINDING 
    104104         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    105105         INTEGER (kind = C_INT)     , VALUE :: data_nj 
    106       END SUBROUTINE xios_set_domaingroup_data_nj 
    107  
    108       SUBROUTINE xios_set_domaingroup_data_ibegin(domaingroup_hdl, data_ibegin) BIND(C) 
     106      END SUBROUTINE cxios_set_domaingroup_data_nj 
     107 
     108      SUBROUTINE cxios_set_domaingroup_data_ibegin(domaingroup_hdl, data_ibegin) BIND(C) 
    109109         USE ISO_C_BINDING 
    110110         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    111111         INTEGER (kind = C_INT)     , VALUE :: data_ibegin 
    112       END SUBROUTINE xios_set_domaingroup_data_ibegin 
    113  
    114       SUBROUTINE xios_set_domaingroup_data_jbegin(domaingroup_hdl, data_jbegin) BIND(C) 
     112      END SUBROUTINE cxios_set_domaingroup_data_ibegin 
     113 
     114      SUBROUTINE cxios_set_domaingroup_data_jbegin(domaingroup_hdl, data_jbegin) BIND(C) 
    115115         USE ISO_C_BINDING 
    116116         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    117117         INTEGER (kind = C_INT)     , VALUE  :: data_jbegin 
    118       END SUBROUTINE xios_set_domaingroup_data_jbegin 
    119  
    120       SUBROUTINE xios_set_domaingroup_zoom_ni(domaingroup_hdl, zoom_ni) BIND(C) 
     118      END SUBROUTINE cxios_set_domaingroup_data_jbegin 
     119 
     120      SUBROUTINE cxios_set_domaingroup_zoom_ni(domaingroup_hdl, zoom_ni) BIND(C) 
    121121         USE ISO_C_BINDING 
    122122         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    123123         INTEGER (kind = C_INT)     , VALUE :: zoom_ni 
    124       END SUBROUTINE xios_set_domaingroup_zoom_ni 
    125  
    126       SUBROUTINE xios_set_domaingroup_zoom_nj(domaingroup_hdl, zoom_nj) BIND(C) 
     124      END SUBROUTINE cxios_set_domaingroup_zoom_ni 
     125 
     126      SUBROUTINE cxios_set_domaingroup_zoom_nj(domaingroup_hdl, zoom_nj) BIND(C) 
    127127         USE ISO_C_BINDING 
    128128         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    129129         INTEGER (kind = C_INT)     , VALUE :: zoom_nj 
    130       END SUBROUTINE xios_set_domaingroup_zoom_nj 
    131  
    132       SUBROUTINE xios_set_domaingroup_zoom_ibegin(domaingroup_hdl, zoom_ibegin) BIND(C) 
     130      END SUBROUTINE cxios_set_domaingroup_zoom_nj 
     131 
     132      SUBROUTINE cxios_set_domaingroup_zoom_ibegin(domaingroup_hdl, zoom_ibegin) BIND(C) 
    133133         USE ISO_C_BINDING 
    134134         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    135135         INTEGER (kind = C_INT)     , VALUE :: zoom_ibegin 
    136       END SUBROUTINE xios_set_domaingroup_zoom_ibegin 
    137  
    138       SUBROUTINE xios_set_domaingroup_zoom_jbegin(domaingroup_hdl, zoom_jbegin) BIND(C) 
     136      END SUBROUTINE cxios_set_domaingroup_zoom_ibegin 
     137 
     138      SUBROUTINE cxios_set_domaingroup_zoom_jbegin(domaingroup_hdl, zoom_jbegin) BIND(C) 
    139139         USE ISO_C_BINDING 
    140140         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    141141         INTEGER (kind = C_INT)     , VALUE :: zoom_jbegin 
    142       END SUBROUTINE xios_set_domaingroup_zoom_jbegin 
    143  
    144       SUBROUTINE xios_set_domaingroup_zoom_ni_loc(domaingroup_hdl, zoom_ni_loc) BIND(C) 
     142      END SUBROUTINE cxios_set_domaingroup_zoom_jbegin 
     143 
     144      SUBROUTINE cxios_set_domaingroup_zoom_ni_loc(domaingroup_hdl, zoom_ni_loc) BIND(C) 
    145145         USE ISO_C_BINDING 
    146146         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    147147         INTEGER (kind = C_INT)     , VALUE :: zoom_ni_loc 
    148       END SUBROUTINE xios_set_domaingroup_zoom_ni_loc 
    149  
    150       SUBROUTINE xios_set_domaingroup_zoom_nj_loc(domaingroup_hdl, zoom_nj_loc) BIND(C) 
     148      END SUBROUTINE cxios_set_domaingroup_zoom_ni_loc 
     149 
     150      SUBROUTINE cxios_set_domaingroup_zoom_nj_loc(domaingroup_hdl, zoom_nj_loc) BIND(C) 
    151151         USE ISO_C_BINDING 
    152152         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    153153         INTEGER (kind = C_INT)     , VALUE :: zoom_nj_loc 
    154       END SUBROUTINE xios_set_domaingroup_zoom_nj_loc 
    155  
    156       SUBROUTINE xios_set_domaingroup_zoom_ibegin_loc(domaingroup_hdl, zoom_ibegin_loc) BIND(C) 
     154      END SUBROUTINE cxios_set_domaingroup_zoom_nj_loc 
     155 
     156      SUBROUTINE cxios_set_domaingroup_zoom_ibegin_loc(domaingroup_hdl, zoom_ibegin_loc) BIND(C) 
    157157         USE ISO_C_BINDING 
    158158         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    159159         INTEGER (kind = C_INT)     , VALUE :: zoom_ibegin_loc 
    160       END SUBROUTINE xios_set_domaingroup_zoom_ibegin_loc 
    161  
    162       SUBROUTINE xios_set_domaingroup_zoom_jbegin_loc(domaingroup_hdl, zoom_jbegin_loc) BIND(C) 
     160      END SUBROUTINE cxios_set_domaingroup_zoom_ibegin_loc 
     161 
     162      SUBROUTINE cxios_set_domaingroup_zoom_jbegin_loc(domaingroup_hdl, zoom_jbegin_loc) BIND(C) 
    163163         USE ISO_C_BINDING 
    164164         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    165165         INTEGER (kind = C_INT)     , VALUE :: zoom_jbegin_loc 
    166       END SUBROUTINE xios_set_domaingroup_zoom_jbegin_loc 
    167  
    168       SUBROUTINE xios_set_domaingroup_data_n_index(domaingroup_hdl, data_n_index) BIND(C) 
     166      END SUBROUTINE cxios_set_domaingroup_zoom_jbegin_loc 
     167 
     168      SUBROUTINE cxios_set_domaingroup_data_n_index(domaingroup_hdl, data_n_index) BIND(C) 
    169169         USE ISO_C_BINDING 
    170170         INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    171171         INTEGER (kind = C_INT)     , VALUE :: data_n_index 
    172       END SUBROUTINE xios_set_domaingroup_data_n_index 
    173  
    174       SUBROUTINE xios_set_domaingroup_data_i_index(domaingroup_hdl, data_i_index, data_i_index_extent1) BIND(C) 
     172      END SUBROUTINE cxios_set_domaingroup_data_n_index 
     173 
     174      SUBROUTINE cxios_set_domaingroup_data_i_index(domaingroup_hdl, data_i_index, data_i_index_extent1) BIND(C) 
    175175         USE ISO_C_BINDING 
    176176         INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    177177         INTEGER (kind = C_INT)     , DIMENSION(*) :: data_i_index 
    178178         INTEGER (kind = C_INT)     , VALUE        :: data_i_index_extent1 
    179       END SUBROUTINE xios_set_domaingroup_data_i_index 
    180  
    181       SUBROUTINE xios_set_domaingroup_data_j_index(domaingroup_hdl, data_j_index, data_j_index_extent1) BIND(C) 
     179      END SUBROUTINE cxios_set_domaingroup_data_i_index 
     180 
     181      SUBROUTINE cxios_set_domaingroup_data_j_index(domaingroup_hdl, data_j_index, data_j_index_extent1) BIND(C) 
    182182         USE ISO_C_BINDING 
    183183         INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    184184         INTEGER (kind = C_INT)     , DIMENSION(*) :: data_j_index 
    185185         INTEGER (kind = C_INT)     , VALUE        :: data_j_index_extent1 
    186       END SUBROUTINE xios_set_domaingroup_data_j_index 
    187  
    188       SUBROUTINE xios_set_domaingroup_lonvalue(domaingroup_hdl, lonvalue, lonvalue_extent1) BIND(C) 
     186      END SUBROUTINE cxios_set_domaingroup_data_j_index 
     187 
     188      SUBROUTINE cxios_set_domaingroup_lonvalue(domaingroup_hdl, lonvalue, lonvalue_extent1) BIND(C) 
    189189         USE ISO_C_BINDING 
    190190         INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    191191         REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: lonvalue 
    192192         INTEGER (kind = C_INT)     , VALUE        :: lonvalue_extent1 
    193       END SUBROUTINE xios_set_domaingroup_lonvalue 
    194  
    195       SUBROUTINE xios_set_domaingroup_latvalue(domaingroup_hdl, latvalue, latvalue_extent1) BIND(C) 
     193      END SUBROUTINE cxios_set_domaingroup_lonvalue 
     194 
     195      SUBROUTINE cxios_set_domaingroup_latvalue(domaingroup_hdl, latvalue, latvalue_extent1) BIND(C) 
    196196         USE ISO_C_BINDING 
    197197         INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    198198         REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: latvalue 
    199199         INTEGER (kind = C_INT)     , VALUE        :: latvalue_extent1 
    200       END SUBROUTINE xios_set_domaingroup_latvalue 
     200      END SUBROUTINE cxios_set_domaingroup_latvalue 
    201201       
    202       SUBROUTINE xios_domaingroup_handle_create(ret, idt, idt_size) BIND(C) 
     202      SUBROUTINE cxios_domaingroup_handle_create(ret, idt, idt_size) BIND(C) 
    203203         USE ISO_C_BINDING 
    204204         INTEGER  (kind = C_INTPTR_T)               :: ret 
    205205         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    206206         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    207       END SUBROUTINE xios_domaingroup_handle_create 
    208  
    209       SUBROUTINE xios_domaingroup_valid_id(ret, idt, idt_size) BIND(C) 
     207      END SUBROUTINE cxios_domaingroup_handle_create 
     208 
     209      SUBROUTINE cxios_domaingroup_valid_id(ret, idt, idt_size) BIND(C) 
    210210         USE ISO_C_BINDING 
    211211         LOGICAL  (kind = C_BOOL)                   :: ret 
    212212         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    213213         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    214       END SUBROUTINE xios_domaingroup_valid_id 
     214      END SUBROUTINE cxios_domaingroup_valid_id 
    215215 
    216216   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/field_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55    
    6       SUBROUTINE xios_set_field_name(field_hdl, name ,name_size) BIND(C) 
     6      SUBROUTINE cxios_set_field_name(field_hdl, name ,name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    99         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    1010         INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_field_name 
     11      END SUBROUTINE cxios_set_field_name 
    1212 
    13       SUBROUTINE xios_set_field_standard_name(field_hdl, standard_name ,standard_name_size) BIND(C) 
     13      SUBROUTINE cxios_set_field_standard_name(field_hdl, standard_name ,standard_name_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    1616         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    1717         INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE xios_set_field_standard_name 
     18      END SUBROUTINE cxios_set_field_standard_name 
    1919 
    20       SUBROUTINE xios_set_field_long_name(field_hdl, long_name ,long_name_size) BIND(C) 
     20      SUBROUTINE cxios_set_field_long_name(field_hdl, long_name ,long_name_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER (kind = C_INTPTR_T), VALUE        :: field_hdl 
    2323         CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: long_name 
    2424         INTEGER (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE xios_set_field_long_name 
     25      END SUBROUTINE cxios_set_field_long_name 
    2626 
    27       SUBROUTINE xios_set_field_unit(field_hdl, unit ,unit_size) BIND(C) 
     27      SUBROUTINE cxios_set_field_unit(field_hdl, unit ,unit_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: unit_size 
    32       END SUBROUTINE xios_set_field_unit 
     32      END SUBROUTINE cxios_set_field_unit 
    3333 
    34       SUBROUTINE xios_set_field_operation(field_hdl, operation ,operation_size) BIND(C) 
     34      SUBROUTINE cxios_set_field_operation(field_hdl, operation ,operation_size) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    3737         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: operation 
    3838         INTEGER  (kind = C_INT)     , VALUE        :: operation_size 
    39       END SUBROUTINE xios_set_field_operation 
     39      END SUBROUTINE cxios_set_field_operation 
    4040 
    41       SUBROUTINE xios_set_field_freq_op(field_hdl, freq_op ,freq_op_size) BIND(C) 
     41      SUBROUTINE cxios_set_field_freq_op(field_hdl, freq_op ,freq_op_size) BIND(C) 
    4242         USE ISO_C_BINDING 
    4343         INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    4444         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: freq_op 
    4545         INTEGER  (kind = C_INT)     , VALUE        :: freq_op_size 
    46       END SUBROUTINE xios_set_field_freq_op 
     46      END SUBROUTINE cxios_set_field_freq_op 
    4747 
    48       SUBROUTINE xios_set_field_level(field_hdl, level) BIND(C) 
     48      SUBROUTINE cxios_set_field_level(field_hdl, level) BIND(C) 
    4949         USE ISO_C_BINDING 
    5050         INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
    5151         INTEGER (kind = C_INT)     , VALUE :: level 
    52       END SUBROUTINE xios_set_field_level 
     52      END SUBROUTINE cxios_set_field_level 
    5353 
    54       SUBROUTINE xios_set_field_prec(field_hdl, prec) BIND(C) 
     54      SUBROUTINE cxios_set_field_prec(field_hdl, prec) BIND(C) 
    5555         USE ISO_C_BINDING 
    5656         INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
    5757         INTEGER (kind = C_INT)     , VALUE :: prec 
    58       END SUBROUTINE xios_set_field_prec 
     58      END SUBROUTINE cxios_set_field_prec 
    5959 
    60       SUBROUTINE xios_set_field_enabled(field_hdl, enabled) BIND(C) 
     60      SUBROUTINE cxios_set_field_enabled(field_hdl, enabled) BIND(C) 
    6161         USE ISO_C_BINDING 
    6262         INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
    6363         LOGICAL (kind = C_BOOL)    , VALUE :: enabled 
    64          END SUBROUTINE xios_set_field_enabled 
     64         END SUBROUTINE cxios_set_field_enabled 
    6565 
    66       SUBROUTINE xios_set_field_domain_ref(field_hdl, domain_ref ,domain_ref_size) BIND(C) 
     66      SUBROUTINE cxios_set_field_domain_ref(field_hdl, domain_ref ,domain_ref_size) BIND(C) 
    6767         USE ISO_C_BINDING 
    6868         INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    6969         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: domain_ref 
    7070         INTEGER  (kind = C_INT)     , VALUE        :: domain_ref_size 
    71       END SUBROUTINE xios_set_field_domain_ref 
     71      END SUBROUTINE cxios_set_field_domain_ref 
    7272 
    73       SUBROUTINE xios_set_field_axis_ref(field_hdl, axis_ref ,axis_ref_size) BIND(C) 
     73      SUBROUTINE cxios_set_field_axis_ref(field_hdl, axis_ref ,axis_ref_size) BIND(C) 
    7474         USE ISO_C_BINDING 
    7575         INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    7676         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_ref 
    7777         INTEGER  (kind = C_INT)     , VALUE        :: axis_ref_size 
    78       END SUBROUTINE xios_set_field_axis_ref 
     78      END SUBROUTINE cxios_set_field_axis_ref 
    7979 
    80       SUBROUTINE xios_set_field_grid_ref(field_hdl, grid_ref ,grid_ref_size) BIND(C) 
     80      SUBROUTINE cxios_set_field_grid_ref(field_hdl, grid_ref ,grid_ref_size) BIND(C) 
    8181         USE ISO_C_BINDING 
    8282         INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    8383         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: grid_ref 
    8484         INTEGER  (kind = C_INT)     , VALUE        :: grid_ref_size 
    85       END SUBROUTINE xios_set_field_grid_ref 
     85      END SUBROUTINE cxios_set_field_grid_ref 
    8686 
    87       SUBROUTINE xios_set_field_field_ref(field_hdl, field_ref ,field_ref_size) BIND(C) 
     87      SUBROUTINE cxios_set_field_field_ref(field_hdl, field_ref ,field_ref_size) BIND(C) 
    8888         USE ISO_C_BINDING 
    8989         INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    9090         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: field_ref 
    9191         INTEGER  (kind = C_INT)     , VALUE        :: field_ref_size 
    92       END SUBROUTINE xios_set_field_field_ref 
     92      END SUBROUTINE cxios_set_field_field_ref 
    9393 
    94       SUBROUTINE xios_set_field_default_value(field_hdl, default_value) BIND(C) 
     94      SUBROUTINE cxios_set_field_default_value(field_hdl, default_value) BIND(C) 
    9595         USE ISO_C_BINDING 
    9696         INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
    9797         REAL    (kind = C_DOUBLE)  , VALUE :: default_value 
    98       END SUBROUTINE xios_set_field_default_value 
     98      END SUBROUTINE cxios_set_field_default_value 
    9999    
    100       SUBROUTINE xios_field_handle_create(ret, idt, idt_size) BIND(C) 
     100      SUBROUTINE cxios_field_handle_create(ret, idt, idt_size) BIND(C) 
    101101         USE ISO_C_BINDING 
    102102         INTEGER  (kind = C_INTPTR_T)               :: ret 
    103103         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    104104         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    105       END SUBROUTINE xios_field_handle_create 
     105      END SUBROUTINE cxios_field_handle_create 
    106106 
    107       SUBROUTINE xios_field_valid_id(ret, idt, idt_size) BIND(C) 
     107      SUBROUTINE cxios_field_valid_id(ret, idt, idt_size) BIND(C) 
    108108         USE ISO_C_BINDING 
    109109         LOGICAL  (kind = C_BOOL)                   :: ret 
    110110         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    111111         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    112       END SUBROUTINE xios_field_valid_id 
     112      END SUBROUTINE cxios_field_valid_id 
    113113 
    114114   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/fieldgroup_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55    
    6       SUBROUTINE xios_set_fieldgroup_name(fieldgroup_hdl, name ,name_size) BIND(C) 
     6      SUBROUTINE cxios_set_fieldgroup_name(fieldgroup_hdl, name ,name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    99         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    1010         INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_fieldgroup_name 
     11      END SUBROUTINE cxios_set_fieldgroup_name 
    1212 
    13       SUBROUTINE xios_set_fieldgroup_standard_name(fieldgroup_hdl, standard_name ,standard_name_size) BIND(C) 
     13      SUBROUTINE cxios_set_fieldgroup_standard_name(fieldgroup_hdl, standard_name ,standard_name_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    1616         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    1717         INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE xios_set_fieldgroup_standard_name 
     18      END SUBROUTINE cxios_set_fieldgroup_standard_name 
    1919 
    20       SUBROUTINE xios_set_fieldgroup_long_name(fieldgroup_hdl, long_name ,long_name_size) BIND(C) 
     20      SUBROUTINE cxios_set_fieldgroup_long_name(fieldgroup_hdl, long_name ,long_name_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    2323         CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: long_name 
    2424         INTEGER (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE xios_set_fieldgroup_long_name 
     25      END SUBROUTINE cxios_set_fieldgroup_long_name 
    2626 
    27       SUBROUTINE xios_set_fieldgroup_unit(fieldgroup_hdl, unit ,unit_size) BIND(C) 
     27      SUBROUTINE cxios_set_fieldgroup_unit(fieldgroup_hdl, unit ,unit_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: unit_size 
    32       END SUBROUTINE xios_set_fieldgroup_unit 
     32      END SUBROUTINE cxios_set_fieldgroup_unit 
    3333 
    34       SUBROUTINE xios_set_fieldgroup_operation(fieldgroup_hdl, operation ,operation_size) BIND(C) 
     34      SUBROUTINE cxios_set_fieldgroup_operation(fieldgroup_hdl, operation ,operation_size) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    3737         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: operation 
    3838         INTEGER  (kind = C_INT)     , VALUE        :: operation_size 
    39       END SUBROUTINE xios_set_fieldgroup_operation 
     39      END SUBROUTINE cxios_set_fieldgroup_operation 
    4040 
    41       SUBROUTINE xios_set_fieldgroup_freq_op(fieldgroup_hdl, freq_op ,freq_op_size) BIND(C) 
     41      SUBROUTINE cxios_set_fieldgroup_freq_op(fieldgroup_hdl, freq_op ,freq_op_size) BIND(C) 
    4242         USE ISO_C_BINDING 
    4343         INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    4444         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: freq_op 
    4545         INTEGER  (kind = C_INT)     , VALUE        :: freq_op_size 
    46       END SUBROUTINE xios_set_fieldgroup_freq_op 
     46      END SUBROUTINE cxios_set_fieldgroup_freq_op 
    4747 
    48       SUBROUTINE xios_set_fieldgroup_level(fieldgroup_hdl, level) BIND(C) 
     48      SUBROUTINE cxios_set_fieldgroup_level(fieldgroup_hdl, level) BIND(C) 
    4949         USE ISO_C_BINDING 
    5050         INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
    5151         INTEGER (kind = C_INT)     , VALUE :: level 
    52       END SUBROUTINE xios_set_fieldgroup_level 
     52      END SUBROUTINE cxios_set_fieldgroup_level 
    5353 
    54       SUBROUTINE xios_set_fieldgroup_prec(fieldgroup_hdl, prec) BIND(C) 
     54      SUBROUTINE cxios_set_fieldgroup_prec(fieldgroup_hdl, prec) BIND(C) 
    5555         USE ISO_C_BINDING 
    5656         INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
    5757         INTEGER (kind = C_INT)     , VALUE :: prec 
    58       END SUBROUTINE xios_set_fieldgroup_prec 
     58      END SUBROUTINE cxios_set_fieldgroup_prec 
    5959 
    60       SUBROUTINE xios_set_fieldgroup_enabled(fieldgroup_hdl, enabled) BIND(C) 
     60      SUBROUTINE cxios_set_fieldgroup_enabled(fieldgroup_hdl, enabled) BIND(C) 
    6161         USE ISO_C_BINDING 
    6262         INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
    6363         LOGICAL (kind = C_BOOL)    , VALUE :: enabled 
    64          END SUBROUTINE xios_set_fieldgroup_enabled 
     64         END SUBROUTINE cxios_set_fieldgroup_enabled 
    6565 
    66       SUBROUTINE xios_set_fieldgroup_domain_ref(fieldgroup_hdl, domain_ref ,domain_ref_size) BIND(C) 
     66      SUBROUTINE cxios_set_fieldgroup_domain_ref(fieldgroup_hdl, domain_ref ,domain_ref_size) BIND(C) 
    6767         USE ISO_C_BINDING 
    6868         INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    6969         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: domain_ref 
    7070         INTEGER  (kind = C_INT)     , VALUE        :: domain_ref_size 
    71       END SUBROUTINE xios_set_fieldgroup_domain_ref 
     71      END SUBROUTINE cxios_set_fieldgroup_domain_ref 
    7272 
    73       SUBROUTINE xios_set_fieldgroup_axis_ref(fieldgroup_hdl, axis_ref ,axis_ref_size) BIND(C) 
     73      SUBROUTINE cxios_set_fieldgroup_axis_ref(fieldgroup_hdl, axis_ref ,axis_ref_size) BIND(C) 
    7474         USE ISO_C_BINDING 
    7575         INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    7676         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_ref 
    7777         INTEGER  (kind = C_INT)     , VALUE        :: axis_ref_size 
    78       END SUBROUTINE xios_set_fieldgroup_axis_ref 
     78      END SUBROUTINE cxios_set_fieldgroup_axis_ref 
    7979 
    80       SUBROUTINE xios_set_fieldgroup_grid_ref(fieldgroup_hdl, grid_ref ,grid_ref_size) BIND(C) 
     80      SUBROUTINE cxios_set_fieldgroup_grid_ref(fieldgroup_hdl, grid_ref ,grid_ref_size) BIND(C) 
    8181         USE ISO_C_BINDING 
    8282         INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    8383         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: grid_ref 
    8484         INTEGER  (kind = C_INT)     , VALUE        :: grid_ref_size 
    85       END SUBROUTINE xios_set_fieldgroup_grid_ref 
     85      END SUBROUTINE cxios_set_fieldgroup_grid_ref 
    8686 
    87       SUBROUTINE xios_set_fieldgroup_field_ref(fieldgroup_hdl, field_ref ,field_ref_size) BIND(C) 
     87      SUBROUTINE cxios_set_fieldgroup_field_ref(fieldgroup_hdl, field_ref ,field_ref_size) BIND(C) 
    8888         USE ISO_C_BINDING 
    8989         INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    9090         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: field_ref 
    9191         INTEGER  (kind = C_INT)     , VALUE        :: field_ref_size 
    92       END SUBROUTINE xios_set_fieldgroup_field_ref 
     92      END SUBROUTINE cxios_set_fieldgroup_field_ref 
    9393 
    94       SUBROUTINE xios_set_fieldgroup_default_value(fieldgroup_hdl, default_value) BIND(C) 
     94      SUBROUTINE cxios_set_fieldgroup_default_value(fieldgroup_hdl, default_value) BIND(C) 
    9595         USE ISO_C_BINDING 
    9696         INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
    9797         REAL    (kind = C_DOUBLE)  , VALUE :: default_value 
    98       END SUBROUTINE xios_set_fieldgroup_default_value 
     98      END SUBROUTINE cxios_set_fieldgroup_default_value 
    9999       
    100       SUBROUTINE xios_fieldgroup_handle_create(ret, idt, idt_size) BIND(C) 
     100      SUBROUTINE cxios_fieldgroup_handle_create(ret, idt, idt_size) BIND(C) 
    101101         USE ISO_C_BINDING 
    102102         INTEGER  (kind = C_INTPTR_T)               :: ret 
    103103         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    104104         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    105       END SUBROUTINE xios_fieldgroup_handle_create 
     105      END SUBROUTINE cxios_fieldgroup_handle_create 
    106106 
    107       SUBROUTINE xios_fieldgroup_valid_id(ret, idt, idt_size) BIND(C) 
     107      SUBROUTINE cxios_fieldgroup_valid_id(ret, idt, idt_size) BIND(C) 
    108108         USE ISO_C_BINDING 
    109109         LOGICAL  (kind = C_BOOL)                   :: ret 
    110110         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    111111         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    112       END SUBROUTINE xios_fieldgroup_valid_id 
     112      END SUBROUTINE cxios_fieldgroup_valid_id 
    113113    
    114114   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/file_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55    
    6       SUBROUTINE xios_set_file_name(file_hdl, name, name_size) BIND(C) 
     6      SUBROUTINE cxios_set_file_name(file_hdl, name, name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER  (kind = C_INTPTR_T), VALUE        :: file_hdl 
    99         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    1010         INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_file_name 
     11      END SUBROUTINE cxios_set_file_name 
    1212 
    13       SUBROUTINE xios_set_file_description(file_hdl, description, description_size) BIND(C) 
     13      SUBROUTINE cxios_set_file_description(file_hdl, description, description_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER  (kind = C_INTPTR_T), VALUE        :: file_hdl 
    1616         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: description 
    1717         INTEGER  (kind = C_INT)     , VALUE        :: description_size 
    18       END SUBROUTINE xios_set_file_description 
     18      END SUBROUTINE cxios_set_file_description 
    1919       
    20       SUBROUTINE xios_set_file_name_suffix(file_hdl, name_suffix, name_suffix_size) BIND(C) 
     20      SUBROUTINE cxios_set_file_name_suffix(file_hdl, name_suffix, name_suffix_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER  (kind = C_INTPTR_T), VALUE        :: file_hdl 
    2323         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name_suffix 
    2424         INTEGER  (kind = C_INT)     , VALUE        :: name_suffix_size 
    25       END SUBROUTINE xios_set_file_name_suffix 
     25      END SUBROUTINE cxios_set_file_name_suffix 
    2626 
    27       SUBROUTINE xios_set_file_output_freq(file_hdl, output_freq, output_freq_size) BIND(C) 
     27      SUBROUTINE cxios_set_file_output_freq(file_hdl, output_freq, output_freq_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE        :: file_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: output_freq 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: output_freq_size 
    32       END SUBROUTINE xios_set_file_output_freq 
     32      END SUBROUTINE cxios_set_file_output_freq 
    3333 
    34       SUBROUTINE xios_set_file_output_level(file_hdl, output_level) BIND(C) 
     34      SUBROUTINE cxios_set_file_output_level(file_hdl, output_level) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
    3737         INTEGER (kind = C_INT)     , VALUE :: output_level 
    38       END SUBROUTINE xios_set_file_output_level 
     38      END SUBROUTINE cxios_set_file_output_level 
    3939 
    40       SUBROUTINE xios_set_file_enabled(file_hdl, enabled) BIND(C) 
     40      SUBROUTINE cxios_set_file_enabled(file_hdl, enabled) BIND(C) 
    4141         USE ISO_C_BINDING 
    4242         INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
    4343         LOGICAL (kind = C_BOOL)    , VALUE :: enabled 
    44       END SUBROUTINE xios_set_file_enabled 
     44      END SUBROUTINE cxios_set_file_enabled 
    4545    
    46       SUBROUTINE xios_file_handle_create(ret, idt, idt_size) BIND(C) 
     46      SUBROUTINE cxios_file_handle_create(ret, idt, idt_size) BIND(C) 
    4747         USE ISO_C_BINDING 
    4848         INTEGER  (kind = C_INTPTR_T)               :: ret 
    4949         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    5050         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    51       END SUBROUTINE xios_file_handle_create 
     51      END SUBROUTINE cxios_file_handle_create 
    5252 
    53       SUBROUTINE xios_file_valid_id(ret, idt, idt_size) BIND(C) 
     53      SUBROUTINE cxios_file_valid_id(ret, idt, idt_size) BIND(C) 
    5454         USE ISO_C_BINDING 
    5555         LOGICAL  (kind = C_BOOL)                   :: ret 
    5656         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    5757         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    58       END SUBROUTINE xios_file_valid_id 
     58      END SUBROUTINE cxios_file_valid_id 
    5959 
    6060   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/filegroup_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55    
    6       SUBROUTINE xios_set_filegroup_name(filegroup_hdl, name ,name_size) BIND(C) 
     6      SUBROUTINE cxios_set_filegroup_name(filegroup_hdl, name ,name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER  (kind = C_INTPTR_T), VALUE        :: filegroup_hdl 
    99         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    1010         INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_filegroup_name 
     11      END SUBROUTINE cxios_set_filegroup_name 
    1212 
    13       SUBROUTINE xios_set_filegroup_description(filegroup_hdl, description ,description_size) BIND(C) 
     13      SUBROUTINE cxios_set_filegroup_description(filegroup_hdl, description ,description_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER  (kind = C_INTPTR_T), VALUE        :: filegroup_hdl 
    1616         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: description 
    1717         INTEGER  (kind = C_INT)     , VALUE        :: description_size 
    18       END SUBROUTINE xios_set_filegroup_description 
     18      END SUBROUTINE cxios_set_filegroup_description 
    1919       
    20       SUBROUTINE xios_set_filegroup_name_suffix(filegroup_hdl, name_suffix ,name_suffix_size) BIND(C) 
     20      SUBROUTINE cxios_set_filegroup_name_suffix(filegroup_hdl, name_suffix ,name_suffix_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER  (kind = C_INTPTR_T), VALUE        :: filegroup_hdl 
    2323         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name_suffix 
    2424         INTEGER  (kind = C_INT)     , VALUE        :: name_suffix_size 
    25       END SUBROUTINE xios_set_filegroup_name_suffix 
     25      END SUBROUTINE cxios_set_filegroup_name_suffix 
    2626 
    27       SUBROUTINE xios_set_filegroup_output_freq(filegroup_hdl, output_freq ,output_freq_size) BIND(C) 
     27      SUBROUTINE cxios_set_filegroup_output_freq(filegroup_hdl, output_freq ,output_freq_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE        :: filegroup_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: output_freq 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: output_freq_size 
    32       END SUBROUTINE xios_set_filegroup_output_freq 
     32      END SUBROUTINE cxios_set_filegroup_output_freq 
    3333 
    34       SUBROUTINE xios_set_filegroup_output_level(filegroup_hdl, output_level) BIND(C) 
     34      SUBROUTINE cxios_set_filegroup_output_level(filegroup_hdl, output_level) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
    3737         INTEGER (kind = C_INT)     , VALUE :: output_level 
    38       END SUBROUTINE xios_set_filegroup_output_level 
     38      END SUBROUTINE cxios_set_filegroup_output_level 
    3939 
    40       SUBROUTINE xios_set_filegroup_enabled(filegroup_hdl, enabled) BIND(C) 
     40      SUBROUTINE cxios_set_filegroup_enabled(filegroup_hdl, enabled) BIND(C) 
    4141         USE ISO_C_BINDING 
    4242         INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
    4343         LOGICAL (kind = C_BOOL)    , VALUE :: enabled 
    44       END SUBROUTINE xios_set_filegroup_enabled 
     44      END SUBROUTINE cxios_set_filegroup_enabled 
    4545       
    46       SUBROUTINE xios_filegroup_handle_create(ret, idt, idt_size) BIND(C) 
     46      SUBROUTINE cxios_filegroup_handle_create(ret, idt, idt_size) BIND(C) 
    4747         USE ISO_C_BINDING 
    4848         INTEGER  (kind = C_INTPTR_T)               :: ret 
    4949         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    5050         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    51       END SUBROUTINE xios_filegroup_handle_create 
     51      END SUBROUTINE cxios_filegroup_handle_create 
    5252 
    53       SUBROUTINE xios_filegroup_valid_id(ret, idt, idt_size) BIND(C) 
     53      SUBROUTINE cxios_filegroup_valid_id(ret, idt, idt_size) BIND(C) 
    5454         USE ISO_C_BINDING 
    5555         LOGICAL  (kind = C_BOOL)                   :: ret 
    5656         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    5757         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    58       END SUBROUTINE xios_filegroup_valid_id 
     58      END SUBROUTINE cxios_filegroup_valid_id 
    5959 
    6060   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/grid_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55      
    6       SUBROUTINE xios_set_grid_name(grid_hdl, name, name_size) BIND(C) 
     6      SUBROUTINE cxios_set_grid_name(grid_hdl, name, name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER (kind = C_INTPTR_T), VALUE        :: grid_hdl 
    99         CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: name 
    1010         INTEGER (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_grid_name 
     11      END SUBROUTINE cxios_set_grid_name 
    1212 
    13       SUBROUTINE xios_set_grid_description(grid_hdl, description, description_size) BIND(C) 
     13      SUBROUTINE cxios_set_grid_description(grid_hdl, description, description_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER (kind = C_INTPTR_T), VALUE        :: grid_hdl 
    1616         CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: description 
    1717         INTEGER (kind = C_INT)     , VALUE        :: description_size 
    18       END SUBROUTINE xios_set_grid_description 
     18      END SUBROUTINE cxios_set_grid_description 
    1919 
    20       SUBROUTINE xios_set_grid_domain_ref(grid_hdl, domain_ref, domain_ref_size) BIND(C) 
     20      SUBROUTINE cxios_set_grid_domain_ref(grid_hdl, domain_ref, domain_ref_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER (kind = C_INTPTR_T), VALUE        :: grid_hdl 
    2323         CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: domain_ref 
    2424         INTEGER (kind = C_INT)     , VALUE        :: domain_ref_size 
    25       END SUBROUTINE xios_set_grid_domain_ref 
     25      END SUBROUTINE cxios_set_grid_domain_ref 
    2626 
    27       SUBROUTINE xios_set_grid_axis_ref(grid_hdl, axis_ref, axis_ref_size) BIND(C) 
     27      SUBROUTINE cxios_set_grid_axis_ref(grid_hdl, axis_ref, axis_ref_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE        :: grid_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_ref 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: axis_ref_size 
    32       END SUBROUTINE xios_set_grid_axis_ref 
     32      END SUBROUTINE cxios_set_grid_axis_ref 
    3333       
    34       SUBROUTINE xios_grid_handle_create(ret, idt, idt_size) BIND(C) 
     34      SUBROUTINE cxios_grid_handle_create(ret, idt, idt_size) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER  (kind = C_INTPTR_T)               :: ret 
    3737         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    3838         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    39       END SUBROUTINE xios_grid_handle_create 
     39      END SUBROUTINE cxios_grid_handle_create 
    4040 
    41       SUBROUTINE xios_grid_valid_id(ret, idt, idt_size) BIND(C) 
     41      SUBROUTINE cxios_grid_valid_id(ret, idt, idt_size) BIND(C) 
    4242         USE ISO_C_BINDING 
    4343         LOGICAL  (kind = C_BOOL)                   :: ret 
    4444         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    4545         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    46       END SUBROUTINE xios_grid_valid_id 
     46      END SUBROUTINE cxios_grid_valid_id 
    4747 
    4848   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/gridgroup_interface.f90

    r280 r286  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55      
    6       SUBROUTINE xios_set_gridgroup_name(gridgroup_hdl, name, name_size) BIND(C) 
     6      SUBROUTINE cxios_set_gridgroup_name(gridgroup_hdl, name, name_size) BIND(C) 
    77         USE ISO_C_BINDING 
    88         INTEGER (kind = C_INTPTR_T), VALUE        :: gridgroup_hdl 
    99         CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: name 
    1010         INTEGER (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE xios_set_gridgroup_name 
     11      END SUBROUTINE cxios_set_gridgroup_name 
    1212 
    13       SUBROUTINE xios_set_gridgroup_description(gridgroup_hdl, description, description_size) BIND(C) 
     13      SUBROUTINE cxios_set_gridgroup_description(gridgroup_hdl, description, description_size) BIND(C) 
    1414         USE ISO_C_BINDING 
    1515         INTEGER (kind = C_INTPTR_T), VALUE        :: gridgroup_hdl 
    1616         CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: description 
    1717         INTEGER (kind = C_INT)     , VALUE        :: description_size 
    18       END SUBROUTINE xios_set_gridgroup_description 
     18      END SUBROUTINE cxios_set_gridgroup_description 
    1919 
    20       SUBROUTINE xios_set_gridgroup_domain_ref(gridgroup_hdl, domain_ref, domain_ref_size) BIND(C) 
     20      SUBROUTINE cxios_set_gridgroup_domain_ref(gridgroup_hdl, domain_ref, domain_ref_size) BIND(C) 
    2121         USE ISO_C_BINDING 
    2222         INTEGER (kind = C_INTPTR_T), VALUE        :: gridgroup_hdl 
    2323         CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: domain_ref 
    2424         INTEGER (kind = C_INT)     , VALUE        :: domain_ref_size 
    25       END SUBROUTINE xios_set_gridgroup_domain_ref 
     25      END SUBROUTINE cxios_set_gridgroup_domain_ref 
    2626 
    27       SUBROUTINE xios_set_gridgroup_axis_ref(gridgroup_hdl, axis_ref, axis_ref_size) BIND(C) 
     27      SUBROUTINE cxios_set_gridgroup_axis_ref(gridgroup_hdl, axis_ref, axis_ref_size) BIND(C) 
    2828         USE ISO_C_BINDING 
    2929         INTEGER  (kind = C_INTPTR_T), VALUE        :: gridgroup_hdl 
    3030         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_ref 
    3131         INTEGER  (kind = C_INT)     , VALUE        :: axis_ref_size 
    32       END SUBROUTINE xios_set_gridgroup_axis_ref 
     32      END SUBROUTINE cxios_set_gridgroup_axis_ref 
    3333       
    34       SUBROUTINE xios_domaingroup_handle_create(ret, idt, idt_size) BIND(C) 
     34      SUBROUTINE cxios_domaingroup_handle_create(ret, idt, idt_size) BIND(C) 
    3535         USE ISO_C_BINDING 
    3636         INTEGER  (kind = C_INTPTR_T)               :: ret 
    3737         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    3838         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    39       END SUBROUTINE xios_domaingroup_handle_create 
     39      END SUBROUTINE cxios_domaingroup_handle_create 
    4040 
    41       SUBROUTINE xios_gridgroup_valid_id(ret, idt, idt_size) BIND(C) 
     41      SUBROUTINE cxios_gridgroup_valid_id(ret, idt, idt_size) BIND(C) 
    4242         USE ISO_C_BINDING 
    4343         LOGICAL  (kind = C_BOOL)                   :: ret 
    4444         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
    4545         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
    46       END SUBROUTINE xios_gridgroup_valid_id 
     46      END SUBROUTINE cxios_gridgroup_valid_id 
    4747 
    4848   END INTERFACE 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icaxis.cpp

    r280 r286  
    2424 
    2525   // ------------------------- Attributs des axes ----------------------------- 
    26    void xios_set_axis_name  
     26   void cxios_set_axis_name  
    2727      (XAxisPtr axis_hdl, const char * name , int name_size) 
    2828   { 
     
    3333   } 
    3434 
    35    void xios_set_axis_standard_name 
     35   void cxios_set_axis_standard_name 
    3636      (XAxisPtr axis_hdl, const char * standard_name , int standard_name_size) 
    3737   { 
     
    4242   } 
    4343     
    44    void xios_set_axis_long_name  
     44   void cxios_set_axis_long_name  
    4545      (XAxisPtr axis_hdl, const char * long_name , int long_name_size) 
    4646   { 
     
    5151   } 
    5252 
    53    void xios_set_axis_unit  
     53   void cxios_set_axis_unit  
    5454      (XAxisPtr axis_hdl, const char * unit , int unit_size) 
    5555   { 
     
    6060   } 
    6161     
    62    void xios_set_axis_size(XAxisPtr axis_hdl, int size) 
     62   void cxios_set_axis_size(XAxisPtr axis_hdl, int size) 
    6363   { 
    6464      axis_hdl->size.setValue(size); 
    6565   } 
    6666 
    67    void xios_set_axis_zvalue  
     67   void cxios_set_axis_zvalue  
    6868      (XAxisPtr axis_hdl, const double * zvalue , int zvalue_extent1) 
    6969   { 
     
    7777   // -------------------- Attributs des groupes d'axes ------------------------- 
    7878    
    79    void xios_set_axisgroup_name  
     79   void cxios_set_axisgroup_name  
    8080      (XAxisGroupPtr axisgroup_hdl, const char * name , int name_size) 
    8181   { 
     
    8686   } 
    8787 
    88    void xios_set_axisgroup_standard_name 
     88   void cxios_set_axisgroup_standard_name 
    8989      (XAxisGroupPtr axisgroup_hdl, const char * standard_name , int standard_name_size) 
    9090   { 
     
    9595   } 
    9696     
    97    void xios_set_axisgroup_long_name  
     97   void cxios_set_axisgroup_long_name  
    9898      (XAxisGroupPtr axisgroup_hdl, const char * long_name , int long_name_size) 
    9999   { 
     
    104104   } 
    105105 
    106    void xios_set_axisgroup_unit  
     106   void cxios_set_axisgroup_unit  
    107107      (XAxisGroupPtr axisgroup_hdl, const char * unit , int unit_size) 
    108108   { 
     
    113113   } 
    114114     
    115    void xios_set_axisgroup_size(XAxisGroupPtr axisgroup_hdl, int size) 
     115   void cxios_set_axisgroup_size(XAxisGroupPtr axisgroup_hdl, int size) 
    116116   { 
    117117      axisgroup_hdl->size.setValue(size); 
    118118   } 
    119119 
    120    void xios_set_axisgroup_zvalue  
     120   void cxios_set_axisgroup_zvalue  
    121121      (XAxisGroupPtr axisgroup_hdl, const double * zvalue , int zvalue_extent1) 
    122122   { 
     
    129129   // ------------------------ Création des handle ----------------------------- 
    130130    
    131    void xios_axis_handle_create (XAxisPtr * _ret, const char * _id, int _id_len) 
     131   void cxios_axis_handle_create (XAxisPtr * _ret, const char * _id, int _id_len) 
    132132   { 
    133133      std::string id;  
     
    137137   } 
    138138    
    139    void xios_axisgroup_handle_create (XAxisGroupPtr * _ret, const char * _id, int _id_len) 
     139   void cxios_axisgroup_handle_create (XAxisGroupPtr * _ret, const char * _id, int _id_len) 
    140140   { 
    141141      std::string id;  
     
    147147   // -------------------- Vérification des identifiants ----------------------- 
    148148 
    149    void xios_axis_valid_id (bool * _ret, const char * _id, int _id_len) 
     149   void cxios_axis_valid_id (bool * _ret, const char * _id, int _id_len) 
    150150   { 
    151151      std::string id; 
     
    155155   } 
    156156 
    157    void xios_axisgroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     157   void cxios_axisgroup_valid_id (bool * _ret, const char * _id, int _id_len) 
    158158   { 
    159159      std::string id; 
  • XMLIO_V2/dev/common/src/xmlio/fortran/iccontext.cpp

    r280 r286  
    2929    
    3030    
    31    void xios_set_context_calendar_type(XContextPtr context_hdl, const char * calendar_type, int calendar_type_size) 
     31   void cxios_set_context_calendar_type(XContextPtr context_hdl, const char * calendar_type, int calendar_type_size) 
    3232   { 
    3333      std::string calendar_type_str;  
     
    3737   } 
    3838    
    39    void xios_set_context_start_date(XContextPtr context_hdl, const char * start_date, int start_date_size) 
     39   void cxios_set_context_start_date(XContextPtr context_hdl, const char * start_date, int start_date_size) 
    4040   { 
    4141      std::string start_date_str;  
     
    4545   } 
    4646    
    47    void xios_set_context_output_dir(XContextPtr context_hdl, const char * output_dir, int output_dir_size) 
     47   void cxios_set_context_output_dir(XContextPtr context_hdl, const char * output_dir, int output_dir_size) 
    4848   { 
    4949      std::string output_dir_str;  
     
    5555   // ------------------------ Création des handle ----------------------------- 
    5656    
    57    void xios_context_handle_create (XContextPtr * _ret, const char * _id, int _id_len) 
     57   void cxios_context_handle_create (XContextPtr * _ret, const char * _id, int _id_len) 
    5858   { 
    5959      std::string id;  
     
    7474   // ------------------------ Changements de contextes ------------------------ 
    7575    
    76    void xios_context_set_current(XContextPtr context, bool withswap) 
     76   void cxios_context_set_current(XContextPtr context, bool withswap) 
    7777   { 
    7878      CTreeManager::SetCurrentContextId(context->getId()); 
     
    8181   // ------------------------ Création de contexte ---------------------------- 
    8282    
    83    void xios_context_create(XContextPtr * context, 
     83   void cxios_context_create(XContextPtr * context, 
    8484                            const char  * context_id, 
    8585                            int           context_id_size, 
     
    140140   // -------------------- Vérification des identifiants ----------------------- 
    141141 
    142    void xios_context_valid_id (bool * _ret, const char * _id, int _id_len) 
     142   void cxios_context_valid_id (bool * _ret, const char * _id, int _id_len) 
    143143   { 
    144144      std::string id; 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icdata.cpp

    r278 r286  
    55#include <boost/multi_array.hpp> 
    66#include <boost/shared_ptr.hpp> 
     7#include <string> 
     8#include <iostream> 
     9 
    710 
    811#include "xmlioserver.hpp" 
     12#include "oasis_cinterface.hpp" 
    913 
    1014#include "attribute_template_impl.hpp" 
     
    1317 
    1418#include "icutil.hpp" 
     19#include "mpi_manager.hpp" 
     20#include "buffer.hpp" 
    1521 
    1622extern "C" 
     
    2632   // -------------------- Traitement des données ------------------------------ 
    2733    
    28    void xios_dtreatment_start(XContextPtr context_hdl, XFileType filetype, int comm_client_server, int comm_server) 
     34   void cxios_dtreatment_start() 
    2935   { 
    3036      using namespace xmlioserver::tree; 
     
    3238      try 
    3339      { 
     40        MPI_Comm comm_client_server=comm::CMPIManager::GetCommClientServer() ; 
     41        MPI_Comm comm_server=comm::CMPIManager::GetCommServer() ; 
     42         
    3443         boost::shared_ptr<CContext> context = 
    35                 CObjectFactory::GetObject<CContext>(context_hdl); 
     44            CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()); 
     45                 
    3646         StdOStringStream oss; 
    3747         oss << StdString("def_client_next.") 
    38              << CMPIManager::GetCommRank(CMPIManager::GetCommWorld()); 
     48             << CMPIManager::GetCommRank(CMPIManager::GetCommClient()); 
    3949         CTreeManager::PrintTreeToFile(oss.str()); 
    4050         oss.str(""); 
     
    4353 
    4454         oss << StdString("def_client_end.") 
    45              << CMPIManager::GetCommRank(CMPIManager::GetCommWorld()); 
     55             << CMPIManager::GetCommRank(CMPIManager::GetCommClient()); 
    4656         CTreeManager::PrintTreeToFile(oss.str()); 
    4757 
    48          if ((comm_client_server != -1)) 
     58         if ( !comm::CMPIManager::IsConnected() ) 
    4959         { 
    5060            MPI_Request request = 0; 
    5161            StdOStringStream ostrs; 
     62/* 
    5263            if (CMPIManager::GetCommRank(comm_client_server) == 1) 
    5364            { 
    5465               CTreeManager::ToBinary(ostrs); 
    55                CLinearBuffer lbuffer(ostrs.str().size()+13); 
     66               CLinearBuffer lbuffer(ostrs.str().size()+CBuffer::getDataHeaderSize()); 
     67               std::cout<<"lbuffer size "<<ostrs.str().size()<<std::endl ; 
    5668               lbuffer.appendString(ostrs.str()); 
    5769               CMPIManager::SendLinearBuffer(comm_client_server, 0, lbuffer, request); 
     
    6173            { 
    6274               CTreeManager::DomainsToBinary(ostrs); 
    63                CLinearBuffer lbuffer(ostrs.str().size()+13); 
     75               CLinearBuffer lbuffer(ostrs.str().size()+CBuffer::getDataHeaderSize());  
     76               std::cout<<"lbuffer size "<<ostrs.str().size()<<std::endl ; 
    6477               lbuffer.appendString(ostrs.str()); 
    6578               CMPIManager::SendLinearBuffer(comm_client_server, 0, lbuffer, request); 
    6679               CMPIManager::Wait(request);  // Pas encore en mode RPC 
    6780            } 
    68             CXIOSManager::RunClient(false, CMPIManager::GetCommWorld()); 
    69             CClient::CreateClient(comm_client_server); 
     81*/ 
     82            CTreeManager::ToBinary(ostrs); 
     83            CLinearBuffer lbuffer(ostrs.str().size()+CBuffer::getDataHeaderSize()); 
     84            lbuffer.appendString(ostrs.str()); 
     85            CMPIManager::SendLinearBuffer(comm_client_server, 0, lbuffer, request); 
     86            CMPIManager::Wait(request);  // Pas encore en mode RPC 
     87                
     88                
     89            CXIOSManager::RunClient(false, CMPIManager::GetCommClient()); 
     90            CClient::CreateClient(CMPIManager::GetCommClientServer()); 
    7091         } 
    7192         else 
    7293         { 
    73             dt->createDataOutput<CNc4DataOutput>(CMPIManager::GetCommWorld()); 
     94            dt->createDataOutput<CNc4DataOutput>(CMPIManager::GetCommClient()); 
    7495         } 
    7596      } 
     
    81102   } 
    82103    
    83    void xios_dtreatment_end(void) 
     104   void cxios_dtreatment_end(void) 
     105   { 
     106      try 
     107      { 
     108         boost::shared_ptr<xmlioserver::tree::CContext> context = 
     109         xmlioserver::CObjectFactory::GetObject<xmlioserver::tree::CContext> 
     110            (CObjectFactory::GetCurrentContextId()); 
     111         boost::shared_ptr<xmlioserver::data::CDataTreatment> dtreat = context->getDataTreatment(); 
     112         dtreat->finalize(); 
     113          
     114//         CMPIManager::Finalize(); 
     115      } 
     116      catch (CException & exc) 
     117      { 
     118         std::cerr << exc.getMessage() << std::endl; 
     119         exit (EXIT_FAILURE); 
     120      } 
     121   } 
     122 
     123   // ---------------------- Finalize du serveur ------------------------- 
     124 
     125   void cxios_finalize_ioserver(void) 
    84126   { 
    85127      try 
     
    92134         exit (EXIT_FAILURE); 
    93135      } 
    94    } 
     136    } 
    95137 
    96138   // ---------------------- Initialisation du serveur ------------------------- 
    97139 
    98    void xios_init_ioserver(MPIComm * comm_client) 
    99    { 
    100       try 
    101       { 
    102          MPIComm comm_client_server, comm_server; 
    103          CMPIManager::Initialise(NULL, NULL); 
    104          CMPIManager::DispatchClient(false, *comm_client, comm_client_server, comm_server); 
     140   void cxios_init_ioserver(MPIComm * f_comm_client, MPIComm * f_comm_parent) 
     141   { 
     142      try 
     143      { 
     144         MPI_Comm comm_client_server, comm_server,comm_client,comm_parent; 
     145         xmlioserver::CTreeManager::ParseFile("iodef.xml"); 
     146         CTreeManager::SetCurrentContextId(StdString("xios")); 
     147         CMPIManager::InitialiseClient(NULL, NULL); 
     148         comm_parent=MPI_Comm_f2c(*f_comm_parent) ; 
     149         CMPIManager::DispatchClient(false, comm_client, comm_client_server, comm_server,comm_parent); 
     150         *f_comm_client=MPI_Comm_c2f(comm_client) ; 
    105151      } 
    106152      catch (CException & exc) 
     
    113159   // ---------------------- Ecriture des données ------------------------------ 
    114160    
    115    void xios_write_data_k81(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize) 
     161   void cxios_write_data_k81(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize) 
    116162   { 
    117163      std::string fieldid_str; 
     
    129175   } 
    130176    
    131    void xios_write_data_k82(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize, int data_Ysize) 
     177   void cxios_write_data_k82(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize, int data_Ysize) 
    132178   { 
    133179      std::string fieldid_str; 
     
    145191   } 
    146192    
    147    void xios_write_data_k83(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
     193   void cxios_write_data_k83(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
    148194   { 
    149195      std::string fieldid_str; 
     
    161207   } 
    162208    
    163    void xios_write_data_k41(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize) 
     209   void cxios_write_data_k41(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize) 
    164210   { 
    165211      std::string fieldid_str; 
     
    177223   } 
    178224    
    179    void xios_write_data_k42(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize, int data_Ysize) 
     225   void cxios_write_data_k42(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize, int data_Ysize) 
    180226   { 
    181227      std::string fieldid_str; 
     
    193239   } 
    194240    
    195    void xios_write_data_k43(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
     241   void cxios_write_data_k43(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
    196242   { 
    197243      std::string fieldid_str; 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icdate.cpp

    r278 r286  
    2020// /////////////////////////////// Définitions ////////////////////////////// // 
    2121 
    22    void xios_set_timestep(double ts_year, double ts_month,  double ts_day, 
     22   void cxios_set_timestep(double ts_year, double ts_month,  double ts_day, 
    2323                          double ts_hour, double ts_minute, double ts_second) 
    2424   { 
     
    4848   } 
    4949    
    50    void xios_update_calendar(int step) 
     50   void cxios_update_calendar(int step) 
    5151   { 
    5252      try 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icdomain.cpp

    r280 r286  
    2525   // ------------------------- Attributs des axes ----------------------------- 
    2626    
    27    void xios_set_domain_name(XDomainPtr domain_hdl, const char * name, int name_size) 
     27   void cxios_set_domain_name(XDomainPtr domain_hdl, const char * name, int name_size) 
    2828   { 
    2929      std::string name_str;  
     
    3333   } 
    3434    
    35    void xios_set_domain_standard_name(XDomainPtr domain_hdl, const char * standard_name, int standard_name_size) 
     35   void cxios_set_domain_standard_name(XDomainPtr domain_hdl, const char * standard_name, int standard_name_size) 
    3636   { 
    3737      std::string standard_name_str;  
     
    4141   } 
    4242    
    43    void xios_set_domain_long_name(XDomainPtr domain_hdl, const char * long_name, int long_name_size) 
     43   void cxios_set_domain_long_name(XDomainPtr domain_hdl, const char * long_name, int long_name_size) 
    4444   { 
    4545      std::string long_name_str;  
     
    4949   } 
    5050    
    51    void xios_set_domain_domain_group_ref(XDomainPtr domain_hdl, const char * domain_group_ref, int domain_group_ref_size) 
     51   void cxios_set_domain_domain_group_ref(XDomainPtr domain_hdl, const char * domain_group_ref, int domain_group_ref_size) 
    5252   { 
    5353      std::string domain_group_ref_str;  
     
    5757   } 
    5858    
    59    void xios_set_domain_ni_glo(XDomainPtr domain_hdl, int ni_glo) 
     59   void cxios_set_domain_ni_glo(XDomainPtr domain_hdl, int ni_glo) 
    6060   { 
    6161      domain_hdl->ni_glo.setValue(ni_glo); 
    6262   } 
    6363    
    64    void xios_set_domain_nj_glo(XDomainPtr domain_hdl, int nj_glo) 
     64   void cxios_set_domain_nj_glo(XDomainPtr domain_hdl, int nj_glo) 
    6565   { 
    6666      domain_hdl->nj_glo.setValue(nj_glo); 
    6767   } 
    6868    
    69    void xios_set_domain_ibegin(XDomainPtr domain_hdl, int ibegin) 
     69   void cxios_set_domain_ibegin(XDomainPtr domain_hdl, int ibegin) 
    7070   { 
    7171      domain_hdl->ibegin.setValue(ibegin); 
    7272   } 
    7373    
    74    void xios_set_domain_iend(XDomainPtr domain_hdl, int iend) 
     74   void cxios_set_domain_iend(XDomainPtr domain_hdl, int iend) 
    7575   { 
    7676      domain_hdl->iend.setValue(iend); 
    7777   } 
    7878    
    79    void xios_set_domain_ni(XDomainPtr domain_hdl, int ni) 
     79   void cxios_set_domain_ni(XDomainPtr domain_hdl, int ni) 
    8080   { 
    8181      domain_hdl->ni.setValue(ni); 
    8282   } 
    8383    
    84    void xios_set_domain_jbegin(XDomainPtr domain_hdl, int jbegin) 
     84   void cxios_set_domain_jbegin(XDomainPtr domain_hdl, int jbegin) 
    8585   { 
    8686      domain_hdl->jbegin.setValue(jbegin); 
    8787   } 
    8888    
    89    void xios_set_domain_jend(XDomainPtr domain_hdl, int jend) 
     89   void cxios_set_domain_jend(XDomainPtr domain_hdl, int jend) 
    9090   { 
    9191      domain_hdl->jend.setValue(jend); 
    9292   } 
    9393    
    94    void xios_set_domain_nj(XDomainPtr domain_hdl, int nj) 
     94   void cxios_set_domain_nj(XDomainPtr domain_hdl, int nj) 
    9595   { 
    9696      domain_hdl->nj.setValue(nj); 
    9797   } 
    9898    
    99    void xios_set_domain_mask(XDomainPtr domain_hdl, bool * mask, int mask_extent1, int mask_extent2) 
     99   void cxios_set_domain_mask(XDomainPtr domain_hdl, bool * mask, int mask_extent1, int mask_extent2) 
    100100   { 
    101101      ARRAY(bool, 2) mask_val(new CArray<bool, 2>(boost::extents [mask_extent1][mask_extent2])); 
     
    105105   } 
    106106    
    107    void xios_set_domain_data_dim(XDomainPtr domain_hdl, int data_dim) 
     107   void cxios_set_domain_data_dim(XDomainPtr domain_hdl, int data_dim) 
    108108   { 
    109109      domain_hdl->data_dim.setValue(data_dim); 
    110110   } 
    111111    
    112    void xios_set_domain_data_ni(XDomainPtr domain_hdl, int data_ni) 
     112   void cxios_set_domain_data_ni(XDomainPtr domain_hdl, int data_ni) 
    113113   { 
    114114      domain_hdl->data_ni.setValue(data_ni); 
    115115   } 
    116116    
    117    void xios_set_domain_data_nj(XDomainPtr domain_hdl, int data_nj) 
     117   void cxios_set_domain_data_nj(XDomainPtr domain_hdl, int data_nj) 
    118118   { 
    119119      domain_hdl->data_nj.setValue(data_nj); 
    120120   } 
    121121    
    122    void xios_set_domain_data_ibegin(XDomainPtr domain_hdl, int data_ibegin) 
     122   void cxios_set_domain_data_ibegin(XDomainPtr domain_hdl, int data_ibegin) 
    123123   { 
    124124      domain_hdl->data_ibegin.setValue(data_ibegin); 
    125125   } 
    126126    
    127    void xios_set_domain_data_jbegin(XDomainPtr domain_hdl, int data_jbegin) 
     127   void cxios_set_domain_data_jbegin(XDomainPtr domain_hdl, int data_jbegin) 
    128128   { 
    129129      domain_hdl->data_jbegin.setValue(data_jbegin); 
    130130   } 
    131131    
    132    void xios_set_domain_zoom_ni(XDomainPtr domain_hdl, int zoom_ni) 
     132   void cxios_set_domain_zoom_ni(XDomainPtr domain_hdl, int zoom_ni) 
    133133   { 
    134134      domain_hdl->zoom_ni.setValue(zoom_ni); 
    135135   } 
    136136    
    137    void xios_set_domain_zoom_nj(XDomainPtr domain_hdl, int zoom_nj) 
     137   void cxios_set_domain_zoom_nj(XDomainPtr domain_hdl, int zoom_nj) 
    138138   { 
    139139      domain_hdl->zoom_nj.setValue(zoom_nj); 
    140140   } 
    141141    
    142    void xios_set_domain_zoom_ibegin(XDomainPtr domain_hdl, int zoom_ibegin) 
     142   void cxios_set_domain_zoom_ibegin(XDomainPtr domain_hdl, int zoom_ibegin) 
    143143   { 
    144144      domain_hdl->zoom_ibegin.setValue(zoom_ibegin); 
    145145   } 
    146146     
    147    void xios_set_domain_zoom_jbegin(XDomainPtr domain_hdl, int zoom_jbegin) 
     147   void cxios_set_domain_zoom_jbegin(XDomainPtr domain_hdl, int zoom_jbegin) 
    148148   { 
    149149      domain_hdl->zoom_jbegin.setValue(zoom_jbegin); 
    150150   } 
    151151    
    152    void xios_set_domain_zoom_ni_loc(XDomainPtr domain_hdl, int zoom_ni_loc) 
     152   void cxios_set_domain_zoom_ni_loc(XDomainPtr domain_hdl, int zoom_ni_loc) 
    153153   { 
    154154      domain_hdl->zoom_ni_loc.setValue(zoom_ni_loc); 
    155155   } 
    156156    
    157    void xios_set_domain_zoom_nj_loc(XDomainPtr domain_hdl, int zoom_nj_loc) 
     157   void cxios_set_domain_zoom_nj_loc(XDomainPtr domain_hdl, int zoom_nj_loc) 
    158158   { 
    159159      domain_hdl->zoom_nj_loc.setValue(zoom_nj_loc); 
    160160   } 
    161161    
    162    void xios_set_domain_zoom_ibegin_loc(XDomainPtr domain_hdl, int zoom_ibegin_loc) 
     162   void cxios_set_domain_zoom_ibegin_loc(XDomainPtr domain_hdl, int zoom_ibegin_loc) 
    163163   { 
    164164      domain_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc); 
    165165   } 
    166166    
    167    void xios_set_domain_zoom_jbegin_loc(XDomainPtr domain_hdl, int zoom_jbegin_loc) 
     167   void cxios_set_domain_zoom_jbegin_loc(XDomainPtr domain_hdl, int zoom_jbegin_loc) 
    168168   { 
    169169      domain_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc); 
    170170   } 
    171171    
    172    void xios_set_domain_data_n_index(XDomainPtr domain_hdl, int data_n_index) 
     172   void cxios_set_domain_data_n_index(XDomainPtr domain_hdl, int data_n_index) 
    173173   { 
    174174      domain_hdl->data_n_index.setValue(data_n_index); 
    175175   } 
    176176    
    177    void xios_set_domain_data_i_index(XDomainPtr domain_hdl, int * data_i_index, int data_i_index_extent1) 
     177   void cxios_set_domain_data_i_index(XDomainPtr domain_hdl, int * data_i_index, int data_i_index_extent1) 
    178178   { 
    179179      ARRAY(int, 1) data_i_index_val(new CArray<int, 1>(boost::extents [data_i_index_extent1])); 
     
    183183   } 
    184184    
    185    void xios_set_domain_data_j_index(XDomainPtr domain_hdl, int * data_j_index, int data_j_index_extent1) 
     185   void cxios_set_domain_data_j_index(XDomainPtr domain_hdl, int * data_j_index, int data_j_index_extent1) 
    186186   { 
    187187      ARRAY(int, 1) data_j_index_val(new CArray<int, 1>(boost::extents [data_j_index_extent1])); 
     
    191191   } 
    192192     
    193    void xios_set_domain_lonvalue(XDomainPtr domain_hdl, double * lonvalue, int lonvalue_extent1) 
     193   void cxios_set_domain_lonvalue(XDomainPtr domain_hdl, double * lonvalue, int lonvalue_extent1) 
    194194   { 
    195195      ARRAY(double, 1) lonvalue_val(new CArray<double, 1>(boost::extents [lonvalue_extent1])); 
     
    199199   } 
    200200    
    201    void xios_set_domain_latvalue(XDomainPtr domain_hdl, double * latvalue, int latvalue_extent1) 
     201   void cxios_set_domain_latvalue(XDomainPtr domain_hdl, double * latvalue, int latvalue_extent1) 
    202202   { 
    203203      ARRAY(double, 1) latvalue_val(new CArray<double, 1>(boost::extents [latvalue_extent1])); 
     
    210210    
    211211    
    212    void xios_set_domaingroup_name(XDomainGroupPtr domaingroup_hdl, const char * name, int name_size) 
     212   void cxios_set_domaingroup_name(XDomainGroupPtr domaingroup_hdl, const char * name, int name_size) 
    213213   { 
    214214      std::string name_str;  
     
    218218   } 
    219219    
    220    void xios_set_domaingroup_standard_name(XDomainGroupPtr domaingroup_hdl, const char * standard_name, int standard_name_size) 
     220   void cxios_set_domaingroup_standard_name(XDomainGroupPtr domaingroup_hdl, const char * standard_name, int standard_name_size) 
    221221   { 
    222222      std::string standard_name_str;  
     
    226226   } 
    227227    
    228    void xios_set_domaingroup_long_name(XDomainGroupPtr domaingroup_hdl, const char * long_name, int long_name_size) 
     228   void cxios_set_domaingroup_long_name(XDomainGroupPtr domaingroup_hdl, const char * long_name, int long_name_size) 
    229229   { 
    230230      std::string long_name_str;  
     
    234234   } 
    235235    
    236    void xios_set_domaingroup_domain_group_ref(XDomainGroupPtr domaingroup_hdl, const char * domain_group_ref, int domain_group_ref_size) 
     236   void cxios_set_domaingroup_domain_group_ref(XDomainGroupPtr domaingroup_hdl, const char * domain_group_ref, int domain_group_ref_size) 
    237237   { 
    238238      std::string domain_group_ref_str;  
     
    242242   } 
    243243    
    244    void xios_set_domaingroup_ni_glo(XDomainGroupPtr domaingroup_hdl, int ni_glo) 
     244   void cxios_set_domaingroup_ni_glo(XDomainGroupPtr domaingroup_hdl, int ni_glo) 
    245245   { 
    246246      domaingroup_hdl->ni_glo.setValue(ni_glo); 
    247247   } 
    248248    
    249    void xios_set_domaingroup_nj_glo(XDomainGroupPtr domaingroup_hdl, int nj_glo) 
     249   void cxios_set_domaingroup_nj_glo(XDomainGroupPtr domaingroup_hdl, int nj_glo) 
    250250   { 
    251251      domaingroup_hdl->nj_glo.setValue(nj_glo); 
    252252   } 
    253253    
    254    void xios_set_domaingroup_ibegin(XDomainGroupPtr domaingroup_hdl, int ibegin) 
     254   void cxios_set_domaingroup_ibegin(XDomainGroupPtr domaingroup_hdl, int ibegin) 
    255255   { 
    256256      domaingroup_hdl->ibegin.setValue(ibegin); 
    257257   } 
    258258    
    259    void xios_set_domaingroup_iend(XDomainGroupPtr domaingroup_hdl, int iend) 
     259   void cxios_set_domaingroup_iend(XDomainGroupPtr domaingroup_hdl, int iend) 
    260260   { 
    261261      domaingroup_hdl->iend.setValue(iend); 
    262262   } 
    263263    
    264    void xios_set_domaingroup_ni(XDomainGroupPtr domaingroup_hdl, int ni) 
     264   void cxios_set_domaingroup_ni(XDomainGroupPtr domaingroup_hdl, int ni) 
    265265   { 
    266266      domaingroup_hdl->ni.setValue(ni); 
    267267   } 
    268268    
    269    void xios_set_domaingroup_jbegin(XDomainGroupPtr domaingroup_hdl, int jbegin) 
     269   void cxios_set_domaingroup_jbegin(XDomainGroupPtr domaingroup_hdl, int jbegin) 
    270270   { 
    271271      domaingroup_hdl->jbegin.setValue(jbegin); 
    272272   } 
    273273    
    274    void xios_set_domaingroup_jend(XDomainGroupPtr domaingroup_hdl, int jend) 
     274   void cxios_set_domaingroup_jend(XDomainGroupPtr domaingroup_hdl, int jend) 
    275275   { 
    276276      domaingroup_hdl->jend.setValue(jend); 
    277277   } 
    278278    
    279    void xios_set_domaingroup_nj(XDomainGroupPtr domaingroup_hdl, int nj) 
     279   void cxios_set_domaingroup_nj(XDomainGroupPtr domaingroup_hdl, int nj) 
    280280   { 
    281281      domaingroup_hdl->nj.setValue(nj); 
    282282   } 
    283283    
    284    void xios_set_domaingroup_mask(XDomainGroupPtr domaingroup_hdl, bool * mask, int mask_extent1, int mask_extent2) 
     284   void cxios_set_domaingroup_mask(XDomainGroupPtr domaingroup_hdl, bool * mask, int mask_extent1, int mask_extent2) 
    285285   { 
    286286      ARRAY(bool, 2) mask_val(new CArray<bool, 2>(boost::extents [mask_extent1][mask_extent2])); 
     
    290290   } 
    291291    
    292    void xios_set_domaingroup_data_dim(XDomainGroupPtr domaingroup_hdl, int data_dim) 
     292   void cxios_set_domaingroup_data_dim(XDomainGroupPtr domaingroup_hdl, int data_dim) 
    293293   { 
    294294      domaingroup_hdl->data_dim.setValue(data_dim); 
    295295   } 
    296296    
    297    void xios_set_domaingroup_data_ni(XDomainGroupPtr domaingroup_hdl, int data_ni) 
     297   void cxios_set_domaingroup_data_ni(XDomainGroupPtr domaingroup_hdl, int data_ni) 
    298298   { 
    299299      domaingroup_hdl->data_ni.setValue(data_ni); 
    300300   } 
    301301    
    302    void xios_set_domaingroup_data_nj(XDomainGroupPtr domaingroup_hdl, int data_nj) 
     302   void cxios_set_domaingroup_data_nj(XDomainGroupPtr domaingroup_hdl, int data_nj) 
    303303   { 
    304304      domaingroup_hdl->data_nj.setValue(data_nj); 
    305305   } 
    306306    
    307    void xios_set_domaingroup_data_ibegin(XDomainGroupPtr domaingroup_hdl, int data_ibegin) 
     307   void cxios_set_domaingroup_data_ibegin(XDomainGroupPtr domaingroup_hdl, int data_ibegin) 
    308308   { 
    309309      domaingroup_hdl->data_ibegin.setValue(data_ibegin); 
    310310   } 
    311311    
    312    void xios_set_domaingroup_data_jbegin(XDomainGroupPtr domaingroup_hdl, int data_jbegin) 
     312   void cxios_set_domaingroup_data_jbegin(XDomainGroupPtr domaingroup_hdl, int data_jbegin) 
    313313   { 
    314314      domaingroup_hdl->data_jbegin.setValue(data_jbegin); 
    315315   } 
    316316    
    317    void xios_set_domaingroup_zoom_ni(XDomainGroupPtr domaingroup_hdl, int zoom_ni) 
     317   void cxios_set_domaingroup_zoom_ni(XDomainGroupPtr domaingroup_hdl, int zoom_ni) 
    318318   { 
    319319      domaingroup_hdl->zoom_ni.setValue(zoom_ni); 
    320320   } 
    321321    
    322    void xios_set_domaingroup_zoom_nj(XDomainGroupPtr domaingroup_hdl, int zoom_nj) 
     322   void cxios_set_domaingroup_zoom_nj(XDomainGroupPtr domaingroup_hdl, int zoom_nj) 
    323323   { 
    324324      domaingroup_hdl->zoom_nj.setValue(zoom_nj); 
    325325   } 
    326326    
    327    void xios_set_domaingroup_zoom_ibegin(XDomainGroupPtr domaingroup_hdl, int zoom_ibegin) 
     327   void cxios_set_domaingroup_zoom_ibegin(XDomainGroupPtr domaingroup_hdl, int zoom_ibegin) 
    328328   { 
    329329      domaingroup_hdl->zoom_ibegin.setValue(zoom_ibegin); 
    330330   } 
    331331     
    332    void xios_set_domaingroup_zoom_jbegin(XDomainGroupPtr domaingroup_hdl, int zoom_jbegin) 
     332   void cxios_set_domaingroup_zoom_jbegin(XDomainGroupPtr domaingroup_hdl, int zoom_jbegin) 
    333333   { 
    334334      domaingroup_hdl->zoom_jbegin.setValue(zoom_jbegin); 
    335335   } 
    336336    
    337    void xios_set_domaingroup_zoom_ni_loc(XDomainGroupPtr domaingroup_hdl, int zoom_ni_loc) 
     337   void cxios_set_domaingroup_zoom_ni_loc(XDomainGroupPtr domaingroup_hdl, int zoom_ni_loc) 
    338338   { 
    339339      domaingroup_hdl->zoom_ni_loc.setValue(zoom_ni_loc); 
    340340   } 
    341341    
    342    void xios_set_domaingroup_zoom_nj_loc(XDomainGroupPtr domaingroup_hdl, int zoom_nj_loc) 
     342   void cxios_set_domaingroup_zoom_nj_loc(XDomainGroupPtr domaingroup_hdl, int zoom_nj_loc) 
    343343   { 
    344344      domaingroup_hdl->zoom_nj_loc.setValue(zoom_nj_loc); 
    345345   } 
    346346    
    347    void xios_set_domaingroup_zoom_ibegin_loc(XDomainGroupPtr domaingroup_hdl, int zoom_ibegin_loc) 
     347   void cxios_set_domaingroup_zoom_ibegin_loc(XDomainGroupPtr domaingroup_hdl, int zoom_ibegin_loc) 
    348348   { 
    349349      domaingroup_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc); 
    350350   } 
    351351    
    352    void xios_set_domaingroup_zoom_jbegin_loc(XDomainGroupPtr domaingroup_hdl, int zoom_jbegin_loc) 
     352   void cxios_set_domaingroup_zoom_jbegin_loc(XDomainGroupPtr domaingroup_hdl, int zoom_jbegin_loc) 
    353353   { 
    354354      domaingroup_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc); 
    355355   } 
    356356    
    357    void xios_set_domaingroup_data_n_index(XDomainGroupPtr domaingroup_hdl, int data_n_index) 
     357   void cxios_set_domaingroup_data_n_index(XDomainGroupPtr domaingroup_hdl, int data_n_index) 
    358358   { 
    359359      domaingroup_hdl->data_n_index.setValue(data_n_index); 
    360360   } 
    361361    
    362    void xios_set_domaingroup_data_i_index(XDomainGroupPtr domaingroup_hdl, int * data_i_index, int data_i_index_extent1) 
     362   void cxios_set_domaingroup_data_i_index(XDomainGroupPtr domaingroup_hdl, int * data_i_index, int data_i_index_extent1) 
    363363   { 
    364364      ARRAY(int, 1) data_i_index_val(new CArray<int, 1>(boost::extents [data_i_index_extent1])); 
     
    368368   } 
    369369    
    370    void xios_set_domaingroup_data_j_index(XDomainGroupPtr domaingroup_hdl, int * data_j_index, int data_j_index_extent1) 
     370   void cxios_set_domaingroup_data_j_index(XDomainGroupPtr domaingroup_hdl, int * data_j_index, int data_j_index_extent1) 
    371371   { 
    372372      ARRAY(int, 1) data_j_index_val(new CArray<int, 1>(boost::extents [data_j_index_extent1])); 
     
    376376   } 
    377377     
    378    void xios_set_domaingroup_lonvalue(XDomainGroupPtr domaingroup_hdl, double * lonvalue, int lonvalue_extent1) 
     378   void cxios_set_domaingroup_lonvalue(XDomainGroupPtr domaingroup_hdl, double * lonvalue, int lonvalue_extent1) 
    379379   { 
    380380      ARRAY(double, 1) lonvalue_val(new CArray<double, 1>(boost::extents [lonvalue_extent1])); 
     
    384384   } 
    385385    
    386    void xios_set_domaingroup_latvalue(XDomainGroupPtr domaingroup_hdl, double * latvalue, int latvalue_extent1) 
     386   void cxios_set_domaingroup_latvalue(XDomainGroupPtr domaingroup_hdl, double * latvalue, int latvalue_extent1) 
    387387   { 
    388388      ARRAY(double, 1) latvalue_val(new CArray<double, 1>(boost::extents [latvalue_extent1])); 
     
    394394   // ------------------------ Création des handle ----------------------------- 
    395395    
    396    void xios_domain_handle_create (XDomainPtr * _ret, const char * _id, int _id_len) 
     396   void cxios_domain_handle_create (XDomainPtr * _ret, const char * _id, int _id_len) 
    397397   { 
    398398      std::string id;  
     
    402402   } 
    403403    
    404    void xios_domaingroup_handle_create (XDomainGroupPtr * _ret, const char * _id, int _id_len) 
     404   void cxios_domaingroup_handle_create (XDomainGroupPtr * _ret, const char * _id, int _id_len) 
    405405   { 
    406406      std::string id;  
     
    412412   // -------------------- Vérification des identifiants ----------------------- 
    413413 
    414    void xios_domain_valid_id (bool * _ret, const char * _id, int _id_len) 
     414   void cxios_domain_valid_id (bool * _ret, const char * _id, int _id_len) 
    415415   { 
    416416      std::string id; 
     
    420420   } 
    421421 
    422    void xios_domaingroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     422   void cxios_domaingroup_valid_id (bool * _ret, const char * _id, int _id_len) 
    423423   { 
    424424      std::string id; 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icfield.cpp

    r280 r286  
    2525   // ------------------------- Attributs des champs --------------------------- 
    2626    
    27    void xios_set_field_name(XFieldPtr field_hdl, const char * name, int name_size) 
     27   void cxios_set_field_name(XFieldPtr field_hdl, const char * name, int name_size) 
    2828   { 
    2929      std::string name_str;  
     
    3333   } 
    3434    
    35    void xios_set_field_standard_name(XFieldPtr field_hdl, const char * standard_name, int standard_name_size) 
     35   void cxios_set_field_standard_name(XFieldPtr field_hdl, const char * standard_name, int standard_name_size) 
    3636   { 
    3737      std::string standard_name_str;  
     
    4141   } 
    4242    
    43    void xios_set_field_long_name(XFieldPtr field_hdl, const char * long_name, int long_name_size) 
     43   void cxios_set_field_long_name(XFieldPtr field_hdl, const char * long_name, int long_name_size) 
    4444   { 
    4545      std::string long_name_str;  
     
    4949   } 
    5050    
    51    void xios_set_field_unit(XFieldPtr field_hdl, const char * unit, int unit_size) 
     51   void cxios_set_field_unit(XFieldPtr field_hdl, const char * unit, int unit_size) 
    5252   { 
    5353      std::string unit_str;  
     
    5757   } 
    5858    
    59    void xios_set_field_operation(XFieldPtr field_hdl, const char * operation, int operation_size)  
     59   void cxios_set_field_operation(XFieldPtr field_hdl, const char * operation, int operation_size)  
    6060   { 
    6161      std::string operation_str;  
     
    6565   } 
    6666    
    67    void xios_set_field_freq_op(XFieldPtr field_hdl, const char * freq_op, int freq_op_size) 
     67   void cxios_set_field_freq_op(XFieldPtr field_hdl, const char * freq_op, int freq_op_size) 
    6868   { 
    6969      std::string freq_op_str;  
     
    7373   } 
    7474    
    75    void xios_set_field_level(XFieldPtr field_hdl, int level) 
     75   void cxios_set_field_level(XFieldPtr field_hdl, int level) 
    7676   { 
    7777      field_hdl->level.setValue(level); 
    7878   } 
    7979    
    80    void xios_set_field_prec(XFieldPtr field_hdl, int prec) 
     80   void cxios_set_field_prec(XFieldPtr field_hdl, int prec) 
    8181   { 
    8282      field_hdl->prec.setValue(prec); 
    8383   } 
    8484    
    85    void xios_set_field_enabled(XFieldPtr field_hdl, bool enabled) 
     85   void cxios_set_field_enabled(XFieldPtr field_hdl, bool enabled) 
    8686   { 
    8787      field_hdl->enabled.setValue(enabled); 
    8888   } 
    8989    
    90    void xios_set_field_domain_ref(XFieldPtr field_hdl,  const char * domain_ref, int domain_ref_size) 
     90   void cxios_set_field_domain_ref(XFieldPtr field_hdl,  const char * domain_ref, int domain_ref_size) 
    9191   { 
    9292      std::string domain_ref_str;  
     
    9696   } 
    9797    
    98    void xios_set_field_axis_ref(XFieldPtr field_hdl,  const char * axis_ref,  int axis_ref_size) 
     98   void cxios_set_field_axis_ref(XFieldPtr field_hdl,  const char * axis_ref,  int axis_ref_size) 
    9999   { 
    100100      std::string axis_ref_str;  
     
    104104   } 
    105105    
    106    void xios_set_field_grid_ref(XFieldPtr field_hdl,  const char * grid_ref, int grid_ref_size) 
     106   void cxios_set_field_grid_ref(XFieldPtr field_hdl,  const char * grid_ref, int grid_ref_size) 
    107107   { 
    108108      std::string grid_ref_str;  
     
    112112   } 
    113113    
    114    void xios_set_field_field_ref(XFieldPtr field_hdl,  const char * field_ref,  int field_ref_size) 
     114   void cxios_set_field_field_ref(XFieldPtr field_hdl,  const char * field_ref,  int field_ref_size) 
    115115   { 
    116116      std::string field_ref_str;  
     
    120120   } 
    121121    
    122    void xios_set_field_default_value(XFieldPtr field_hdl, double default_value) 
     122   void cxios_set_field_default_value(XFieldPtr field_hdl, double default_value) 
    123123   { 
    124124      field_hdl->default_value.setValue(default_value); 
     
    127127   // -------------------- Attributs des groupes de champs --------------------- 
    128128   
    129    void xios_set_fieldgroup_name(XFieldGroupPtr fieldgroup_hdl, const char * name, int name_size) 
     129   void cxios_set_fieldgroup_name(XFieldGroupPtr fieldgroup_hdl, const char * name, int name_size) 
    130130   { 
    131131      std::string name_str;  
     
    135135   } 
    136136    
    137    void xios_set_fieldgroup_standard_name(XFieldGroupPtr fieldgroup_hdl, const char * standard_name, int standard_name_size) 
     137   void cxios_set_fieldgroup_standard_name(XFieldGroupPtr fieldgroup_hdl, const char * standard_name, int standard_name_size) 
    138138   { 
    139139      std::string standard_name_str;  
     
    143143   } 
    144144    
    145    void xios_set_fieldgroup_long_name(XFieldGroupPtr fieldgroup_hdl, const char * long_name, int long_name_size) 
     145   void cxios_set_fieldgroup_long_name(XFieldGroupPtr fieldgroup_hdl, const char * long_name, int long_name_size) 
    146146   { 
    147147      std::string long_name_str;  
     
    151151   } 
    152152    
    153    void xios_set_fieldgroup_unit(XFieldGroupPtr fieldgroup_hdl, const char * unit, int unit_size) 
     153   void cxios_set_fieldgroup_unit(XFieldGroupPtr fieldgroup_hdl, const char * unit, int unit_size) 
    154154   { 
    155155      std::string unit_str;  
     
    159159   } 
    160160    
    161    void xios_set_fieldgroup_operation(XFieldGroupPtr fieldgroup_hdl, const char * operation, int operation_size)  
     161   void cxios_set_fieldgroup_operation(XFieldGroupPtr fieldgroup_hdl, const char * operation, int operation_size)  
    162162   { 
    163163      std::string operation_str;  
     
    167167   } 
    168168    
    169    void xios_set_fieldgroup_freq_op(XFieldGroupPtr fieldgroup_hdl, const char * freq_op, int freq_op_size) 
     169   void cxios_set_fieldgroup_freq_op(XFieldGroupPtr fieldgroup_hdl, const char * freq_op, int freq_op_size) 
    170170   { 
    171171      std::string freq_op_str;  
     
    175175   } 
    176176    
    177    void xios_set_fieldgroup_level(XFieldGroupPtr fieldgroup_hdl, int level) 
     177   void cxios_set_fieldgroup_level(XFieldGroupPtr fieldgroup_hdl, int level) 
    178178   { 
    179179      fieldgroup_hdl->level.setValue(level); 
    180180   } 
    181181    
    182    void xios_set_fieldgroup_prec(XFieldGroupPtr fieldgroup_hdl, int prec) 
     182   void cxios_set_fieldgroup_prec(XFieldGroupPtr fieldgroup_hdl, int prec) 
    183183   { 
    184184      fieldgroup_hdl->prec.setValue(prec); 
    185185   } 
    186186    
    187    void xios_set_fieldgroup_enabled(XFieldGroupPtr fieldgroup_hdl, bool enabled) 
     187   void cxios_set_fieldgroup_enabled(XFieldGroupPtr fieldgroup_hdl, bool enabled) 
    188188   { 
    189189      fieldgroup_hdl->enabled.setValue(enabled); 
    190190   } 
    191191    
    192    void xios_set_fieldgroup_domain_ref(XFieldGroupPtr fieldgroup_hdl,  const char * domain_ref, int domain_ref_size) 
     192   void cxios_set_fieldgroup_domain_ref(XFieldGroupPtr fieldgroup_hdl,  const char * domain_ref, int domain_ref_size) 
    193193   { 
    194194      std::string domain_ref_str;  
     
    198198   } 
    199199    
    200    void xios_set_fieldgroup_axis_ref(XFieldGroupPtr fieldgroup_hdl,  const char * axis_ref,  int axis_ref_size) 
     200   void cxios_set_fieldgroup_axis_ref(XFieldGroupPtr fieldgroup_hdl,  const char * axis_ref,  int axis_ref_size) 
    201201   { 
    202202      std::string axis_ref_str;  
     
    206206   } 
    207207    
    208    void xios_set_fieldgroup_grid_ref(XFieldGroupPtr fieldgroup_hdl,  const char * grid_ref, int grid_ref_size) 
     208   void cxios_set_fieldgroup_grid_ref(XFieldGroupPtr fieldgroup_hdl,  const char * grid_ref, int grid_ref_size) 
    209209   { 
    210210      std::string grid_ref_str;  
     
    214214   } 
    215215    
    216    void xios_set_fieldgroup_field_ref(XFieldGroupPtr fieldgroup_hdl,  const char * field_ref,  int field_ref_size) 
     216   void cxios_set_fieldgroup_field_ref(XFieldGroupPtr fieldgroup_hdl,  const char * field_ref,  int field_ref_size) 
    217217   { 
    218218      std::string field_ref_str;  
     
    222222   } 
    223223    
    224    void xios_set_fieldgroup_default_value(XFieldGroupPtr fieldgroup_hdl, double default_value) 
     224   void cxios_set_fieldgroup_default_value(XFieldGroupPtr fieldgroup_hdl, double default_value) 
    225225   { 
    226226      fieldgroup_hdl->default_value.setValue(default_value); 
     
    229229   // ------------------------ Création des handle ----------------------------- 
    230230    
    231    void xios_field_handle_create (XFieldPtr * _ret, const char * _id, int _id_len) 
     231   void cxios_field_handle_create (XFieldPtr * _ret, const char * _id, int _id_len) 
    232232   { 
    233233      std::string id;  
     
    237237   } 
    238238    
    239    void xios_fieldgroup_handle_create (XFieldGroupPtr * _ret, const char * _id, int _id_len) 
     239   void cxios_fieldgroup_handle_create (XFieldGroupPtr * _ret, const char * _id, int _id_len) 
    240240   { 
    241241      std::string id;  
     
    248248   // -------------------- Vérification des identifiants ----------------------- 
    249249 
    250    void xios_field_valid_id (bool * _ret, const char * _id, int _id_len) 
     250   void cxios_field_valid_id (bool * _ret, const char * _id, int _id_len) 
    251251   { 
    252252      std::string id; 
     
    256256   } 
    257257 
    258    void xios_fieldgroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     258   void cxios_fieldgroup_valid_id (bool * _ret, const char * _id, int _id_len) 
    259259   { 
    260260      std::string id; 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icfile.cpp

    r280 r286  
    2525   // ------------------------- Attributs des axes ----------------------------- 
    2626    
    27    void xios_set_file_name(XFilePtr file_hdl, const char * name, int name_size) 
     27   void cxios_set_file_name(XFilePtr file_hdl, const char * name, int name_size) 
    2828   { 
    2929      std::string name_str;  
     
    3333   } 
    3434    
    35    void xios_set_file_description(XFilePtr file_hdl, const char * description, int description_size) 
     35   void cxios_set_file_description(XFilePtr file_hdl, const char * description, int description_size) 
    3636   { 
    3737      std::string description_str;  
     
    4141   }  
    4242    
    43    void xios_set_file_name_suffix(XFilePtr file_hdl, const char * name_suffix, int name_suffix_size) 
     43   void cxios_set_file_name_suffix(XFilePtr file_hdl, const char * name_suffix, int name_suffix_size) 
    4444   { 
    4545      std::string name_suffix_str;  
     
    4949   }  
    5050    
    51    void xios_set_file_output_freq(XFilePtr file_hdl, const char * output_freq, int output_freq_size) 
     51   void cxios_set_file_output_freq(XFilePtr file_hdl, const char * output_freq, int output_freq_size) 
    5252   { 
    5353      std::string output_freq_str;  
     
    5757   } 
    5858    
    59    void xios_set_file_output_level(XFilePtr file_hdl, int output_level) 
     59   void cxios_set_file_output_level(XFilePtr file_hdl, int output_level) 
    6060   { 
    6161      file_hdl->output_level.setValue(output_level); 
    6262   } 
    6363    
    64    void xios_set_file_enabled(XFilePtr file_hdl, bool enabled) 
     64   void cxios_set_file_enabled(XFilePtr file_hdl, bool enabled) 
    6565   { 
    6666      file_hdl->enabled.setValue(enabled); 
     
    6969   // -------------------- Attributs des groupes d'axes ------------------------ 
    7070    
    71    void xios_set_filegroup_name(XFileGroupPtr filegroup_hdl, const char * name, int name_size) 
     71   void cxios_set_filegroup_name(XFileGroupPtr filegroup_hdl, const char * name, int name_size) 
    7272   { 
    7373      std::string name_str;  
     
    7878   } 
    7979    
    80    void xios_set_filegroup_description(XFileGroupPtr filegroup_hdl, const char * description, int description_size) 
     80   void cxios_set_filegroup_description(XFileGroupPtr filegroup_hdl, const char * description, int description_size) 
    8181   { 
    8282      std::string description_str;  
     
    8686   }  
    8787    
    88    void xios_set_filegroup_name_suffix(XFileGroupPtr filegroup_hdl, const char * name_suffix, int name_suffix_size) 
     88   void cxios_set_filegroup_name_suffix(XFileGroupPtr filegroup_hdl, const char * name_suffix, int name_suffix_size) 
    8989   { 
    9090      std::string name_suffix_str;  
     
    9494   }  
    9595    
    96    void xios_set_filegroup_output_freq(XFileGroupPtr filegroup_hdl, const char * output_freq, int output_freq_size) 
     96   void cxios_set_filegroup_output_freq(XFileGroupPtr filegroup_hdl, const char * output_freq, int output_freq_size) 
    9797   { 
    9898      std::string output_freq_str;  
     
    102102   } 
    103103    
    104    void xios_set_filegroup_output_level(XFileGroupPtr filegroup_hdl, int output_level) 
     104   void cxios_set_filegroup_output_level(XFileGroupPtr filegroup_hdl, int output_level) 
    105105   { 
    106106      filegroup_hdl->output_level.setValue(output_level); 
    107107   } 
    108108    
    109    void xios_set_filegroup_enabled(XFileGroupPtr filegroup_hdl, bool enabled) 
     109   void cxios_set_filegroup_enabled(XFileGroupPtr filegroup_hdl, bool enabled) 
    110110   { 
    111111      filegroup_hdl->enabled.setValue(enabled); 
     
    114114   // ------------------------ Création des handle ----------------------------- 
    115115    
    116    void xios_file_handle_create (XFilePtr * _ret, const char * _id, int _id_len) 
     116   void cxios_file_handle_create (XFilePtr * _ret, const char * _id, int _id_len) 
    117117   { 
    118118      std::string id;  
     
    122122   } 
    123123    
    124    void xios_filegroup_handle_create (XFileGroupPtr * _ret, const char * _id, int _id_len) 
     124   void cxios_filegroup_handle_create (XFileGroupPtr * _ret, const char * _id, int _id_len) 
    125125   { 
    126126      std::string id;  
     
    132132   // -------------------- Vérification des identifiants ----------------------- 
    133133 
    134    void xios_file_valid_id (bool * _ret, const char * _id, int _id_len) 
     134   void cxios_file_valid_id (bool * _ret, const char * _id, int _id_len) 
    135135   { 
    136136      std::string id; 
     
    140140   } 
    141141 
    142    void xios_filegroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     142   void cxios_filegroup_valid_id (bool * _ret, const char * _id, int _id_len) 
    143143   { 
    144144      std::string id; 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icgrid.cpp

    r280 r286  
    2525   // ------------------------- Attributs des axes ----------------------------- 
    2626    
    27    void xios_set_grid_name(XGridPtr grid_hdl, const char * name,  int name_size) 
     27   void cxios_set_grid_name(XGridPtr grid_hdl, const char * name,  int name_size) 
    2828   { 
    2929      std::string name_str;  
     
    3333   } 
    3434    
    35    void xios_set_grid_description(XGridPtr grid_hdl, const char * description,  int description_size) 
     35   void cxios_set_grid_description(XGridPtr grid_hdl, const char * description,  int description_size) 
    3636   { 
    3737      std::string description_str;  
     
    4141   } 
    4242    
    43    void xios_set_grid_domain_ref(XGridPtr grid_hdl, const char * domain_ref,  int domain_ref_size) 
     43   void cxios_set_grid_domain_ref(XGridPtr grid_hdl, const char * domain_ref,  int domain_ref_size) 
    4444   { 
    4545      std::string domain_ref_str;  
     
    4949   } 
    5050    
    51    void xios_set_grid_axis_ref(XGridPtr grid_hdl, const char * axis_ref,  int axis_ref_size) 
     51   void cxios_set_grid_axis_ref(XGridPtr grid_hdl, const char * axis_ref,  int axis_ref_size) 
    5252   { 
    5353      std::string axis_ref_str;  
     
    5959   // -------------------- Attributs des groupes de grilles -------------------- 
    6060    
    61    void xios_set_gridgroup_name(XGridGroupPtr gridgroup_hdl, const char * name,  int name_size) 
     61   void cxios_set_gridgroup_name(XGridGroupPtr gridgroup_hdl, const char * name,  int name_size) 
    6262   { 
    6363      std::string name_str;  
     
    6767   } 
    6868    
    69    void xios_set_gridgroup_description(XGridGroupPtr gridgroup_hdl, const char * description,  int description_size) 
     69   void cxios_set_gridgroup_description(XGridGroupPtr gridgroup_hdl, const char * description,  int description_size) 
    7070   { 
    7171      std::string description_str;  
     
    7575   } 
    7676    
    77    void xios_set_gridgroup_domain_ref(XGridGroupPtr gridgroup_hdl, const char * domain_ref,  int domain_ref_size) 
     77   void cxios_set_gridgroup_domain_ref(XGridGroupPtr gridgroup_hdl, const char * domain_ref,  int domain_ref_size) 
    7878   { 
    7979      std::string domain_ref_str;  
     
    8383   } 
    8484    
    85    void xios_set_gridgroup_axis_ref(XGridGroupPtr gridgroup_hdl, const char * axis_ref,  int axis_ref_size) 
     85   void cxios_set_gridgroup_axis_ref(XGridGroupPtr gridgroup_hdl, const char * axis_ref,  int axis_ref_size) 
    8686   { 
    8787      std::string axis_ref_str;  
     
    9393   // ------------------------ Création des handle ----------------------------- 
    9494   
    95    void xios_grid_handle_create (XGridPtr * _ret, const char * _id, int _id_len) 
     95   void cxios_grid_handle_create (XGridPtr * _ret, const char * _id, int _id_len) 
    9696   { 
    9797      std::string id;  
     
    101101   } 
    102102    
    103    void xios_gridgroup_handle_create (XGridGroupPtr * _ret, const char * _id, int _id_len) 
     103   void cxios_gridgroup_handle_create (XGridGroupPtr * _ret, const char * _id, int _id_len) 
    104104   { 
    105105      std::string id;  
     
    111111   // -------------------- Vérification des identifiants ----------------------- 
    112112 
    113    void xios_grid_valid_id (bool * _ret, const char * _id, int _id_len) 
     113   void cxios_grid_valid_id (bool * _ret, const char * _id, int _id_len) 
    114114   { 
    115115      std::string id; 
     
    119119   } 
    120120 
    121    void xios_gridgroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     121   void cxios_gridgroup_valid_id (bool * _ret, const char * _id, int _id_len) 
    122122   { 
    123123      std::string id; 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icxml_tree.cpp

    r274 r286  
    3939   // ----------------------- Ajout d'enfant à un parent ----------------------- 
    4040    
    41    void xios_xml_tree_add_field 
     41   void cxios_xml_tree_add_field 
    4242      (XFieldGroupPtr  parent_, XFieldPtr * child_, const char * child_id, int child_id_size) 
    4343   { 
     
    5252   } 
    5353    
    54    void xios_xml_tree_add_grid 
     54   void cxios_xml_tree_add_grid 
    5555      (XGridGroupPtr   parent_, XGridPtr * child_, const char * child_id, int child_id_size) 
    5656   { 
     
    6565   } 
    6666    
    67    void xios_xml_tree_add_file 
     67   void cxios_xml_tree_add_file 
    6868      (XFileGroupPtr parent_, XFilePtr * child_, const char * child_id, int child_id_size) 
    6969   { 
     
    7878   } 
    7979    
    80    void xios_xml_tree_add_axis 
     80   void cxios_xml_tree_add_axis 
    8181      (XAxisGroupPtr parent_, XAxisPtr * child_, const char * child_id, int child_id_size) 
    8282   { 
     
    9191   } 
    9292    
    93    void xios_xml_tree_add_domain 
     93   void cxios_xml_tree_add_domain 
    9494      (XDomainGroupPtr parent_, XDomainPtr * child_, const char * child_id, int child_id_size) 
    9595   { 
     
    104104   } 
    105105    
    106    void xios_xml_tree_add_fieldtofile 
     106   void cxios_xml_tree_add_fieldtofile 
    107107      (XFilePtr parent_, XFieldPtr * child_, const char * child_id, int child_id_size) 
    108108   { 
     
    122122   // ----------------------- Ajout de groupe à un parent ---------------------- 
    123123 
    124    void xios_xml_tree_add_fieldgroup 
     124   void cxios_xml_tree_add_fieldgroup 
    125125      (XFieldGroupPtr  parent_, XFieldGroupPtr * child_, const char * child_id, int child_id_size) 
    126126   { 
     
    135135   } 
    136136 
    137    void xios_xml_tree_add_gridgroup 
     137   void cxios_xml_tree_add_gridgroup 
    138138      (XGridGroupPtr   parent_, XGridGroupPtr * child_, const char * child_id, int child_id_size) 
    139139   { 
     
    148148   } 
    149149 
    150    void xios_xml_tree_add_filegroup 
     150   void cxios_xml_tree_add_filegroup 
    151151      (XFileGroupPtr parent_, XFileGroupPtr * child_, const char * child_id, int child_id_size) 
    152152   { 
     
    161161   } 
    162162 
    163    void xios_xml_tree_add_axisgroup 
     163   void cxios_xml_tree_add_axisgroup 
    164164      (XAxisGroupPtr parent_, XAxisGroupPtr * child_, const char * child_id, int child_id_size) 
    165165   { 
     
    174174   } 
    175175 
    176    void xios_xml_tree_add_domaingroup 
     176   void cxios_xml_tree_add_domaingroup 
    177177      (XDomainGroupPtr parent_, XDomainGroupPtr * child_, const char * child_id, int child_id_size) 
    178178   { 
     
    187187   } 
    188188 
    189    void xios_xml_tree_add_fieldgrouptofile 
     189   void cxios_xml_tree_add_fieldgrouptofile 
    190190      (XFilePtr parent_, XFieldGroupPtr * child_, const char * child_id, int child_id_size) 
    191191   { 
     
    206206   // ----------------------- Affichage de l'arborescence ---------------------- 
    207207    
    208    void xios_xml_tree_show   (const char * filename, int filename_size)  
     208   void cxios_xml_tree_show   (const char * filename, int filename_size)  
    209209   { 
    210210      std::string filename_str; 
     
    226226   // ----------------------- Parsing de document xml -------------------------- 
    227227    
    228    void xios_xml_parse_file  (const char * filename  , int filename_size) 
     228   void cxios_xml_parse_file  (const char * filename  , int filename_size) 
    229229   { 
    230230      std::string filename_str;  
     
    242242   } 
    243243    
    244    void xios_xml_parse_string(const char * xmlcontent, int xmlcontent_size) 
     244   void cxios_xml_parse_string(const char * xmlcontent, int xmlcontent_size) 
    245245   { 
    246246      std::string xmlcontent_str;  
  • XMLIO_V2/dev/common/src/xmlio/functor/maximum.cpp

    r266 r286  
    2626         if (this->nbcall == 1) 
    2727              for (; it1 != end1; it1++, it++) *it = *it1; 
    28          else for (; it1 != end1; it1++, it++) *it = std::max(*it1, *it);   
     28         else for (; it1 != end1; it1++, it++) *it = std::max(*it1, *it); 
     29 
     30         it1  = _dinput->data(), 
     31         end1 = _dinput->data() + _dinput->num_elements(); 
     32         it  = _doutput->data(); 
     33         double sum=0 ; 
     34         for (; it1 != end1; it1++, it++) sum+=*it; 
    2935      } 
    3036 
  • XMLIO_V2/dev/common/src/xmlio/group_factory_impl.hpp

    r219 r286  
    4646      if (id.size() == 0) 
    4747      { 
    48          boost::shared_ptr<U> value = CObjectFactory::CreateObject<U>(); 
     48         boost::shared_ptr<U> value = CObjectFactory::CreateObject<U>(CObjectFactory::GenUId<U>()); 
    4949         group->groupList.insert(group->groupList.end(), value); 
     50         group->groupMap.insert(std::make_pair(value->getId(), value)); 
    5051         return (value); 
    5152      } 
     
    7273               CObjectFactory::CreateObject<typename U::RelChild>(); 
    7374         group->childList.insert(group->childList.end(), value); 
     75         group->childMap.insert(std::make_pair(value->getId(), value)); 
    7476         return (value); 
    7577      } 
  • XMLIO_V2/dev/common/src/xmlio/main_server.cpp

    r278 r286  
    77#include "client.hpp" 
    88#include "server.hpp" 
    9 extern "C" 
    10 { 
    11    void xios_dtreatment_start(tree::CContext * context_hdl, int filetype, int comm_client_server, int comm_server); 
    12    void xios_set_timestep(double ts_year, double ts_month,  double ts_day, 
    13                           double ts_hour, double ts_minute, double ts_second); 
    14    void xios_write_data_k83(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize, int data_Ysize, int data_Zsize); 
    15    void xios_update_calendar(int step); 
    16 } 
     9#include "oasis_cinterface.hpp" 
     10#include <string> 
     11#include <iostream> 
     12 
     13#include <unistd.h> 
     14 
     15 
    1716// Point d'entrée du programme principal 
    1817 
     
    2120   try 
    2221   { 
    23       MPIComm comm_client, comm_client_server, comm_server; 
    24       CXIOSManager::Initialise (CXIOSManager::CLIENT_SERVER, &argc, &argv); 
    25       CMPIManager::DispatchClient(true, comm_client, comm_client_server,  comm_server); 
     22      MPI_Comm comm_client=MPI_COMM_NULL, comm_client_server=MPI_COMM_NULL, comm_server=MPI_COMM_NULL, comm_parent=MPI_COMM_NULL; 
     23//      sleep(60) ; 
     24      CTreeManager::ParseFile("iodef.xml"); 
     25 
     26      CTreeManager::SetCurrentContextId(StdString("xios")); 
     27      boost::shared_ptr<CVariable> var = CObjectFactory::GetObject<CVariable>("buffer_client_size");  
     28      std::cout<<CObjectFactory::GetObject<CVariable>("xios","using_oasis")->getData<bool>()<<std::endl; 
     29      
     30//      oasis_init(std::string("ionemo")) ; 
     31//      std::cout<<"Initialisation OASIS Ok"<<std::endl ; 
     32//      oasis_get_intracomm(comm_parent,std::string("oceanx")) ; 
     33//      std::cout<<"Appel Oasis intracom Ok"<<std::endl ; 
     34      CXIOSManager::Initialise(CXIOSManager::CLIENT_SERVER, &argc, &argv); 
     35      
     36      std::cout<<"Appel Dispatch client ?"<<std::endl ; 
     37      std::cout<<comm_client<<" "<<comm_client_server<<" "<<comm_server<<"  "<<comm_parent<<std::endl ; 
     38      CMPIManager::DispatchClient(true, comm_client, comm_client_server, comm_server, comm_parent); 
     39      std::cout<<"Appel Dispatch client Ok"<<std::endl ; 
    2640      CXIOSManager::RunServer("Nemo", comm_client_server, comm_server); 
    27       CXIOSManager::Finalize ();          
     41      CTreeManager::SetCurrentContextId(StdString("nemo")); 
     42      CServer::CreateServer(comm_client_server)->run(); 
     43      CXIOSManager::Finalize ();   
     44 
    2845   } 
    2946   catch (CException & exc) 
  • XMLIO_V2/dev/common/src/xmlio/manager/mpi_manager.cpp

    r274 r286  
    1212  
    1313// XMLIOServer headers 
     14#include "xmlioserver.hpp" 
    1415#include "mpi_manager.hpp" 
     16#include "oasis_cinterface.hpp" 
    1517 
    1618 
     
    2123 
    2224   // ---------------------- Initialisation & Finalisation --------------------- 
     25 
     26   bool CMPIManager::Initialized=false ; 
     27   MPI_Comm CMPIManager::CommClient ; 
     28   MPI_Comm CMPIManager::CommServer ; 
     29   MPI_Comm CMPIManager::CommClientServer ; 
     30   int CMPIManager::NbClient ; 
     31   int CMPIManager::NbServer ;    
     32   bool CMPIManager::_IsClient ; 
     33   bool CMPIManager::_IsServer ;    
     34   bool CMPIManager::using_server ; 
     35   bool CMPIManager::using_oasis ; 
     36 
    2337 
    2438   void CMPIManager::Initialise(int * _argc, char *** _argv) 
     
    3145         if (MPI_Init(_argc, _argv) != MPI_SUCCESS) 
    3246            ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !"); 
    33       } 
    34  
    35    } 
    36     
     47         Initialized=true ; 
     48      } 
     49 
     50   } 
     51   void CMPIManager::InitialiseClient(int * _argc, char *** _argv) 
     52   { 
     53      int flag = 0; 
     54      using_oasis=CObjectFactory::GetObject<CVariable>("xios","using_oasis")->getData<bool>() ;  
     55      using_server=CObjectFactory::GetObject<CVariable>("xios","using_server")->getData<bool>();  
     56 
     57      Initialized=false ; 
     58 
     59      if (MPI_Initialized(&flag) != MPI_SUCCESS) 
     60         ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !"); 
     61 
     62      if (!flag) 
     63      { 
     64         if (using_oasis)  
     65         { 
     66           StdString oasisClientId=CObjectFactory::GetObject<CVariable>("xios","client_id")->getData<StdString>(); 
     67           oasis_init(oasisClientId) ; 
     68         } 
     69         else 
     70         {         
     71           if (MPI_Init(_argc, _argv) != MPI_SUCCESS) 
     72            ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !"); 
     73         } 
     74         Initialized=true ; 
     75       } 
     76 
     77   } 
     78    
     79   void CMPIManager::InitialiseServer(int * _argc, char *** _argv) 
     80   { 
     81      int flag = 0; 
     82       
     83      using_oasis=CObjectFactory::GetObject<CVariable>("xios","using_oasis")->getData<bool>();  
     84      using_server=CObjectFactory::GetObject<CVariable>("xios","using_server")->getData<bool>();  
     85    
     86      if (using_oasis) 
     87      { 
     88         StdString oasisServerId=CObjectFactory::GetObject<CVariable>("xios","server_id")->getData<StdString>();  
     89         oasis_init(oasisServerId) ; 
     90      } 
     91      else 
     92      { 
     93         if (MPI_Init(_argc, _argv) != MPI_SUCCESS) 
     94            ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !"); 
     95      } 
     96      Initialized=true ; 
     97   } 
     98     
    3799   void CMPIManager::Finalize(void) 
    38100   { 
    39       if (MPI_Finalize() != MPI_SUCCESS) 
    40          ERROR("CMPIManager::Finalize(void)", << " MPI Error !"); 
     101      if (Initialized) 
     102      { 
     103        if (using_oasis) oasis_finalize() ; 
     104        else if (MPI_Finalize() != MPI_SUCCESS) 
     105                ERROR("CMPIManager::Finalize(void)", << " MPI Error !"); 
     106      } 
    41107   } 
    42108    
     
    86152                                    MPI_Comm   _comm_parent) 
    87153   { 
     154      if (_is_server) { _IsServer=true ; _IsClient=false ; } 
     155      else { _IsServer=false ; _IsClient=true; } 
     156 
     157      if (_is_server) 
     158      { 
     159        if (using_oasis) 
     160        { 
     161          StdString oasisClientId=CObjectFactory::GetObject<CVariable>("xios","client_id")->getData<StdString>() ; 
     162          oasis_get_intracomm(_comm_parent,oasisClientId) ; 
     163        } 
     164        else _comm_parent=MPI_COMM_WORLD ; 
     165      } 
     166      else 
     167      { 
     168        if (!using_server) 
     169        { 
     170          NbClient=GetCommSize(_comm_parent) ; 
     171          NbServer=0 ; 
     172          _comm_server = _comm_client = _comm_parent ; 
     173          CommClient=_comm_client ; 
     174          CommServer=_comm_server ; 
     175          CommClientServer=_comm_client_server ; 
     176           return false ; 
     177        } 
     178        if (using_oasis)   
     179        { 
     180          StdString oasisServerId=CObjectFactory::GetObject<CVariable>("xios","server_id")->getData<StdString>() ; 
     181          oasis_get_intracomm(_comm_parent,oasisServerId) ; 
     182        } 
     183      }     
     184       
     185       
    88186      int value = (_is_server) ? 1 : 2; 
    89       std::size_t nbClient = 0, nbServer = 0, nbClientByServer = 0; 
     187      std::size_t nbClient = 0, nbServer = 0 ; 
     188      std::vector<int> nbClientByServer ; 
     189       
    90190      std::vector<int> info, rank_client, rank_server; 
    91191      CMPIManager::AllGather(value, info, _comm_parent); 
     
    99199      nbServer = rank_server.size(); 
    100200       
     201      NbClient=nbClient ; 
     202      NbServer=nbServer ; 
     203       
    101204      if (nbClient == 0) 
    102205         ERROR("CMPIManager::DispatchClient()", << " Aucun client disponible !"); 
     
    104207 
    105208      _comm_client = CMPIManager::CreateComm(CMPIManager::CreateSubGroup( 
    106                      CMPIManager::GetGroupWorld(), rank_client), _comm_parent); 
     209                     CMPIManager::GetGroup(_comm_parent), rank_client), _comm_parent); 
    107210 
    108211      if (nbServer != 0) 
    109212      { 
    110213         std::size_t currentServer = 0; 
    111          nbClientByServer = nbClient/nbServer; 
     214          
     215//         nbClientByServer = nbClient/nbServer; 
    112216         _comm_server = CMPIManager::CreateComm(CMPIManager::CreateSubGroup( 
    113                         CMPIManager::GetGroupWorld(), rank_server), _comm_parent); 
    114  
    115          //std::cout << nbClient << "," << nbServer  << "," << nbClientByServer << std::endl; 
    116  
    117          for (std::size_t mm = 0; mm < nbClient; mm += nbClientByServer) 
     217                        CMPIManager::GetGroup(_comm_parent), rank_server), _comm_parent); 
     218 
     219         for(std::size_t mm=0;mm<nbServer;mm++)  
     220         { 
     221           int x=nbClient/nbServer ; 
     222           if (mm<nbClient%nbServer) x++ ; 
     223           nbClientByServer.push_back(x) ; 
     224         } 
     225 
     226         for (std::size_t mm = 0; mm < nbClient; mm += nbClientByServer[currentServer],currentServer++ ) 
    118227         { 
    119228            std::vector<int> group_rank; 
    120             group_rank.push_back(rank_server[currentServer++]); 
    121             for (std::size_t nn = 0; nn < nbClientByServer; nn++) 
     229            group_rank.push_back(rank_server[currentServer]); 
     230            for (std::size_t nn = 0; nn < nbClientByServer[currentServer]; nn++) 
    122231               group_rank.push_back(rank_client[nn+mm]); 
    123232            MPI_Comm comm_client_server_ = CMPIManager::CreateComm(CMPIManager::CreateSubGroup( 
    124                                            CMPIManager::GetGroupWorld(), group_rank), _comm_parent); 
     233                                           CMPIManager::GetGroup(_comm_parent), group_rank), _comm_parent); 
    125234 
    126235            if (std::find(group_rank.begin(), group_rank.end(), 
     
    132241            group_rank.clear(); 
    133242         } 
     243         CommClient=_comm_client ; 
     244         CommServer=_comm_server ; 
     245         CommClientServer=_comm_client_server ; 
    134246         return (true); 
    135247      } 
     
    137249      { 
    138250         _comm_server = _comm_client; 
     251         CommClient=_comm_client ; 
     252         CommServer=_comm_server ; 
     253         CommClientServer=_comm_client_server ; 
    139254         return (false); 
    140255      } 
     
    149264      if (MPI_Comm_group(MPI_COMM_WORLD, &group) != MPI_SUCCESS) 
    150265         ERROR("CMPIManager::GetGroupWorld()", << " MPI Error !"); 
     266      return (group); 
     267   } 
     268 
     269   MPI_Group CMPIManager::GetGroup(MPI_Comm comm) 
     270   { 
     271      MPI_Group group = 0; 
     272      if (MPI_Comm_group(comm, &group) != MPI_SUCCESS) 
     273         ERROR("CMPIManager::GetGroup()", << " MPI Error !"); 
    151274      return (group); 
    152275   } 
  • XMLIO_V2/dev/common/src/xmlio/manager/mpi_manager.hpp

    r268 r286  
    5252          
    5353            static void Initialise(int * argc, char *** argv); 
     54            static void InitialiseClient(int * argc, char *** argv); 
     55            static void InitialiseServer(int * argc, char *** argv); 
    5456            static void Finalize(void); 
    5557 
     
    5759          
    5860          
    59             static inline int GetCommRank(MPIComm _comm)             
    60             { return (CMPIManager::GetCommRank(MPI_Comm_f2c(_comm))); }    
    61                      
    62             static inline int GetCommSize(MPIComm _comm)             
    63             { return (CMPIManager::GetCommSize(MPI_Comm_f2c(_comm))); } 
    64              
    65             static inline MPIComm GetCommWorld(void)             
    66             { return (MPI_Comm_c2f(MPI_COMM_WORLD)); } 
    67              
    68             static inline MPIComm CreateComm(MPI_Group _group, MPIComm _pcomm = CMPIManager::GetCommWorld()) 
    69             { return (MPI_Comm_c2f(CMPIManager::CreateComm( _group, MPI_Comm_f2c(_pcomm)))); }      
     61            
     62            static inline MPI_Comm GetCommWorld(void)             
     63            { return (MPI_COMM_WORLD); } 
    7064             
    7165            static int GetCommRank(MPI_Comm _comm = MPI_COMM_WORLD); 
    7266            static int GetCommSize(MPI_Comm _comm = MPI_COMM_WORLD);        
    7367             
    74             static MPI_Comm CreateComm(MPI_Group _group, MPI_Comm _pcomm); 
     68            static MPI_Comm CreateComm(MPI_Group _group, MPI_Comm _pcomm=MPI_COMM_WORLD); 
     69 
     70            static inline MPI_Comm GetCommClient(void)  
     71            { return CommClient; }    
     72            static inline MPI_Comm GetCommServer(void)  
     73            { return CommServer; }    
     74            static inline MPI_Comm GetCommClientServer(void)              
     75            { return CommClientServer; }    
     76            static inline int GetNbClient(void)              
     77            { return NbClient; }    
     78            static inline int GetNbServer(void)              
     79            { return NbServer; }    
     80 
     81            static inline bool IsConnected(void)              
     82            { return (NbServer==0)?true:false; }    
     83 
     84            static inline bool IsClient(void)              
     85            { return _IsClient; }    
     86 
     87            static inline bool IsServer(void)              
     88            { return _IsServer; }    
    7589 
    7690         public : // Autre 
     
    7892            static void Barrier(MPI_Comm _comm = MPI_COMM_WORLD); 
    7993             
    80             static inline bool DispatchClient(bool       _is_server, 
    81                                               MPIComm & _comm_client, 
    82                                               MPIComm & _comm_client_server, 
    83                                               MPIComm & _comm_server, 
    84                                               MPIComm   _comm_parent =  CMPIManager::GetCommWorld()) 
    85             { 
    86                MPI_Comm comm_client        = MPI_Comm_f2c(_comm_client); 
    87                MPI_Comm comm_client_server = MPI_Comm_f2c(_comm_client_server); 
    88                MPI_Comm comm_server        = MPI_Comm_f2c(_comm_server); 
    89                MPI_Comm comm_parent        = MPI_Comm_f2c(_comm_parent); 
    90                bool ret = CMPIManager::DispatchClient(_is_server, comm_client, comm_client_server, comm_server, comm_parent); 
    91                _comm_client        = MPI_Comm_c2f(comm_client); 
    92                _comm_client_server = MPI_Comm_c2f(comm_client_server); 
    93                _comm_server        = MPI_Comm_c2f(comm_server);  
    94                return (ret);                           
    95             } 
    96                                        
    97              
    9894            static bool DispatchClient(bool       _is_server, 
    9995                                       MPI_Comm & _comm_client, 
    10096                                       MPI_Comm & _comm_client_server, 
    10197                                       MPI_Comm & _comm_server, 
    102                                        MPI_Comm   _comm_parent = MPI_COMM_WORLD); 
     98                                       MPI_Comm _comm_parent); 
    10399 
    104100         public : // Groupes 
    105101          
    106102            static MPI_Group GetGroupWorld(void); 
     103            static MPI_Group GetGroup(MPI_Comm Comm); 
    107104            static MPI_Group CreateSubGroup(MPI_Group _pgroup, const std::vector<int> & _ranks); 
    108105            static MPI_Group CreateSubGroup(MPI_Group _pgroup, int _min_rank, int _max_rank, int _intval = 1); 
     
    110107         public : // Tests  
    111108          
    112             static inline bool IsMaster(MPIComm _comm) 
    113             { return (CMPIManager::IsMaster(MPI_Comm_f2c(_comm))); } 
    114              
    115             static inline bool IsRank(int _rank, MPIComm _comm) 
    116             { return (CMPIManager::IsRank(_rank, MPI_Comm_f2c(_comm))); } 
     109        
    117110          
    118111            static bool IsMaster(MPI_Comm _comm = MPI_COMM_WORLD); 
     
    126119            static bool Test (MPI_Request & _request); 
    127120 
    128  
    129             static inline bool HasReceivedData(MPIComm _comm, int _src_rank) 
    130             { return (CMPIManager::HasReceivedData(MPI_Comm_f2c(_comm), _src_rank));  } 
    131              
    132             static inline std::size_t GetReceivedDataSize(MPIComm _comm, int _src_rank) 
    133             { return (CMPIManager::GetReceivedDataSize(MPI_Comm_f2c(_comm), _src_rank)); } 
    134              
    135              
    136121             
    137122            static bool HasReceivedData(MPI_Comm _comm, int _src_rank); 
    138123             
    139124            static std::size_t GetReceivedDataSize(MPI_Comm _comm, int _src_rank); 
     125 
    140126            static void Receive(MPI_Comm _comm, int _src_rank, char * _data); 
    141127             
     
    150136         public : // Communication 'complexe' 
    151137          
    152             static inline void SendLinearBuffer(MPIComm _comm, int _dest_rank, CLinearBuffer & _lbuffer, MPI_Request & _request) 
    153             { CMPIManager::SendLinearBuffer(MPI_Comm_f2c(_comm), _dest_rank, _lbuffer, _request); } 
    154              
    155             static inline void ReceiveLinearBuffer(MPIComm _comm, int _src_rank, CLinearBuffer & _lbuffer) 
    156             { CMPIManager::ReceiveLinearBuffer(MPI_Comm_f2c(_comm), _src_rank, _lbuffer); } 
    157              
    158             static inline boost::shared_ptr<CLinearBuffer> ReceiveLinearBuffer(MPIComm _comm, int _src_rank) 
    159             { return (CMPIManager::ReceiveLinearBuffer(MPI_Comm_f2c(_comm), _src_rank)); } 
    160              
    161             static inline void ReceiveCircularBuffer(MPIComm _comm, int _src_rank, CCircularBuffer & _cbuffer) 
    162             { CMPIManager::ReceiveCircularBuffer(MPI_Comm_f2c(_comm), _src_rank, _cbuffer); } 
    163              
    164           
     138 
    165139            static void SendLinearBuffer(MPI_Comm _comm, int _dest_rank, CLinearBuffer & _lbuffer, MPI_Request & _request); 
    166140            static void ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank, CLinearBuffer & _lbuffer); 
     
    175149            static void FreeMemory (void * _data); 
    176150          
     151          private : 
     152           
     153            static bool Initialized ; 
     154            static MPI_Comm CommClient ; 
     155            static MPI_Comm CommServer ; 
     156            static MPI_Comm CommClientServer ; 
     157            static int NbClient ; 
     158            static int NbServer ; 
     159 
     160            static bool _IsClient ; 
     161            static bool _IsServer ; 
     162            static bool using_server ; 
     163            static bool using_oasis ; 
     164             
    177165      }; // class CMPIManager 
    178166       
  • XMLIO_V2/dev/common/src/xmlio/manager/tree_manager.cpp

    r274 r286  
    129129                   
    130130                   
    131 //         std::cout << "Nombre de contexte :" << ctxtnb << std::endl; 
    132131 
    133132         for (StdSize i = 0; i < ctxtnb; i++) 
     
    148147               is.read (const_cast<char *>(id.data()), size * sizeof(char)); 
    149148                
    150 //               std::cout << "context ::::" << id << std::endl; 
    151149                
    152150               CTreeManager::SetCurrentContextId(id);                
     
    187185         os.write (reinterpret_cast<const char*>(&genum) , sizeof(ENodeType));  
    188186         os.write (reinterpret_cast<const char*>(&size) , sizeof(StdSize)); 
    189           
     187 
    190188         for (StdSize i = 0; i < size; i++) 
    191189         { 
     
    232230                      
    233231                  os.write (reinterpret_cast<const char*>(&idsize), sizeof(StdSize)); 
    234                   os.write (id.data(), idsize * sizeof(char));          
     232                  os.write (id.data(), idsize * sizeof(char));   
    235233               }          
    236234               domain->toBinary(os);                
     
    273271         const StdSize size = def_vector.size();   
    274272                   
    275          is.read (reinterpret_cast<char*>(&renum), sizeof(StdSize));    
    276          is.read (reinterpret_cast<char*>(&ctxtnb), sizeof(ENodeType)); 
     273         is.read (reinterpret_cast<char*>(&renum), sizeof(ENodeType));    
     274         is.read (reinterpret_cast<char*>(&ctxtnb), sizeof(StdSize)); 
    277275 
    278276         if (renum != CContextGroup::GetType()) 
     
    282280         if (size != ctxtnb) 
    283281            ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)", 
    284                   << "[ size = " << size << "] Bad context group size !"); 
     282                  << "[ size = " << size << "] != "<<ctxtnb<<" : Bad context group size !"); 
    285283                   
    286284         for (StdSize i = 0; i < ctxtnb; i++) 
     
    330328                      
    331329            // Lecture successive des informations binaires de domaine. 
     330               
    332331            for (StdSize j = 0; j < alldomain_size; j++) 
    333332            { 
     
    352351                  if (domain->getId().compare(id) != 0) 
    353352                     ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)", 
    354                            << "[ id = " << id << "] Bad id !");  
     353                           << "[ id = " <<  id <<" != "<<domain->getId()<< "] Bad id !");  
    355354               } 
    356355               domain->fromBinary(is); 
     
    380379                  if (grid->getId().compare(id) != 0) 
    381380                     ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)", 
    382                            << "[ id = " << id << "] Bad id !");  
     381                           << "[ id = " << id <<" != "<<grid->getId()<< "] Bad id !");  
    383382               } 
    384383               grid->fromBinary(is); 
  • XMLIO_V2/dev/common/src/xmlio/manager/xios_manager.cpp

    r278 r286  
    1717         { 
    1818            // Initialisation de la biliothÚque MPI si nécessaire 
    19             comm::CMPIManager::Initialise(argc, argv); 
     19            comm::CMPIManager::InitialiseServer(argc, argv); 
    2020            ExeName = StdString((*argv)[0]); 
    2121            for (int i = 1; i < *argc; i++) 
     
    4343 
    4444      StdString     CXIOSManager::ClientName("unknown name"); 
    45       comm::MPIComm CXIOSManager::Comm_Client_Server = -1; 
    46       comm::MPIComm CXIOSManager::Comm_Server = -1; 
     45      MPI_Comm CXIOSManager::Comm_Client_Server = MPI_COMM_NULL; 
     46      MPI_Comm CXIOSManager::Comm_Server = MPI_COMM_NULL; 
    4747 
    4848      xios_map<StdString, CXIOSManager::XIOSClient> CXIOSManager::Clients; 
     
    5151       
    5252      void CXIOSManager::RunServer 
    53          (StdString clientName, comm::MPIComm comm_client_server, comm::MPIComm comm_server) 
     53         (StdString clientName, MPI_Comm comm_client_server, MPI_Comm comm_server) 
    5454      { 
    5555         using namespace comm; 
     
    6969         // La quasi-totalité de l'arborescence est obtenue depuis les informations 
    7070         // fournies par le client 1 du sous-groupe. 
    71          StdString main_data_tree = clientBuffer[0]->getString(0);         
     71/*         StdString main_data_tree = clientBuffer[0]->getString(0);         
    7272         tree::CTreeManager::FromBinary(main_data_tree); 
    7373          
     
    7878            tree::CTreeManager::DomainsFromBinary(main_data_tree); 
    7979         } 
     80*/ 
     81 
     82         // Obtention des sous-domaines clients. 
     83         for (StdSize j = 0; j < clientBuffer.size(); j++) 
     84         { 
     85             StdString main_data_tree = clientBuffer[j]->getString(0); 
     86            tree::CTreeManager::FromBinary(main_data_tree); 
     87         } 
     88 
    8089          
    8190         StdOStringStream osss; 
     
    111120      //-------------------------------------------------------------- 
    112121       
    113       void CXIOSManager::ShowInformation_CS(comm::MPIComm comm_client_server) 
     122      void CXIOSManager::ShowInformation_CS(MPI_Comm comm_client_server) 
    114123      { 
    115124         using namespace comm; 
     
    149158         } 
    150159 
    151          comm::CMPIManager::Barrier(); 
     160         comm::CMPIManager::Barrier(comm_client_server); 
    152161          
    153162      } 
     
    155164      //-------------------------------------------------------------- 
    156165       
    157       void CXIOSManager::RunClientServer(comm::MPIComm comm_client_server) 
     166      void CXIOSManager::RunClientServer(MPI_Comm comm_client_server) 
    158167      { 
    159168         using namespace comm; 
     
    171180          
    172181         bool isClient = true, isIncl = false, isIncl_ = false; 
    173          MPIComm comm_client = 0, comm_client_grp = 0; comm_client_server = 0; 
     182         MPI_Comm comm_client = 0, comm_client_grp = 0; comm_client_server = 0; 
    174183 
    175184         for (;iit != eend; iit++) 
     
    187196            { 
    188197               end = start + nbClientPServer; 
    189                MPIComm comm_  =  CMPIManager::CreateComm 
     198               MPI_Comm comm_  =  CMPIManager::CreateComm 
    190199                  (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), start, end)); 
    191                MPIComm comm__ =  CMPIManager::CreateComm 
     200               MPI_Comm comm__ =  CMPIManager::CreateComm 
    192201                  (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), start+1, end)); 
    193202                   
     
    212221               if (clieindex.size() == nbClient) 
    213222               { 
    214                   MPIComm comm___ = CMPIManager::CreateComm 
     223                  MPI_Comm comm___ = CMPIManager::CreateComm 
    215224                  (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), clieindex)); 
    216225                  if (isIncl) comm_client = comm___; 
     
    221230               start = start + nbClientPServer + 1; 
    222231            } 
    223             MPIComm comm____ = CMPIManager::CreateComm 
     232            MPI_Comm comm____ = CMPIManager::CreateComm 
    224233               (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), servindex)); 
    225234            if (isIncl_) CXIOSManager::Comm_Server = comm____;                
     
    245254      //--------------------------------------------------------------- 
    246255       
    247       void CXIOSManager::RunClient(bool launch, comm::MPIComm comm_client) 
     256      void CXIOSManager::RunClient(bool launch, MPI_Comm comm_client) 
    248257      { 
    249258         if (launch) 
     
    263272 
    264273      void CXIOSManager::AddClient(StdString clientName, StdSize nbClient, StdSize nbClientPServer, 
    265                                    void (*entry_point)(comm::MPIComm, comm::MPIComm, comm::MPIComm)) 
     274                                   void (*entry_point)(MPI_Comm, MPI_Comm, MPI_Comm)) 
    266275      { 
    267276         StdSize nbprocess  = comm::CMPIManager::GetCommSize(comm::CMPIManager::GetCommWorld()); 
  • XMLIO_V2/dev/common/src/xmlio/manager/xios_manager.hpp

    r278 r286  
    2525            StdSize nbClient; 
    2626            StdSize nbClientPServer; 
    27             void (*entry)(comm::MPIComm, comm::MPIComm, comm::MPIComm) ; 
     27            void (*entry)(MPI_Comm, MPI_Comm, MPI_Comm) ; 
    2828         } XIOSClient; 
    2929          
     
    3838         /// Ajout de client en mode CLIENT_SERVER et CLIENT/// 
    3939         static void AddClient(StdString clientName, StdSize nbClient, StdSize nbClientPServer, 
    40                                void (*entry_point)(comm::MPIComm, comm::MPIComm, comm::MPIComm)); 
     40                               void (*entry_point)(MPI_Comm, MPI_Comm, MPI_Comm)); 
    4141 
    4242         /// Lancement des serveurs et/ou des clients /// 
    43          static void RunServer(StdString clientName, 
    44                                comm::MPIComm comm_client_server, comm::MPIComm comm_server); 
    45          static void RunClient(bool launch = false, comm::MPIComm comm_client = 
    46                                                     comm::CMPIManager::GetCommWorld()); 
    47          static void RunClientServer(comm::MPIComm comm_client_server = 
    48                                      comm::CMPIManager::GetCommWorld()); 
     43         static void RunServer(StdString clientName,MPI_Comm comm_client_server,MPI_Comm comm_server); 
     44         static void RunClient(bool launch = false, MPI_Comm comm_client = comm::CMPIManager::GetCommWorld()); 
     45         static void RunClientServer(MPI_Comm comm_client_server = comm::CMPIManager::GetCommWorld()); 
    4946 
    5047      public : 
     
    6663       
    6764         /// Information /// 
    68          static void ShowInformation_CS(comm::MPIComm comm_client_server); 
     65         static void ShowInformation_CS(MPI_Comm comm_client_server); 
    6966 
    7067         /// Variables statiques privées /// 
     
    7572         static XIOSStatus Status; 
    7673         static StdString  ClientName; 
    77          static comm::MPIComm Comm_Client_Server, Comm_Server; 
     74         static MPI_Comm Comm_Client_Server, Comm_Server; 
    7875         static xios_map<StdString, XIOSClient> Clients; 
    7976 
  • XMLIO_V2/dev/common/src/xmlio/node/context.cpp

    r278 r286  
    143143#define DECLARE_NODE_PAR(Name_, name_) 
    144144#include "node_type.conf" 
    145             std::cout << name << std::endl; 
     145 
    146146            DEBUG(<< "L'élément nommé \'"     << name 
    147147                  << "\' dans le contexte \'" << CObjectFactory::GetCurrentContextId() 
  • XMLIO_V2/dev/common/src/xmlio/node/domain.cpp

    r278 r286  
    517517            const int zoom_ibegin_cl = ibegin_zoom_sub[k], zoom_ni_cl = ni_zoom_sub[k], 
    518518                      zoom_jbegin_cl = jbegin_zoom_sub[k], zoom_nj_cl = nj_zoom_sub[k], 
     519                      ibegin_cl = ibegin_sub[k] , 
     520                      jbegin_cl = jbegin_sub[k] , 
    519521                      ni_cl = iend_sub[k] - ibegin_sub[k] + 1; 
    520522                       
     
    523525               for (int j = 0; j < zoom_nj_cl; j++) 
    524526               { 
    525                   int ii = i /*- (ibegin_serv - 1)*/ + (zoom_ibegin_cl - 1) - (ibegin_zoom_srv - 1); 
    526                   int jj = j /*- (jbegin_serv - 1)*/ + (zoom_jbegin_cl - 1) - (jbegin_zoom_srv - 1); 
     527                  int ii = i + (ibegin_cl-1) - (ibegin_serv - 1) + (zoom_ibegin_cl - 1) - (ibegin_zoom_srv - 1); 
     528                  int jj = j + (jbegin_cl-1) - (jbegin_serv - 1) + (zoom_jbegin_cl - 1) - (jbegin_zoom_srv - 1); 
    527529                  (*lonvalue_temp)[ii + jj * zoom_ni_serv] = 
    528530                  (*lonvalue_loc)[i + j * zoom_ni_cl]; 
     
    602604         { 
    603605            zoom_ni_loc.setValue(0); 
    604             zoom_ibegin_loc.setValue(-1); 
     606            zoom_ibegin_loc.setValue(zoom_ibegin.getValue()); 
    605607         } 
    606608         else 
     
    622624         { 
    623625            zoom_nj_loc.setValue(0); 
    624             zoom_jbegin_loc.setValue(-1); 
     626            zoom_jbegin_loc.setValue(zoom_jbegin.getValue()); 
    625627         } 
    626628         else 
     
    662664         this->iend_sub.push_back(this->iend.getValue()); 
    663665         this->jend_sub.push_back(this->jend.getValue());  
     666 
     667         this->ibegin_zoom_sub.push_back(this->zoom_ibegin_loc.getValue()); 
     668         this->jbegin_zoom_sub.push_back(this->zoom_jbegin_loc.getValue()); 
     669         this->ni_zoom_sub.push_back(this->zoom_ni_loc.getValue()); 
     670         this->nj_zoom_sub.push_back(this->zoom_nj_loc.getValue()); 
    664671       
    665672         this->latvalue_sub.push_back(this->latvalue.getValue()); 
    666673         this->lonvalue_sub.push_back(this->lonvalue.getValue());   
    667           
    668          if (!this->isEmpty()) 
    669          { 
     674 
     675 
     676//         if (!this->isEmpty()) 
     677//         { 
    670678            this->completeLonLatClient(); 
    671          } 
     679//         } 
    672680      } 
    673681      else 
    674682      { // CÃŽté serveur uniquement 
    675          if (!this->isEmpty()) 
     683//         if (!this->isEmpty()) 
    676684            this->completeLonLatServer(); 
    677685      } 
     
    707715   { 
    708716      return (this->ibegin_zoom_sub); 
     717   } 
     718 
     719   const std::vector<int> & CDomain::getNiZoomSub(void) const 
     720   { 
     721      return (this->ni_zoom_sub); 
    709722   } 
    710723                
     
    729742      return (this->jbegin_zoom_sub); 
    730743   } 
     744 
     745   const std::vector<int> & CDomain::getNjZoomSub(void) const 
     746   { 
     747      return (this->nj_zoom_sub); 
     748   } 
    731749                   
    732750    
     
    735753   const std::vector<int> & CDomain::getJEndSub(void) const 
    736754   { 
    737       return (this->iend_sub); 
     755      return (this->jend_sub); 
    738756   } 
    739757    
  • XMLIO_V2/dev/common/src/xmlio/node/domain.hpp

    r278 r286  
    8080         const std::vector<int> & getIBeginZoomSub(void) const; 
    8181         const std::vector<int> & getJBeginZoomSub(void) const; 
     82         const std::vector<int> & getNiZoomSub(void) const; 
     83         const std::vector<int> & getNjZoomSub(void) const; 
    8284          
    8385         const std::vector<ARRAY(double, 1)> & getLonValueSub(void) const; 
  • XMLIO_V2/dev/common/src/xmlio/node/field.cpp

    r278 r286  
    220220         sset.insert(refer_ptr); 
    221221         baseRefObject = refer_sptr; 
    222          refObject.push_back(refer_sptr); 
     222//ym         refObject.push_back(refer_sptr); 
    223223      } 
    224224   } 
  • XMLIO_V2/dev/common/src/xmlio/node/field.hpp

    r278 r286  
    166166//      std::cout       << "(writeDate <= currDate) = " << std::boolalpha << (writeDate <= currDate) << std::endl;    
    167167    
    168        //std::cout << ">> " << currDate <<  " : Envoi de données " << this->getBaseFieldId() << std::endl; 
     168      std::cout << ">> " << currDate <<  " : Envoi de données " << this->getBaseFieldId() << std::endl; 
     169      std::cout << ">> next operation "  << opeDate<<std::endl; 
    169170      if (opeDate <= currDate) 
    170171      { 
     
    180181          
    181182         *last_operation = currDate; 
    182 //         std::cout << "(*last_operation = currDate) : " << *last_operation << " = " << currDate << std::endl;  
     183         std::cout << "(*last_operation = currDate) : " << *last_operation << " = " << currDate << std::endl;  
    183184      } 
    184185       
     
    188189         this->incrementNStep(); 
    189190         *last_Write = writeDate; 
    190 //         std::cout << "(*last_Write = currDate) : " << *last_Write << " = " << currDate       << std::endl; 
     191         std::cout << "(*last_Write = currDate) : " << *last_Write << " = " << currDate << std::endl; 
    191192         return (true);         
    192193      } 
  • XMLIO_V2/dev/common/src/xmlio/node/file.cpp

    r266 r286  
    6262      this->enabledFields = this->getAllFields(); 
    6363 
     64      std::cout<<"---> File :"<<this->name.getValue()<<std::endl ; 
    6465      for ( it = this->enabledFields.begin() ; it != this->enabledFields.end(); it++ ) 
    6566      { 
     
    8687         } 
    8788 
    88          // Le champ est finalement actif, on ajoute la référence au champ de base. 
     89         // Le champ est finalement actif, on y ajoute sa propre reference. 
     90         (*it)->refObject.push_back(*it); 
     91         // Le champ est finalement actif, on y ajoute la référence au champ de base. 
     92         std::cout<<"    Field Enabled : "<<(*it)->getId()<<std::endl ; 
    8993         (*it)->setRelFile(CObjectFactory::GetObject(this)); 
    9094         (*it)->baseRefObject->refObject.push_back(*it); 
     95         // A faire, ajouter les references intermediaires... 
    9196      } 
    9297 
     
    133138   } 
    134139 
     140   void CFile::close(void) 
     141   { 
     142     this->data_out->closeFile(); 
     143   } 
    135144   //---------------------------------------------------------------- 
    136145 
  • XMLIO_V2/dev/common/src/xmlio/node/file.hpp

    r219 r286  
    6363 
    6464         void initializeDataOutput(boost::shared_ptr<io::CDataOutput> dout); 
    65  
     65         void close(void) ; 
     66          
    6667         /// Traitements /// 
    6768         virtual void solveDescInheritance(const CAttributeMap * const parent = 0); 
  • XMLIO_V2/dev/common/src/xmlio/node/grid.cpp

    r278 r286  
    55#include "object_template_impl.hpp" 
    66#include "group_template_impl.hpp" 
     7#include <iostream> 
     8#include "mpi_manager.hpp" 
    79 
    810namespace xmlioserver { 
     
    140142      for (StdSize s = 0; s < shape_.size(); s++) 
    141143         retvalue *= shape_[s]; 
     144      return (retvalue); 
     145   } 
     146 
     147   StdSize CGrid::getDataSize(void) const 
     148   { 
     149      StdSize retvalue ; 
     150      retvalue=domain->data_ni.getValue() ; 
     151      if (domain->data_dim.getValue()==2) retvalue*=domain->data_nj.getValue() ; 
     152      if (this->withAxis) retvalue*=this->axis->size.getValue() ; 
     153 
    142154      return (retvalue); 
    143155   } 
     
    437449      const std::vector<int> & ibegin = this->domain->getIBeginSub(); 
    438450      const std::vector<int> & jbegin = this->domain->getJBeginSub(); 
     451      const std::vector<int> & iend = this->domain->getIEndSub(); 
     452      const std::vector<int> & jend = this->domain->getJEndSub(); 
    439453      const std::vector<int> & ibegin_zoom = this->domain->getIBeginZoomSub(); 
    440454      const std::vector<int> & jbegin_zoom = this->domain->getJBeginZoomSub(); 
     455      const std::vector<int> & ni_zoom = this->domain->getNiZoomSub(); 
     456      const std::vector<int> & nj_zoom = this->domain->getNjZoomSub(); 
    441457       
    442458      const int ibegin_srv  = this->domain->ibegin.getValue(); 
    443459      const int jbegin_srv  = this->domain->jbegin.getValue(); 
     460      const int iend_srv  = this->domain->iend.getValue(); 
     461      const int jend_srv  = this->domain->jend.getValue(); 
    444462      const int zoom_ni_srv = this->domain->zoom_ni_loc.getValue(); 
    445463      const int zoom_nj_srv = this->domain->zoom_nj_loc.getValue(); 
     
    447465      const int ibegin_zoom_srv = this->domain->zoom_ibegin_loc.getValue(); 
    448466      const int jbegin_zoom_srv = this->domain->zoom_jbegin_loc.getValue(); 
    449             
     467       const int iend_zoom_srv = ibegin_zoom_srv + zoom_ni_srv-1 ; 
     468      const int  jend_zoom_srv = jbegin_zoom_srv + zoom_nj_srv-1 ; 
     469         
     470//      std::cout<<"----> computeIndexServer !!"<<std::endl ; 
    450471      StdSize dn = 0;       
    451472      for (StdSize j = 1; j < this->out_i_index.size(); j++) 
     
    466487         int ibegin_zoom_cl = ibegin[i]; //ibegin_zoom[i]; 
    467488         int jbegin_zoom_cl = jbegin[i]; //jbegin_zoom[i]; 
     489         int iend_zoom_cl = iend[i]; //ibegin_zoom[i]; 
     490         int jend_zoom_cl = jend[i]; //jbegin_zoom[i]; 
     491 
     492         int ibegin_cl = ibegin[i]; //ibegin[i]; 
     493         int jbegin_cl = jbegin[i]; //jbegin[i]; 
     494         int iend_cl = iend[i]; //ibegin[i]; 
     495         int jend_cl = jend[i]; //jbegin[i]; 
    468496          
    469497         if (ibegin_zoom.size() != 0) 
     
    471499            ibegin_zoom_cl = ibegin_zoom[i]; 
    472500            jbegin_zoom_cl = jbegin_zoom[i]; 
     501            iend_zoom_cl = ibegin_zoom[i]+ni_zoom[i]-1; 
     502            jend_zoom_cl = jbegin_zoom[i]+nj_zoom[i]-1; 
    473503         } 
    474504          
    475          for (StdSize n = dn, m = 0; n < (dn + storeIndex_cl->size()); n++, m++) 
    476          { 
    477             (*storeIndex_srv)[n]  = (*storeIndex_cl)[m]; // Faux mais inutile dans le cas serveur. 
     505//         std::cout<<"--> client No "<<i<<std::endl ; 
     506//         std::cout<<" ibegin "<<ibegin[i]<<" iend "<<iend[i]<<" jbegin "<<jbegin[i]<<" jend "<<jend[i]<<std::endl ; 
     507//         std::cout<<"zoom cl : ibegin "<<ibegin_zoom_cl<<" iend "<<iend_zoom_cl<<" jbegin "<<jbegin_zoom_cl<<" jend "<<jend_zoom_cl<<std::endl ; 
     508//         std::cout<<"--> server "<<std::endl ; 
     509//         std::cout<<" ibegin "<<ibegin_srv<<" iend "<<iend_srv<<" jbegin "<<jbegin_srv<<" jend "<<jend_srv<<std::endl ; 
     510//        std::cout<<"zoom : ibegin "<<ibegin_zoom_srv<<" iend "<<iend_zoom_srv<< " ni "<<zoom_ni_srv<<" jbegin "<<jbegin_zoom_srv<<" jend "<<jend_zoom_srv<<" nj "<<zoom_nj_srv<<std::endl ; 
     511//         std::cout<<"zoom_size "<<ibegin_zoom.size()<<std::endl ; 
     512 
     513         if (comm::CMPIManager::IsClient()) 
     514         { 
     515           for (StdSize n = dn, m = 0; n < (dn + storeIndex_cl->size()); n++, m++) 
     516           { 
     517              (*storeIndex_srv)[n]  = (*storeIndex_cl)[m]; // Faux mais inutile dans le cas serveur. 
     518 
     519//            (*out_i_index_srv)[n] = (*out_i_index_cl)[m]  
     520//                                  /*+ (ibegin_cl - 1) - (ibegin_srv - 1)*/ + (ibegin_zoom_cl - 1) - (ibegin_zoom_srv - 1); 
     521//            (*out_j_index_srv)[n] = (*out_j_index_cl)[m] 
     522//                                  /*+ (jbegin_cl - 1) - (jbegin_srv - 1)*/ + (jbegin_zoom_cl - 1) - (jbegin_zoom_srv - 1); 
     523//            (*out_l_index_srv)[n] = (*out_l_index_cl)[m]; 
     524              (*out_i_index_srv)[n] = (*out_i_index_cl)[m] + ibegin_cl - 1 - (ibegin_srv + ibegin_zoom_srv - 1) + 1 ; 
     525              (*out_j_index_srv)[n] = (*out_j_index_cl)[m] + jbegin_cl - 1 - (jbegin_srv + jbegin_zoom_srv - 1) + 1 ; 
     526              (*out_l_index_srv)[n] = (*out_l_index_cl)[m]; 
     527           } 
     528         } 
     529         else 
     530         { 
     531           for (StdSize n = dn, m = 0; n < (dn + storeIndex_cl->size()); n++, m++) 
     532           { 
     533              (*storeIndex_srv)[n]  = (*storeIndex_cl)[m]; // Faux mais inutile dans le cas serveur. 
    478534            (*out_i_index_srv)[n] = (*out_i_index_cl)[m]  
    479                                   /*+ (ibegin_cl - 1) - (ibegin_srv - 1)*/ + (ibegin_zoom_cl - 1) - (ibegin_zoom_srv - 1); 
     535                                   + (ibegin_cl - 1) - (ibegin_srv - 1) + (ibegin_zoom_cl - 1) - (ibegin_zoom_srv - 1); 
    480536            (*out_j_index_srv)[n] = (*out_j_index_cl)[m] 
    481                                   /*+ (jbegin_cl - 1) - (jbegin_srv - 1)*/ + (jbegin_zoom_cl - 1) - (jbegin_zoom_srv - 1); 
     537                                   + (jbegin_cl - 1) - (jbegin_srv - 1) + (jbegin_zoom_cl - 1) - (jbegin_zoom_srv - 1); 
    482538            (*out_l_index_srv)[n] = (*out_l_index_cl)[m]; 
     539           }          
     540             
    483541         } 
    484542                   
    485          dn += storeIndex_cl->size();                  
    486       } 
    487             
     543         dn += storeIndex_cl->size();  
     544//         std::cout<<"storeIndex_cl->size() "<<storeIndex_cl->size()<<std::endl;                
     545       
     546//         std::cout<<"storeIndex_srv->size() "<<storeIndex_srv->size()<<std::endl;                
     547      } 
     548       
    488549      if (storeIndex_srv->size() != 0) 
    489550      { 
     
    496557         const int jend_t   = 
    497558            *std::max_element(out_j_index_srv->begin(), out_j_index_srv->end()); 
    498              
     559                
     560//                std::cout<< "[ grille = "      << this->getId() 
     561//                         << ", ibegin_t = "    << ibegin_t 
     562//                         << ", jbegin_t = "    << jbegin_t 
     563//                         << ", iend_t = "      << iend_t 
     564//                         << ", jend_t = "      << jend_t 
     565//                         << ", zoom_ni_srv = " << zoom_ni_srv 
     566//                         << ", zoom_nj_srv = " << zoom_nj_srv 
     567//                         << ", nb subdomain = "   << out_i_index.size()-1<<std::endl   ;   
     568                                  
    499569         if ((ibegin_t < 0) || (jbegin_t < 0) || 
    500570             (iend_t >= zoom_ni_srv) || (jend_t >= zoom_nj_srv)) 
     
    508578                  << ", zoom_ni_srv = " << zoom_ni_srv 
    509579                  << ", zoom_nj_srv = " << zoom_nj_srv 
     580                  << ", nb subdomain = "   << out_i_index.size()-1 
    510581                  <<" ] Erreur d'indexation de la grille au niveau du serveur") ; 
    511582         } 
  • XMLIO_V2/dev/common/src/xmlio/node/grid.hpp

    r266 r286  
    7171         StdSize getLocalSize(void) const; 
    7272         StdSize getGlobalSize(void) const; 
     73         StdSize  getDataSize(void) const; 
    7374         std::vector<StdSize> getLocalShape(void) const; 
    7475         std::vector<StdSize> getGlobalShape(void) const; 
     
    133134      void CGrid::inputField(const  ARRAY(double, n) field, ARRAY(double, 1) stored) const 
    134135   { 
    135       if (this->getGlobalSize() != field->num_elements()) 
     136      if (this->getDataSize() != field->num_elements()) 
    136137         ERROR("CGrid::inputField(const  ARRAY(double, n) field, ARRAY(double, 1) stored)", 
    137                 << "[ Taille des données attendue = " << this->getGlobalSize()       << ", " 
     138                << "[ Taille des données attendue = " << this->getDataSize()       << ", " 
    138139                << "Taille des données reçue = "      << field->num_elements() << " ] " 
    139140                << "Le tableau de données n'a pas la bonne taille !") ; 
  • XMLIO_V2/dev/common/src/xmlio/node/variable.hpp

    r274 r286  
    6464 
    6565             
    66             template <typename T> inline void getData(T & _data) const; 
     66            template <typename T> inline T getData(void) const; 
     67//            bool inline getData<bool>(void) const ; 
     68             
    6769            template <typename T, StdSize N> 
    6870               inline void getData(ARRAY(T, N) _data_array) const; 
     
    8183      }; // class CVar 
    8284 
     85      
     86      template <typename T> 
     87      T CVariable::getData(void) const 
     88      { 
     89         T retval ; 
     90         std::stringstream sstr(std::stringstream::in | std::stringstream::out);  
     91         sstr<<content ; 
     92         sstr>>retval ; 
     93         if (sstr.fail()) ERROR("CVariable::getdata()", 
     94               << "Cannot convert string <" << content << "> into type required" ); 
     95         return retval ; 
     96      }  
     97 
     98      template<> 
     99      bool CVariable::getData<bool>(void) const 
     100      { 
     101         if (content.compare("true")==0 || content.compare(".true.")==0 || content.compare(".TRUE.")==0) return true ;  
     102         else if (content.compare("false")==0 || content.compare(".false.")==0 || content.compare(".FALSE.")==0) return false ;  
     103         else ERROR("CVariable::getdata()", 
     104               << "Cannot convert string <" << content << "> into type required" ); 
     105         return false ; 
     106      }  
    83107      ///-------------------------------------------------------------- 
    84108 
  • XMLIO_V2/dev/common/src/xmlio/object_factory.hpp

    r219 r286  
    2727 
    2828         template <typename U> 
     29            static inline boost::shared_ptr<U> GetObject(const StdString& context,const StdString & id); 
     30 
     31         template <typename U> 
    2932            static inline boost::shared_ptr<U> GetObject(const U * const object); 
    3033 
     
    4245            static inline bool HasObject(const StdString & id); 
    4346 
     47         template <typename U> 
     48            static inline bool HasObject(const StdString& context,const StdString & id); 
     49 
    4450         /// Instanciateur /// 
    4551         template <typename U> 
    4652            static inline boost::shared_ptr<U> CreateObject(const StdString & id = StdString("")); 
    4753 
     54         template <typename U> static inline StdString GenUId(void) ;  
    4855 
    4956      private : 
  • XMLIO_V2/dev/common/src/xmlio/object_factory_impl.hpp

    r266 r286  
    3131      return (U::AllMapObj[CObjectFactory::CurrContext].find(id) != 
    3232              U::AllMapObj[CObjectFactory::CurrContext].end()); 
     33   } 
     34 
     35   template <typename U> 
     36      bool CObjectFactory::HasObject(const StdString & context, const StdString & id) 
     37   { 
     38      if (U::AllMapObj.find(context) == U::AllMapObj.end()) return false ; 
     39      else return (U::AllMapObj[context].find(id) !=  U::AllMapObj[context].end()); 
    3340   } 
    3441 
     
    7380 
    7481   template <typename U> 
     82      boost::shared_ptr<U> CObjectFactory::GetObject(const StdString & context, const StdString & id) 
     83   { 
     84      if (!CObjectFactory::HasObject<U>(context,id)) 
     85         ERROR("CObjectFactory::GetObject(const StdString & id)", 
     86               << "[ id = " << id << ", U = " << U::GetName() <<", context = "<<context<< " ] " 
     87               << " object is not referenced !"); 
     88      return (U::AllMapObj[CObjectFactory::CurrContext][id]); 
     89   } 
     90 
     91   template <typename U> 
    7592      boost::shared_ptr<U> CObjectFactory::CreateObject(const StdString & id) 
    7693   { 
     
    8097      if (id.size() == 0) 
    8198      { 
    82          boost::shared_ptr<U> value(new U); 
     99         boost::shared_ptr<U> value(new U(CObjectFactory::GenUId<U>())); 
    83100         U::AllVectObj[CObjectFactory::CurrContext].insert 
    84101            (U::AllVectObj[CObjectFactory::CurrContext].end(), value); 
     102         U::AllMapObj[CObjectFactory::CurrContext].insert(std::make_pair(value->getId(), value)); 
    85103         return (value); 
    86104      } 
     
    105123      return (U::AllVectObj[context]); 
    106124   } 
    107  
     125    
     126   template <typename U>  
     127       StdString CObjectFactory::GenUId(void) 
     128       { 
     129          long int seed ; 
     130           
     131          xios_map<StdString,long int>::iterator it ; 
     132          it=U::GenId.find(CObjectFactory::CurrContext); 
     133          if (it==U::GenId.end()) 
     134          { 
     135            seed=0 ; 
     136            U::GenId[CObjectFactory::CurrContext]=seed ; 
     137          } 
     138          else 
     139          { 
     140            seed=it->second ; 
     141            seed++ ; 
     142            it->second=seed ; 
     143          } 
     144           
     145          StdOStringStream oss ; 
     146          oss<<"__"<<U::GetName()<<"_undef_id_"<<seed ; 
     147          return StdString(oss.str()) ; 
     148        } 
     149           
    108150} // namespace xmlioserver 
    109151 
  • XMLIO_V2/dev/common/src/xmlio/object_template.hpp

    r219 r286  
    7171         static xios_map<StdString, 
    7272                std::vector<boost::shared_ptr<DerivedType> > > AllVectObj; 
     73                 
     74         static xios_map< StdString, long int > GenId ; 
    7375 
    7476   }; // class CObjectTemplate 
  • XMLIO_V2/dev/common/src/xmlio/object_template_impl.hpp

    r219 r286  
    1313      xios_map<StdString, 
    1414      std::vector<boost::shared_ptr<T> > > CObjectTemplate<T>::AllVectObj; 
     15 
     16   template <class T> 
     17      xios_map<StdString,long int> CObjectTemplate<T>::GenId; 
    1518 
    1619   template <class T> 
  • XMLIO_V2/dev/common/src/xmlio/output/nc4_data_output.cpp

    r278 r286  
    2929 
    3030      CNc4DataOutput::CNc4DataOutput 
    31          (const StdString & filename, bool exist, bool multigroup, MPI_Comm comm_server) 
     31         (const StdString & filename, bool exist, MPI_Comm comm_server,bool multifile) 
    3232            : SuperClass() 
    33             , SuperClassWriter(filename, exist, &comm_server) 
     33            , SuperClassWriter(filename, exist, &comm_server,multifile) 
    3434            , comm_server(comm_server) 
    3535            , filename(filename) 
    3636      { 
    3737         StdString timeid = StdString("time_counter"); 
    38          SuperClass::type = (multigroup) ? MULTI_GROUP : ONE_FILE; 
     38 
     39         SuperClass::type = (multifile) ? MULTI_FILE : ONE_FILE; 
     40          
    3941         if (!exist) 
    4042            SuperClassWriter::addDimension(timeid); 
    4143      } 
    4244 
    43       CNc4DataOutput::CNc4DataOutput 
    44          (const StdString & filename, bool exist, bool multigroup, comm::MPIComm comm_server, bool) 
    45             : SuperClass() 
    46             , SuperClassWriter(filename, exist, &comm_server, true) 
    47             , filename(filename) 
    48       { 
    49          StdString timeid = StdString("time_counter"); 
    50          SuperClass::type = (multigroup) ? MULTI_GROUP : ONE_FILE; 
    51          if (!exist) 
    52             SuperClassWriter::addDimension(timeid); 
    53       } 
    5445 
    5546      CNc4DataOutput::~CNc4DataOutput(void) 
     
    7061         domain->checkAttributes(); 
    7162          
    72          if (domain->isEmpty()) return; 
     63//         if (domain->isEmpty()) return; 
    7364 
    7465         std::vector<StdString> dim0, dim1; 
     
    9081         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize); 
    9182 
    92          if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
    93          { 
    94             SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue()); 
    95             SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue()); 
    96          } 
    97  
    98          if (isCurvilinear) 
    99          { 
    100             dim0.push_back(latid_loc); dim0.push_back(lonid_loc); 
    101             lonid = StdString("nav_lon_").append(domid); 
    102             latid = StdString("nav_lat_").append(domid); 
    103          } 
    104          else 
    105          { 
    106             dim0.push_back(latid_loc); 
    107             dim1.push_back(lonid_loc); 
    108          } 
    10983         switch (SuperClass::type) 
    11084         { 
    11185            case (MULTI_FILE) : 
    11286            { 
     87               if (domain->isEmpty()) return; 
     88                
     89               if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
     90               { 
     91                 SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue()); 
     92                 SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue()); 
     93               } 
     94 
     95               if (isCurvilinear) 
     96               { 
     97                 dim0.push_back(latid_loc); dim0.push_back(lonid_loc); 
     98                 lonid = StdString("nav_lon_").append(domid); 
     99                 latid = StdString("nav_lat_").append(domid); 
     100               } 
     101               else 
     102               { 
     103                 dim0.push_back(latid_loc); 
     104                 dim1.push_back(lonid_loc); 
     105               } 
     106 
    113107               SuperClassWriter::addDimension(lonid_loc, domain->zoom_ni_loc.getValue()); 
    114108               SuperClassWriter::addDimension(latid_loc, domain->zoom_nj_loc.getValue()); 
     
    133127               } 
    134128               this->writeAxisAttributes 
    135                   (latid, "X", "longitude", "Longitude", "degrees_east", domid); 
     129                  (lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    136130               this->writeAxisAttributes 
    137                   (lonid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     131                  (latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
    138132 
    139133               dim0.clear(); 
     
    164158               break; 
    165159            } 
     160            case (ONE_FILE) : 
     161            { 
     162               SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue()); 
     163               SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue()); 
     164 
     165                
     166               if (isCurvilinear) 
     167               { 
     168                  dim0.push_back(latid); dim0.push_back(lonid); 
     169                  lonid = StdString("nav_lon_").append(domid); 
     170                  latid = StdString("nav_lat_").append(domid); 
     171                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     172                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     173               } 
     174               else 
     175               { 
     176                  dim0.push_back(latid); 
     177                  dim1.push_back(lonid); 
     178                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     179                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     180               } 
     181               this->writeAxisAttributes 
     182                  (latid, "X", "longitude", "Longitude", "degrees_east", domid); 
     183               this->writeAxisAttributes 
     184                  (lonid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     185 
     186 
     187               SuperClassWriter::definition_end(); 
     188               std::vector<StdSize> start(2) ;  
     189               std::vector<StdSize> count(2) ; 
     190               if (domain->isEmpty()) 
     191               { 
     192                 start[0]=0 ; start [1]=0 ;  
     193                 count[0]=0 ; count[1]=0 ;  
     194               } 
     195               else 
     196               { 
     197                 start[1]=domain->zoom_ibegin_loc.getValue()+domain->ibegin.getValue()-1-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_loc.getValue()+domain->jbegin.getValue()-1-domain->zoom_jbegin.getValue() ;  
     198                 count[1]=domain->zoom_ni_loc.getValue() ; count[0]=domain->zoom_nj_loc.getValue() ;  
     199               } 
     200                
     201               SuperClassWriter::writeData(domain->latvalue.getValue(), latid, true, 0,&start,&count); 
     202               SuperClassWriter::writeData(domain->lonvalue.getValue(), lonid, true, 0,&start,&count); 
     203               SuperClassWriter::definition_start(); 
     204 
     205               break; 
     206            }            
    166207            default : 
    167208               ERROR("CNc4DataOutput::writeDomain(domain)", 
     
    183224         SuperClassWriter::addDimension(axisid, axis->size.getValue()); 
    184225         dims.push_back(axisid); 
    185  
     226          
    186227         switch (SuperClass::type) 
    187228         { 
     229            case (MULTI_FILE ) : 
     230            {} 
    188231            case (ONE_FILE) : 
    189             case (MULTI_FILE) : 
    190232            { 
    191233               SuperClassWriter::addVariable(axisid, NC_FLOAT, dims); 
     
    228270         boost::shared_ptr<CDomain> domain = 
    229271            CObjectFactory::GetObject<CDomain>(grid->domain_ref.getValue()); 
    230              
    231          if (domain->isEmpty()) return; 
     272            
     273         if (domain->isEmpty())  
     274           if (SuperClass::type==MULTI_FILE) return ; 
    232275 
    233276         StdString timeid    = StdString("time_counter"); 
     
    291334               dims.push_back(latid_loc); 
    292335               dims.push_back(lonid_loc); 
    293                SuperClassWriter::addVariable(fieldid, type, dims); 
    294  
    295                if (!field->standard_name.isEmpty()) 
    296                   SuperClassWriter::addAttribute 
    297                      ("standard_name",  field->standard_name.getValue(), &fieldid); 
    298  
    299                if (!field->long_name.isEmpty()) 
    300                   SuperClassWriter::addAttribute 
    301                      ("long_name", field->long_name.getValue(), &fieldid); 
    302  
    303                if (!field->unit.isEmpty()) 
    304                   SuperClassWriter::addAttribute 
    305                      ("units", field->unit.getValue(), &fieldid); 
    306                       
    307                SuperClassWriter::addAttribute 
    308                      ("online_operation", field->operation.getValue(), &fieldid); 
    309                       
    310                if (wtime) 
    311                { 
    312                   SuperClassWriter::addAttribute 
    313                         ("interval_operation", field->freq_op.getValue(), &fieldid); 
    314                   SuperClassWriter::addAttribute 
    315                         ("interval_write", field->getRelFile()->output_freq.getValue(), &fieldid); 
    316                } 
    317                 
    318                if (!field->default_value.isEmpty()) 
    319                { 
    320                   double default_value = field->default_value.getValue(); 
    321                   float fdefault_value = (float)default_value; 
    322                   if (type == NC_DOUBLE) 
    323                      SuperClassWriter::setDefaultValue(fieldid, &default_value); 
    324                   else 
    325                      SuperClassWriter::setDefaultValue(fieldid, &fdefault_value); 
    326                } 
    327                else 
    328                { 
    329                   double * default_value = NULL; 
    330                   SuperClassWriter::setDefaultValue(fieldid, default_value); 
    331                }              
    332  
    333                {  // Ecriture des coordonnées 
    334                 
    335                   StdString coordstr; //boost::algorithm::join(coodinates, " ") 
    336                   std::vector<StdString>::iterator  
    337                      itc = coodinates.begin(), endc = coodinates.end(); 
    338                    
    339                   for (; itc!= endc; itc++) 
    340                   { 
    341                      StdString & coord = *itc; 
    342                      if (itc+1 != endc) 
    343                            coordstr.append(coord).append(" "); 
    344                      else  coordstr.append(coord); 
    345                   } 
    346  
    347                   SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid); 
    348  
    349                } 
    350  
     336               break ; 
     337            } 
     338            case (ONE_FILE) : 
     339            { 
     340               dims.push_back(latid); 
     341               dims.push_back(lonid); 
    351342               break; 
    352343            } 
     
    356347                     << " not implemented yet !"); 
    357348         } 
     349           
     350         SuperClassWriter::addVariable(fieldid, type, dims); 
     351          
     352         if (!field->standard_name.isEmpty()) 
     353            SuperClassWriter::addAttribute 
     354               ("standard_name",  field->standard_name.getValue(), &fieldid); 
     355 
     356         if (!field->long_name.isEmpty()) 
     357            SuperClassWriter::addAttribute 
     358               ("long_name", field->long_name.getValue(), &fieldid); 
     359 
     360         if (!field->unit.isEmpty()) 
     361            SuperClassWriter::addAttribute 
     362               ("units", field->unit.getValue(), &fieldid); 
     363                
     364         SuperClassWriter::addAttribute 
     365               ("online_operation", field->operation.getValue(), &fieldid); 
     366                
     367         if (wtime) 
     368         { 
     369            SuperClassWriter::addAttribute 
     370                  ("interval_operation", field->freq_op.getValue(), &fieldid); 
     371            SuperClassWriter::addAttribute 
     372                  ("interval_write", field->getRelFile()->output_freq.getValue(), &fieldid); 
     373         } 
     374          
     375         if (!field->default_value.isEmpty()) 
     376         { 
     377            double default_value = field->default_value.getValue(); 
     378            float fdefault_value = (float)default_value; 
     379            if (type == NC_DOUBLE) 
     380               SuperClassWriter::setDefaultValue(fieldid, &default_value); 
     381            else 
     382               SuperClassWriter::setDefaultValue(fieldid, &fdefault_value); 
     383         } 
     384         else 
     385         { 
     386            double * default_value = NULL; 
     387            SuperClassWriter::setDefaultValue(fieldid, default_value); 
     388         }              
     389 
     390         {  // Ecriture des coordonnées 
     391          
     392            StdString coordstr; //boost::algorithm::join(coodinates, " ") 
     393            std::vector<StdString>::iterator  
     394               itc = coodinates.begin(), endc = coodinates.end(); 
     395             
     396            for (; itc!= endc; itc++) 
     397            { 
     398               StdString & coord = *itc; 
     399               if (itc+1 != endc) 
     400                     coordstr.append(coord).append(" "); 
     401               else  coordstr.append(coord);