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

Last change on this file since 959 was 959, checked in by ymipsl, 6 years ago

Fix bug introduced in rev 952 causing trouble for reading functionalities.

YM

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
  • Property svn:executable set to *
File size: 39.9 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 "xios_spl.hpp"
11#include "type.hpp"
12#include "timer.hpp"
13#include "context_client.hpp"
14#include "context_server.hpp"
15#include <set>
16#include "garbage_collector.hpp"
17#include "source_filter.hpp"
18#include "store_filter.hpp"
19#include "file_writer_filter.hpp"
20#include "pass_through_filter.hpp"
21#include "filter_expr_node.hpp"
22#include "lex_parser.hpp"
23#include "temporal_filter.hpp"
24#include "spatial_transform_filter.hpp"
25
26namespace xios{
27
28   /// ////////////////////// Définitions ////////////////////// ///
29
30   CField::CField(void)
31      : CObjectTemplate<CField>(), CFieldAttributes()
32      , grid(), file()
33      , written(false)
34      , nstep(0), nstepMax(0)
35      , hasOutputFile(false)
36      , domAxisScalarIds_(vector<StdString>(3,"")), areAllReferenceSolved(false), isReferenceSolved(false)
37      , useCompressedOutput(false)
38      , isReadDataRequestPending(false)
39   { setVirtualVariableGroup(CVariableGroup::create(getId() + "_virtual_variable_group")); }
40
41   CField::CField(const StdString& id)
42      : CObjectTemplate<CField>(id), CFieldAttributes()
43      , grid(), file()
44      , written(false)
45      , nstep(0), nstepMax(0)
46      , hasOutputFile(false)
47      , domAxisScalarIds_(vector<StdString>(3,"")), areAllReferenceSolved(false), isReferenceSolved(false)
48      , useCompressedOutput(false)
49      , isReadDataRequestPending(false)
50   { setVirtualVariableGroup(CVariableGroup::create(getId() + "_virtual_variable_group")); }
51
52   CField::~CField(void)
53   {}
54
55  //----------------------------------------------------------------
56
57   void CField::setVirtualVariableGroup(CVariableGroup* newVVariableGroup)
58   {
59      this->vVariableGroup = newVVariableGroup;
60   }
61
62   CVariableGroup* CField::getVirtualVariableGroup(void) const
63   {
64      return this->vVariableGroup;
65   }
66
67   std::vector<CVariable*> CField::getAllVariables(void) const
68   {
69      return this->vVariableGroup->getAllChildren();
70   }
71
72   void CField::solveDescInheritance(bool apply, const CAttributeMap* const parent)
73   {
74      SuperClassAttribute::setAttributes(parent, apply);
75      this->getVirtualVariableGroup()->solveDescInheritance(apply, NULL);
76   }
77
78  //----------------------------------------------------------------
79
80  bool CField::dispatchEvent(CEventServer& event)
81  {
82    if (SuperClass::dispatchEvent(event)) return true;
83    else
84    {
85      switch(event.type)
86      {
87        case EVENT_ID_UPDATE_DATA :
88          recvUpdateData(event);
89          return true;
90          break;
91
92        case EVENT_ID_READ_DATA :
93          recvReadDataRequest(event);
94          return true;
95          break;
96
97        case EVENT_ID_READ_DATA_READY :
98          recvReadDataReady(event);
99          return true;
100          break;
101
102        case EVENT_ID_ADD_VARIABLE :
103          recvAddVariable(event);
104          return true;
105          break;
106
107        case EVENT_ID_ADD_VARIABLE_GROUP :
108          recvAddVariableGroup(event);
109          return true;
110          break;
111
112        default :
113          ERROR("bool CField::dispatchEvent(CEventServer& event)", << "Unknown Event");
114          return false;
115      }
116    }
117  }
118
119  void CField::sendUpdateData(const CArray<double,1>& data)
120  {
121    CTimer::get("XIOS Send Data").resume();
122
123    CContext* context = CContext::getCurrent();
124    CContextClient* client = context->client;
125
126    CEventClient event(getType(), EVENT_ID_UPDATE_DATA);
127
128    map<int, CArray<int,1> >::iterator it;
129    list<CMessage> list_msg;
130    list<CArray<double,1> > list_data;
131
132    if (!grid->doGridHaveDataDistributed())
133    {
134       if (0 == client->clientRank)
135       {
136          for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++)
137          {
138            int rank = it->first;
139            CArray<int,1>& index = it->second;
140
141            list_msg.push_back(CMessage());
142            list_data.push_back(CArray<double,1>(index.numElements()));
143
144            CArray<double,1>& data_tmp = list_data.back();
145            for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n));
146
147            list_msg.back() << getId() << data_tmp;
148            event.push(rank, 1, list_msg.back());
149          }
150          client->sendEvent(event);
151       } else client->sendEvent(event);
152    }
153    else
154    {
155      for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++)
156      {
157        int rank = it->first;
158        CArray<int,1>& index = it->second;
159
160        list_msg.push_back(CMessage());
161        list_data.push_back(CArray<double,1>(index.numElements()));
162
163        CArray<double,1>& data_tmp = list_data.back();
164        for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n));
165
166        list_msg.back() << getId() << data_tmp;
167        event.push(rank, grid->nbSenders[rank], list_msg.back());
168      }
169      client->sendEvent(event);
170    }
171
172    CTimer::get("XIOS Send Data").suspend();
173  }
174
175  void CField::recvUpdateData(CEventServer& event)
176  {
177    vector<int> ranks;
178    vector<CBufferIn*> buffers;
179
180    list<CEventServer::SSubEvent>::iterator it;
181    string fieldId;
182
183    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
184    {
185      int rank = it->rank;
186      CBufferIn* buffer = it->buffer;
187      *buffer >> fieldId;
188      ranks.push_back(rank);
189      buffers.push_back(buffer);
190    }
191    get(fieldId)->recvUpdateData(ranks,buffers);
192  }
193
194  void  CField::recvUpdateData(vector<int>& ranks, vector<CBufferIn*>& buffers)
195  {
196    if (data_srv.empty())
197    {
198      for (map<int, CArray<size_t, 1> >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it)
199      {
200        int rank = it->first;
201        data_srv.insert(std::make_pair(rank, CArray<double,1>(it->second.numElements())));
202        foperation_srv.insert(pair<int,boost::shared_ptr<func::CFunctor> >(rank,boost::shared_ptr<func::CFunctor>(new func::CInstant(data_srv[rank]))));
203      }
204    }
205
206    CContext* context = CContext::getCurrent();
207    const CDate& currDate = context->getCalendar()->getCurrentDate();
208    const CDate opeDate      = last_operation_srv +freq_op + freq_operation_srv - freq_op;
209    const CDate writeDate    = last_Write_srv     + freq_write_srv;
210
211    if (opeDate <= currDate)
212    {
213      for (int n = 0; n < ranks.size(); n++)
214      {
215        CArray<double,1> data_tmp;
216        *buffers[n] >> data_tmp;
217        (*foperation_srv[ranks[n]])(data_tmp);
218      }
219      last_operation_srv = currDate;
220    }
221
222    if (writeDate < (currDate + freq_operation_srv))
223    {
224      for (int n = 0; n < ranks.size(); n++)
225      {
226        this->foperation_srv[ranks[n]]->final();
227      }
228
229      last_Write_srv = writeDate;
230      writeField();
231      lastlast_Write_srv = last_Write_srv;
232    }
233  }
234
235  void CField::writeField(void)
236  {
237    if (!getRelFile()->allDomainEmpty)
238    {
239      if (grid->doGridHaveDataToWrite() || getRelFile()->type == CFile::type_attr::one_file)
240      {
241        getRelFile()->checkFile();
242        this->incrementNStep();
243        getRelFile()->getDataOutput()->writeFieldData(CField::get(this));
244      }
245    }
246  }
247
248  void CField::sendReadDataRequest(void)
249  {
250    CContext* context = CContext::getCurrent();
251    CContextClient* client = context->client;
252
253    lastDataRequestedFromServer = context->getCalendar()->getCurrentDate();
254    isReadDataRequestPending = true;
255
256    CEventClient event(getType(), EVENT_ID_READ_DATA);
257    if (client->isServerLeader())
258    {
259      CMessage msg;
260      msg << getId();
261      const std::list<int>& ranks = client->getRanksServerLeader();
262      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
263        event.push(*itRank, 1, msg);
264      client->sendEvent(event);
265    }
266    else client->sendEvent(event);
267  }
268
269  /*!
270  Send request new data read from file if need be, that is the current data is out-of-date.
271  \return true if and only if some data was requested
272  */
273  bool CField::sendReadDataRequestIfNeeded(void)
274  {
275    const CDate& currentDate = CContext::getCurrent()->getCalendar()->getCurrentDate();
276
277    bool requestData = (currentDate >= lastDataRequestedFromServer + file->output_freq.getValue());
278
279    if (requestData)
280    {
281      cout<<"currentDate : "<<currentDate<<endl ;
282      cout<<"lastDataRequestedFromServer : "<<lastDataRequestedFromServer<<endl ;
283      cout<<"file->output_freq.getValue() : "<<file->output_freq.getValue()<<endl ;
284      cout<<"lastDataRequestedFromServer + file->output_freq.getValue() : "<<lastDataRequestedFromServer + file->output_freq.getValue()<<endl ;
285
286      sendReadDataRequest();
287    }
288
289    return requestData;
290  }
291
292  void CField::recvReadDataRequest(CEventServer& event)
293  {
294    CBufferIn* buffer = event.subEvents.begin()->buffer;
295    StdString fieldId;
296    *buffer >> fieldId;
297    get(fieldId)->recvReadDataRequest();
298  }
299
300  void CField::recvReadDataRequest(void)
301  {
302    CContext* context = CContext::getCurrent();
303    CContextClient* client = context->client;
304
305    CEventClient event(getType(), EVENT_ID_READ_DATA_READY);
306    std::list<CMessage> msgs;
307
308    bool hasData = readField();
309
310    map<int, CArray<double,1> >::iterator it;
311    for (it = data_srv.begin(); it != data_srv.end(); it++)
312    {
313      msgs.push_back(CMessage());
314      CMessage& msg = msgs.back();
315      msg << getId();
316      if (hasData)
317        msg << getNStep() - 1 << it->second;
318      else
319        msg << int(-1);
320      event.push(it->first, grid->nbSenders[it->first], msg);
321    }
322    client->sendEvent(event);
323  }
324
325  bool CField::readField(void)
326  {
327    if (!getRelFile()->allDomainEmpty)
328    {
329      if (grid->doGridHaveDataToWrite() || getRelFile()->type == CFile::type_attr::one_file)
330      {
331        if (data_srv.empty())
332        {
333          for (map<int, CArray<size_t, 1> >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it)
334            data_srv.insert(std::make_pair(it->first, CArray<double,1>(it->second.numElements())));
335        }
336
337        getRelFile()->checkFile();
338        if (!nstepMax)
339        {
340          nstepMax = getRelFile()->getDataInput()->getFieldNbRecords(CField::get(this));
341        }
342
343        this->incrementNStep();
344
345
346
347        if (getNStep() > nstepMax && (getRelFile()->cyclic.isEmpty() || !getRelFile()->cyclic) )
348          return false;
349
350        getRelFile()->getDataInput()->readFieldData(CField::get(this));
351      }
352    }
353
354    return true;
355  }
356
357  void CField::recvReadDataReady(CEventServer& event)
358  {
359    string fieldId;
360    vector<int> ranks;
361    vector<CBufferIn*> buffers;
362
363    list<CEventServer::SSubEvent>::iterator it;
364    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
365    {
366      ranks.push_back(it->rank);
367      CBufferIn* buffer = it->buffer;
368      *buffer >> fieldId;
369      buffers.push_back(buffer);
370    }
371    get(fieldId)->recvReadDataReady(ranks, buffers);
372  }
373
374  void CField::recvReadDataReady(vector<int> ranks, vector<CBufferIn*> buffers)
375  {
376    CContext* context = CContext::getCurrent();
377    int record;
378    std::map<int, CArray<double,1> > data;
379
380    bool isEOF = false;
381
382    for (int i = 0; i < ranks.size(); i++)
383    {
384      int rank = ranks[i];
385      *buffers[i] >> record;
386      isEOF = (record == int(-1));
387
388      if (!isEOF)
389        *buffers[i] >> data[rank];
390      else
391        break;
392    }
393
394    if (isEOF)
395      serverSourceFilter->signalEndOfStream(lastDataRequestedFromServer);
396    else
397      serverSourceFilter->streamDataFromServer(lastDataRequestedFromServer, data);
398
399    isReadDataRequestPending = false;
400  }
401
402   //----------------------------------------------------------------
403
404   void CField::setRelFile(CFile* _file)
405   {
406      this->file = _file;
407      hasOutputFile = true;
408   }
409
410   //----------------------------------------------------------------
411
412   StdString CField::GetName(void)    { return StdString("field"); }
413   StdString CField::GetDefName(void) { return CField::GetName(); }
414   ENodeType CField::GetType(void)    { return eField; }
415
416   //----------------------------------------------------------------
417
418   CGrid* CField::getRelGrid(void) const
419   {
420      return this->grid;
421   }
422
423   //----------------------------------------------------------------
424
425   CFile* CField::getRelFile(void) const
426   {
427      return this->file;
428   }
429
430   int CField::getNStep(void) const
431   {
432      return this->nstep;
433   }
434
435   func::CFunctor::ETimeType CField::getOperationTimeType() const
436   {
437     return operationTimeType;
438   }
439
440   //----------------------------------------------------------------
441
442   void CField::incrementNStep(void)
443   {
444      this->nstep++;
445   }
446
447   void CField::resetNStep(int nstep /*= 0*/)
448   {
449      this->nstep = nstep;
450   }
451
452   void CField::resetNStepMax(void)
453   {
454      this->nstepMax = 0;
455   }
456
457   //----------------------------------------------------------------
458
459   bool CField::isActive(void) const
460   {
461      return (instantDataFilter != NULL);
462   }
463
464   //----------------------------------------------------------------
465
466   bool CField::wasWritten() const
467   {
468     return written;
469   }
470
471   void CField::setWritten()
472   {
473     written = true;
474   }
475
476   //----------------------------------------------------------------
477
478   bool CField::getUseCompressedOutput() const
479   {
480     return useCompressedOutput;
481   }
482
483   void CField::setUseCompressedOutput()
484   {
485     useCompressedOutput = true;
486   }
487
488   //----------------------------------------------------------------
489
490   boost::shared_ptr<COutputPin> CField::getInstantDataFilter()
491   {
492     return instantDataFilter;
493   }
494
495   //----------------------------------------------------------------
496
497   void CField::solveOnlyReferenceEnabledField(bool doSending2Server)
498   {
499     CContext* context = CContext::getCurrent();
500     if (!isReferenceSolved)
501     {
502        isReferenceSolved = true;
503
504        if (context->hasClient)
505        {
506          solveRefInheritance(true);
507          if (hasDirectFieldReference()) getDirectFieldReference()->solveOnlyReferenceEnabledField(false);
508        }
509        else if (context->hasServer)
510          solveServerOperation();
511
512        solveGridReference();
513
514       if (context->hasClient)
515       {
516         solveGenerateGrid();
517         buildGridTransformationGraph();
518       }
519     }
520   }
521
522   /*!
523     Build up graph of grids which plays role of destination and source in grid transformation
524     This function should be called before \func solveGridReference()
525   */
526   void CField::buildGridTransformationGraph()
527   {
528     CContext* context = CContext::getCurrent();
529     if (context->hasClient)
530     {
531       if (grid && !grid->isTransformed() && hasDirectFieldReference() && grid != getDirectFieldReference()->grid)
532       {
533         grid->addTransGridSource(getDirectFieldReference()->grid);
534       }
535     }
536   }
537
538   /*!
539     Generate a new grid destination if there are more than one grid source pointing to a same grid destination
540   */
541   void CField::generateNewTransformationGridDest()
542   {
543     CContext* context = CContext::getCurrent();
544     if (context->hasClient)
545     {
546       std::map<CGrid*,std::pair<bool,StdString> >& gridSrcMap = grid->getTransGridSource();
547       if (1 < gridSrcMap.size())
548       {
549         // Search for grid source
550         CGrid* gridSrc = grid;
551         CField* currField = this;
552         std::vector<CField*> hieraField;
553
554         while (currField->hasDirectFieldReference() && (gridSrc == grid))
555         {
556           hieraField.push_back(currField);
557           CField* tmp = currField->getDirectFieldReference();
558           currField = tmp;
559           gridSrc = currField->grid;
560         }
561
562         if (gridSrcMap.end() != gridSrcMap.find(gridSrc))
563         {
564           CGrid* gridTmp;
565           std::pair<bool,StdString> newGridDest = gridSrcMap[gridSrc];
566           if (newGridDest.first)
567           {
568             StdString newIdGridDest = newGridDest.second;
569             if (!CGrid::has(newIdGridDest))
570             {
571                ERROR("CGrid* CGrid::generateNewTransformationGridDest()",
572                  << " Something wrong happened! Grid whose id " << newIdGridDest
573                  << "should exist ");
574             }
575             gridTmp = CGrid::get(newIdGridDest);
576           }
577           else
578           {
579             StdString newIdGridDest = CGrid::generateId(gridSrc, grid);
580             gridTmp = CGrid::cloneGrid(newIdGridDest, grid);
581
582             (gridSrcMap[gridSrc]).first = true;
583             (gridSrcMap[gridSrc]).second = newIdGridDest;
584           }
585
586           // Update all descendants
587           for (std::vector<CField*>::iterator it = hieraField.begin(); it != hieraField.end(); ++it)
588           {
589             (*it)->grid = gridTmp;
590             (*it)->updateRef((*it)->grid);
591           }
592         }
593       }
594     }
595   }
596
597   void CField::updateRef(CGrid* grid)
598   {
599     if (!grid_ref.isEmpty()) grid_ref.setValue(grid->getId());
600     else
601     {
602       std::vector<CAxis*> axisTmp = grid->getAxis();
603       std::vector<CDomain*> domainTmp = grid->getDomains();
604       if ((1<axisTmp.size()) || (1<domainTmp.size()))
605         ERROR("void CField::updateRef(CGrid* grid)",
606           << "More than one domain or axis is available for domain_ref/axis_ref of field " << this->getId());
607
608       if ((!domain_ref.isEmpty()) && (domainTmp.empty()))
609         ERROR("void CField::updateRef(CGrid* grid)",
610           << "Incoherent between available domain and domain_ref of field " << this->getId());
611       if ((!axis_ref.isEmpty()) && (axisTmp.empty()))
612         ERROR("void CField::updateRef(CGrid* grid)",
613           << "Incoherent between available axis and axis_ref of field " << this->getId());
614
615       if (!domain_ref.isEmpty()) domain_ref.setValue(domainTmp[0]->getId());
616       if (!axis_ref.isEmpty()) axis_ref.setValue(axisTmp[0]->getId());
617     }
618   }
619
620   void CField::solveAllReferenceEnabledField(bool doSending2Server)
621   {
622     CContext* context = CContext::getCurrent();
623     solveOnlyReferenceEnabledField(doSending2Server);
624
625     if (!areAllReferenceSolved)
626     {
627        areAllReferenceSolved = true;
628
629        if (context->hasClient)
630        {
631          solveRefInheritance(true);
632          if (hasDirectFieldReference()) getDirectFieldReference()->solveAllReferenceEnabledField(false);
633        }
634        else if (context->hasServer)
635          solveServerOperation();
636
637        solveGridReference();
638     }
639
640     solveGridDomainAxisRef(doSending2Server);
641
642     if (context->hasClient)
643     {
644       solveTransformedGrid();
645     }
646
647     solveCheckMaskIndex(doSending2Server);
648   }
649
650   std::map<int, StdSize> CField::getGridAttributesBufferSize()
651   {
652     return grid->getAttributesBufferSize();
653   }
654
655   std::map<int, StdSize> CField::getGridDataBufferSize()
656   {
657     return grid->getDataBufferSize(getId());
658   }
659
660   //----------------------------------------------------------------
661
662   void CField::solveServerOperation(void)
663   {
664      CContext* context = CContext::getCurrent();
665
666      if (!context->hasServer || !hasOutputFile) return;
667
668      if (freq_op.isEmpty())
669        freq_op.setValue(TimeStep);
670
671      if (freq_offset.isEmpty())
672        freq_offset.setValue(NoneDu);
673
674      freq_operation_srv = file->output_freq.getValue();
675      freq_write_srv     = file->output_freq.getValue();
676
677      lastlast_Write_srv = context->getCalendar()->getInitDate();
678      last_Write_srv     = context->getCalendar()->getInitDate();
679      last_operation_srv = context->getCalendar()->getInitDate();
680
681      const CDuration toffset = freq_operation_srv - freq_offset.getValue() - context->getCalendar()->getTimeStep();
682      last_operation_srv     = last_operation_srv - toffset;
683
684      if (operation.isEmpty())
685        ERROR("void CField::solveServerOperation(void)",
686              << "An operation must be defined for field \"" << getId() << "\".");
687
688      boost::shared_ptr<func::CFunctor> functor;
689      CArray<double, 1> dummyData;
690
691#define DECLARE_FUNCTOR(MType, mtype) \
692      if (operation.getValue().compare(#mtype) == 0) \
693      { \
694        functor.reset(new func::C##MType(dummyData)); \
695      }
696
697#include "functor_type.conf"
698
699      if (!functor)
700        ERROR("void CField::solveServerOperation(void)",
701              << "\"" << operation << "\" is not a valid operation.");
702
703      operationTimeType = functor->timeType();
704   }
705
706   //----------------------------------------------------------------
707
708   /*!
709    * Constructs the graph filter for the field, enabling or not the data output.
710    * This method should not be called more than once with enableOutput equal to true.
711    *
712    * \param gc the garbage collector to use when building the filter graph
713    * \param enableOutput must be true when the field data is to be
714    *                     read by the client or/and written to a file
715    */
716   void CField::buildFilterGraph(CGarbageCollector& gc, bool enableOutput)
717   {
718     if (!areAllReferenceSolved) solveAllReferenceEnabledField(false);
719
720     // Start by building a filter which can provide the field's instant data
721     if (!instantDataFilter)
722     {
723       // Check if we have an expression to parse
724       if (!content.empty())
725       {
726         boost::scoped_ptr<IFilterExprNode> expr(parseExpr(content + '\0'));
727         instantDataFilter = expr->reduce(gc, *this);
728       }
729       // Check if we have a reference on another field
730       else if (!field_ref.isEmpty())
731         instantDataFilter = getFieldReference(gc);
732       // Check if the data is to be read from a file
733       else if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read)
734         instantDataFilter = serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(grid,
735                                                                                                     freq_offset.isEmpty() ? NoneDu : freq_offset));
736       else // The data might be passed from the model
737         instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(grid));
738     }
739
740     // If the field data is to be read by the client or/and written to a file
741     if (enableOutput && !storeFilter && !fileWriterFilter)
742     {
743       if (!read_access.isEmpty() && read_access)
744       {
745         storeFilter = boost::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid));
746         instantDataFilter->connectOutput(storeFilter, 0);
747       }
748
749       if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
750       {
751         fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
752         getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0);
753       }
754     }
755   }
756
757   /*!
758    * Returns the filter needed to handle the field reference.
759    * This method should only be called when building the filter graph corresponding to the field.
760    *
761    * \param gc the garbage collector to use
762    * \return the output pin corresponding to the field reference
763    */
764   boost::shared_ptr<COutputPin> CField::getFieldReference(CGarbageCollector& gc)
765   {
766     if (instantDataFilter || field_ref.isEmpty())
767       ERROR("COutputPin* CField::getFieldReference(CGarbageCollector& gc)",
768             "Impossible to get the field reference for a field which has already been parsed or which does not have a field_ref.");
769
770     CField* fieldRef = CField::get(field_ref);
771     fieldRef->buildFilterGraph(gc, false);
772
773     std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters;
774     // Check if a spatial transformation is needed
775     if (grid && grid != fieldRef->grid && grid->hasTransform())
776     {
777       double defaultValue = 0.0;
778       if (!default_value.isEmpty()) defaultValue = this->default_value;
779       filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, defaultValue);
780     }
781
782     else
783       filters.first = filters.second = boost::shared_ptr<CFilter>(new CPassThroughFilter(gc));
784
785     fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0);
786
787     return filters.second;
788   }
789
790   /*!
791    * Returns the filter needed to handle a self reference in the field's expression.
792    * If the needed filter does not exist, it is created, otherwise it is reused.
793    * This method should only be called when building the filter graph corresponding
794    * to the field's expression.
795    *
796    * \param gc the garbage collector to use
797    * \return the output pin corresponding to a self reference
798    */
799   boost::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc)
800   {
801     if (instantDataFilter || content.empty())
802       ERROR("COutputPin* CField::getSelfReference(CGarbageCollector& gc)",
803             "Impossible to add a self reference to a field which has already been parsed or which does not have an expression.");
804
805     if (!selfReferenceFilter)
806     {
807       if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read)
808       {
809         if (!serverSourceFilter)
810           serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(grid,
811                                                                                   freq_offset.isEmpty() ? NoneDu : freq_offset));
812
813         selfReferenceFilter = serverSourceFilter;
814       }
815       else if (!field_ref.isEmpty())
816         selfReferenceFilter = getFieldReference(gc);
817       else
818       {
819         if (!clientSourceFilter)
820           clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(grid));
821
822         selfReferenceFilter = clientSourceFilter;
823       }
824     }
825
826     return selfReferenceFilter;
827   }
828
829   /*!
830    * Returns the temporal filter corresponding to the field's temporal operation
831    * for the specified operation frequency. The filter is created if it does not
832    * exist, otherwise it is reused.
833    *
834    * \param gc the garbage collector to use
835    * \param outFreq the operation frequency, i.e. the frequency at which the output data will be computed
836    * \return the output pin corresponding to the requested temporal filter
837    */
838   boost::shared_ptr<COutputPin> CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
839   {
840     std::map<CDuration, boost::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq);
841
842     if (it == temporalDataFilters.end())
843     {
844       if (operation.isEmpty())
845         ERROR("void CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)",
846               << "An operation must be defined for field \"" << getId() << "\".");
847
848       if (freq_op.isEmpty())
849         freq_op.setValue(TimeStep);
850       if (freq_offset.isEmpty())
851         freq_offset.setValue(NoneDu);
852
853       const bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
854
855       boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
856                                                                             CContext::getCurrent()->getCalendar()->getInitDate(),
857                                                                             freq_op, freq_offset, outFreq,
858                                                                             ignoreMissingValue, ignoreMissingValue ? default_value : 0.0));
859       instantDataFilter->connectOutput(temporalFilter, 0);
860
861       it = temporalDataFilters.insert(std::make_pair(outFreq, temporalFilter)).first;
862     }
863
864     return it->second;
865   }
866
867   //----------------------------------------------------------------
868/*
869   void CField::fromBinary(StdIStream& is)
870   {
871      SuperClass::fromBinary(is);
872#define CLEAR_ATT(name_)\
873      SuperClassAttribute::operator[](#name_)->reset()
874
875         CLEAR_ATT(domain_ref);
876         CLEAR_ATT(axis_ref);
877#undef CLEAR_ATT
878
879   }
880*/
881   //----------------------------------------------------------------
882
883   void CField::solveGridReference(void)
884   {
885      if (grid_ref.isEmpty() && domain_ref.isEmpty() && axis_ref.isEmpty() && scalar_ref.isEmpty())
886      {
887        ERROR("CField::solveGridReference(void)",
888              << "A grid must be defined for field '" << getFieldOutputName() << "' .");
889      }
890      else if (!grid_ref.isEmpty() && (!domain_ref.isEmpty() || !axis_ref.isEmpty() || !scalar_ref.isEmpty()))
891      {
892        ERROR("CField::solveGridReference(void)",
893              << "Field '" << getFieldOutputName() << "' has both a grid and a domain/axis/scalar." << std::endl
894              << "Please define either 'grid_ref' or 'domain_ref'/'axis_ref'/'scalar_ref'.");
895      }
896
897      if (grid_ref.isEmpty())
898      {
899        std::vector<CDomain*> vecDom;
900        std::vector<CAxis*> vecAxis;
901        std::vector<CScalar*> vecScalar;
902        std::vector<int> axisDomainOrderTmp;
903       
904        if (!domain_ref.isEmpty())
905        {
906          StdString tmp = domain_ref.getValue();
907          if (CDomain::has(domain_ref))
908          {
909            vecDom.push_back(CDomain::get(domain_ref));
910            axisDomainOrderTmp.push_back(2);
911          }
912          else
913            ERROR("CField::solveGridReference(void)",
914                  << "Invalid reference to domain '" << domain_ref.getValue() << "'.");
915        }
916
917        if (!axis_ref.isEmpty())
918        {
919          if (CAxis::has(axis_ref))
920          {
921            vecAxis.push_back(CAxis::get(axis_ref));
922            axisDomainOrderTmp.push_back(1);
923          }
924          else
925            ERROR("CField::solveGridReference(void)",
926                  << "Invalid reference to axis '" << axis_ref.getValue() << "'.");
927        }
928
929        if (!scalar_ref.isEmpty())
930        {
931          if (CScalar::has(scalar_ref))
932          {
933            vecScalar.push_back(CScalar::get(scalar_ref));
934            axisDomainOrderTmp.push_back(0);
935          }
936          else
937            ERROR("CField::solveGridReference(void)",
938                  << "Invalid reference to scalar '" << scalar_ref.getValue() << "'.");
939        }
940       
941        CArray<int,1> axisDomainOrder(axisDomainOrderTmp.size());
942        for (int idx = 0; idx < axisDomainOrderTmp.size(); ++idx)
943        {
944          axisDomainOrder(idx) = axisDomainOrderTmp[idx];
945        }
946
947        // Warning: the gridId shouldn't be set as the grid_ref since it could be inherited
948        StdString gridId = CGrid::generateId(vecDom, vecAxis, vecScalar,axisDomainOrder);
949        if (CGrid::has(gridId))
950          this->grid = CGrid::get(gridId);
951        else
952          this->grid = CGrid::createGrid(gridId, vecDom, vecAxis, vecScalar,axisDomainOrder);
953      }
954      else
955      {
956        if (CGrid::has(grid_ref))
957          this->grid = CGrid::get(grid_ref);
958        else
959          ERROR("CField::solveGridReference(void)",
960                << "Invalid reference to grid '" << grid_ref.getValue() << "'.");
961      }
962   }
963
964   void CField::solveGridDomainAxisRef(bool checkAtt)
965   {
966     grid->solveDomainAxisRef(checkAtt);
967   }
968
969   void CField::solveCheckMaskIndex(bool doSendingIndex)
970   {
971     grid->checkMaskIndex(doSendingIndex);
972   }
973
974   void CField::solveTransformedGrid()
975   {
976     if (grid && !grid->isTransformed() && hasDirectFieldReference() && grid != getDirectFieldReference()->grid)
977     {
978       std::vector<CGrid*> grids;
979       // Source grid
980       grids.push_back(getDirectFieldReference()->grid);
981       // Intermediate grids
982       if (!grid_path.isEmpty())
983       {
984         std::string gridId;
985         size_t start = 0, end;
986
987         do
988         {
989           end = grid_path.getValue().find(',', start);
990           if (end != std::string::npos)
991           {
992             gridId = grid_path.getValue().substr(start, end - start);
993             start = end + 1;
994           }
995           else
996             gridId = grid_path.getValue().substr(start);
997
998           if (!CGrid::has(gridId))
999             ERROR("void CField::solveTransformedGrid()",
1000                   << "Invalid grid_path, the grid '" << gridId << "' does not exist.");
1001
1002           grids.push_back(CGrid::get(gridId));
1003         }
1004         while (end != std::string::npos);
1005       }
1006       // Destination grid
1007       grids.push_back(grid);
1008
1009       for (size_t i = 0, count = grids.size() - 1; i < count; ++i)
1010       {
1011         CGrid *gridSrc  = grids[i];
1012         CGrid *gridDest = grids[i + 1];
1013         if (!gridDest->isTransformed())
1014           gridDest->transformGrid(gridSrc);
1015       }
1016     }
1017     else if (grid && grid->hasTransform() && !grid->isTransformed())
1018     {
1019       grid->transformGrid(grid);
1020     }
1021   }
1022
1023   void CField::solveGenerateGrid()
1024   {
1025     if (grid && !grid->isTransformed() && hasDirectFieldReference() && grid != getDirectFieldReference()->grid)
1026       grid->completeGrid(getDirectFieldReference()->grid);
1027     else
1028       grid->completeGrid();
1029   }
1030
1031   void CField::solveGridDomainAxisBaseRef()
1032   {
1033     grid->solveDomainAxisRef(false);
1034     grid->solveDomainAxisBaseRef();
1035   }
1036
1037   ///-------------------------------------------------------------------
1038
1039   template <>
1040   void CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)
1041   {
1042      if (this->group_ref.isEmpty()) return;
1043      StdString gref = this->group_ref.getValue();
1044
1045      if (!CFieldGroup::has(gref))
1046         ERROR("CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)",
1047               << "[ gref = " << gref << "]"
1048               << " invalid group name !");
1049
1050      CFieldGroup* group = CFieldGroup::get(gref);
1051      CFieldGroup* owner = CFieldGroup::get(boost::polymorphic_downcast<CFieldGroup*>(this));
1052
1053      std::vector<CField*> allChildren  = group->getAllChildren();
1054      std::vector<CField*>::iterator it = allChildren.begin(), end = allChildren.end();
1055
1056      for (; it != end; it++)
1057      {
1058         CField* child = *it;
1059         if (child->hasId()) owner->createChild()->field_ref.setValue(child->getId());
1060
1061      }
1062   }
1063
1064   void CField::scaleFactorAddOffset(double scaleFactor, double addOffset)
1065   {
1066     map<int, CArray<double,1> >::iterator it;
1067     for (it = data_srv.begin(); it != data_srv.end(); it++) it->second = (it->second - addOffset) / scaleFactor;
1068   }
1069
1070   void CField::invertScaleFactorAddOffset(double scaleFactor, double addOffset)
1071   {
1072     map<int, CArray<double,1> >::iterator it;
1073     for (it = data_srv.begin(); it != data_srv.end(); it++) it->second = it->second * scaleFactor + addOffset;
1074   }
1075
1076   void CField::outputField(CArray<double,3>& fieldOut)
1077   {
1078      map<int, CArray<double,1> >::iterator it;
1079      for (it = data_srv.begin(); it != data_srv.end(); it++)
1080      {
1081        grid->outputField(it->first, it->second, fieldOut.dataFirst());
1082      }
1083   }
1084
1085   void CField::outputField(CArray<double,2>& fieldOut)
1086   {
1087      map<int, CArray<double,1> >::iterator it;
1088      for(it=data_srv.begin();it!=data_srv.end();it++)
1089      {
1090         grid->outputField(it->first, it->second, fieldOut.dataFirst());
1091      }
1092   }
1093
1094   void CField::outputField(CArray<double,1>& fieldOut)
1095   {
1096      map<int, CArray<double,1> >::iterator it;
1097
1098      for (it = data_srv.begin(); it != data_srv.end(); it++)
1099      {
1100         grid->outputField(it->first, it->second, fieldOut.dataFirst());
1101      }
1102   }
1103
1104   void CField::inputField(CArray<double,3>& fieldOut)
1105   {
1106      map<int, CArray<double,1> >::iterator it;
1107      for (it = data_srv.begin(); it != data_srv.end(); it++)
1108      {
1109        grid->inputField(it->first, fieldOut.dataFirst(), it->second);
1110      }
1111   }
1112
1113   void CField::inputField(CArray<double,2>& fieldOut)
1114   {
1115      map<int, CArray<double,1> >::iterator it;
1116      for(it = data_srv.begin(); it != data_srv.end(); it++)
1117      {
1118         grid->inputField(it->first, fieldOut.dataFirst(), it->second);
1119      }
1120   }
1121
1122   void CField::inputField(CArray<double,1>& fieldOut)
1123   {
1124      map<int, CArray<double,1> >::iterator it;
1125      for (it = data_srv.begin(); it != data_srv.end(); it++)
1126      {
1127         grid->inputField(it->first, fieldOut.dataFirst(), it->second);
1128      }
1129   }
1130
1131   void CField::outputCompressedField(CArray<double,1>& fieldOut)
1132   {
1133      map<int, CArray<double,1> >::iterator it;
1134
1135      for (it = data_srv.begin(); it != data_srv.end(); it++)
1136      {
1137         grid->outputCompressedField(it->first, it->second, fieldOut.dataFirst());
1138      }
1139   }
1140
1141   ///-------------------------------------------------------------------
1142
1143   void CField::parse(xml::CXMLNode& node)
1144   {
1145      SuperClass::parse(node);
1146      if (!node.getContent(this->content))
1147      {
1148        if (node.goToChildElement())
1149        {
1150          do
1151          {
1152            if (node.getElementName() == "variable" || node.getElementName() == "variable_group") this->getVirtualVariableGroup()->parseChild(node);
1153          } while (node.goToNextElement());
1154          node.goToParentElement();
1155        }
1156      }
1157    }
1158
1159   /*!
1160     This function retrieves Id of corresponding domain_ref and axis_ref (if any)
1161   of a field. In some cases, only domain exists but axis doesn't
1162   \return pair of Domain and Axis id
1163   */
1164   const std::vector<StdString>& CField::getRefDomainAxisIds()
1165   {
1166     CGrid* cgPtr = getRelGrid();
1167     if (NULL != cgPtr)
1168     {
1169       std::vector<StdString>::iterator it;
1170       if (!domain_ref.isEmpty())
1171       {
1172         std::vector<StdString> domainList = cgPtr->getDomainList();
1173         it = std::find(domainList.begin(), domainList.end(), domain_ref.getValue());
1174         if (domainList.end() != it) domAxisScalarIds_[0] = *it;
1175       }
1176
1177       if (!axis_ref.isEmpty())
1178       {
1179         std::vector<StdString> axisList = cgPtr->getAxisList();
1180         it = std::find(axisList.begin(), axisList.end(), axis_ref.getValue());
1181         if (axisList.end() != it) domAxisScalarIds_[1] = *it;
1182       }
1183
1184       if (!scalar_ref.isEmpty())
1185       {
1186         std::vector<StdString> scalarList = cgPtr->getScalarList();
1187         it = std::find(scalarList.begin(), scalarList.end(), scalar_ref.getValue());
1188         if (scalarList.end() != it) domAxisScalarIds_[2] = *it;
1189       }
1190     }
1191     return (domAxisScalarIds_);
1192   }
1193
1194   CVariable* CField::addVariable(const string& id)
1195   {
1196     return vVariableGroup->createChild(id);
1197   }
1198
1199   CVariableGroup* CField::addVariableGroup(const string& id)
1200   {
1201     return vVariableGroup->createChildGroup(id);
1202   }
1203
1204   void CField::sendAddAllVariables()
1205   {
1206     std::vector<CVariable*> allVar = getAllVariables();
1207     std::vector<CVariable*>::const_iterator it = allVar.begin();
1208     std::vector<CVariable*>::const_iterator itE = allVar.end();
1209
1210     for (; it != itE; ++it)
1211     {
1212       this->sendAddVariable((*it)->getId());
1213       (*it)->sendAllAttributesToServer();
1214       (*it)->sendValue();
1215     }
1216   }
1217
1218   void CField::sendAddVariable(const string& id)
1219   {
1220    CContext* context = CContext::getCurrent();
1221
1222    if (!context->hasServer)
1223    {
1224       CContextClient* client = context->client;
1225
1226       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE);
1227       if (client->isServerLeader())
1228       {
1229         CMessage msg;
1230         msg << this->getId();
1231         msg << id;
1232         const std::list<int>& ranks = client->getRanksServerLeader();
1233         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
1234           event.push(*itRank,1,msg);
1235         client->sendEvent(event);
1236       }
1237       else client->sendEvent(event);
1238    }
1239   }
1240
1241   void CField::sendAddVariableGroup(const string& id)
1242   {
1243    CContext* context = CContext::getCurrent();
1244    if (!context->hasServer)
1245    {
1246       CContextClient* client = context->client;
1247
1248       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE_GROUP);
1249       if (client->isServerLeader())
1250       {
1251         CMessage msg;
1252         msg << this->getId();
1253         msg << id;
1254         const std::list<int>& ranks = client->getRanksServerLeader();
1255         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
1256           event.push(*itRank,1,msg);
1257         client->sendEvent(event);
1258       }
1259       else client->sendEvent(event);
1260    }
1261   }
1262
1263   void CField::recvAddVariable(CEventServer& event)
1264   {
1265
1266      CBufferIn* buffer = event.subEvents.begin()->buffer;
1267      string id;
1268      *buffer >> id;
1269      get(id)->recvAddVariable(*buffer);
1270   }
1271
1272   void CField::recvAddVariable(CBufferIn& buffer)
1273   {
1274      string id;
1275      buffer >> id;
1276      addVariable(id);
1277   }
1278
1279   void CField::recvAddVariableGroup(CEventServer& event)
1280   {
1281
1282      CBufferIn* buffer = event.subEvents.begin()->buffer;
1283      string id;
1284      *buffer >> id;
1285      get(id)->recvAddVariableGroup(*buffer);
1286   }
1287
1288   void CField::recvAddVariableGroup(CBufferIn& buffer)
1289   {
1290      string id;
1291      buffer >> id;
1292      addVariableGroup(id);
1293   }
1294
1295   DEFINE_REF_FUNC(Field,field)
1296} // namespace xios
Note: See TracBrowser for help on using the repository browser.