Changeset 489


Ignore:
Timestamp:
09/22/14 14:17:33 (7 years ago)
Author:
mhnguyen
Message:

Ticket 50: Implementing the getting/setting methods for Fortran interface

+) Add some C and Fortran functions to set and get data to/from CVariable with an id
+) Add method to send, receive and dispatch in CVariable
+) Add dispatch method in server class

Test
-) On Curie
-) Test data: integer, float, double, boolean, string
-) File: one and multiple, using_server: ON and OFF
+) All test cases passed and had correct results

Location:
XIOS/trunk
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/bld.cfg

    r475 r489  
    3131bld::target libxios.a 
    3232#bld::target generate_fortran_interface.exe  
    33 bld::target xios_server.exe test_client.exe parse_xml.exe 
     33bld::target xios_server.exe test_client.exe parse_xml.exe test_complete.exe test_xios_interface.exe 
    3434bld::exe_dep 
    3535 
  • XIOS/trunk/inputs/COMPLETE/context_surface.xml

    r486 r489  
    1717        <variable id="my_attribute2" type="integer" > 10 </variable> 
    1818        <variable id="my_attribute3" type="float" >6.8</variable> 
     19        <variable id="my_attribute4" type="double" >100.201</variable> 
    1920      </field> 
    2021      <field field_ref="field_A_srf_K" /> 
     
    3132        <variable id="my_attribute2" type="integer" >10</variable> 
    3233        <variable id="my_attribute3" type="float" >6.8</variable> 
     34        <variable id="my_attribute4" type="double" >100.201</variable> 
    3335      </field> 
    3436      <field field_ref="field_A_srf_K" /> 
     
    3840      <field field_ref="field_A_srf_max" name="field_A_srf_mean_max" long_name="Average of hourly maximum over 1d" operation="average" freq_op="1h" > @field_A_srf_max </field> 
    3941      <variable id="my_global_attribute" type="string" >file_1d</variable> 
     42      <variable id="my_global_attribute_bool" type="boolean" >false</variable> 
    4043    </file> 
    4144  </file_definition> 
  • XIOS/trunk/src/context_server.cpp

    r401 r489  
    3838    pendingEvent=true ; 
    3939  } 
    40    
     40 
    4141  bool CContextServer::hasPendingEvent(void) 
    4242  { 
    4343    return pendingEvent ; 
    4444  } 
    45    
     45 
    4646  bool CContextServer::eventLoop(void) 
    4747  { 
     
    5858    int count ; 
    5959    char * addr ; 
    60     MPI_Status status;  
     60    MPI_Status status; 
    6161    map<int,CServerBuffer*>::iterator it; 
    62      
     62 
    6363    for(rank=0;rank<commSize;rank++) 
    6464    { 
     
    6666      { 
    6767        traceOff() ; 
    68         MPI_Iprobe(rank,20,interComm,&flag,&status);      
     68        MPI_Iprobe(rank,20,interComm,&flag,&status); 
    6969        traceOn() ; 
    7070        if (flag==true) 
    7171        { 
    7272          it=buffers.find(rank) ; 
    73           if (it==buffers.end())  
     73          if (it==buffers.end()) 
    7474            it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer))).first ; 
    7575          MPI_Get_count(&status,MPI_CHAR,&count) ; 
     
    8484    } 
    8585  } 
    86    
     86 
    8787  void CContextServer::checkPendingRequest(void) 
    8888  { 
     
    9494    int count ; 
    9595    MPI_Status status ; 
    96      
     96 
    9797    for(it=pendingRequest.begin();it!=pendingRequest.end();it++) 
    9898    { 
     
    108108      } 
    109109    } 
    110      
    111     for(itRecv=recvRequest.begin();itRecv!=recvRequest.end();itRecv++)  
     110 
     111    for(itRecv=recvRequest.begin();itRecv!=recvRequest.end();itRecv++) 
    112112    { 
    113113      pendingRequest.erase(*itRecv) ; 
     
    115115    } 
    116116  } 
    117    
     117 
    118118  void CContextServer::processRequest(int rank, char* buff,int count) 
    119119  { 
    120      
     120 
    121121    CBufferIn buffer(buff,count) ; 
    122122    char* startBuffer,endBuffer ; 
     
    124124    size_t timeLine ; 
    125125    map<size_t,CEventServer*>::iterator it ; 
    126         
     126 
    127127    while(count>0) 
    128128    { 
     
    136136 
    137137      buffer.advance(size) ; 
    138       count=buffer.remain() ;            
    139     }  
    140    
    141   } 
    142      
     138      count=buffer.remain() ; 
     139    } 
     140 
     141  } 
     142 
    143143  void CContextServer::processEvents(void) 
    144144  { 
    145145    map<size_t,CEventServer*>::iterator it ; 
    146146    CEventServer* event ; 
    147      
     147 
    148148    it=events.find(currentTimeLine) ; 
    149     if (it!=events.end())  
     149    if (it!=events.end()) 
    150150    { 
    151151      event=it->second ; 
     
    162162     } 
    163163   } 
    164         
     164 
    165165  CContextServer::~CContextServer() 
    166166  { 
    167167    map<int,CServerBuffer*>::iterator it ; 
    168     for(it=buffers.begin();it!=buffers.end();++it) delete it->second ;  
    169   }  
     168    for(it=buffers.begin();it!=buffers.end();++it) delete it->second ; 
     169  } 
    170170 
    171171 
     
    178178    list<CEventServer::SSubEvent>::iterator it ; 
    179179    CContext::setCurrent(context->getId()) ; 
    180          
     180 
    181181    if (event.classId==CContext::GetType() && event.type==CContext::EVENT_ID_CONTEXT_FINALIZE) 
    182182    { 
     
    198198    else if (event.classId==CFile::GetType()) CFile::dispatchEvent(event) ; 
    199199    else if (event.classId==CFileGroup::GetType()) CFileGroup::dispatchEvent(event) ; 
     200    else if (event.classId==CVariable::GetType()) CVariable::dispatchEvent(event) ; 
    200201    else 
    201202    { 
  • XIOS/trunk/src/interface/c/icdata.cpp

    r461 r489  
    66#include <boost/shared_ptr.hpp> 
    77#include <string> 
     8#include <cstring> 
    89#include <iostream> 
    910 
     
    3233 
    3334   // ----------------------- Redéfinition de types ---------------------------- 
    34     
     35 
    3536   typedef enum { NETCDF4 = 0 } XFileType; 
    36     
     37 
    3738   typedef xios::CContext * XContextPtr; 
    3839 
     
    4041   void cxios_init_server(void) 
    4142   { 
    42      CXios::initServerSide();       
     43     CXios::initServerSide(); 
    4344   } 
    4445 
    4546   void cxios_init_client(const char * client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm ) 
    4647   { 
    47       std::string str;  
     48      std::string str; 
    4849      MPI_Comm local_comm ; 
    4950      MPI_Comm return_comm ; 
    50        
     51 
    5152      if (!cstr2string(client_id, len_client_id, str)) return; 
    5253 
     
    6364   void cxios_context_initialize(const char * context_id , int len_context_id, MPI_Fint* f_comm) 
    6465   { 
    65      std::string str;  
     66     std::string str; 
    6667     MPI_Comm comm ; 
    67       
     68 
    6869     if (!cstr2string(context_id, len_context_id, str)) return; 
    6970     CTimer::get("XIOS").resume() ; 
     
    7475     CTimer::get("XIOS").suspend() ; 
    7576   } 
    76   
     77 
    7778   void cxios_context_is_initialized(const char * context_id , int len_context_id, bool* initialized) 
    7879   { 
    79      std::string str;  
    80       
     80     std::string str; 
     81 
    8182     if (!cstr2string(context_id, len_context_id, str)) return; 
    8283     CTimer::get("XIOS").resume() ; 
     
    8485     *initialized=context->isInitialized() ; 
    8586     CTimer::get("XIOS").suspend() ; 
    86    }   
    87     
     87   } 
     88 
    8889    void cxios_context_close_definition() 
    8990   { 
     
    9495     CTimer::get("XIOS close definition").suspend() ; 
    9596     CTimer::get("XIOS").suspend() ; 
    96    }   
     97   } 
    9798 
    9899   void cxios_context_finalize() 
     
    105106     CTimer::get("XIOS").suspend() ; 
    106107   } 
    107     
     108 
    108109   void cxios_finalize() 
    109110   { 
     
    119120     context->solveAllInheritance(false) ; 
    120121     CTimer::get("XIOS").suspend() ; 
    121    }  
    122     
     122   } 
     123 
     124   /*! \brief This group of functions retrieve variable information from the configuration file (.xml) 
     125    * 
     126    * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml), 
     127    * from a Fortran one, for example the value of a variable with id = "using_server". 
     128    * Each function corresponds to each basic type. 
     129    * \param varId        [in] id of the variable that we'd like to get 
     130    * \param varIdSize    [in] size of the variable type (integer, float, double, string) 
     131    * \param dataInt      [in/out] the retrieved data 
     132    * \param isVarExisted [in/out] Verify whether variable with varId exists 
     133   */ 
     134   void cxios_get_variable_data_k8(const char * varId, int varIdSize, double * data, bool * isVarExisted) 
     135   { 
     136      std::string varIdStr; 
     137      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     138 
     139      CTimer::get("XIOS").resume(); 
     140      CTimer::get("XIOS get variable data").resume(); 
     141 
     142      CContext* context = CContext::getCurrent(); 
     143      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     144 
     145      if (*isVarExisted) 
     146      { 
     147        *data = CVariable::get(context->getId(),varIdStr)->getData<double>(); 
     148      } 
     149 
     150      CTimer::get("XIOS get variable data").suspend() ; 
     151      CTimer::get("XIOS").suspend() ; 
     152   } 
     153 
     154   void cxios_get_variable_data_k4(const char * varId, int varIdSize, float * data, bool * isVarExisted) 
     155   { 
     156      std::string varIdStr; 
     157      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     158 
     159      CTimer::get("XIOS").resume(); 
     160      CTimer::get("XIOS get variable data").resume(); 
     161 
     162      CContext* context = CContext::getCurrent(); 
     163      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     164 
     165      if (*isVarExisted) 
     166      { 
     167        *data = CVariable::get(context->getId(),varIdStr)->getData<float>(); 
     168      } 
     169 
     170      CTimer::get("XIOS get variable data").suspend() ; 
     171      CTimer::get("XIOS").suspend() ; 
     172   } 
     173 
     174   void cxios_get_variable_data_int(const char * varId, int varIdSize, int * data, bool * isVarExisted) 
     175   { 
     176      std::string varIdStr; 
     177      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     178 
     179      CTimer::get("XIOS").resume(); 
     180      CTimer::get("XIOS get variable data").resume(); 
     181 
     182      CContext* context = CContext::getCurrent(); 
     183      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     184 
     185      if (*isVarExisted) 
     186      { 
     187        *data = CVariable::get(context->getId(),varIdStr)->getData<int>(); 
     188      } 
     189 
     190      CTimer::get("XIOS get variable data").suspend() ; 
     191      CTimer::get("XIOS").suspend() ; 
     192   } 
     193 
     194   void cxios_get_variable_data_logic(const char * varId, int varIdSize, bool * data, bool * isVarExisted) 
     195   { 
     196      std::string varIdStr; 
     197      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     198 
     199      CTimer::get("XIOS").resume(); 
     200      CTimer::get("XIOS get variable data").resume(); 
     201 
     202      CContext* context = CContext::getCurrent(); 
     203      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     204 
     205      if (*isVarExisted) 
     206      { 
     207        *data = CVariable::get(context->getId(),varIdStr)->getData<bool>(); 
     208      } 
     209 
     210      CTimer::get("XIOS get variable data").suspend() ; 
     211      CTimer::get("XIOS").suspend() ; 
     212   } 
     213 
     214   void cxios_get_variable_data_char(const char * varId, int varIdSize, char * data, int dataSizeIn, bool * isVarExisted) 
     215   { 
     216      std::string varIdStr; 
     217      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     218 
     219      CTimer::get("XIOS").resume(); 
     220      CTimer::get("XIOS get variable data").resume(); 
     221 
     222      CContext* context = CContext::getCurrent(); 
     223      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     224 
     225      if (*isVarExisted) 
     226      { 
     227        int dataSizeOut = CVariable::get(context->getId(),varIdStr)->getData<string>().length(); 
     228        strncpy(data, CVariable::get(context->getId(),varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut)); 
     229      } 
     230 
     231      CTimer::get("XIOS get variable data").suspend() ; 
     232      CTimer::get("XIOS").suspend() ; 
     233   } 
     234 
     235   /*! \brief This group of functions write information into existing variable in the configuration file (.xml) 
     236    * 
     237    *  These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml), 
     238    * from a Fortran one, for example the value of a variable with id = "using_server". 
     239    * Each function corresponds to each basic type. 
     240    * \param varId        [in] id of the variable that we'd like to get 
     241    * \param varIdSize    [in] size of the variable type (integer, float, double, string) 
     242    * \param data         [in] the input data 
     243    * \param isVarExisted [in/out] Verify whether variable with varId exists 
     244   */ 
     245   void cxios_set_variable_data_k8(const char * varId, int varIdSize, double data, bool * isVarExisted) 
     246   { 
     247      std::string varIdStr; 
     248      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     249 
     250      CTimer::get("XIOS").resume(); 
     251      CTimer::get("XIOS set variable data").resume(); 
     252 
     253      CContext* context = CContext::getCurrent() ; 
     254      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     255 
     256      if (*isVarExisted) 
     257      { 
     258        CVariable::get(context->getId(),varIdStr)->setData<double>(data); 
     259        CVariable::get(context->getId(),varIdStr)->sendValue(); 
     260      } 
     261 
     262      CTimer::get("XIOS set variable data").suspend() ; 
     263      CTimer::get("XIOS").suspend() ; 
     264   } 
     265 
     266   void cxios_set_variable_data_k4(const char * varId, int varIdSize, float data, bool * isVarExisted) 
     267   { 
     268      std::string varIdStr; 
     269      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     270 
     271      CTimer::get("XIOS").resume(); 
     272      CTimer::get("XIOS set variable data").resume(); 
     273 
     274      CContext* context = CContext::getCurrent() ; 
     275      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     276 
     277      if (*isVarExisted) 
     278      { 
     279        CVariable::get(context->getId(),varIdStr)->setData<float>(data); 
     280        CVariable::get(context->getId(),varIdStr)->sendValue(); 
     281      } 
     282 
     283      CTimer::get("XIOS set variable data").suspend() ; 
     284      CTimer::get("XIOS").suspend() ; 
     285   } 
     286 
     287   void cxios_set_variable_data_int(const char * varId, int varIdSize, int data, bool * isVarExisted) 
     288   { 
     289      std::string varIdStr; 
     290      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     291 
     292      CTimer::get("XIOS").resume(); 
     293      CTimer::get("XIOS set variable data").resume(); 
     294 
     295      CContext* context = CContext::getCurrent() ; 
     296      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     297 
     298      if (*isVarExisted) 
     299      { 
     300        CVariable::get(context->getId(),varIdStr)->setData<int>(data); 
     301        CVariable::get(context->getId(),varIdStr)->sendValue(); 
     302      } 
     303 
     304 
     305      CTimer::get("XIOS set variable data").suspend() ; 
     306      CTimer::get("XIOS").suspend() ; 
     307   } 
     308 
     309   void cxios_set_variable_data_logic(const char * varId, int varIdSize, bool data, bool * isVarExisted) 
     310   { 
     311      std::string varIdStr; 
     312      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     313 
     314      CTimer::get("XIOS").resume(); 
     315      CTimer::get("XIOS set variable data").resume(); 
     316 
     317      CContext* context = CContext::getCurrent() ; 
     318      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     319 
     320      if (*isVarExisted) 
     321      { 
     322        CVariable::get(context->getId(),varIdStr)->setData<bool>(data); 
     323        CVariable::get(context->getId(),varIdStr)->sendValue(); 
     324      } 
     325 
     326      CTimer::get("XIOS set variable data").suspend() ; 
     327      CTimer::get("XIOS").suspend() ; 
     328   } 
     329 
     330   void cxios_set_variable_data_char(const char * varId, int varIdSize, const char * data, int dataSizeIn, bool * isVarExisted) 
     331   { 
     332      std::string varIdStr, dataStr; 
     333      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     334      if (!cstr2string(data, dataSizeIn, dataStr)) 
     335      { 
     336        *isVarExisted = false; 
     337        return; 
     338      } 
     339 
     340      CTimer::get("XIOS").resume(); 
     341      CTimer::get("XIOS set variable data").resume(); 
     342 
     343      CContext* context = CContext::getCurrent() ; 
     344      *isVarExisted = CVariable::has(context->getId(), varIdStr); 
     345 
     346      if (*isVarExisted) 
     347      { 
     348        CVariable::get(context->getId(),varIdStr)->setData<string>(dataStr); 
     349        CVariable::get(context->getId(),varIdStr)->sendValue(); 
     350      } 
     351 
     352      CTimer::get("XIOS set variable data").suspend() ; 
     353      CTimer::get("XIOS").suspend() ; 
     354   } 
     355 
     356 
    123357   // ---------------------- Ecriture des données ------------------------------ 
    124     
     358 
    125359   void cxios_write_data_k81(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize) 
    126360   { 
    127361      std::string fieldid_str; 
    128       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
    129        
     362      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     363 
    130364      CTimer::get("XIOS").resume() ; 
    131365      CTimer::get("XIOS send field").resume() ; 
     
    139373      CTimer::get("XIOS").suspend() ; 
    140374   } 
    141     
     375 
    142376   void cxios_write_data_k82(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize, int data_Ysize) 
    143377   { 
    144378      std::string fieldid_str; 
    145379      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    146        
    147       CTimer::get("XIOS").resume() ; 
    148       CTimer::get("XIOS send field").resume() ; 
    149       CContext* context = CContext::getCurrent() ; 
    150       if (!context->hasServer) context->client->checkBuffers() ; 
    151        
     380 
     381      CTimer::get("XIOS").resume() ; 
     382      CTimer::get("XIOS send field").resume() ; 
     383      CContext* context = CContext::getCurrent() ; 
     384      if (!context->hasServer) context->client->checkBuffers() ; 
     385 
    152386      CArray<double,2>data(data_k8,shape(data_Xsize,data_Ysize),neverDeleteData) ; 
    153387      CField::get(fieldid_str)->setData(data) ; 
     
    155389      CTimer::get("XIOS").suspend() ; 
    156390   } 
    157     
     391 
    158392   void cxios_write_data_k83(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
    159393   { 
    160394      std::string fieldid_str; 
    161       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
     395      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    162396 
    163397      CTimer::get("XIOS").resume() ; 
     
    171405      CTimer::get("XIOS").suspend() ; 
    172406   } 
    173     
     407 
    174408   void cxios_write_data_k41(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize) 
    175409   { 
    176410      std::string fieldid_str; 
    177      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
     411     if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    178412 
    179413      CTimer::get("XIOS").resume() ; 
     
    189423      CTimer::get("XIOS").suspend() ; 
    190424   } 
    191     
     425 
    192426   void cxios_write_data_k42(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize, int data_Ysize) 
    193427   { 
    194428      std::string fieldid_str; 
    195       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
     429      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    196430 
    197431      CTimer::get("XIOS").resume() ; 
     
    207441      CTimer::get("XIOS").suspend() ; 
    208442   } 
    209     
     443 
    210444   void cxios_write_data_k43(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
    211445   { 
    212446      std::string fieldid_str; 
    213   
    214       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
    215   
     447 
     448      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     449 
    216450      CTimer::get("XIOS").resume() ; 
    217451      CTimer::get("XIOS send field").resume() ; 
     
    222456      CArray<double,3> data(data_Xsize,data_Ysize,data_Zsize) ; 
    223457      data=data_tmp ; 
    224   
    225       CField::get(fieldid_str)->setData(data) ; 
    226       CTimer::get("XIOS send field").suspend() ; 
    227       CTimer::get("XIOS").suspend() ; 
    228  
    229     }  
     458 
     459      CField::get(fieldid_str)->setData(data) ; 
     460      CTimer::get("XIOS send field").suspend() ; 
     461      CTimer::get("XIOS").suspend() ; 
     462 
     463    } 
    230464 
    231465} // extern "C" 
  • XIOS/trunk/src/interface/fortran/idata.F90

    r461 r489  
    44   USE, INTRINSIC :: ISO_C_BINDING 
    55   USE ICONTEXT 
    6     
     6 
    77   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    88 
     
    1717         INTEGER  (kind = C_INT)                    :: f_return_comm 
    1818      END SUBROUTINE cxios_init_client 
    19        
     19 
    2020      SUBROUTINE  cxios_context_initialize(context_id,len_context_id,f_comm) BIND(C) 
    2121         USE ISO_C_BINDING 
     
    3131         LOGICAL  (kind = C_BOOL)                   :: initialized 
    3232      END SUBROUTINE cxios_context_is_initialized 
    33        
    34        
     33 
     34 
    3535       SUBROUTINE  cxios_context_close_definition() BIND(C) 
    3636         USE ISO_C_BINDING 
    3737      END SUBROUTINE cxios_context_close_definition 
    38       
     38 
    3939 
    4040       SUBROUTINE  cxios_context_finalize() BIND(C) 
    4141         USE ISO_C_BINDING 
    4242      END SUBROUTINE cxios_context_finalize 
    43       
    44   
     43 
     44 
    4545      SUBROUTINE  cxios_finalize() BIND(C) 
    4646      END SUBROUTINE cxios_finalize 
     
    4949      END SUBROUTINE cxios_solve_inheritance 
    5050 
    51   
     51 
    5252      SUBROUTINE cxios_write_data_k81(fieldid, fieldid_size, data_k8, data_Xsize) BIND(C) 
    5353         USE ISO_C_BINDING 
     
    5757         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
    5858      END SUBROUTINE cxios_write_data_k81 
    59        
     59 
    6060      SUBROUTINE cxios_write_data_k82(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize) BIND(C) 
    6161         USE ISO_C_BINDING 
     
    6565         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize 
    6666      END SUBROUTINE cxios_write_data_k82 
    67        
     67 
    6868      SUBROUTINE cxios_write_data_k83(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
    6969         USE ISO_C_BINDING 
     
    7373         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize 
    7474      END SUBROUTINE cxios_write_data_k83 
    75        
     75 
    7676      SUBROUTINE cxios_write_data_k41(fieldid, fieldid_size, data_k4, data_Xsize) BIND(C) 
    7777         USE ISO_C_BINDING 
     
    8181         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
    8282      END SUBROUTINE cxios_write_data_k41 
    83        
     83 
    8484      SUBROUTINE cxios_write_data_k42(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize) BIND(C) 
    8585         USE ISO_C_BINDING 
     
    8989         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize 
    9090      END SUBROUTINE cxios_write_data_k42 
    91        
     91 
    9292      SUBROUTINE cxios_write_data_k43(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
    9393         USE ISO_C_BINDING 
     
    9797         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize 
    9898      END SUBROUTINE cxios_write_data_k43 
    99        
     99 
     100      ! Binding C and Fortran interface of get_variable (icdata.cpp) 
     101      SUBROUTINE cxios_get_variable_data_k8(vardid, varid_size, data_k8, is_var_existed) BIND(C) 
     102         USE ISO_C_BINDING 
     103         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     104         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     105         REAL     (kind = C_DOUBLE)               :: data_k8 
     106         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     107      END SUBROUTINE cxios_get_variable_data_k8 
     108 
     109      SUBROUTINE cxios_get_variable_data_k4(vardid, varid_size, data_k4, is_var_existed) BIND(C) 
     110         USE ISO_C_BINDING 
     111         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     112         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     113         REAL     (kind = C_FLOAT)                :: data_k4 
     114         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     115      END SUBROUTINE cxios_get_variable_data_k4 
     116 
     117      SUBROUTINE cxios_get_variable_data_int(vardid, varid_size, data_int, is_var_existed) BIND(C) 
     118         USE ISO_C_BINDING 
     119         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     120         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     121         INTEGER  (kind = C_INT)                  :: data_int 
     122         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     123      END SUBROUTINE cxios_get_variable_data_int 
     124 
     125      SUBROUTINE cxios_get_variable_data_logic(vardid, varid_size, data_logic, is_var_existed) BIND(C) 
     126         USE ISO_C_BINDING 
     127         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     128         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     129         LOGICAL  (kind = 4)                      :: data_logic 
     130         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     131      END SUBROUTINE cxios_get_variable_data_logic 
     132 
     133      SUBROUTINE cxios_get_variable_data_char(vardid, varid_size, data_char, data_size_in, is_var_existed) BIND(C) 
     134         USE ISO_C_BINDING 
     135         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     136         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     137         INTEGER  (kind = C_INT)   , VALUE        :: data_size_in 
     138         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: data_char 
     139         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     140      END SUBROUTINE cxios_get_variable_data_char 
     141 
     142      ! Binding C and Fortran interface of set_variable (icdata.cpp) 
     143      SUBROUTINE cxios_set_variable_data_k8(vardid, varid_size, data_k8, is_var_existed) BIND(C) 
     144         USE ISO_C_BINDING 
     145         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     146         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     147         REAL     (kind = C_DOUBLE), VALUE        :: data_k8 
     148         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     149      END SUBROUTINE cxios_set_variable_data_k8 
     150 
     151      SUBROUTINE cxios_set_variable_data_k4(vardid, varid_size, data_k4, is_var_existed) BIND(C) 
     152         USE ISO_C_BINDING 
     153         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     154         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     155         REAL     (kind = C_FLOAT) , VALUE        :: data_k4 
     156         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     157      END SUBROUTINE cxios_set_variable_data_k4 
     158 
     159      SUBROUTINE cxios_set_variable_data_int(vardid, varid_size, data_int, is_var_existed) BIND(C) 
     160         USE ISO_C_BINDING 
     161         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     162         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     163         INTEGER  (kind = C_INT)   , VALUE        :: data_int 
     164         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     165      END SUBROUTINE cxios_set_variable_data_int 
     166 
     167      SUBROUTINE cxios_set_variable_data_logic(vardid, varid_size, data_logic, is_var_existed) BIND(C) 
     168         USE ISO_C_BINDING 
     169         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     170         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     171         LOGICAL  (kind = 4)       , VALUE        :: data_logic 
     172         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     173      END SUBROUTINE cxios_set_variable_data_logic 
     174 
     175      SUBROUTINE cxios_set_variable_data_char(vardid, varid_size, data_char, data_size_in, is_var_existed) BIND(C) 
     176         USE ISO_C_BINDING 
     177         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
     178         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
     179         INTEGER  (kind = C_INT)   , VALUE        :: data_size_in 
     180         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: data_char 
     181         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
     182      END SUBROUTINE cxios_set_variable_data_char 
     183 
    100184   END INTERFACE 
    101     
    102     
     185 
     186 
    103187   CONTAINS ! Fonctions disponibles pour les utilisateurs. 
    104188 
     
    107191     CALL cxios_init_server() 
    108192   END SUBROUTINE xios(init_server) 
    109     
     193 
    110194   SUBROUTINE  xios(initialize)(client_id, local_comm, return_comm) 
    111195   IMPLICIT NONE 
    112196   INCLUDE 'mpif.h' 
    113197   CHARACTER(LEN=*),INTENT(IN) :: client_id 
    114    INTEGER,INTENT(IN),OPTIONAL         :: local_comm   
     198   INTEGER,INTENT(IN),OPTIONAL         :: local_comm 
    115199   INTEGER,INTENT(OUT),OPTIONAL        :: return_comm 
    116200   INTEGER :: f_local_comm 
    117201   INTEGER :: f_return_comm 
    118     
     202 
    119203      IF (PRESENT(local_comm)) THEN 
    120         f_local_comm=local_comm  
     204        f_local_comm=local_comm 
    121205      ELSE 
    122         f_local_comm = MPI_COMM_NULL  
     206        f_local_comm = MPI_COMM_NULL 
    123207      ENDIF 
    124        
     208 
    125209      CALL cxios_init_client(client_id,LEN(client_id),f_local_comm,f_return_comm) 
    126   
     210 
    127211      IF (PRESENT(return_comm)) return_comm=f_return_comm 
    128212 
     
    134218   CHARACTER(LEN=*),INTENT(IN)  :: context_id 
    135219   INTEGER, INTENT(IN)          :: comm 
    136        
     220 
    137221      CALL cxios_context_initialize(context_id,LEN(context_id),comm) 
    138   
     222 
    139223    END SUBROUTINE  xios(context_initialize) 
    140224 
     
    145229   CHARACTER(LEN=*),INTENT(IN)  :: context_id 
    146230   LOGICAL(KIND=C_BOOL) :: is_init 
    147           
     231 
    148232      CALL cxios_context_is_initialized(context_id, LEN(context_id), is_init) 
    149233      xios(context_is_initialized) = is_init 
    150   
    151     END FUNCTION xios(context_is_initialized)    
    152  
    153      
     234 
     235    END FUNCTION xios(context_is_initialized) 
     236 
     237 
    154238   SUBROUTINE  xios(finalize) 
    155239   IMPLICIT NONE 
     
    159243    END SUBROUTINE  xios(finalize) 
    160244 
    161     
     245 
    162246   SUBROUTINE xios(close_context_definition)() 
    163247   IMPLICIT NONE 
     
    165249   END SUBROUTINE xios(close_context_definition) 
    166250 
    167     
     251 
    168252   SUBROUTINE xios(context_finalize)() 
    169253   IMPLICIT NONE 
    170254      CALL cxios_context_finalize() 
    171255   END SUBROUTINE xios(context_finalize) 
    172     
     256 
    173257   SUBROUTINE xios(solve_inheritance)() 
    174258   IMPLICIT NONE 
    175259      CALL cxios_solve_inheritance() 
    176260   END SUBROUTINE xios(solve_inheritance) 
    177    
    178     
     261 
     262 
    179263   SUBROUTINE xios(send_field_r8_1d)(fieldid, data1d_k8) 
    180264   IMPLICIT NONE 
     
    183267      CALL cxios_write_data_k81(fieldid, len(fieldid), data1d_k8, size(data1d_k8, 1)) 
    184268   END SUBROUTINE xios(send_field_r8_1d) 
    185     
     269 
    186270   SUBROUTINE  xios(send_field_r8_2d)(fieldid, data2d_k8) 
    187271   IMPLICIT NONE 
     
    190274      CALL cxios_write_data_k82(fieldid, len(fieldid), data2d_k8, size(data2d_k8, 1), size(data2d_k8, 2)) 
    191275   END SUBROUTINE  xios(send_field_r8_2d) 
    192     
     276 
    193277   SUBROUTINE  xios(send_field_r8_3d)(fieldid, data3d_k8) 
    194278   IMPLICIT NONE 
     
    197281      CALL cxios_write_data_k83(fieldid, len(fieldid), data3d_k8, size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3)) 
    198282   END SUBROUTINE  xios(send_field_r8_3d) 
    199     
     283 
    200284   SUBROUTINE xios(send_field_r4_1d)(fieldid, data1d_k4) 
    201285   IMPLICIT NONE 
     
    204288      CALL cxios_write_data_k41(fieldid, len(fieldid), data1d_k4, size(data1d_k4, 1)) 
    205289   END SUBROUTINE xios(send_field_r4_1d) 
    206     
     290 
    207291   SUBROUTINE xios(send_field_r4_2d)(fieldid, data2d_k4) 
    208292   IMPLICIT NONE 
     
    211295      CALL cxios_write_data_k42(fieldid, len(fieldid), data2d_k4, size(data2d_k4, 1), size(data2d_k4, 2)) 
    212296   END SUBROUTINE xios(send_field_r4_2d) 
    213     
     297 
    214298   SUBROUTINE xios(send_field_r4_3d)(fieldid, data3d_k4) 
    215299   IMPLICIT NONE 
     
    218302      CALL cxios_write_data_k43(fieldid, len(fieldid), data3d_k4, size(data3d_k4, 1), size(data3d_k4, 2), size(data3d_k4, 3)) 
    219303   END SUBROUTINE xios(send_field_r4_3d) 
    220     
    221     
     304 
     305   ! Get variable functions 
     306   LOGICAL FUNCTION xios(getVar_k8)(varId, data_k8) 
     307   IMPLICIT NONE 
     308      LOGICAL  (kind = 1)                           :: val 
     309      CHARACTER(len = *)               , INTENT(IN) :: varId 
     310      REAL     (kind = 8)              , INTENT(OUT):: data_k8 
     311 
     312      CALL cxios_get_variable_data_k8(varId, len(varId), data_k8, val) 
     313 
     314      xios(getVar_k8) = val 
     315   END FUNCTION xios(getVar_k8) 
     316 
     317   LOGICAL FUNCTION xios(getVar_k4)(varId, data_k4) 
     318   IMPLICIT NONE 
     319      LOGICAL  (kind = 1)                           :: val 
     320      CHARACTER(len = *)               , INTENT(IN) :: varId 
     321      REAL     (kind = 4)              , INTENT(OUT):: data_k4 
     322 
     323      CALL cxios_get_variable_data_k4(varId, len(varId), data_k4, val) 
     324 
     325      xios(getVar_k4) = val 
     326   END FUNCTION xios(getVar_k4) 
     327 
     328   LOGICAL FUNCTION xios(getVar_int)(varId, data_int) 
     329   IMPLICIT NONE 
     330      LOGICAL  (kind = 1)                           :: val 
     331      CHARACTER(len = *)               , INTENT(IN) :: varId 
     332      INTEGER                          , INTENT(OUT):: data_int 
     333 
     334      CALL cxios_get_variable_data_int(varId, len(varId), data_int, val) 
     335 
     336      xios(getVar_int) = val 
     337   END FUNCTION xios(getVar_int) 
     338 
     339   LOGICAL FUNCTION xios(getVar_logic)(varId, data_logic) 
     340   IMPLICIT NONE 
     341      LOGICAL  (kind = 1)                           :: val 
     342      CHARACTER(len  = *)              , INTENT(IN) :: varId 
     343      LOGICAL  (kind = 4)              , INTENT(OUT):: data_logic 
     344 
     345      CALL cxios_get_variable_data_logic(varId, len(varId), data_logic, val) 
     346 
     347      xios(getVar_logic) = val 
     348   END FUNCTION xios(getVar_logic) 
     349 
     350   LOGICAL FUNCTION xios(getVar_char)(varId, data_char) 
     351   IMPLICIT NONE 
     352      LOGICAL  (kind = 1)                           :: val 
     353      CHARACTER(len  = *)              , INTENT(IN) :: varId 
     354      CHARACTER(len  = *)              , INTENT(OUT):: data_char 
     355 
     356      CALL cxios_get_variable_data_char(varId, len(varId), data_char, len(data_char), val) 
     357 
     358      xios(getVar_char) = val 
     359   END FUNCTION xios(getVar_char) 
     360 
     361   ! Set variable functions 
     362   LOGICAL FUNCTION xios(setVar_k8)(varId, data_k8) 
     363   IMPLICIT NONE 
     364      LOGICAL  (kind = 1)                           :: val 
     365      CHARACTER(len = *)               , INTENT(IN) :: varId 
     366      REAL     (kind = 8)              , INTENT(IN) :: data_k8 
     367 
     368      CALL cxios_set_variable_data_k8(varId, len(varId), data_k8, val) 
     369 
     370      xios(setVar_k8) = val 
     371   END FUNCTION xios(setVar_k8) 
     372 
     373   LOGICAL FUNCTION xios(setVar_k4)(varId, data_k4) 
     374   IMPLICIT NONE 
     375      LOGICAL  (kind = 1)                           :: val 
     376      CHARACTER(len = *)               , INTENT(IN) :: varId 
     377      REAL     (kind = 4)              , INTENT(IN) :: data_k4 
     378 
     379      CALL cxios_set_variable_data_k4(varId, len(varId), data_k4, val) 
     380 
     381      xios(setVar_k4) = val 
     382   END FUNCTION xios(setVar_k4) 
     383 
     384   LOGICAL FUNCTION xios(setVar_int)(varId, data_int) 
     385   IMPLICIT NONE 
     386      LOGICAL  (kind = 1)                           :: val 
     387      CHARACTER(len = *)               , INTENT(IN) :: varId 
     388      INTEGER                          , INTENT(IN) :: data_int 
     389 
     390      CALL cxios_set_variable_data_int(varId, len(varId), data_int, val) 
     391 
     392      xios(setVar_int) = val 
     393   END FUNCTION xios(setVar_int) 
     394 
     395   LOGICAL FUNCTION xios(setVar_logic)(varId, data_logic) 
     396   IMPLICIT NONE 
     397      LOGICAL  (kind = 1)                           :: val 
     398      CHARACTER(len  = *)              , INTENT(IN) :: varId 
     399      LOGICAL  (kind = 4)              , INTENT(IN) :: data_logic 
     400 
     401      CALL cxios_set_variable_data_logic(varId, len(varId), data_logic, val) 
     402 
     403      xios(setVar_logic) = val 
     404   END FUNCTION xios(setVar_logic) 
     405 
     406   LOGICAL FUNCTION xios(setVar_char)(varId, data_char) 
     407   IMPLICIT NONE 
     408      LOGICAL  (kind = 1)                           :: val 
     409      CHARACTER(len  = *)              , INTENT(IN) :: varId 
     410      CHARACTER(len  = *)              , INTENT(IN) :: data_char 
     411 
     412      CALL cxios_set_variable_data_char(varId, len(varId), data_char, len(data_char), val) 
     413 
     414      xios(setVar_char) = val 
     415   END FUNCTION xios(setVar_char) 
     416 
    222417END MODULE IDATA 
  • XIOS/trunk/src/interface/fortran/ixios.F90

    r472 r489  
    1010                          xios(get_context_attr), xios(get_context_attr_hdl), & 
    1111                          xios(is_defined_context_attr), xios(is_defined_context_attr_hdl) 
    12                                                 
     12 
    1313USE idata, ONLY : xios(initialize),xios(init_server), xios(finalize), xios(context_initialize),  & 
    1414                  xios(context_is_initialized), xios(close_context_definition),xios(solve_inheritance),       & 
    1515                  xios(context_finalize), xios(send_field_r8_1d), xios(send_field_r8_2d), & 
    1616                  xios(send_field_r8_3d), xios(send_field_r4_1d), xios(send_field_r4_2d), & 
    17                   xios(send_field_r4_3d) 
     17                  xios(send_field_r4_3d), xios(getVar_k8), xios(getVar_k4), xios(getVar_int), & 
     18                  xios(getVar_logic), xios(getVar_char), xios(setVar_k8), xios(setVar_k4), xios(setVar_int), & 
     19                  xios(setVar_logic), xios(setVar_char) 
    1820 
    1921USE idate, ONLY : txios(date),txios(time), xios(set_timestep),xios(update_calendar) 
     
    2729                          xios(is_defined_domain_attr), xios(is_defined_domain_attr_hdl) 
    2830 
    29 USE idomaingroup_attr, ONLY : xios(set_domaingroup_attr), xios(set_domaingroup_attr_hdl),  &  
    30                               xios(get_domaingroup_attr), xios(get_domaingroup_attr_hdl), &  
    31                               xios(is_defined_domaingroup_attr), xios(is_defined_domaingroup_attr_hdl)  
    32                      
     31USE idomaingroup_attr, ONLY : xios(set_domaingroup_attr), xios(set_domaingroup_attr_hdl),  & 
     32                              xios(get_domaingroup_attr), xios(get_domaingroup_attr_hdl), & 
     33                              xios(is_defined_domaingroup_attr), xios(is_defined_domaingroup_attr_hdl) 
     34 
    3335USE ifield, ONLY : txios(field), txios(fieldgroup), xios(get_field_handle),  & 
    3436                   xios(get_fieldgroup_handle), xios(is_valid_field),        & 
    35                    xios(is_valid_fieldgroup),xios(field_is_active_id),xios(field_is_active_hdl)   
     37                   xios(is_valid_fieldgroup),xios(field_is_active_id),xios(field_is_active_hdl) 
    3638 
    3739USE ifield_attr, ONLY : xios(set_field_attr),xios(set_field_attr_hdl),    & 
    3840                        xios(get_field_attr),xios(get_field_attr_hdl), & 
    3941                        xios(is_defined_field_attr),xios(is_defined_field_attr_hdl) 
    40    
     42 
    4143USE ifieldgroup_attr, ONLY : xios(set_fieldgroup_attr), xios(set_fieldgroup_attr_hdl),  & 
    4244                             xios(get_fieldgroup_attr), xios(get_fieldgroup_attr_hdl), & 
     
    5052                        xios(get_variable_attr),xios(get_variable_attr_hdl), & 
    5153                        xios(is_defined_variable_attr),xios(is_defined_variable_attr_hdl) 
    52    
     54 
    5355USE ivariablegroup_attr, ONLY : xios(set_variablegroup_attr), xios(set_variablegroup_attr_hdl),  & 
    5456                             xios(get_variablegroup_attr), xios(get_variablegroup_attr_hdl), & 
    5557                             xios(is_defined_variablegroup_attr), xios(is_defined_variablegroup_attr_hdl) 
    56                               
    57 USE ifile, ONLY : txios(file), txios(filegroup), xios(get_file_handle),    &  
     58 
     59USE ifile, ONLY : txios(file), txios(filegroup), xios(get_file_handle),    & 
    5860                  xios(get_filegroup_handle), xios(is_valid_file), xios(is_valid_filegroup) 
    5961 
     
    6567                            xios(get_filegroup_attr), xios(get_filegroup_attr_hdl), & 
    6668                            xios(is_defined_filegroup_attr), xios(is_defined_filegroup_attr_hdl) 
    67                    
     69 
    6870USE igrid, ONLY : txios(grid), txios(gridgroup), xios(get_grid_handle),     & 
    69                   xios(get_gridgroup_handle), xios(is_valid_grid), xios(is_valid_gridgroup)  
     71                  xios(get_gridgroup_handle), xios(is_valid_grid), xios(is_valid_gridgroup) 
    7072 
    7173USE igrid_attr, ONLY : xios(set_grid_attr_hdl), xios(set_grid_attr), & 
     
    7880 
    7981USE iaxis, ONLY : txios(axis), txios(axisgroup), xios(get_axis_handle),     & 
    80                   xios(get_axisgroup_handle), xios(is_valid_axis), xios(is_valid_axisgroup)  
     82                  xios(get_axisgroup_handle), xios(is_valid_axis), xios(is_valid_axisgroup) 
    8183 
    8284USE iaxis_attr, ONLY :  xios(set_axis_attr), xios(set_axis_attr_hdl), & 
     
    9092USE ixml_tree, ONLY : xios(add_axis), xios(add_file), xios(add_grid), xios(add_field), xios(add_domain),          & 
    9193                     xios(add_fieldtofile), xios(add_variabletofile), xios(add_variabletofield),                  & 
    92                      xios(add_axisgroup), xios(add_filegroup), xios(add_gridgroup), xios(add_fieldgroup),         &  
     94                     xios(add_axisgroup), xios(add_filegroup), xios(add_gridgroup), xios(add_fieldgroup),         & 
    9395                     xios(add_domaingroup), xios(add_fieldgrouptofile), xios(add_variablegrouptofile),            & 
    9496                     xios(add_variablegrouptofield) 
     
    127129                    xios(get_field_handle), xios(get_fieldgroup_handle),xios(get_variable_handle),          & 
    128130                    xios(get_variablegroup_handle) 
    129 END INTERFACE xios(get_handle)  
     131END INTERFACE xios(get_handle) 
    130132 
    131133INTERFACE xios(add_child) 
     
    133135                   xios(add_fieldtofile), xios(add_variabletofile), xios(add_variabletofield), xios(add_axisgroup),  & 
    134136                   xios(add_filegroup), xios(add_gridgroup), xios(add_fieldgroup), xios(add_domaingroup),            & 
    135                    xios(add_fieldgrouptofile), xios(add_variablegrouptofile),xios(add_variablegrouptofield)  
     137                   xios(add_fieldgrouptofile), xios(add_variablegrouptofile),xios(add_variablegrouptofield) 
    136138END INTERFACE xios(add_child) 
    137139 
     
    145147  MODULE PROCEDURE xios(field_is_active_id),xios(field_is_active_hdl) 
    146148END INTERFACE 
    147    
     149 
     150INTERFACE xios(getVar) 
     151  MODULE PROCEDURE xios(getVar_k8), xios(getVar_k4), xios(getVar_int), xios(getVar_logic), xios(getVar_char) 
     152END INTERFACE xios(getVar) 
     153 
     154INTERFACE xios(setVar) 
     155  MODULE PROCEDURE xios(setVar_k8), xios(setVar_k4), xios(setVar_int), xios(setVar_logic), xios(setVar_char) 
     156END INTERFACE xios(setVar) 
     157 
    148158 PUBLIC :: txios(domain), txios(domaingroup),txios(field), txios(fieldgroup),txios(file), txios(filegroup), & 
    149           txios(grid), txios(gridgroup), txios(axis), txios(axisgroup),txios(context), txios(date),txios(time)   
     159          txios(grid), txios(gridgroup), txios(axis), txios(axisgroup),txios(context), txios(date),txios(time) 
    150160 
    151161 PUBLIC :: xios(set_attr), xios(set_domain_attr), xios(set_domaingroup_attr), xios(set_fieldgroup_attr), & 
     
    164174          xios(is_defined_axisgroup_attr), xios(is_defined_context_attr) 
    165175 
    166  PUBLIC :: xios(get_handle)  
    167  PUBLIC :: xios(add_child)  
     176 PUBLIC :: xios(get_handle) 
     177 PUBLIC :: xios(add_child) 
    168178 
    169179 PUBLIC :: xios(is_valid_context),xios(is_valid_domain), xios(is_valid_domaingroup),xios(is_valid_field),        & 
    170180          xios(is_valid_fieldgroup), xios(is_valid_file), xios(is_valid_filegroup), xios(is_valid_grid),         & 
    171181          xios(is_valid_gridgroup), xios(is_valid_axis), xios(is_valid_axisgroup) 
    172            
    173  PUBLIC :: xios(set_current_context)   
     182 
     183 PUBLIC :: xios(set_current_context) 
    174184 PUBLIC :: xios(set_timestep),xios(update_calendar) 
    175185 PUBLIC :: xios(initialize), xios(init_server), xios(finalize), xios(context_initialize),xios(context_is_initialized), & 
     
    177187           xios(field_is_active) 
    178188 
     189 PUBLIC :: xios(getVar) 
     190 PUBLIC :: xios(setVar) 
     191 
    179192END MODULE XIOS 
  • XIOS/trunk/src/node/variable.cpp

    r477 r489  
    77#include "xmlioserver_spl.hpp" 
    88#include "type.hpp" 
     9#include "context.hpp" 
     10#include "context_client.hpp" 
    911#include <boost/algorithm/string.hpp> 
    1012 
     
    4850   { 
    4951      return (this->content); 
     52   } 
     53 
     54   void CVariable::setContent(const StdString& contentStr) 
     55   { 
     56     this->content = contentStr; 
    5057   } 
    5158 
     
    6168      oss << "</" << CVariable::GetName() << " >"; 
    6269      return (oss.str()); 
    63    }  
    64     
     70   } 
     71 
    6572   CVariable::EVarType CVariable::getVarType(void) const 
    6673   { 
    6774     EVarType ret ; 
    68       
     75 
    6976     if (type.isEmpty()) ret=t_undefined ; 
    7077     else 
     
    8390     return ret ; 
    8491   } 
    85         
     92 
     93   /* 
     94   *\brief Sending value of a variable with its id from client to server 
     95   * 
     96   */ 
     97   void CVariable::sendValue() 
     98   { 
     99     CContext* context=CContext::getCurrent() ; 
     100     if (!context->hasServer) 
     101     { 
     102       CContextClient* client=context->client ; 
     103 
     104       CEventClient event(this->getType(),EVENT_ID_VARIABLE_VALUE) ; 
     105       if (client->isServerLeader()) 
     106       { 
     107         CMessage msg ; 
     108         msg<<this->getId() ; 
     109         msg<<content ; 
     110         event.push(client->getServerLeader(),1,msg) ; 
     111         client->sendEvent(event) ; 
     112       } 
     113       else client->sendEvent(event) ; 
     114    } 
     115   } 
     116 
     117   /* 
     118   *\brief Receive value of a variable with its id from client to server 
     119   * 
     120   */ 
     121   void CVariable::recvValue(CEventServer& event) 
     122   { 
     123      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     124      string id; 
     125      *buffer>>id ; 
     126      get(id)->recvValue(*buffer); 
     127   } 
     128 
     129 
     130   /* 
     131   *\brief Receive value of a variable with its id from client to server 
     132   * 
     133   */ 
     134   void CVariable::recvValue(CBufferIn& buffer) 
     135   { 
     136      string str ; 
     137      buffer>>str; 
     138      setContent(str); 
     139   } 
     140 
     141   bool CVariable::dispatchEvent(CEventServer& event) 
     142   { 
     143    if (SuperClass::dispatchEvent(event)) return true ; 
     144    else 
     145    { 
     146      switch(event.type) 
     147      { 
     148        case EVENT_ID_VARIABLE_VALUE : 
     149          recvValue(event) ; 
     150          return true ; 
     151          break ; 
     152 
     153        default : 
     154          ERROR("bool CVariable::dispatchEvent(CEventServer& event)",<<"Unknown Event") ; 
     155          return false ; 
     156      } 
     157    } 
     158   } 
     159 
    86160/* 
    87161   void CVariable::toBinary(StdOStream & os) const 
  • XIOS/trunk/src/node/variable.hpp

    r472 r489  
    1515      class CVariableAttributes; 
    1616      class CVariable; 
    17  
     17      class CContext; 
    1818      ///-------------------------------------------------------------- 
    1919 
     
    2929         , public CVariableAttributes 
    3030      { 
     31            enum EEventId 
     32            { 
     33             EVENT_ID_VARIABLE_VALUE 
     34            }; 
     35 
    3136            /// typedef /// 
    3237            typedef CObjectTemplate<CVariable>   SuperClass; 
     
    5257            enum EVarType 
    5358            {  t_int, t_short_int, t_long_int, t_float, t_double, t_long_double, t_bool, t_string, t_undefined } ; 
    54                
    55                       
     59 
     60 
    5661            /// Autres /// 
    5762            virtual void parse(xml::CXMLNode & node); 
     
    6065            /// Accesseur /// 
    6166            const StdString & getContent (void) const; 
    62              
    63              
     67 
     68            void setContent(const StdString& content); 
     69 
     70 
    6471            template <typename T> inline T getData(void) const; 
    65              
     72            template <typename T> inline void setData(T data); 
     73 
    6674            template <typename T, StdSize N> 
    6775            inline void getData(CArray<T, N>& _data_array) const; 
    68              
     76 
    6977            EVarType getVarType(void) const ; 
    70              
     78 
     79            static bool dispatchEvent(CEventServer& event) ; 
     80 
     81            //! Sending a request to set up variable data 
     82            void sendValue(); 
     83 
     84            static void recvValue(CEventServer& event) ; 
     85            void recvValue(CBufferIn& buffer) ; 
     86 
    7187         public : 
    72           
     88 
    7389            /// Accesseurs statiques /// 
    7490            static StdString GetName(void); 
     
    85101      inline bool CVariable::getData(void) const 
    86102      { 
    87          if (content.compare("true")==0 || content.compare(".true.")==0 || content.compare(".TRUE.")==0) return true ;  
    88          else if (content.compare("false")==0 || content.compare(".false.")==0 || content.compare(".FALSE.")==0) return false ;  
     103         if (content.compare("true")==0 || content.compare(".true.")==0 || content.compare(".TRUE.")==0) return true ; 
     104         else if (content.compare("false")==0 || content.compare(".false.")==0 || content.compare(".FALSE.")==0) return false ; 
    89105         else ERROR("CVariable::getdata()", 
    90106               << "Cannot convert string <" << content << "> into type required" ); 
    91107         return false ; 
    92       }  
    93        
     108      } 
     109 
    94110      template <typename T> 
    95111      inline T CVariable::getData(void) const 
    96112      { 
    97113         T retval ; 
    98          std::stringstream sstr(std::stringstream::in | std::stringstream::out);  
     114         std::stringstream sstr(std::stringstream::in | std::stringstream::out); 
    99115         sstr<<content ; 
    100116         sstr>>retval ; 
     
    102118               << "Cannot convert string <" << content << "> into type required" ); 
    103119         return retval ; 
    104       }  
     120      } 
    105121 
     122      template<> 
     123      inline void CVariable::setData(bool data) 
     124      { 
     125        if (true == data) content.assign("true"); 
     126        else content.assign("false"); 
     127      } 
     128 
     129      template <typename T> 
     130      inline void CVariable::setData(T data) 
     131      { 
     132        std::stringstream sstr; 
     133        sstr<<data; 
     134        content = sstr.str(); 
     135      } 
    106136 
    107137      ///-------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.