source: XIOS/trunk/src/node/field.cpp @ 327

Last change on this file since 327 was 321, checked in by ymipsl, 12 years ago

Add splitting file functionality
new file attribut "split_freq" to put the frequency of splitting

YM
File size: 17.5 KB
Line 
1#include "field.hpp"
2
3#include "attribute_template_impl.hpp"
4#include "object_template_impl.hpp"
5#include "group_template_impl.hpp"
6
7#include "node_type.hpp"
8#include "calendar_util.hpp"
9
10namespace xmlioserver{
11namespace tree {
12   
13   /// ////////////////////// Définitions ////////////////////// ///
14
15   CField::CField(void)
16      : CObjectTemplate<CField>(), CFieldAttributes()
17      , refObject(), baseRefObject()
18      , grid(), file()
19      , freq_operation(), freq_write()
20      , nstep(0)
21      , last_Write(), last_operation()
22      , foperation()
23      , data(new CArray<double, 1>(boost::extents[0]))
24   { /* Ne rien faire de plus */ }
25
26   CField::CField(const StdString & id)
27      : CObjectTemplate<CField>(id), CFieldAttributes()
28      , refObject(), baseRefObject()
29      , grid(), file()
30      , freq_operation(), freq_write()
31      , nstep(0)
32      , last_Write(), last_operation()
33      , foperation()
34      , data(new CArray<double, 1>(boost::extents[0]))
35   { /* Ne rien faire de plus */ }
36
37   CField::~CField(void)
38   {
39      this->grid.reset() ;
40      this->file.reset() ;
41      this->foperation.reset() ;
42      this->data.reset() ;
43   }
44
45   //----------------------------------------------------------------
46
47   bool CField::updateDataServer
48      (const date::CDate & currDate,
49       const std::deque<ARRAY(double, 1)> storedClient)
50   {
51      const date::CDate opeDate      = *last_operation + freq_operation;
52      const date::CDate writeDate    = *last_Write     + freq_write; 
53     
54      if (opeDate <= currDate)
55      {
56         if (this->data->num_elements() != this->grid->storeIndex[0]->num_elements())
57         {
58            this->data->resize(boost::extents[this->grid->storeIndex[0] ->num_elements()]);
59         } 
60         ARRAY_CREATE(input, double, 1, [this->data->num_elements()]);
61         this->grid->inputFieldServer(storedClient, input);         
62         (*this->foperation)(input);
63         *last_operation = currDate;
64      }
65      if (writeDate < (currDate + freq_operation))
66      {
67         this->foperation->final();
68         this->incrementNStep();
69         *last_Write = writeDate;
70         return (true);       
71      }
72      return (false);
73   }
74   
75   bool CField::dispatchEvent(CEventServer& event)
76  {
77     
78    if (SuperClass::dispatchEvent(event)) return true ;
79    else
80    {
81      switch(event.type)
82      {
83        case EVENT_ID_UPDATE_DATA :
84          recvUpdateData(event) ;
85          return true ;
86          break ;
87 
88        default :
89          ERROR("bool CField::dispatchEvent(CEventServer& event)",<<"Unknown Event") ;
90          return false ;
91      }
92    }
93  }
94 
95  void CField::sendUpdateData(void)
96  {
97    shared_ptr<CContext> context=CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()) ;
98    CContextClient* client=context->client ;
99   
100    CEventClient event(getType(),EVENT_ID_UPDATE_DATA) ;
101   
102    map<int,ARRAY(int, 1)>::iterator it ;
103    list<shared_ptr<CMessage> > list_msg ;
104    list<ARRAY(double,1) > list_data ;
105   
106    for(it=grid->storeIndex_toSrv.begin();it!=grid->storeIndex_toSrv.end();it++)
107    {
108      int rank=(*it).first ;
109      ARRAY(int,1) index=(*it).second ;
110      ARRAY_CREATE(data_tmp,double,1,[index->num_elements()]) ;
111      for(int n=0;n<data_tmp->num_elements();n++) (*data_tmp)[n]=(*data)[(*index)[n]] ;
112      list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ;
113      list_data.push_back(data_tmp) ;
114      *list_msg.back()<<getId()<<list_data.back() ;
115      event.push(rank,grid->nbSenders[rank],*list_msg.back()) ;
116    }
117    client->sendEvent(event) ;
118  }
119 
120  void CField::recvUpdateData(CEventServer& event)
121  {
122    vector<int> ranks ;
123    vector<CBufferIn*> buffers ;
124     
125    list<CEventServer::SSubEvent>::iterator it ;
126    string fieldId ;
127
128    for (it=event.subEvents.begin();it!=event.subEvents.end();++it)
129    {
130      int rank=it->rank;
131      CBufferIn* buffer=it->buffer;
132      *buffer>>fieldId ;
133      ranks.push_back(rank) ;
134      buffers.push_back(buffer) ;
135    }
136    get(fieldId)->recvUpdateData(ranks,buffers) ;   
137  }
138 
139  void  CField::recvUpdateData(vector<int>& ranks, vector<CBufferIn*>& buffers)
140  {
141   
142    if (data_srv.empty())
143    {
144      for(map<int,ARRAY(int, 1)>::iterator it=grid->out_i_fromClient.begin();it!=grid->out_i_fromClient.end();it++)
145      {
146        int rank=it->first ;
147        ARRAY_CREATE(data_tmp,double,1,[it->second->num_elements()]) ;
148        data_srv.insert(pair<int, ARRAY(double,1)>(rank,data_tmp)) ;
149        foperation_srv.insert(pair<int,boost::shared_ptr<func::CFunctor> >(rank,boost::shared_ptr<func::CFunctor>(new func::CInstant(data_srv[rank])))) ;
150      }
151    }
152
153    shared_ptr<CContext> context=CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()) ;
154    const date::CDate & currDate = context->getCalendar()->getCurrentDate();
155    const date::CDate opeDate      = *last_operation_srv + freq_operation_srv;
156    const date::CDate writeDate    = *last_Write_srv     + freq_write_srv; 
157   
158
159   
160    if (opeDate <= currDate)
161    {
162      for(int n=0;n<ranks.size();n++)
163      {
164        ARRAY_CREATE(data_tmp,double,1,[0]) ;
165        *buffers[n]>>data_tmp ;
166        (*foperation_srv[ranks[n]])(data_tmp) ;
167      }
168      *last_operation_srv = currDate;
169    }
170     
171    if (writeDate < (currDate + freq_operation_srv))
172    {
173      for(int n=0;n<ranks.size();n++)
174      {
175        this->foperation_srv[ranks[n]]->final();
176      }
177     
178      *last_Write_srv = writeDate;
179      writeField() ;
180    }
181  }
182 
183  void CField::writeField(void)
184  {
185    if (! grid->domain->isEmpty() || getRelFile()->type.getValue()=="one_file")
186    {
187      getRelFile()->checkFile();
188      this->incrementNStep();
189      getRelFile()->getDataOutput()->writeFieldData(CObjectFactory::GetObject<CField>(this));
190    }
191  }
192   //----------------------------------------------------------------
193
194   void CField::setRelFile(const boost::shared_ptr<CFile> _file)
195   { 
196      this->file = _file; 
197   }
198
199   //----------------------------------------------------------------
200
201   StdString CField::GetName(void)   { return (StdString("field")); }
202   StdString CField::GetDefName(void){ return (CField::GetName()); }
203   ENodeType CField::GetType(void)   { return (eField); }
204
205   //----------------------------------------------------------------
206
207   boost::shared_ptr<CGrid> CField::getRelGrid(void) const
208   { 
209      return (this->grid); 
210   }
211
212   //----------------------------------------------------------------
213
214   boost::shared_ptr<CFile> CField::getRelFile(void) const
215   { 
216      return (this->file);
217   }
218   
219   StdSize CField::getNStep(void) const
220   {
221      return (this->nstep);
222   }
223   
224   void CField::incrementNStep(void)
225   {
226      this->nstep++;
227   }
228 
229   void CField::resetNStep(void)
230   {
231      this->nstep=0;
232   }
233
234   //----------------------------------------------------------------
235
236   boost::shared_ptr<CField> CField::getDirectFieldReference(void) const
237   {
238      if (this->field_ref.isEmpty())
239         return (this->getBaseFieldReference());
240
241      if (! CObjectFactory::HasObject<CField>(this->field_ref.getValue()))
242         ERROR("CField::getDirectFieldReference(void)",
243               << "[ ref_name = " << this->field_ref.getValue() << "]"
244               << " invalid field name !");
245
246      return (CObjectFactory::GetObject<CField>(this->field_ref.getValue()));
247   }
248
249   //----------------------------------------------------------------
250
251   const boost::shared_ptr<CField> CField::getBaseFieldReference(void) const
252   { 
253      return (baseRefObject); 
254   }
255
256   //----------------------------------------------------------------
257
258   const std::vector<boost::shared_ptr<CField> > & CField::getAllReference(void) const 
259   { 
260      return (refObject);
261   }
262
263   //----------------------------------------------------------------
264
265   const StdString & CField::getBaseFieldId(void) const
266   { 
267      return (this->getBaseFieldReference()->getId());
268   }
269   
270   //----------------------------------------------------------------
271   
272   const date::CDuration & CField::getFreqOperation(void) const
273   {
274      return (this->freq_operation);
275   }
276   
277   //----------------------------------------------------------------
278   const date::CDuration & CField::getFreqWrite(void) const
279   {
280      return (this->freq_write);
281   }
282   
283   //----------------------------------------------------------------
284         
285   boost::shared_ptr<func::CFunctor> CField::getFieldOperation(void) const
286   {
287      return (this->foperation);
288   }
289
290   //----------------------------------------------------------------
291
292   bool CField::hasDirectFieldReference(void) const
293   { 
294     return (!this->field_ref.isEmpty()); 
295   }
296   
297   bool CField::isActive(void) const
298   { 
299      return (!this->refObject.empty()); 
300   }
301   //----------------------------------------------------------------
302   
303   ARRAY(double, 1) CField::getData(void) const
304   {
305      return(this->data);
306   }
307
308   //----------------------------------------------------------------
309
310   boost::shared_ptr<date::CDate> CField::getLastWriteDate(void) const
311   {
312      return(this->last_Write);
313   }
314
315   //----------------------------------------------------------------
316
317   boost::shared_ptr<date::CDate> CField::getLastOperationDate(void) const
318   {
319      return(this->last_operation);
320   }
321
322   //----------------------------------------------------------------
323
324   void CField::solveRefInheritance(void)
325   {
326      std::set<CField *> sset;
327      boost::shared_ptr<CField> refer_sptr;
328      CField * refer_ptr = this;
329     
330      this->baseRefObject = CObjectFactory::GetObject<CField>(this);
331     
332      while (refer_ptr->hasDirectFieldReference())
333      {
334         refer_sptr = refer_ptr->getDirectFieldReference();
335         refer_ptr  = refer_sptr.get();
336
337         if(sset.end() != sset.find(refer_ptr))
338         {
339            DEBUG (<< "Dépendance circulaire stoppée pour l'objet de type CField sur "
340                   << "\"" + refer_ptr->getId() + "\" !");
341            break;
342         }
343
344         SuperClassAttribute::setAttributes(refer_ptr);
345         sset.insert(refer_ptr);
346         baseRefObject = refer_sptr;
347//ym         refObject.push_back(refer_sptr);
348      }
349   }
350
351   //----------------------------------------------------------------
352
353   void  CField::solveOperation(void)
354   {
355      using namespace func;
356      using namespace date;
357       
358      StdString id = this->getBaseFieldReference()->getId();
359      boost::shared_ptr<CContext> context =
360         CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId());
361
362      if (operation.isEmpty() || freq_op.isEmpty() || this->file->output_freq.isEmpty())
363      {
364         ERROR("CField::solveOperation(void)",
365               << "[ id = " << id << "]"
366               << "Impossible de définir une opération pour le champ !");
367      }
368     
369      CDuration freq_offset_ = NoneDu;
370      if (!freq_offset.isEmpty())
371      {
372         freq_offset_ = CDuration::FromString(freq_offset.getValue());
373      }
374      else
375      {
376         freq_offset.setValue(NoneDu.toString());
377      } 
378
379//      if (CXIOSManager::GetStatus() == CXIOSManager::LOC_SERVER)
380      if (context->hasServer)
381      {
382         this->freq_operation_srv =
383             CDuration::FromString(this->file->output_freq.getValue());
384         this->freq_write_srv     =
385             CDuration::FromString(this->file->output_freq.getValue());
386         this->last_Write_srv     = boost::shared_ptr<xmlioserver::date::CDate>
387                        (new date::CDate(context->getCalendar()->getInitDate()));
388         this->last_operation_srv = boost::shared_ptr<xmlioserver::date::CDate>
389                        (new date::CDate(context->getCalendar()->getInitDate()));
390//         this->foperation_srv     =
391//             boost::shared_ptr<func::CFunctor>(new CInstant(this->data_srv));
392             
393         const CDuration toffset = this->freq_operation_srv - freq_offset_ - context->getCalendar()->getTimeStep(); 
394         *this->last_operation_srv   = *this->last_operation_srv - toffset; 
395      }
396     
397      if (context->hasClient)
398      {                 
399         this->freq_operation = CDuration::FromString(freq_op.getValue());
400         this->freq_write     = CDuration::FromString(this->file->output_freq.getValue());
401         this->last_Write     = boost::shared_ptr<xmlioserver::date::CDate>
402                        (new date::CDate(context->getCalendar()->getInitDate()));
403         this->last_operation = boost::shared_ptr<xmlioserver::date::CDate>
404                        (new date::CDate(context->getCalendar()->getInitDate()));
405                       
406         const CDuration toffset = this->freq_operation - freq_offset_ - context->getCalendar()->getTimeStep(); 
407         *this->last_operation   = *this->last_operation - toffset; 
408         
409#define DECLARE_FUNCTOR(MType, mtype)              \
410   if  (operation.getValue().compare(#mtype) == 0) \
411   {                                               \
412      boost::shared_ptr<func::CFunctor>            \
413            foperation_(new C##MType(this->data)); \
414      this->foperation = foperation_;              \
415      return;                                      \
416   }
417   
418#include "functor_type.conf"
419         
420         ERROR("CField::solveOperation(void)",
421               << "[ operation = " << operation.getValue() << "]"
422               << "L'opération n'est pas définie dans le code !");
423      }
424   }
425   
426   //----------------------------------------------------------------
427   
428   void CField::fromBinary(StdIStream & is)
429   {
430      SuperClass::fromBinary(is);
431#define CLEAR_ATT(name_)\
432      SuperClassAttribute::operator[](#name_)->clear()
433
434         CLEAR_ATT(domain_ref);
435         CLEAR_ATT(axis_ref);
436#undef CLEAR_ATT
437
438   }
439
440   //----------------------------------------------------------------
441
442   void CField::solveGridReference(void)
443   {
444      boost::shared_ptr<CDomain> domain;
445      boost::shared_ptr<CAxis> axis;
446
447      if (!domain_ref.isEmpty())
448      {
449         if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue()))
450            domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ;
451         else
452            ERROR("CField::solveGridReference(void)",
453                  << "Référence au domaine nommé \'"
454                  << domain_ref.getValue() << "\' incorrecte") ;
455      }
456
457      if (!axis_ref.isEmpty())
458      {
459         if (CObjectFactory::HasObject<CAxis>(axis_ref.getValue()))
460            axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ;
461         else
462            ERROR("CField::solveGridReference(void)",
463                  << "Référence à l'axe nommé \'"
464                  << axis_ref.getValue() <<"\' incorrecte") ;
465      }
466
467      if (!grid_ref.isEmpty())
468      {
469         if (CObjectFactory::HasObject<CGrid>(grid_ref.getValue()))
470            this->grid = CObjectFactory::GetObject<CGrid>(grid_ref.getValue()) ;
471         else
472            ERROR("CField::solveGridReference(void)",
473                  << "Référence à la grille nommée \'"
474                  << grid_ref.getValue() << "\' incorrecte");
475         if (!domain_ref.isEmpty())
476            DEBUG(<< "Définition conjointe de la grille "
477                  << "et du domaine, la grille prévaut..." );
478         if (!axis_ref.isEmpty())
479            DEBUG(<< "Définition conjointe de la grille "
480                  << "et de l'axe vertical, la grille prévaut...") ;
481      }
482      else
483      {
484         if (!domain_ref.isEmpty())
485         {
486            if (!axis_ref.isEmpty())
487            {
488               this->grid = CGrid::CreateGrid(domain, axis) ;
489               this->grid_ref.setValue(this->grid->getId());
490            }
491            else
492            {
493               this->grid = CGrid::CreateGrid(domain) ;
494               this->grid_ref.setValue(this->grid->getId());
495            }
496         }
497         else
498         {
499            ERROR("CField::solveGridReference(void)",
500                  << "Le domaine horizontal pour le champ X n'est pas défini");
501         }
502      }
503      grid->solveReference() ;
504   }
505
506   } // namespace tree
507
508   ///-------------------------------------------------------------------
509
510   template <>
511      void CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)
512   {
513      if (this->group_ref.isEmpty()) return;
514      StdString gref = this->group_ref.getValue();
515
516      if (!CObjectFactory::HasObject<CFieldGroup>(gref))
517         ERROR("CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)",
518               << "[ gref = " << gref << "]"
519               << " invalid group name !");
520
521      boost::shared_ptr<CFieldGroup> group
522               = CObjectFactory::GetObject<CFieldGroup>(gref);
523      boost::shared_ptr<CFieldGroup> owner
524               = CObjectFactory::GetObject<CFieldGroup>
525                  (boost::polymorphic_downcast<CFieldGroup*>(this));
526
527      std::vector<boost::shared_ptr<CField> > allChildren  = group->getAllChildren();
528      std::vector<boost::shared_ptr<CField> >::iterator
529         it = allChildren.begin(), end = allChildren.end();
530     
531      for (; it != end; it++)
532      {
533         boost::shared_ptr<CField> child = *it;
534         if (child->hasId())
535            CGroupFactory::CreateChild(owner)->field_ref.setValue(child->getId());
536      }
537   }
538   
539   void CField::outputField(ARRAY(double,3) fieldOut)
540   {
541      map<int,ARRAY(double,1)>::iterator it;
542      for(it=data_srv.begin();it!=data_srv.end();it++)
543         grid->outputField(it->first,it->second, fieldOut) ;
544     
545   }
546   
547   void CField::outputField(ARRAY(double,2) fieldOut)
548   {
549      map<int,ARRAY(double,1)>::iterator it;
550
551      for(it=data_srv.begin();it!=data_srv.end();it++)
552      {
553         grid->outputField(it->first,it->second, fieldOut) ;
554      }
555   }
556   ///-------------------------------------------------------------------
557
558} // namespace xmlioserver
Note: See TracBrowser for help on using the repository browser.