source: XIOS/trunk/src/node/axis.cpp @ 670

Last change on this file since 670 was 670, checked in by rlacroix, 6 years ago

Fix index computation for distributed axis.

Typo in r667.

  • 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: 21.4 KB
Line 
1#include "axis.hpp"
2
3#include "attribute_template.hpp"
4#include "object_template.hpp"
5#include "group_template.hpp"
6#include "message.hpp"
7#include "type.hpp"
8#include "context.hpp"
9#include "context_client.hpp"
10#include "xios_spl.hpp"
11#include "inverse_axis.hpp"
12#include "zoom_axis.hpp"
13#include "interpolate_axis.hpp"
14#include "server_distribution_description.hpp"
15#include "client_server_mapping_distributed.hpp"
16
17namespace xios {
18
19   /// ////////////////////// Définitions ////////////////////// ///
20
21   CAxis::CAxis(void)
22      : CObjectTemplate<CAxis>()
23      , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
24      , isDistributed_(false), hasBounds_(false)
25      , transformationMap_(), global_zoom_begin(0), global_zoom_size(0)
26   {
27   }
28
29   CAxis::CAxis(const StdString & id)
30      : CObjectTemplate<CAxis>(id)
31      , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
32      , isDistributed_(false), hasBounds_(false)
33      , transformationMap_(), global_zoom_begin(0), global_zoom_size(0)
34   {
35   }
36
37   CAxis::~CAxis(void)
38   { /* Ne rien faire de plus */ }
39
40   ///---------------------------------------------------------------
41
42   const std::set<StdString> & CAxis::getRelFiles(void) const
43   {
44      return (this->relFiles);
45   }
46
47   bool CAxis::IsWritten(const StdString & filename) const
48   {
49      return (this->relFiles.find(filename) != this->relFiles.end());
50   }
51
52   bool CAxis::isDistributed(void) const
53   {
54      return isDistributed_;
55   }
56
57   void CAxis::addRelFile(const StdString & filename)
58   {
59      this->relFiles.insert(filename);
60   }
61
62   //----------------------------------------------------------------
63
64   StdString CAxis::GetName(void)   { return (StdString("axis")); }
65   StdString CAxis::GetDefName(void){ return (CAxis::GetName()); }
66   ENodeType CAxis::GetType(void)   { return (eAxis); }
67
68   //----------------------------------------------------------------
69
70   CAxis* CAxis::createAxis()
71   {
72     CAxis* axis = CAxisGroup::get("axis_definition")->createChild();
73     return axis;
74   }
75
76   void CAxis::checkAttributes(void)
77   {
78      if (this->n_glo.isEmpty())
79         ERROR("CAxis::checkAttributes(void)",
80               << "Attribute <n_glo> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be specified");
81      StdSize size = this->n_glo.getValue();
82
83      isDistributed_ = !this->begin.isEmpty() || !this->n.isEmpty();
84
85      if (!this->begin.isEmpty())
86      {
87        StdSize ibegin = this->begin.getValue();
88        if ((ibegin < 0) || (ibegin > size-1))
89          ERROR("CAxis::checkAttributes(void)",
90                << "Attribute <ibegin> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be non-negative and smaller than size-1");
91      }
92      else this->begin.setValue(0);
93
94      if (!this->n.isEmpty())
95      {
96        StdSize ni = this->n.getValue();
97        if ((ni < 0) || (ni > size))
98          ERROR("CAxis::checkAttributes(void)",
99                << "Attribute <ni> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be non-negative and smaller than size");
100      }
101      else this->n.setValue(size);
102
103      StdSize true_size = value.numElements();
104      if (this->n.getValue() != true_size)
105         ERROR("CAxis::checkAttributes(void)",
106               << "The array \'value\' of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] has a different size that the one defined by the \'size\' attribute");
107
108      this->checkData();
109      this->checkZoom();
110      this->checkMask();
111      this->checkBounds();
112   }
113
114   void CAxis::checkData()
115   {
116      if (data_begin.isEmpty()) data_begin.setValue(0);
117      if (!data_n.isEmpty() && data_n.getValue() <= 0)
118      {
119        ERROR("CAxis::checkData(void)",
120              << "Data dimension is negative (data_n).");
121      }
122      else if (data_n.isEmpty())
123        data_n.setValue(n.getValue());
124
125      if (data_index.isEmpty())
126      {
127        int dn = data_n.getValue();
128        data_index.resize(dn);
129        for (int i = 0; i < dn; ++i) data_index(i) = i;
130      }
131   }
132
133   void CAxis::checkZoom(void)
134   {
135     if (0 == global_zoom_size) global_zoom_size = this->n_glo.getValue();
136   }
137
138   void CAxis::checkMask()
139   {
140      if (!mask.isEmpty())
141      {
142         if (mask.extent(0) != n)
143            ERROR("CAxis::checkMask(void)",
144                  << "the mask has not the same size than the local axis" << endl
145                  << "Local size is " << n << "x" << endl
146                  << "Mask size is " << mask.extent(0) << "x");
147      }
148      else // (!mask.hasValue())
149      { // Si aucun masque n'est défini,
150        // on en crée un nouveau qui valide l'intégralité du domaine.
151         mask.resize(n);
152         for (int i = 0; i < n.getValue(); ++i)
153         {
154           mask(i) = true;
155         }
156      }
157   }
158
159  void CAxis::checkBounds()
160  {
161    if (!bounds.isEmpty())
162    {
163      if (bounds.extent(0) != n || bounds.extent(1) != 2)
164          ERROR("CAxis::checkAttributes(void)",
165                << "The bounds array of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be of dimension axis size x 2" << endl
166                << "Axis size is " << n << endl
167                << "Bounds size is "<< bounds.extent(0) << " x " << bounds.extent(1));
168      hasBounds_ = true;
169    }
170    else hasBounds_ = false;
171  }
172
173
174  bool CAxis::dispatchEvent(CEventServer& event)
175   {
176      if (SuperClass::dispatchEvent(event)) return true;
177      else
178      {
179        switch(event.type)
180        {
181           case EVENT_ID_SERVER_ATTRIBUT :
182             recvServerAttribut(event);
183             return true;
184             break;
185           case EVENT_ID_INDEX:
186            recvIndex(event);
187            return true;
188            break;
189          case EVENT_ID_DISTRIBUTED_VALUE:
190            recvDistributedValue(event);
191            return true;
192            break;
193          case EVENT_ID_NON_DISTRIBUTED_VALUE:
194            recvNonDistributedValue(event);
195            return true;
196            break;
197           default :
198             ERROR("bool CContext::dispatchEvent(CEventServer& event)",
199                    << "Unknown Event");
200           return false;
201         }
202      }
203   }
204
205   void CAxis::checkAttributesOnClient(const std::vector<int>& globalDim, int orderPositionInGrid,
206                                       CServerDistributionDescription::ServerDistributionType distType)
207   {
208     if (this->areClientAttributesChecked_) return;
209
210     this->checkAttributes();
211
212     this->areClientAttributesChecked_ = true;
213   }
214
215   // Send all checked attributes to server
216   void CAxis::sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
217                                     CServerDistributionDescription::ServerDistributionType distType)
218   {
219     if (!this->areClientAttributesChecked_) checkAttributesOnClient(globalDim,
220                                                                     orderPositionInGrid,
221                                                                     distType);
222     CContext* context = CContext::getCurrent();
223
224     if (this->isChecked) return;
225     if (context->hasClient)
226     {
227       sendServerAttribut(globalDim, orderPositionInGrid, distType);
228       sendValue();
229     }
230
231     this->isChecked = true;
232   }
233
234  void CAxis::sendValue()
235  {
236     if (n.getValue() == n_glo.getValue())
237     {
238       sendNonDistributedValue();
239     }
240     else
241     {
242       computeConnectedServer();
243       sendDistributedValue();
244     }
245  }
246
247  void CAxis::computeConnectedServer()
248  {
249    CContext* context = CContext::getCurrent();
250    CContextClient* client = context->client;
251    int nbServer = client->serverSize;
252    int range, clientSize = client->clientSize;
253
254    size_t ni = this->n.getValue();
255    size_t ibegin = this->begin.getValue();
256    size_t zoom_end = global_zoom_begin+global_zoom_size-1;
257    size_t nZoomCount = 0;
258    for (size_t idx = 0; idx < ni; ++idx)
259    {
260      size_t globalIndex = ibegin + idx;
261
262      if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end) ++nZoomCount;
263    }
264
265    CArray<size_t,1> globalIndexAxis(ni);
266    std::vector<size_t> globalAxisZoom(nZoomCount);
267    nZoomCount = 0;
268    for (size_t idx = 0; idx < ni; ++idx)
269    {
270      size_t globalIndex = ibegin + idx;
271      globalIndexAxis(idx) = globalIndex;
272      if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end)
273      {
274        globalAxisZoom[nZoomCount] = globalIndex;
275        ++nZoomCount;
276      }
277    }
278
279    std::vector<int> nGlobDomain(1);
280    nGlobDomain[0] = n_glo.getValue();
281
282    size_t globalSizeIndex = 1, indexBegin, indexEnd;
283    for (int i = 0; i < nGlobDomain.size(); ++i) globalSizeIndex *= nGlobDomain[i];
284    indexBegin = 0;
285    for (int i = 0; i < clientSize; ++i)
286    {
287      range = globalSizeIndex / clientSize;
288      if (i < (globalSizeIndex%clientSize)) ++range;
289      if (i == client->clientRank) break;
290      indexBegin += range;
291    }
292    indexEnd = indexBegin + range - 1;
293
294    CServerDistributionDescription serverDescription(nGlobDomain);
295    serverDescription.computeServerGlobalIndexInRange(nbServer, std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
296    CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm);
297    clientServerMap->computeServerIndexMapping(globalIndexAxis);
298    const std::map<int, std::vector<size_t> >& globalIndexAxisOnServer = clientServerMap->getGlobalIndexOnServer();
299
300    std::map<int, std::vector<size_t> >::const_iterator it = globalIndexAxisOnServer.begin(),
301                                                       ite = globalIndexAxisOnServer.end();
302    std::vector<size_t>::const_iterator itbVec = (globalAxisZoom).begin(),
303                                        iteVec = (globalAxisZoom).end();
304    indSrv_.clear();
305    for (; it != ite; ++it)
306    {
307      int rank = it->first;
308      const std::vector<size_t>& globalIndexTmp = it->second;
309      int nb = globalIndexTmp.size();
310
311      for (int i = 0; i < nb; ++i)
312      {
313        if (std::binary_search(itbVec, iteVec, globalIndexTmp[i]))
314        {
315          indSrv_[rank].push_back(globalIndexTmp[i]);
316        }
317      }
318    }
319
320    connectedServerRank_.clear();
321    for (it = globalIndexAxisOnServer.begin(); it != ite; ++it) {
322      connectedServerRank_.push_back(it->first);
323    }
324
325    if (!indSrv_.empty())
326    {
327      connectedServerRank_.clear();
328      for (it = indSrv_.begin(); it != indSrv_.end(); ++it)
329        connectedServerRank_.push_back(it->first);
330    }
331    nbConnectedClients_ = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_);
332    delete clientServerMap;
333  }
334
335  void CAxis::sendNonDistributedValue()
336  {
337    CContext* context = CContext::getCurrent();
338    CContextClient* client = context->client;
339    CEventClient event(getType(),EVENT_ID_NON_DISTRIBUTED_VALUE);
340
341    int zoom_end = global_zoom_begin+global_zoom_size-1;
342    int nb =0;
343    for (size_t idx = 0; idx < n; ++idx)
344    {
345      size_t globalIndex = begin + idx;
346      if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end) ++nb;
347    }
348
349    CArray<double,1> val(nb);
350    nb = 0;
351    for (size_t idx = 0; idx < n; ++idx)
352    {
353      size_t globalIndex = begin + idx;
354      if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end)
355      {
356        val(nb) = value(idx);
357        ++nb;
358      }
359    }
360
361    if (client->isServerLeader())
362    {
363      std::list<CMessage> msgs;
364
365      const std::list<int>& ranks = client->getRanksServerLeader();
366      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
367      {
368        // Use const int to ensure CMessage holds a copy of the value instead of just a reference
369        msgs.push_back(CMessage());
370        CMessage& msg = msgs.back();
371        msg << this->getId();
372        msg << val;
373        event.push(*itRank,1,msg);
374      }
375      client->sendEvent(event);
376    }
377    else client->sendEvent(event);
378  }
379
380  void CAxis::sendDistributedValue(void)
381  {
382    int ns, n, i, j, ind, nv, idx;
383    CContext* context = CContext::getCurrent();
384    CContextClient* client=context->client;
385
386    // send value for each connected server
387    CEventClient eventIndex(getType(), EVENT_ID_INDEX);
388    CEventClient eventVal(getType(), EVENT_ID_DISTRIBUTED_VALUE);
389
390    list<CMessage> list_msgsIndex, list_msgsVal;
391    list<CArray<int,1> > list_indi;
392    list<CArray<double,1> > list_val;
393    list<CArray<double,2> > list_bounds;
394
395    std::map<int, std::vector<size_t> >::const_iterator it, iteMap;
396    iteMap = indSrv_.end();
397    for (int k = 0; k < connectedServerRank_.size(); ++k)
398    {
399      int nbData = 0;
400      int rank = connectedServerRank_[k];
401      it = indSrv_.find(rank);
402      if (iteMap != it)
403        nbData = it->second.size();
404
405      list_indi.push_back(CArray<int,1>(nbData));
406      list_val.push_back(CArray<double,1>(nbData));
407
408      if (hasBounds_)
409      {
410        list_bounds.push_back(CArray<double,2>(2,nbData));
411      }
412
413      CArray<int,1>& indi = list_indi.back();
414      CArray<double,1>& val = list_val.back();
415
416      for (n = 0; n < nbData; ++n)
417      {
418        idx = static_cast<int>(it->second[n]);
419        ind = idx - begin;
420
421        val(n) = value(ind);
422        indi(n) = idx;
423
424        if (hasBounds_)
425        {
426          CArray<double,2>& boundsVal = list_bounds.back();
427          boundsVal(0, n) = bounds(0,n);
428          boundsVal(1, n) = bounds(1,n);
429        }
430      }
431
432      list_msgsIndex.push_back(CMessage());
433      list_msgsIndex.back() << this->getId() << list_indi.back();
434
435      list_msgsVal.push_back(CMessage());
436      list_msgsVal.back() << this->getId() << list_val.back();
437
438      if (hasBounds_)
439      {
440        list_msgsVal.back() << list_bounds.back();
441      }
442
443      eventIndex.push(rank, nbConnectedClients_[rank], list_msgsIndex.back());
444      eventVal.push(rank, nbConnectedClients_[rank], list_msgsVal.back());
445    }
446
447    client->sendEvent(eventIndex);
448    client->sendEvent(eventVal);
449  }
450
451  void CAxis::recvIndex(CEventServer& event)
452  {
453    list<CEventServer::SSubEvent>::iterator it;
454    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
455    {
456      CBufferIn* buffer = it->buffer;
457      string domainId;
458      *buffer >> domainId;
459      get(domainId)->recvIndex(it->rank, *buffer);
460    }
461  }
462
463  void CAxis::recvIndex(int rank, CBufferIn& buffer)
464  {
465    buffer >> indiSrv_[rank];
466  }
467
468  void CAxis::recvDistributedValue(CEventServer& event)
469  {
470    list<CEventServer::SSubEvent>::iterator it;
471    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
472    {
473      CBufferIn* buffer = it->buffer;
474      string domainId;
475      *buffer >> domainId;
476      get(domainId)->recvDistributedValue(it->rank, *buffer);
477    }
478  }
479
480  void CAxis::recvDistributedValue(int rank, CBufferIn& buffer)
481  {
482    CArray<int,1> &indi = indiSrv_[rank];
483    CArray<double,1> val;
484    CArray<double,2> boundsVal;
485
486    buffer >> val;
487    if (hasBounds_) buffer >> boundsVal;
488
489    int i, j, ind_srv;
490    for (int ind = 0; ind < indi.numElements(); ++ind)
491    {
492      i = indi(ind);
493      ind_srv = i - zoom_begin_srv;
494      value_srv(ind_srv) = val(ind);
495      if (hasBounds_)
496      {
497        bound_srv(0,ind_srv) = boundsVal(0, ind);
498        bound_srv(1,ind_srv) = boundsVal(1, ind);
499      }
500    }
501  }
502
503   void CAxis::recvNonDistributedValue(CEventServer& event)
504  {
505    list<CEventServer::SSubEvent>::iterator it;
506    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
507    {
508      CBufferIn* buffer = it->buffer;
509      string domainId;
510      *buffer >> domainId;
511      get(domainId)->recvNonDistributedValue(it->rank, *buffer);
512    }
513  }
514
515  void CAxis::recvNonDistributedValue(int rank, CBufferIn& buffer)
516  {
517    CArray<double,1> val;
518    buffer >> val;
519
520    for (int ind = 0; ind < val.numElements(); ++ind)
521    {
522      value_srv(ind) = val(ind);
523      if (hasBounds_)
524      {
525        bound_srv(0,ind) = bounds(0,ind);
526        bound_srv(1,ind) = bounds(1,ind);
527      }
528    }
529  }
530
531  void CAxis::sendServerAttribut(const std::vector<int>& globalDim, int orderPositionInGrid,
532                                 CServerDistributionDescription::ServerDistributionType distType)
533  {
534    CContext* context = CContext::getCurrent();
535    CContextClient* client = context->client;
536
537    CServerDistributionDescription serverDescription(globalDim);
538
539    int nbServer = client->serverSize;
540
541    serverDescription.computeServerDistribution(nbServer, false, distType);
542    std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
543    std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes();
544
545    CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT);
546    if (client->isServerLeader())
547    {
548      std::list<CMessage> msgs;
549
550      const std::list<int>& ranks = client->getRanksServerLeader();
551      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
552      {
553        // Use const int to ensure CMessage holds a copy of the value instead of just a reference
554        const int begin = serverIndexBegin[*itRank][orderPositionInGrid];
555        const int ni    = serverDimensionSizes[*itRank][orderPositionInGrid];
556        const int end   = begin + ni - 1;
557
558        msgs.push_back(CMessage());
559        CMessage& msg = msgs.back();
560        msg << this->getId();
561        msg << ni << begin << end;
562        msg << global_zoom_begin << global_zoom_size;
563
564        event.push(*itRank,1,msg);
565      }
566      client->sendEvent(event);
567    }
568    else client->sendEvent(event);
569  }
570
571  void CAxis::recvServerAttribut(CEventServer& event)
572  {
573    CBufferIn* buffer = event.subEvents.begin()->buffer;
574    string axisId;
575    *buffer >> axisId;
576    get(axisId)->recvServerAttribut(*buffer);
577  }
578
579  void CAxis::recvServerAttribut(CBufferIn& buffer)
580  {
581    int ni_srv, begin_srv, end_srv, global_zoom_begin_tmp, global_zoom_size_tmp;
582
583    buffer>>ni_srv>>begin_srv>>end_srv>>global_zoom_begin_tmp>>global_zoom_size_tmp;
584    global_zoom_begin = global_zoom_begin_tmp;
585    global_zoom_size  = global_zoom_size_tmp;
586    int global_zoom_end = global_zoom_begin + global_zoom_size - 1;
587
588    zoom_begin_srv = global_zoom_begin > begin_srv ? global_zoom_begin : begin_srv ;
589    zoom_end_srv   = global_zoom_end < end_srv ? global_zoom_end : end_srv ;
590    zoom_size_srv  = zoom_end_srv - zoom_begin_srv + 1;
591
592    if (zoom_size_srv<=0)
593    {
594      zoom_begin_srv = 0; zoom_end_srv = 0; zoom_size_srv = 0;
595    }
596
597    if (n_glo == n)
598    {
599      zoom_begin_srv = global_zoom_begin;
600      zoom_end_srv   = global_zoom_end; //zoom_end;
601      zoom_size_srv  = zoom_end_srv - zoom_begin_srv + 1;
602    }
603    value_srv.resize(zoom_size_srv);
604    bound_srv.resize(2,zoom_size_srv);
605  }
606
607  bool CAxis::hasTransformation()
608  {
609    return (!transformationMap_.empty());
610  }
611
612  void CAxis::setTransformations(const TransMapTypes& axisTrans)
613  {
614    transformationMap_ = axisTrans;
615  }
616
617  CAxis::TransMapTypes CAxis::getAllTransformations(void)
618  {
619    return transformationMap_;
620  }
621
622  /*!
623    Check the validity of all transformations applied on axis
624  This functions is called AFTER all inherited attributes are solved
625  */
626  void CAxis::checkTransformations()
627  {
628    TransMapTypes::const_iterator itb = transformationMap_.begin(), it,
629                                  ite = transformationMap_.end();
630    for (it = itb; it != ite; ++it)
631    {
632      (it->second)->checkValid(this);
633    }
634  }
635
636  void CAxis::solveInheritanceTransformation()
637  {
638    if (this->hasTransformation()) return;
639
640    std::vector<CAxis*> refAxis;
641    CAxis* refer_sptr;
642    CAxis* refer_ptr = this;
643    while (refer_ptr->hasDirectAxisReference())
644    {
645      refAxis.push_back(refer_ptr);
646      refer_sptr = refer_ptr->getDirectAxisReference();
647      refer_ptr  = refer_sptr;
648      if (refer_ptr->hasTransformation()) break;
649    }
650
651    if (refer_ptr->hasTransformation())
652      for (int idx = 0; idx < refAxis.size(); ++idx)
653        refAxis[idx]->setTransformations(refer_ptr->getAllTransformations());
654  }
655
656  void CAxis::parse(xml::CXMLNode & node)
657  {
658    SuperClass::parse(node);
659
660    if (node.goToChildElement())
661    {
662      StdString inverseAxisDefRoot("inverse_axis_definition");
663      StdString inverse("inverse_axis");
664      StdString zoomAxisDefRoot("zoom_axis_definition");
665      StdString zoom("zoom_axis");
666      StdString interpAxisDefRoot("interpolate_axis_definition");
667      StdString interp("interpolate_axis");
668      do
669      {
670        if (node.getElementName() == inverse) {
671          CInverseAxis* tmp = (CInverseAxisGroup::get(inverseAxisDefRoot))->createChild();
672          tmp->parse(node);
673          transformationMap_.push_back(std::make_pair(TRANS_INVERSE_AXIS,tmp));
674        } else if (node.getElementName() == zoom) {
675          CZoomAxis* tmp = (CZoomAxisGroup::get(zoomAxisDefRoot))->createChild();
676          tmp->parse(node);
677          transformationMap_.push_back(std::make_pair(TRANS_ZOOM_AXIS,tmp));
678        }
679        else if (node.getElementName() == interp) {
680          CInterpolateAxis* tmp = (CInterpolateAxisGroup::get(interpAxisDefRoot))->createChild();
681          tmp->parse(node);
682          transformationMap_.push_back(std::make_pair(TRANS_INTERPOLATE_AXIS,tmp));
683        }
684      } while (node.goToNextElement()) ;
685      node.goToParentElement();
686    }
687  }
688
689  DEFINE_REF_FUNC(Axis,axis)
690
691   ///---------------------------------------------------------------
692
693} // namespace xios
Note: See TracBrowser for help on using the repository browser.