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

Last change on this file since 418 was 418, checked in by ymipsl, 10 years ago

Change inheritance order when mixed grid_ref, domain_ref and axis_ref (pour les boués du p'tit Sébastien)

YM

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