Changeset 278


Ignore:
Timestamp:
09/21/11 09:42:30 (12 years ago)
Author:
hozdoba
Message:

Corrections

Location:
XMLIO_V2/dev/common/src/xmlio
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • XMLIO_V2/dev/common/src/xmlio/attribute_map.cpp

    r219 r278  
    9696                                                   it != attributes.end(); 
    9797                                                   it ++) 
     98         { 
    9899            if ((*it).first.compare(StdString("id")) != 0 && 
    99100                (*it).first.compare(StdString("src"))!= 0) 
     
    102103               CAttributeMap::operator[]((*it).first)->fromString((*it).second); 
    103104            } 
     105         } 
    104106      } 
    105107       
  • XMLIO_V2/dev/common/src/xmlio/client.cpp

    r219 r278  
    1616   CClient::~CClient(void) 
    1717   {  
    18       this->finalize(); 
     18      //this->finalize(); 
    1919   }  
    2020    
     
    2727   boost::shared_ptr<CClient> CClient::CreateClient(MPIComm comm_client_server) 
    2828   { 
    29       if (CClient::Client.get() != NULL) 
     29      if (CClient::Client.get() == NULL) 
    3030         CClient::Client = boost::shared_ptr<CClient>(new CClient(comm_client_server)); 
    3131      return (CClient::GetClient()); 
  • XMLIO_V2/dev/common/src/xmlio/client.hpp

    r219 r278  
    2424         ~CClient(void);   
    2525          
    26       protected :  
     26      public :  
    2727       
    2828         /// Accesseur /// 
  • XMLIO_V2/dev/common/src/xmlio/config/context_attribute.conf

    r274 r278  
    11DECLARE_ATTRIBUTE(StdString, calendar_type) 
    22DECLARE_ATTRIBUTE(StdString, start_date) 
    3  
     3DECLARE_ATTRIBUTE(StdString, timestep) 
    44DECLARE_ATTRIBUTE(StdString, output_dir) 
    55 
  • XMLIO_V2/dev/common/src/xmlio/data_treatment.cpp

    r266 r278  
    5050         // Mise à jour cÃŽté client 
    5151         this->currentContext->getCalendar()->setTimeStep(duration); 
     52         this->currentContext->timestep.setValue(duration.toString()); 
    5253         std::cout << "timestep :" << duration << std::endl; 
    5354         if (CXIOSManager::GetStatus() == CXIOSManager::LOC_CLIENT) 
     
    7980            { 
    8081               if (field->updateDataServer(currDate, data)) 
     82               { 
    8183                  file->getDataOutput()->writeFieldData(field); 
     84               } 
    8285               return; 
    8386            } 
  • XMLIO_V2/dev/common/src/xmlio/data_treatment.hpp

    r274 r278  
    4747 
    4848            /// Création des sorties /// 
    49             template <class T> void createDataOutput(void); 
     49            template <class T> void createDataOutput(comm::MPIComm comm_server = CXIOSManager::Comm_Server); 
    5050 
    5151            /// Destructeur /// 
     
    7272 
    7373      template <class T> 
    74          void CDataTreatment::createDataOutput(void) 
     74         void CDataTreatment::createDataOutput(comm::MPIComm comm_server ) 
    7575      { 
    7676         std::vector<boost::shared_ptr<CFile> >::const_iterator 
     
    7979         for (; it != end; it++) 
    8080         { 
     81            CXIOSManager::Comm_Server = comm_server; 
    8182            boost::shared_ptr<CFile> file = *it; 
    8283            StdString filename = (!file->name.isEmpty()) 
     
    8990            if (!file->name_suffix.isEmpty()) 
    9091                oss << file->name_suffix.getValue(); 
    91             if (comm::CMPIManager::GetCommSize() > 1) 
    92                 oss << "_node" << comm::CMPIManager::GetCommRank(); 
    93             oss << ".nc"; 
     92            if (comm::CMPIManager::GetCommSize(comm_server) > 1) 
     93                     oss << "." << comm::CMPIManager::GetCommRank(comm_server); 
     94                 oss << ".nc"; 
    9495            boost::shared_ptr<io::CDataOutput> dout(new T(oss.str(), false)); 
    9596            file->initializeDataOutput(dout); 
  • XMLIO_V2/dev/common/src/xmlio/exception.cpp

    r219 r278  
    2323 
    2424   CException::~CException(void) 
    25    { if (desc_rethrow) throw (*this); } 
     25   {  
     26      if (desc_rethrow) 
     27#ifdef __XIOS_NOABORT 
     28        throw (*this);  
     29#else 
     30      std::cerr << this->getMessage() << std::endl; 
     31      abort(); 
     32#endif 
     33   } 
    2634 
    2735   //--------------------------------------------------------------- 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icdata.cpp

    r274 r278  
    3939         CTreeManager::PrintTreeToFile(oss.str()); 
    4040         oss.str(""); 
    41  
    4241         boost::shared_ptr<CDataTreatment> dt(new CDataTreatment (context)); 
    4342         context->setDataTreatment(dt); 
     
    6766               CMPIManager::Wait(request);  // Pas encore en mode RPC 
    6867            } 
     68            CXIOSManager::RunClient(false, CMPIManager::GetCommWorld()); 
     69            CClient::CreateClient(comm_client_server); 
    6970         } 
    7071         else 
    7172         { 
    72             dt->createDataOutput<CNc4DataOutput>(); 
     73            dt->createDataOutput<CNc4DataOutput>(CMPIManager::GetCommWorld()); 
    7374         } 
    7475      } 
  • XMLIO_V2/dev/common/src/xmlio/fortran/icdate.cpp

    r274 r278  
    3030            (CObjectFactory::GetCurrentContextId()); 
    3131         boost::shared_ptr<xmlioserver::data::CDataTreatment> dtreat = context->getDataTreatment(); 
    32          dtreat->set_timestep(dur); 
     32         if (dtreat.get() != 0) 
     33         { 
     34            dtreat->set_timestep(dur);      
     35         } 
     36         else 
     37         { 
     38            context->solveCalendar(); 
     39            context->timestep.setValue(dur.toString()); 
     40            context->getCalendar()->setTimeStep(dur); 
     41         }        
    3342      } 
    3443      catch (xmlioserver::CException & exc) 
  • XMLIO_V2/dev/common/src/xmlio/group_factory.hpp

    r219 r278  
    1010#include "object_factory.hpp" 
    1111#include "group_template.hpp" 
     12#include "xml_parser.hpp" 
    1213 
    1314namespace xmlioserver 
  • XMLIO_V2/dev/common/src/xmlio/group_parser.hpp

    r219 r278  
    1313 
    1414      StdString name = node.getElementName(); 
     15      xml::THashAttributes attributes = node.getAttributes(); 
    1516      if (withAttr) 
     17      { 
    1618         CGroupTemplate<U, V, W>::SuperClass::parse(node); 
     19         if (attributes.end() != attributes.find("src")) 
     20         { 
     21            StdIFStream ifs ( attributes["src"].c_str() , StdIFStream::in ); 
     22            if (!ifs.good()) 
     23               ERROR("CGroupTemplate<U, V, W>::parse(xml::CXMLNode & node, bool withAttr)", 
     24                     << "[ filename = " << attributes["src"] << " ] Bad xml stream !"); 
     25            xml::CXMLParser::ParseInclude(ifs, *this); 
     26         } 
     27      } 
    1728 
    1829      // PARSING POUR GESTION DES ENFANTS 
    19       xml::THashAttributes attributes; 
    2030      boost::shared_ptr<V> group_ptr = (this->hasId()) 
    2131         ? CObjectFactory::GetObject<V>(this->getId()) 
     
    6171                  << "\' ne peut contenir qu'un objet de type \'" << V::GetName() 
    6272                  << "\' ou de type \'" << U::GetName() 
    63                   << "\' !"); 
     73                  << "\' (reçu : " << name << ") !"); 
    6474 
    6575         } while (node.goToNextElement()); 
  • XMLIO_V2/dev/common/src/xmlio/main_server.cpp

    r274 r278  
    77#include "client.hpp" 
    88#include "server.hpp" 
    9  
     9extern "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} 
    1017// Point d'entrée du programme principal 
    1118 
     
    1522   { 
    1623      MPIComm comm_client, comm_client_server, comm_server; 
    17       comm::CMPIManager::Initialise(&argc, &argv); // < seulement en mode connecté 
    18        
    19       CTreeManager::ParseFile  ("test/iodef_simple_test.xml"); 
    20       CTreeManager::PrintTreeToFile("wk/def/test.xml"); 
    21       
    22       comm::CMPIManager::Finalize();               // < seulement en mode connecté 
    23  
    24       //CXIOSManager::Initialise (CXIOSManager::CLIENT_SERVER, &argc, &argv); 
    25       //CMPIManager::DispatchClient(true, comm_client, comm_client_server,  comm_server); 
    26       //CXIOSManager::RunServer("Nemo", comm_client_server, comm_server); 
    27       //CXIOSManager::Finalize (); 
     24      CXIOSManager::Initialise (CXIOSManager::CLIENT_SERVER, &argc, &argv); 
     25      CMPIManager::DispatchClient(true, comm_client, comm_client_server,  comm_server); 
     26      CXIOSManager::RunServer("Nemo", comm_client_server, comm_server); 
     27      CXIOSManager::Finalize ();          
    2828   } 
    2929   catch (CException & exc) 
  • XMLIO_V2/dev/common/src/xmlio/manager/xios_manager.cpp

    r274 r278  
    2727      { 
    2828         if (CXIOSManager::Type != CLIENT) 
     29 
    2930         { 
    3031            // Finalisation de la biliothÚque MPI si nécessaire 
     
    5354      { 
    5455         using namespace comm; 
     56         CXIOSManager::Comm_Client_Server = comm_client_server; 
     57         CXIOSManager::Comm_Server        = comm_server; 
     58         CXIOSManager::Status             = LOC_SERVER; 
    5559          
    5660         // Reconstruction de l'arborescence d'objet à l'aide des données envoyées par chacun des 
     
    6771         StdString main_data_tree = clientBuffer[0]->getString(0);         
    6872         tree::CTreeManager::FromBinary(main_data_tree); 
    69          std::cout << "main_data_tree" << main_data_tree.size() << std::endl; 
    7073          
    7174         // Obtention des sous-domaines clients. 
     
    156159         using namespace comm; 
    157160         typedef std::pair<StdString, XIOSClient> StdPairStrClient; 
     161         CXIOSManager::Comm_Client_Server = comm_client_server; 
     162         CXIOSManager::Comm_Server        = comm_client_server; 
    158163          
    159164         CXIOSManager::ShowInformation_CS(comm_client_server); 
     
    244249         if (launch) 
    245250         { 
    246             CXIOSManager::Status  = LOC_CLIENT_SERVER;          
     251            CXIOSManager::Status       = LOC_CLIENT_SERVER;     
     252            CXIOSManager::Comm_Server  = comm_client;     
    247253            (CXIOSManager::Clients.begin()->second.entry) 
    248254               (comm_client, comm_client, comm_client); 
  • XMLIO_V2/dev/common/src/xmlio/manager/xios_manager.hpp

    r274 r278  
    5555         static StdString  GetClientName(void); 
    5656          
    57       protected : 
     57      public : 
    5858          
    5959         static StdSize GetNbClient(void); 
     
    6363         static StdSize GetNbLocServer(const StdString & clientName = CXIOSManager::ClientName); 
    6464          
    65       private : 
     65      public : 
    6666       
    6767         /// Information /// 
  • XMLIO_V2/dev/common/src/xmlio/node/context.cpp

    r274 r278  
    88 
    99#include "calendar_type.hpp" 
     10#include "duration.hpp" 
    1011 
    1112#include "data_treatment.hpp" 
     
    8283               << "Impossible de définir un calendrier (un attribut est manquant)."); 
    8384 
    84 #define DECLARE_CALENDAR(MType  , mtype)                        \ 
    85    if (calendar_type.getValue().compare(#mtype) == 0)           \ 
    86    {                                                            \ 
    87       this->calendar =  boost::shared_ptr<date::CCalendar>      \ 
    88          (new date::C##MType##Calendar(start_date.getValue())); \ 
    89       return;                                                   \ 
     85#define DECLARE_CALENDAR(MType  , mtype)                            \ 
     86   if (calendar_type.getValue().compare(#mtype) == 0)               \ 
     87   {                                                                \ 
     88      this->calendar =  boost::shared_ptr<date::CCalendar>          \ 
     89         (new date::C##MType##Calendar(start_date.getValue()));     \ 
     90      if (!this->timestep.isEmpty())                                \ 
     91       this->calendar->setTimeStep                                  \ 
     92          (date::CDuration::FromString(this->timestep.getValue())); \ 
     93      return;                                                       \ 
    9094   } 
    9195#include "calendar_type.conf" 
     
    103107 
    104108      // PARSING POUR GESTION DES ENFANTS 
    105       xml::THashAttributes attributes; 
     109      xml::THashAttributes attributes = node.getAttributes(); 
     110 
     111      if (attributes.end() != attributes.find("src")) 
     112      { 
     113         StdIFStream ifs ( attributes["src"].c_str() , StdIFStream::in ); 
     114         if (!ifs.good()) 
     115            ERROR("CContext::parse(xml::CXMLNode & node)", 
     116                  << "[ filename = " << attributes["src"] << " ] Bad xml stream !"); 
     117         xml::CXMLParser::ParseInclude(ifs, *this); 
     118      } 
    106119 
    107120      if (node.getElementName().compare(CContext::GetName())) 
  • XMLIO_V2/dev/common/src/xmlio/node/domain.cpp

    r274 r278  
    2020      , isChecked(false), local_mask(new CArray<int, 2>(boost::extents[0][0])), relFiles() 
    2121      , ibegin_sub(), iend_sub(), jbegin_sub(), jend_sub() 
    22       , ibegin_zoom_sub(), jbegin_zoom_sub() 
     22      , ibegin_zoom_sub(), jbegin_zoom_sub(), ni_zoom_sub(), nj_zoom_sub() 
    2323      , lonvalue_sub(), latvalue_sub() 
    2424   { /* Ne rien faire de plus */ } 
     
    2828      , isChecked(false), local_mask(new CArray<int, 2>(boost::extents[0][0])), relFiles() 
    2929      , ibegin_sub(), iend_sub(), jbegin_sub(), jend_sub() 
    30       , ibegin_zoom_sub(), jbegin_zoom_sub() 
     30      , ibegin_zoom_sub(), jbegin_zoom_sub(),ni_zoom_sub(), nj_zoom_sub() 
    3131      , lonvalue_sub(), latvalue_sub() 
    3232   { /* Ne rien faire de plus */ } 
     
    100100         this->ibegin_zoom_sub.push_back(this->zoom_ibegin_loc.getValue()); 
    101101         this->jbegin_zoom_sub.push_back(this->zoom_jbegin_loc.getValue()); 
     102         this->ni_zoom_sub.push_back(this->zoom_ni_loc.getValue()); 
     103         this->nj_zoom_sub.push_back(this->zoom_nj_loc.getValue()); 
    102104       
    103105         this->latvalue_sub.push_back(this->latvalue.getValue()); 
     
    151153          (nj_glo.isEmpty() || nj_glo.getValue() <= 0 )) 
    152154      { 
    153          abort(); 
    154155         ERROR("CDomain::checkAttributes(void)", 
    155156               << "[ Id = " << this->getId() << " ] " 
     
    454455            for (int j = 0; j < zoom_nj_client; j++) 
    455456            { 
    456                (*lonvalue_temp)[i + j * zoom_ni_client] = (*lonvalue_)[(i + zoom_ibegin_client -1)+(j + zoom_jbegin_client -1)*ni.getValue()];               
    457                (*latvalue_temp)[i + j * zoom_ni_client] = (*latvalue_)[(i + zoom_ibegin_client -1)+(j + zoom_jbegin_client -1)*ni.getValue()]; 
     457               (*lonvalue_temp)[i + j * zoom_ni_client] = 
     458               (*lonvalue_)[(i + zoom_ibegin_client -1)+(j + zoom_jbegin_client -1)*ni.getValue()];               
     459               (*latvalue_temp)[i + j * zoom_ni_client] = 
     460               (*latvalue_)[(i + zoom_ibegin_client -1)+(j + zoom_jbegin_client -1)*ni.getValue()]; 
    458461            } 
    459462         } 
     
    488491      ARRAY_CREATE(latvalue_temp, double, 1, [0]); 
    489492       
    490       const int ibegin_serv  = ibegin.getValue(), 
    491                 jbegin_serv  = jbegin.getValue(), 
    492                 zoom_ni_serv = zoom_ni_loc.getValue(), 
    493                 zoom_nj_serv = zoom_nj_loc.getValue(); 
     493      const int ibegin_serv     = ibegin.getValue(), 
     494                jbegin_serv     = jbegin.getValue(), 
     495                zoom_ni_serv    = zoom_ni_loc.getValue(), 
     496                zoom_nj_serv    = zoom_nj_loc.getValue(), 
     497                ibegin_zoom_srv = zoom_ibegin_loc.getValue(), 
     498                jbegin_zoom_srv = zoom_jbegin_loc.getValue(); 
    494499                       
    495500      /*std::cout << "Rang du serveur :" << comm::CMPIManager::GetCommRank()   << std::endl 
     
    498503                << "Zoom_loc begin : " << zoom_ibegin_loc << ", " << zoom_jbegin_loc <<  std::endl 
    499504                << "Zoom_loc size : "  << zoom_ni_loc << ", " << zoom_nj_loc <<  std::endl;*/ 
    500        
    501        
    502       ARRAY(double, 1) lonvalue_ = this->lonvalue.getValue(), 
    503                        latvalue_ = this->latvalue.getValue(); 
    504505                        
    505506      if (this->data_dim.getValue() == 2) 
    506507      { 
    507          StdSize dm = zoom_ni_serv * zoom_nj_serv; 
    508          StdSize dn = this->ni.getValue() * this->nj.getValue(); 
    509           
    510          lonvalue_->resize(boost::extents[dn]); 
    511          latvalue_->resize(boost::extents[dn]); 
     508         StdSize dm = zoom_ni_serv * zoom_nj_serv;       
     509          
    512510         lonvalue_temp->resize(boost::extents[dm]); 
    513511         latvalue_temp->resize(boost::extents[dm]); 
     
    515513         for (StdSize k = 0; k < lonvalue_sub.size(); k++) 
    516514         { 
    517             int l = 0; 
    518515            ARRAY(double, 1) lonvalue_loc = this->lonvalue_sub[k], 
    519516                             latvalue_loc = this->latvalue_sub[k]; 
    520             const int ibegin_loc = ibegin_sub[k], iend_loc = iend_sub[k], 
    521                       jbegin_loc = jbegin_sub[k], jend_loc = jend_sub[k]; 
     517            const int zoom_ibegin_cl = ibegin_zoom_sub[k], zoom_ni_cl = ni_zoom_sub[k], 
     518                      zoom_jbegin_cl = jbegin_zoom_sub[k], zoom_nj_cl = nj_zoom_sub[k], 
     519                      ni_cl = iend_sub[k] - ibegin_sub[k] + 1; 
    522520                       
    523             for (int i = ibegin_loc - ibegin_serv; i < (iend_loc - ibegin_serv + 1); i++) 
     521            for (int i = 0; i < zoom_ni_cl; i++) 
    524522            { 
    525                for (int j = jbegin_loc - jbegin_serv; j < (jend_loc - jbegin_serv + 1); j++) 
     523               for (int j = 0; j < zoom_nj_cl; j++) 
    526524               { 
    527                   (*lonvalue_)[i + j * this->ni.getValue()] = (*lonvalue_loc)[l];      // erreur         
    528                   (*latvalue_)[i + j * this->ni.getValue()] = (*latvalue_loc)[l++];    // erreur 
     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                  (*lonvalue_temp)[ii + jj * zoom_ni_serv] = 
     528                  (*lonvalue_loc)[i + j * zoom_ni_cl]; 
     529                  (*latvalue_temp)[ii + jj * zoom_ni_serv] =  
     530                  (*latvalue_loc)[i + j * zoom_ni_cl]; 
    529531               } 
    530532            } 
     
    535537      else 
    536538      { 
    537          lonvalue_->resize(boost::extents[this->ni.getValue()]); 
    538          latvalue_->resize(boost::extents[this->nj.getValue()]); 
    539539         lonvalue_temp->resize(boost::extents[zoom_ni_serv]); 
    540540         latvalue_temp->resize(boost::extents[zoom_nj_serv]); 
     
    542542         for (StdSize k = 0; k < lonvalue_sub.size(); k++) 
    543543         { 
    544             int l = 0; 
    545544            ARRAY(double, 1) lonvalue_loc = this->lonvalue_sub[k], 
    546545                             latvalue_loc = this->latvalue_sub[k]; 
    547             const int ibegin_loc = ibegin_sub[k], iend_loc = iend_sub[k], 
    548                       jbegin_loc = jbegin_sub[k], jend_loc = jend_sub[k]; 
     546            const int zoom_ibegin_cl = ibegin_zoom_sub[k], zoom_ni_cl = ni_zoom_sub[k], 
     547                      zoom_jbegin_cl = jbegin_zoom_sub[k], zoom_nj_cl = nj_zoom_sub[k]; 
    549548                       
    550             for (int i = ibegin_loc - ibegin_serv; i < (iend_loc - ibegin_loc + 1); i++) 
    551                (*lonvalue_)[i] = (*lonvalue_loc)[l++]; 
     549            for (int i = 0; i < zoom_ni_cl; i++) 
     550               (*lonvalue_temp)[i /*- (ibegin_serv - 1)*/ + (zoom_ibegin_cl - 1) - (ibegin_zoom_srv - 1)] = 
     551               (*lonvalue_loc)[i]; 
    552552                
    553             for (int j = jbegin_loc - jbegin_serv; j < (jend_loc - jbegin_loc + 1); j++) 
    554                (*latvalue_)[j] = (*latvalue_loc)[l++]; 
     553            for (int j = 0; j < zoom_nj_cl; j++) 
     554               (*latvalue_temp)[j /*- (jbegin_serv - 1)*/ + (zoom_jbegin_cl - 1) - (jbegin_zoom_srv - 1)] = 
     555               (*latvalue_loc)[j]; 
    555556         }        
    556557         this->lonvalue.setValue(lonvalue_temp); 
  • XMLIO_V2/dev/common/src/xmlio/node/domain.hpp

    r274 r278  
    113113 
    114114         std::vector<int> ibegin_sub, iend_sub, jbegin_sub, jend_sub; 
    115          std::vector<int> ibegin_zoom_sub, jbegin_zoom_sub; 
     115         std::vector<int> ibegin_zoom_sub, jbegin_zoom_sub, ni_zoom_sub, nj_zoom_sub; 
    116116         std::vector<ARRAY(double, 1)> lonvalue_sub, latvalue_sub; 
    117117 
  • XMLIO_V2/dev/common/src/xmlio/node/field.cpp

    r266 r278  
    4747 
    4848   bool CField::updateDataServer 
    49       (const date::CDate & currDate, const std::deque<ARRAY(double, 1)> storedClient) 
    50    { 
    51       if ((*last_operation + freq_operation) >= currDate) 
    52       { 
    53          ARRAY_CREATE(input, double, 1, [0]); 
    54          this->grid->inputFieldServer(storedClient, input); 
     49      (const date::CDate & currDate, 
     50       const std::deque<ARRAY(double, 1)> storedClient) 
     51   { 
     52      const date::CDate opeDate      = *last_operation + freq_operation; 
     53      const date::CDate writeDate    = *last_Write     + freq_write;  
     54       
     55      if (opeDate <= currDate) 
     56      { 
     57         if (this->data->num_elements() != this->grid->storeIndex[0]->num_elements()) 
     58         { 
     59            this->data->resize(boost::extents[this->grid->storeIndex[0] ->num_elements()]); 
     60         }   
     61         ARRAY_CREATE(input, double, 1, [this->data->num_elements()]); 
     62         this->grid->inputFieldServer(storedClient, input);           
    5563         (*this->foperation)(input); 
    5664         *last_operation = currDate; 
    5765      } 
    58  
    59       if ((*last_Write + freq_write) >= currDate) 
    60       { 
    61          *last_Write = currDate; 
    62          return (true); 
     66      if (writeDate < (currDate + freq_operation)) 
     67      { 
     68         this->foperation->final(); 
     69         this->incrementNStep(); 
     70         *last_Write = writeDate; 
     71         return (true);         
    6372      } 
    6473      return (false); 
     
    232241               << "Impossible de définir une opération pour le champ !"); 
    233242      } 
     243       
     244      CDuration freq_offset_ = NoneDu; 
     245      if (!freq_offset.isEmpty()) 
     246      { 
     247         freq_offset_ = CDuration::FromString(freq_offset.getValue()); 
     248      } 
     249      else 
     250      { 
     251         freq_offset.setValue(NoneDu.toString()); 
     252      }   
    234253 
    235254      if (CXIOSManager::GetStatus() == CXIOSManager::LOC_SERVER) 
     
    245264         this->foperation     = 
    246265             boost::shared_ptr<func::CFunctor>(new CInstant(this->data)); 
     266              
     267         const CDuration toffset = this->freq_operation - freq_offset_ - _context->getCalendar()->getTimeStep();  
     268         *this->last_operation   = *this->last_operation - toffset;  
    247269      } 
    248270      else 
    249       { 
    250          CDuration freq_offset_ = NoneDu; 
    251          if (!freq_offset.isEmpty()) 
    252          { 
    253             freq_offset_ = CDuration::FromString(freq_offset.getValue()); 
    254          } 
    255          else 
    256          { 
    257             freq_offset.setValue(NoneDu.toString()); 
    258          }    
    259                    
     271      {                   
    260272         this->freq_operation = CDuration::FromString(freq_op.getValue()); 
    261273         this->freq_write     = CDuration::FromString(this->file->output_freq.getValue()); 
     
    264276         this->last_operation = boost::shared_ptr<xmlioserver::date::CDate> 
    265277                        (new date::CDate(_context->getCalendar()->getInitDate())); 
     278                         
    266279         const CDuration toffset = this->freq_operation - freq_offset_ - _context->getCalendar()->getTimeStep();  
    267          *this->last_operation  = *this->last_operation - toffset;   
     280         *this->last_operation   = *this->last_operation - toffset;   
    268281          
    269282#define DECLARE_FUNCTOR(MType, mtype)              \ 
  • XMLIO_V2/dev/common/src/xmlio/node/field.hpp

    r268 r278  
    170170      { 
    171171         //std::cout << "> " << currDate << ": Operation du champs" << this->getBaseFieldId() << std::endl; 
    172           
    173172         if (this->data->num_elements() != this->grid->storeIndex[0]->num_elements()) 
    174173         { 
  • XMLIO_V2/dev/common/src/xmlio/node/grid.cpp

    r274 r278  
    463463         ARRAY(int, 1) out_j_index_cl  =  this->out_j_index[i + 1]; 
    464464         ARRAY(int, 1) out_l_index_cl  =  this->out_l_index[i + 1]; 
    465           
    466          const int ibegin_cl = ibegin[i]; 
    467          const int jbegin_cl = jbegin[i]; 
    468           
     465                  
    469466         int ibegin_zoom_cl = ibegin[i]; //ibegin_zoom[i]; 
    470467         int jbegin_zoom_cl = jbegin[i]; //jbegin_zoom[i]; 
     
    480477            (*storeIndex_srv)[n]  = (*storeIndex_cl)[m]; // Faux mais inutile dans le cas serveur. 
    481478            (*out_i_index_srv)[n] = (*out_i_index_cl)[m]  
    482                                   /*+ (ibegin_cl - 1)*/ - (ibegin_srv - 1) + (ibegin_zoom_cl - 1) - (ibegin_zoom_srv - 1);  
     479                                  /*+ (ibegin_cl - 1) - (ibegin_srv - 1)*/ + (ibegin_zoom_cl - 1) - (ibegin_zoom_srv - 1); 
    483480            (*out_j_index_srv)[n] = (*out_j_index_cl)[m] 
    484                                   /*+ (jbegin_cl - 1)*/ - (jbegin_srv - 1) + (jbegin_zoom_cl - 1) - (jbegin_zoom_srv - 1); 
     481                                  /*+ (jbegin_cl - 1) - (jbegin_srv - 1)*/ + (jbegin_zoom_cl - 1) - (jbegin_zoom_srv - 1); 
    485482            (*out_l_index_srv)[n] = (*out_l_index_cl)[m]; 
    486483         } 
     
    532529      this->out_i_index[0] = out_i_index_srv; 
    533530      this->out_j_index[0] = out_j_index_srv; 
    534       this->out_l_index[0] = out_l_index_srv; 
    535        
    536       this->storeIndex.resize(1); 
    537       this->out_i_index.resize(1); 
    538       this->out_j_index.resize(1); 
    539       this->out_l_index.resize(1); 
    540        
     531      this->out_l_index[0] = out_l_index_srv;       
    541532   } 
    542533    
     
    552543                << "Les données d'un client sont manquantes !") ; 
    553544      if (storedServer.get() != NULL) 
    554          storedServer->resize(boost::extents[this->storeIndex.size()-1]); 
     545         storedServer->resize(boost::extents[this->storeIndex[0]->num_elements()]); 
    555546      else  
    556          ARRAY_ASSIGN(storedServer, double, 1, [this->storeIndex.size()-1]); 
     547         ARRAY_ASSIGN(storedServer, double, 1, [this->storeIndex[0]->num_elements()]); 
    557548          
    558549      for (StdSize i = 0, n = 0; i < storedClient.size(); i++) 
  • XMLIO_V2/dev/common/src/xmlio/output/nc4_data_output.cpp

    r274 r278  
    88#include "file.hpp" 
    99#include "calendar.hpp" 
     10#include "xios_manager.hpp" 
     11#include "context.hpp" 
    1012 
    1113namespace xmlioserver 
     
    7577         StdString lonid     = StdString("lon_").append(domid); 
    7678         StdString latid     = StdString("lat_").append(domid); 
    77          StdString lonid_loc = StdString("lon_").append(domid).append("_local"); 
    78          StdString latid_loc = StdString("lat_").append(domid).append("_local"); 
     79         StdString lonid_loc = (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
     80                             ? StdString("lon_").append(domid).append("_local") 
     81                             : lonid; 
     82         StdString latid_loc = (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
     83                             ? StdString("lat_").append(domid).append("_local") 
     84                             : latid; 
    7985         StdString maskid    = StdString("mask_").append(domid).append("_local"); 
    8086 
     
    8490         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize); 
    8591 
    86          SuperClassWriter::addDimension(lonid, domain->ni_glo.getValue()); 
    87          SuperClassWriter::addDimension(latid, domain->nj_glo.getValue()); 
     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         } 
    8897 
    8998         if (isCurvilinear) 
     
    104113               SuperClassWriter::addDimension(lonid_loc, domain->zoom_ni_loc.getValue()); 
    105114               SuperClassWriter::addDimension(latid_loc, domain->zoom_nj_loc.getValue()); 
    106                this->writeLocalAttributes(domain->zoom_ibegin_loc.getValue(), 
    107                                           domain->zoom_ni_loc.getValue(), 
    108                                           domain->zoom_jbegin_loc.getValue(), 
    109                                           domain->zoom_nj_loc.getValue(), 
    110                                           domid); 
     115               if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
     116               { 
     117                  this->writeLocalAttributes(domain->zoom_ibegin_loc.getValue(), 
     118                                             domain->zoom_ni_loc.getValue(), 
     119                                             domain->zoom_jbegin_loc.getValue(), 
     120                                             domain->zoom_nj_loc.getValue(), 
     121                                             domid); 
     122               } 
     123                
    111124               if (isCurvilinear) 
    112125               { 
     
    128141               dim0.push_back(lonid_loc); 
    129142 
    130                SuperClassWriter::addVariable(maskid, NC_INT, dim0); 
    131  
    132                this->writeMaskAttributes(maskid, 
    133                   domain->data_dim.getValue()/*, 
    134                   domain->data_ni.getValue(), 
    135                   domain->data_nj.getValue(), 
    136                   domain->data_ibegin.getValue(), 
    137                   domain->data_jbegin.getValue()*/); 
     143               if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
     144               { 
     145                  SuperClassWriter::addVariable(maskid, NC_INT, dim0); 
     146 
     147                  this->writeMaskAttributes(maskid, 
     148                     domain->data_dim.getValue()/*, 
     149                     domain->data_ni.getValue(), 
     150                     domain->data_nj.getValue(), 
     151                     domain->data_ibegin.getValue(), 
     152                     domain->data_jbegin.getValue()*/); 
     153               } 
    138154                   
    139155               //SuperClassWriter::setDefaultValue(maskid, &dvm); 
     
    142158               SuperClassWriter::writeData(domain->latvalue.getValue(), latid, true, 0); 
    143159               SuperClassWriter::writeData(domain->lonvalue.getValue(), lonid, true, 0); 
    144                SuperClassWriter::writeData(mask, maskid); 
     160               if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
     161                  SuperClassWriter::writeData(mask, maskid); 
    145162               SuperClassWriter::definition_start(); 
    146163 
     
    169186         switch (SuperClass::type) 
    170187         { 
     188            case (ONE_FILE) : 
    171189            case (MULTI_FILE) : 
    172190            { 
     
    218236         StdString lonid     = StdString("lon_").append(domid); 
    219237         StdString latid     = StdString("lat_").append(domid); 
    220          StdString lonid_loc = StdString("lon_").append(domid).append("_local"); 
    221          StdString latid_loc = StdString("lat_").append(domid).append("_local"); 
     238         StdString lonid_loc = (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
     239                             ? StdString("lon_").append(domid).append("_local") 
     240                             : lonid; 
     241         StdString latid_loc = (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
     242                             ? StdString("lat_").append(domid).append("_local") 
     243                             : latid; 
    222244         StdString fieldid   = (!field->name.isEmpty()) 
    223245                             ? field->name.getValue() : field->getBaseFieldReference()->getId(); 
     
    376398                             ? field->name.getValue()  
    377399                             : field->getBaseFieldReference()->getId(); 
     400         boost::shared_ptr<xmlioserver::tree::CContext> context = 
     401            CObjectFactory::GetObject<xmlioserver::tree::CContext> 
     402               (CObjectFactory::GetCurrentContextId()); 
     403                              
     404         StdOStringStream oss; 
     405         oss << "time_" << field->operation.getValue() 
     406             << "_" << field->getRelFile()->output_freq.getValue(); 
     407              
    378408         ARRAY(double, 1) field_data = field->getData(); 
     409         ARRAY_CREATE(time_data, double, 1, [1]); 
     410         (*time_data)[0] = date::Time(*field->getLastWriteDate()); 
    379411          
    380412         if (grid->hasAxis()) // 3D 
     
    383415            grid->outputField(field_data, field_data3D); 
    384416            SuperClassWriter::writeData(field_data3D, fieldid, true, field->getNStep()-1); 
     417            SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1); 
    385418             
    386419         } 
     
    390423            grid->outputField(field_data,  field_data2D); 
    391424            SuperClassWriter::writeData(field_data2D, fieldid, true, field->getNStep()-1); 
     425            SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1); 
    392426         } 
    393427      } 
  • XMLIO_V2/dev/common/src/xmlio/server.cpp

    r274 r278  
    3333   boost::shared_ptr<CServer> CServer::CreateServer(MPIComm comm_client_server) 
    3434   { 
    35       if (CServer::Server.get() != NULL) 
     35      if (CServer::Server.get() == NULL) 
    3636         CServer::Server = boost::shared_ptr<CServer>(new CServer(comm_client_server)); 
    3737      return (CServer::GetServer()); 
     
    140140   void CServer::initialize(void) // manager 0, method 0 
    141141   { 
    142       // Ne rien faire de plus 
     142      std::cout << "initialize" << std::endl; 
    143143   } 
    144144    
     
    147147   void CServer::finalize(void) // manager 0, method 1 
    148148   { 
     149      std::cout << "finalize" << std::endl; 
    149150       comm::CMPIManager::Barrier(); 
    150151   }    
  • XMLIO_V2/dev/common/src/xmlio/xml_node.cpp

    r274 r278  
    1111      CXMLNode::CXMLNode(rapidxml::xml_node<char> * const root) 
    1212         : node(root) 
     13         , level(0) 
    1314      { /* Ne rien faire de plus */ } 
    1415 
     
    4849               else if (nextElement->type() == rapidxml::node_element) 
    4950               {  
    50                   node = nextElement;  
     51                  node = nextElement; 
     52                  level++; 
    5153                  return (!retvalue);  
    5254               } 
     
    5961      { 
    6062         bool retvalue = false; 
    61          if (!(this->getElementName().compare(CXMLNode::RootName))) 
     63         if (!(this->getElementName().compare(CXMLNode::RootName)) || (level == 0)) 
    6264            return (retvalue); 
    6365         node = node->parent(); 
     66         level--; 
    6467         return (!retvalue); 
    6568      } 
  • XMLIO_V2/dev/common/src/xmlio/xml_node.hpp

    r274 r278  
    4646 
    4747            rapidxml::xml_node<char> * node; 
     48            int level; 
    4849 
    4950            static StdString RootName; 
  • XMLIO_V2/dev/common/src/xmlio/xml_parser.cpp

    r219 r278  
    11#include "xml_parser.hpp" 
     2 
     3#include "context.hpp" 
    24 
    35#include "attribute_template_impl.hpp" 
     
    1214 
    1315      void CXMLParser::ParseFile(const StdString & filename) 
    14       { StdIFStream ifs ( filename.c_str() , StdIFStream::in ); 
    15         CXMLParser::ParseStream(ifs); } 
     16      { 
     17         StdIFStream ifs ( filename.c_str() , StdIFStream::in ); 
     18         CXMLParser::ParseStream(ifs); 
     19      } 
    1620 
    1721      void CXMLParser::ParseString(const StdString & xmlContent) 
     
    8690         } 
    8791      } 
     92 
    8893   }// namespace xml 
    8994} // namespace xmlioserver 
  • XMLIO_V2/dev/common/src/xmlio/xml_parser.hpp

    r219 r278  
    44/// xmlioserver headers /// 
    55#include "xmlioserver_spl.hpp" 
     6#include "exception.hpp" 
    67#include "xml_node.hpp" 
    7 #include "context.hpp" 
     8 
    89 
    910namespace xmlioserver 
     
    1920            static void ParseString(const StdString & xmlContent); 
    2021            static void ParseStream(StdIStream & stream); 
     22            template <class T> 
     23               static inline void ParseInclude(StdIStream & stream, T & object); 
    2124 
    2225      }; //class CXMLParser 
     26 
     27      template <class T> 
     28         void CXMLParser::ParseInclude(StdIStream & stream, T& object) 
     29      { 
     30         StdOStringStream oss; 
     31         while(!stream.eof() && !stream.fail ()) 
     32            oss.put(stream.get()); 
     33         try 
     34         { 
     35            const StdString xmlcontent( oss.str(), 0, oss.str().size()-1 ); 
     36            rapidxml::xml_document<char> doc; 
     37            doc.parse<0>(const_cast<char*>(xmlcontent.c_str())); 
     38            CXMLNode node(doc.first_node()); 
     39            object.parse(node); 
     40         } 
     41         catch (rapidxml::parse_error & exc) 
     42         { 
     43            ERROR("CXMLParser::ParseStream(StdIStream & stream)", 
     44                  << "RapidXML error : " << exc.what() << " !"); 
     45         } 
     46      } 
    2347 
    2448   }// namespace xml 
Note: See TracChangeset for help on using the changeset viewer.