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

Last change on this file since 460 was 460, checked in by ymipsl, 11 years ago

New functionnalities : expression may combine fields after temporal operation (averaging, min, max ...) using the operator @

YM
File size: 23.2 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#include <set>
14
15namespace xios{
16   
17   /// ////////////////////// Définitions ////////////////////// ///
18
19   CField::CField(void)
20      : CObjectTemplate<CField>(), CFieldAttributes()
21      , refObject(), baseRefObject()
22      , grid(), file()
23      , freq_operation(), freq_write()
24      , nstep(0)
25      , last_Write(), last_operation()
26      , foperation(), hasInstantData(false), hasExpression(false)
27      , active(false) , hasOutputFile(false),hasFieldOut(false), slotUpdateDate(NULL)
28      , processed(false)
29      { /* Ne rien faire de plus */ }
30
31   CField::CField(const StdString & id)
32      : CObjectTemplate<CField>(id), CFieldAttributes()
33      , refObject(), baseRefObject()
34      , grid(), file()
35      , freq_operation(), freq_write()
36      , nstep(0)
37      , last_Write(), last_operation()
38      , foperation(), hasExpression(false)
39      , active(false), hasOutputFile(false), hasFieldOut(false), slotUpdateDate(NULL)
40      , processed(false)
41   { /* Ne rien faire de plus */ }
42
43   CField::~CField(void)
44   {
45//      this->grid.reset() ;
46//      this->file.reset() ;
47      this->foperation.reset() ;
48      if (hasExpression) delete expression ;
49      if (slotUpdateDate!=NULL) delete slotUpdateDate ;
50       
51   }
52
53   //----------------------------------------------------------------
54
55   bool CField::updateDataServer
56      (const CDate & currDate,
57       const std::deque< CArray<double, 1>* > storedClient)
58   {
59      const CDate opeDate      = *last_operation + freq_operation;
60      const CDate writeDate    = *last_Write     + freq_write; 
61     
62      if (opeDate <= currDate)
63      {
64         if (this->data.numElements() != this->grid->storeIndex[0]->numElements())
65         {
66            this->data.resize(this->grid->storeIndex[0] ->numElements());
67         } 
68         CArray<double,1> input(data.numElements()) ;
69         this->grid->inputFieldServer(storedClient, input);         
70         (*this->foperation)(input);
71         *last_operation = currDate;
72      }
73      if (writeDate < (currDate + freq_operation))
74      {
75         this->foperation->final();
76         this->incrementNStep();
77         *last_Write = writeDate;
78         return (true);       
79      }
80      return (false);
81   }
82   
83   bool CField::dispatchEvent(CEventServer& event)
84  {
85     
86    if (SuperClass::dispatchEvent(event)) return true ;
87    else
88    {
89      switch(event.type)
90      {
91        case EVENT_ID_UPDATE_DATA :
92          recvUpdateData(event) ;
93          return true ;
94          break ;
95 
96        default :
97          ERROR("bool CField::dispatchEvent(CEventServer& event)",<<"Unknown Event") ;
98          return false ;
99      }
100    }
101  }
102 
103  void CField::sendUpdateData(void)
104  {
105    CContext* context = CContext::getCurrent() ;
106    CContextClient* client=context->client ;
107   
108    CEventClient event(getType(),EVENT_ID_UPDATE_DATA) ;
109   
110    map<int,CArray<int, 1>* >::iterator it ;
111    list<shared_ptr<CMessage> > list_msg ;
112    list< CArray<double,1>* > list_data ;
113   
114    for(it=grid->storeIndex_toSrv.begin();it!=grid->storeIndex_toSrv.end();it++)
115    {
116      int rank=(*it).first ;
117      CArray<int,1>& index = *(it->second) ;
118      CArray<double,1> data_tmp(index.numElements()) ;
119     
120      for(int n=0;n<data_tmp.numElements();n++) data_tmp(n)=data(index(n)) ;
121      list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ;
122      list_data.push_back(new CArray<double,1>(data_tmp)) ;
123      *list_msg.back()<<getId()<<*list_data.back() ;
124      event.push(rank,grid->nbSenders[rank],*list_msg.back()) ;
125    }
126    client->sendEvent(event) ;
127   
128    for(list< CArray<double,1>* >::iterator it=list_data.begin();it!=list_data.end();it++) delete *it ;
129  }
130 
131  void CField::recvUpdateData(CEventServer& event)
132  {
133    vector<int> ranks ;
134    vector<CBufferIn*> buffers ;
135     
136    list<CEventServer::SSubEvent>::iterator it ;
137    string fieldId ;
138
139    for (it=event.subEvents.begin();it!=event.subEvents.end();++it)
140    {
141      int rank=it->rank;
142      CBufferIn* buffer=it->buffer;
143      *buffer>>fieldId ;
144      ranks.push_back(rank) ;
145      buffers.push_back(buffer) ;
146    }
147    get(fieldId)->recvUpdateData(ranks,buffers) ;   
148  }
149 
150  void  CField::recvUpdateData(vector<int>& ranks, vector<CBufferIn*>& buffers)
151  {
152   
153    if (data_srv.empty())
154    {
155      for(map<int, CArray<int, 1>* >::iterator it=grid->out_i_fromClient.begin();it!=grid->out_i_fromClient.end();it++)
156      {
157        int rank=it->first ;
158        CArray<double,1> data_tmp(it->second->numElements()) ;
159        data_srv.insert( pair<int, CArray<double,1>* >(rank, new CArray<double,1>(data_tmp) ) ) ;
160        foperation_srv.insert(pair<int,boost::shared_ptr<func::CFunctor> >(rank,boost::shared_ptr<func::CFunctor>(new func::CInstant(*data_srv[rank])))) ;
161      }
162    }
163
164    CContext* context = CContext::getCurrent() ;
165    const CDate & currDate = context->getCalendar()->getCurrentDate();
166    const CDate opeDate      = *last_operation_srv + freq_operation_srv;
167    const CDate writeDate    = *last_Write_srv     + freq_write_srv; 
168   
169
170   
171    if (opeDate <= currDate)
172    {
173      for(int n=0;n<ranks.size();n++)
174      {
175        CArray<double,1> data_tmp ;
176        *buffers[n]>>data_tmp ;
177        (*foperation_srv[ranks[n]])(data_tmp) ;
178      }
179      *last_operation_srv = currDate;
180    }
181     
182    if (writeDate < (currDate + freq_operation_srv))
183    {
184      for(int n=0;n<ranks.size();n++)
185      {
186        this->foperation_srv[ranks[n]]->final();
187      }
188     
189      *last_Write_srv = writeDate;
190      writeField() ;
191      *lastlast_Write_srv=*last_Write_srv;
192    }
193  }
194 
195  void CField::writeField(void)
196  {
197    if (! getRelFile()->allDomainEmpty )
198      if (! grid->domain->isEmpty() || getRelFile()->type == CFile::type_attr::one_file)
199      {
200        getRelFile()->checkFile();
201        this->incrementNStep();
202        getRelFile()->getDataOutput()->writeFieldData(CField::get(this));
203      }
204  }
205   //----------------------------------------------------------------
206
207   void CField::setRelFile(CFile* _file)
208   { 
209      this->file = _file;
210      hasOutputFile=true ; 
211   }
212
213   //----------------------------------------------------------------
214
215   StdString CField::GetName(void)   { return (StdString("field")); }
216   StdString CField::GetDefName(void){ return (CField::GetName()); }
217   ENodeType CField::GetType(void)   { return (eField); }
218
219   //----------------------------------------------------------------
220
221   CGrid* CField::getRelGrid(void) const
222   { 
223      return (this->grid); 
224   }
225
226   //----------------------------------------------------------------
227
228   CFile* CField::getRelFile(void) const
229   { 
230      return (this->file);
231   }
232   
233   StdSize CField::getNStep(void) const
234   {
235      return (this->nstep);
236   }
237   
238   void CField::incrementNStep(void)
239   {
240      this->nstep++;
241   }
242 
243   void CField::resetNStep(void)
244   {
245      this->nstep=0;
246   }
247
248   //----------------------------------------------------------------
249
250   CField* CField::getDirectFieldReference(void) const
251   {
252      if (this->field_ref.isEmpty())
253         return (this->getBaseFieldReference());
254
255      if (! CField::has(this->field_ref.getValue()))
256         ERROR("CField::getDirectFieldReference(void)",
257               << "[ ref_name = " << this->field_ref.getValue() << "]"
258               << " invalid field name !");
259
260      return (CField::get(this->field_ref.getValue()));
261   }
262
263   //----------------------------------------------------------------
264
265   CField* CField::getBaseFieldReference(void) const
266   { 
267      return (baseRefObject); 
268   }
269
270   //----------------------------------------------------------------
271
272   const std::vector<CField*>& CField::getAllReference(void) const 
273   { 
274      return (refObject);
275   }
276
277   //----------------------------------------------------------------
278
279   const StdString & CField::getBaseFieldId(void) const
280   { 
281      return (this->getBaseFieldReference()->getId());
282   }
283   
284   //----------------------------------------------------------------
285   
286   const CDuration & CField::getFreqOperation(void) const
287   {
288      return (this->freq_operation);
289   }
290   
291   //----------------------------------------------------------------
292   const CDuration & CField::getFreqWrite(void) const
293   {
294      return (this->freq_write);
295   }
296   
297   //----------------------------------------------------------------
298         
299   boost::shared_ptr<func::CFunctor> CField::getFieldOperation(void) const
300   {
301      return (this->foperation);
302   }
303
304   //----------------------------------------------------------------
305
306   bool CField::hasDirectFieldReference(void) const
307   { 
308     return (!this->field_ref.isEmpty()); 
309   }
310   
311   bool CField::isActive(void) const
312   { 
313      return (!this->refObject.empty()); 
314   }
315   //----------------------------------------------------------------
316   
317   CArray<double, 1> CField::getData(void) const
318   {
319      return(this->data);
320   }
321
322   //----------------------------------------------------------------
323
324   boost::shared_ptr<CDate> CField::getLastWriteDate(void) const
325   {
326      return(this->last_Write);
327   }
328
329   //----------------------------------------------------------------
330
331   boost::shared_ptr<CDate> CField::getLastOperationDate(void) const
332   {
333      return(this->last_operation);
334   }
335
336   //----------------------------------------------------------------
337
338   void CField::processEnabledField(void)
339   {
340      if (!processed)
341      {
342        processed=true ;
343        solveRefInheritance(true) ;
344        solveOperation() ;
345        solveGridReference() ;
346     
347        if (hasDirectFieldReference()) baseRefObject->processEnabledField() ;
348        buildExpression(); 
349        active=true;
350      }
351    }
352   
353   void CField::solveRefInheritance(bool apply)
354   {
355      std::set<CField *> sset;
356      CField* refer_sptr;
357      CField * refer_ptr = this;
358     
359      if (this->hasDirectFieldReference())  baseRefObject = getDirectFieldReference();
360      else  baseRefObject = CField::get(this);
361     
362      while (refer_ptr->hasDirectFieldReference())
363      {
364         refer_sptr = refer_ptr->getDirectFieldReference();
365         refer_ptr  = refer_sptr;
366
367         if(sset.end() != sset.find(refer_ptr))
368         {
369            DEBUG (<< "Dépendance circulaire stoppée pour l'objet de type CField sur "
370                   << "\"" + refer_ptr->getId() + "\" !");
371            break;
372         }
373
374         SuperClassAttribute::setAttributes(refer_ptr, apply);
375         sset.insert(refer_ptr);
376//ym         baseRefObject = refer_sptr;
377//ym         refObject.push_back(refer_sptr);
378      }
379     
380      if (hasDirectFieldReference()) baseRefObject->addReference(this) ;
381   }
382
383   //----------------------------------------------------------------
384
385   void  CField::solveOperation(void)
386   {
387      using namespace func;
388     
389      if (!hasOutputFile && !hasFieldOut) return ;
390     
391      StdString id ;
392      if (hasId()) id=getId();
393      else if (!name.isEmpty()) id=name ;
394      else if (hasDirectFieldReference()) id=baseRefObject->getId() ;
395     
396      CContext* context = CContext::getCurrent();
397     
398      if (freq_op.isEmpty()) freq_op=string("1ts") ;
399     
400      if (operation.isEmpty() )
401      {
402         ERROR("CField::solveOperation(void)",
403               << "[ id = " << id << "]"
404               << "Impossible to define an operation for this field !");
405      }
406     
407      CDuration freq_offset_ = NoneDu;
408      if (!freq_offset.isEmpty())
409      {
410         freq_offset_ = CDuration::FromString(freq_offset.getValue());
411      }
412      else
413      {
414         freq_offset.setValue(NoneDu.toString());
415      } 
416
417//      if (CXIOSManager::GetStatus() == CXIOSManager::LOC_SERVER)
418      if (context->hasServer)
419      {
420         if (hasOutputFile) 
421         {
422           this->freq_operation_srv =CDuration::FromString(this->file->output_freq.getValue());
423           this->freq_write_srv = CDuration::FromString(this->file->output_freq.getValue());
424         }
425         this->lastlast_Write_srv     = boost::shared_ptr<CDate>
426                        (new CDate(context->getCalendar()->getInitDate()));
427         this->last_Write_srv     = boost::shared_ptr<CDate>
428                        (new CDate(context->getCalendar()->getInitDate()));
429         this->last_operation_srv = boost::shared_ptr<CDate>
430                        (new CDate(context->getCalendar()->getInitDate()));
431//         this->foperation_srv     =
432//             boost::shared_ptr<func::CFunctor>(new CInstant(this->data_srv));
433             
434         if (hasOutputFile) 
435         {
436           const CDuration toffset = this->freq_operation_srv - freq_offset_ - context->getCalendar()->getTimeStep(); 
437           *this->last_operation_srv   = *this->last_operation_srv - toffset;
438         }
439      }
440     
441//      if (context->hasClient)
442//      {                 
443         this->freq_operation = CDuration::FromString(freq_op.getValue());
444         if (hasOutputFile) this->freq_write     = CDuration::FromString(this->file->output_freq.getValue());
445         if (hasFieldOut) 
446         {
447           this->freq_write = CDuration::FromString(this->fieldOut->freq_op.getValue());
448         }
449         this->last_Write     = boost::shared_ptr<CDate>
450                        (new CDate(context->getCalendar()->getInitDate()));
451         this->last_operation = boost::shared_ptr<CDate>
452                        (new CDate(context->getCalendar()->getInitDate()));
453                       
454         const CDuration toffset = this->freq_operation - freq_offset_ - context->getCalendar()->getTimeStep(); 
455         *this->last_operation   = *this->last_operation - toffset; 
456     
457        if (operation.get()=="once") isOnceOperation=true ;
458        else isOnceOperation=false;
459        isFirstOperation=true;
460
461#define DECLARE_FUNCTOR(MType, mtype)              \
462   if  (operation.getValue().compare(#mtype) == 0) \
463   {                                               \
464      boost::shared_ptr<func::CFunctor>            \
465            foperation_(new C##MType(this->data)); \
466      this->foperation = foperation_;              \
467      return;                                      \
468   }
469   
470#include "functor_type.conf"
471         
472         ERROR("CField::solveOperation(void)",
473               << "[ operation = " << operation.getValue() << "]"
474               << "The operation is not defined !");
475//      }
476     
477
478   }
479   
480   //----------------------------------------------------------------
481/*
482   void CField::fromBinary(StdIStream & is)
483   {
484      SuperClass::fromBinary(is);
485#define CLEAR_ATT(name_)\
486      SuperClassAttribute::operator[](#name_)->reset()
487
488         CLEAR_ATT(domain_ref);
489         CLEAR_ATT(axis_ref);
490#undef CLEAR_ATT
491
492   }
493*/
494   //----------------------------------------------------------------
495
496   void CField::solveGridReference(void)
497   {
498      CDomain* domain;
499      CAxis* axis;
500
501      if (!domain_ref.isEmpty())
502      {
503         if (CDomain::has(domain_ref.getValue()))
504            domain = CDomain::get(domain_ref.getValue()) ;
505         else
506            ERROR("CField::solveGridReference(void)",
507                  << "Reference to the domain \'"
508                  << domain_ref.getValue() << "\' is wrong") ;
509      }
510
511      if (!axis_ref.isEmpty())
512      {
513         if (CAxis::has(axis_ref.getValue()))
514            axis = CAxis::get(axis_ref.getValue()) ;
515         else
516            ERROR("CField::solveGridReference(void)",
517                  << "Reference to the axis \'"
518                  << axis_ref.getValue() <<"\' is wrong") ;
519      }
520
521      if (!grid_ref.isEmpty())
522      {
523         if (CGrid::has(grid_ref.getValue()))
524            this->grid = CGrid::get(grid_ref.getValue()) ;
525         else
526            ERROR("CField::solveGridReference(void)",
527                  << "Reference to the grid \'"
528                  << grid_ref.getValue() << "\' is wrong");
529      }
530     
531      if (grid_ref.isEmpty() &&  domain_ref.isEmpty())
532      {
533            ERROR("CField::solveGridReference(void)",
534                  << "The horizontal domain for this field is not defined");
535
536     }
537     
538     CType<string> goodDomain ;
539     CType<string> goodAxis ;
540     if (!grid_ref.isEmpty())
541     {
542       if (!grid->domain_ref.isEmpty()) goodDomain=grid->domain_ref ;
543       if (!grid->axis_ref.isEmpty()) goodAxis=grid->axis_ref ;
544     }
545     if (!domain_ref.isEmpty()) goodDomain=domain_ref ;
546     if (!axis_ref.isEmpty()) goodAxis=axis_ref ;
547     
548     
549     if (goodDomain.isEmpty()) 
550     {
551       ERROR("CField::solveGridReference(void)", << "The horizontal domain for this field is not defined");
552     }
553     else 
554     {
555       if (CDomain::has(goodDomain)) domain = CDomain::get(goodDomain) ;
556       else ERROR("CField::solveGridReference(void)",<< "Reference to the domain \'"<<goodDomain.get() << "\' is wrong") ;
557     }
558 
559     if (!goodAxis.isEmpty())
560     {
561       if (CAxis::has(goodAxis))  axis = CAxis::get(goodAxis) ;
562       else  ERROR("CField::solveGridReference(void)", << "Reference to the axis \'"
563                  << goodAxis.get() <<"\' is wrong") ;
564     } 
565   
566     bool nothingToDo=false ;
567     
568     if (!grid_ref.isEmpty())
569     {
570       if (!grid->domain_ref.isEmpty() && goodDomain.get() == grid->domain_ref.get())
571         if (goodAxis.isEmpty()) nothingToDo=true ;
572         else if (!grid->axis_ref.isEmpty()) 
573                 if (grid->axis_ref.get()==goodAxis.get()) nothingToDo=true ;
574     }
575     
576     if (!nothingToDo)
577     {
578       if (!goodAxis.isEmpty())
579       {
580         this->grid = CGrid::createGrid(domain, axis) ;
581         this->grid_ref.setValue(this->grid->getId());
582       }
583       else
584       {
585         this->grid = CGrid::createGrid(domain) ;
586         this->grid_ref.setValue(this->grid->getId());
587       }   
588     }
589
590     grid->solveReference() ;
591
592   }
593
594
595   ///-------------------------------------------------------------------
596
597   template <>
598      void CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)
599   {
600      if (this->group_ref.isEmpty()) return;
601      StdString gref = this->group_ref.getValue();
602
603      if (!CFieldGroup::has(gref))
604         ERROR("CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)",
605               << "[ gref = " << gref << "]"
606               << " invalid group name !");
607
608      CFieldGroup* group = CFieldGroup::get(gref);
609      CFieldGroup* owner = CFieldGroup::get(boost::polymorphic_downcast<CFieldGroup*>(this));
610
611      std::vector<CField*> allChildren  = group->getAllChildren();
612      std::vector<CField*>::iterator
613         it = allChildren.begin(), end = allChildren.end();
614     
615      for (; it != end; it++)
616      {
617         CField* child = *it;
618         if (child->hasId()) owner->createChild()->field_ref.setValue(child->getId()) ;
619           
620      }
621   }
622   
623   void CField::outputField(CArray<double,3>& fieldOut)
624   {
625      map<int, CArray<double,1>* >::iterator it;
626      for(it=data_srv.begin();it!=data_srv.end();it++)
627         grid->outputField(it->first,*it->second, fieldOut) ;
628     
629   }
630   
631   void CField::outputField(CArray<double,2>& fieldOut)
632   {
633      map<int, CArray<double,1>* >::iterator it;
634
635      for(it=data_srv.begin();it!=data_srv.end();it++)
636      {
637         grid->outputField(it->first,*it->second, fieldOut) ;
638      }
639   }
640   ///-------------------------------------------------------------------
641
642   void CField::parse(xml::CXMLNode & node)
643   {
644      SuperClass::parse(node);
645      node.getContent(this->content) ;
646    }
647   
648  CArray<double,1>* CField::getInstantData(void)
649  {
650    if (!hasInstantData) 
651    {
652      instantData.resize(grid->storeIndex_client.numElements()) ;
653      hasInstantData=true ;
654    }
655    return &instantData ;
656  }
657 
658  void CField::addReference(CField* field)
659  {
660    refObject.push_back(field) ;
661  }
662 
663  void CField::addDependency(CField* field, int slotId)
664  {
665    fieldDependency.push_back(pair<CField*,int>(field,slotId)) ;
666  }
667 
668  void CField::buildExpression(void)
669  {
670    if (content.size() > 0) 
671    {
672      CSimpleNodeExpr* simpleExpr=parseExpr(content+'\0') ;
673      expression=CFieldNode::newNode(simpleExpr) ;
674      delete simpleExpr ;
675      set<string> instantFieldIds ;
676      map<string,CField*> associatedInstantFieldIds ;
677      expression->getInstantFieldIds(instantFieldIds) ;
678      for (set<string>::iterator it=instantFieldIds.begin() ; it!=instantFieldIds.end();++it) 
679      {
680        if (*it!="this") 
681        {
682          if (CField::has(*it)) 
683          {
684            CField* field=CField::get(*it) ;
685            field->processEnabledField() ;
686            associatedInstantFieldIds[*it]=field ;
687          }
688          else  ERROR("void CField::buildExpression(void)",<<" Field "<<*it<<" does not exist") ;
689        }
690      }
691     
692      set<string> averageFieldIds ;
693      map<string,CField*> associatedAverageFieldIds ;
694
695      expression->getAverageFieldIds(averageFieldIds) ;
696      for (set<string>::iterator it=averageFieldIds.begin() ; it!=averageFieldIds.end();++it) 
697      {     
698        if (CField::has(*it)) 
699        {
700           CFieldGroup* root=CFieldGroup::get("field_definition") ;
701           CField* averageField=root->createChild() ;
702           CField* instantField=root->createChild() ;
703           averageField->field_ref=*it ;
704           averageField->hasFieldOut=true ;
705           averageField->fieldOut=instantField ;
706           instantField->freq_op=freq_op ;
707           averageField-> processEnabledField() ;
708           cout<<" outputfreq of averageField "<<  freq_op <<"  "<<instantField->freq_op<<"  "<< averageField->freq_write << endl ;
709           instantField->SuperClassAttribute::setAttributes(averageField, true);
710           instantField->field_ref.reset() ;
711           instantField->operation.reset() ;
712
713           instantField-> processEnabledField() ;
714           associatedAverageFieldIds[*it]=instantField  ;
715        }
716        else ERROR("void CField::buildExpression(void)",<<" Field "<<*it<<" does not exist") ;
717      }
718
719      expression->reduce(this,associatedInstantFieldIds,associatedAverageFieldIds) ;
720
721      slots.resize(instantFieldIds.size()+averageFieldIds.size()) ;
722      resetSlots() ;
723      int slotId=0 ;
724      set<CField*> fields ;
725      expression->getFields(fields) ;
726      for (set<CField*>::iterator it=fields.begin() ; it!=fields.end();++it,++slotId) (*it)->addDependency(this,slotId) ;
727      hasExpression=true; 
728    }
729  }
730 
731  void CField::resetSlots(void)
732  {
733    for(vector<bool>::iterator it=slots.begin();it!=slots.end();++it) *it=false ;
734  }
735 
736  bool CField::slotsFull(void)
737  {
738    bool ret=true ;
739    for(vector<bool>::iterator it=slots.begin();it!=slots.end();++it) ret &= *it;
740    return ret ;
741  }
742
743 
744  void CField::setSlot(int slotId)
745  {
746    CContext* context = CContext::getCurrent() ;
747    const CDate & currDate = context->getCalendar()->getCurrentDate();
748    if (slotUpdateDate==NULL || currDate!=*slotUpdateDate) 
749    {
750      resetSlots() ;
751      if (slotUpdateDate==NULL) slotUpdateDate=new CDate(currDate) ;
752      else *slotUpdateDate=currDate ;
753    }
754    slots[slotId]=true ;
755    if (slotsFull())
756    {
757      CArray<double,1> expr(expression->compute()) ;
758     
759      if (hasInstantData) 
760      {
761        instantData=expr ;
762        for(list< pair<CField *,int> >::iterator it=fieldDependency.begin(); it!=fieldDependency.end(); ++it) 
763          if (it->first!=this) it->first->setSlot(it->second) ;
764      }
765     
766      if (hasOutputFile) updateDataFromExpression(expr) ;
767     
768    }
769  }
770 
771} // namespace xios
Note: See TracBrowser for help on using the repository browser.