source: XIOS/dev/dev_trunk_omp/src/transformation/generic_algorithm_transformation.cpp @ 1679

Last change on this file since 1679 was 1679, checked in by yushan, 5 years ago

MARK: Dynamic workflow graph developement. Branch up to date with trunk @1676. Using vis.js
File size: 42.5 KB
Line 
1/*!
2   \file generic_algorithm_transformation.hpp
3   \author Ha NGUYEN
4   \since 14 May 2015
5   \date 21 Mars 2016
6
7   \brief Interface for all transformation algorithms.
8 */
9#include "generic_algorithm_transformation.hpp"
10#include "context.hpp"
11#include "context_client.hpp"
12#include "client_client_dht_template.hpp"
13#include "utils.hpp"
14#include "timer.hpp"
15#include "mpi.hpp"
16
17namespace xios {
18
19CGenericAlgorithmTransformation::CGenericAlgorithmTransformation()
20 : transformationMapping_(), transformationWeight_(), transformationPosition_(),
21   idAuxInputs_(), type_(ELEMENT_NO_MODIFICATION_WITH_DATA), indexElementSrc_(),
22   computedProcSrcNonTransformedElement_(false), eliminateRedondantSrc_(true), isDistributedComputed_(false)
23{
24}
25
26void CGenericAlgorithmTransformation::updateData(CArray<double,1>& dataOut)
27{
28
29}
30
31void CGenericAlgorithmTransformation::apply(const std::vector<std::pair<int,double> >& localIndex,
32                                            const double* dataInput,
33                                            CArray<double,1>& dataOut,
34                                            std::vector<bool>& flagInitial,
35                                            bool ignoreMissingValue, bool firstPass  )
36TRY
37{
38  std::cout<<"================================ CGenericAlgorithmTransformation::apply"<<std::endl;
39
40  int nbLocalIndex = localIndex.size();   
41  double defaultValue = std::numeric_limits<double>::quiet_NaN();
42
43  if (ignoreMissingValue)
44  {
45    if (firstPass) dataOut=defaultValue ;
46 
47    for (int idx = 0; idx < nbLocalIndex; ++idx)
48    {
49      if (! NumTraits<double>::isNan(*(dataInput + idx)))
50      {
51        if (flagInitial[localIndex[idx].first]) dataOut(localIndex[idx].first) = *(dataInput + idx) * localIndex[idx].second;
52        else dataOut(localIndex[idx].first) += *(dataInput + idx) * localIndex[idx].second;
53        flagInitial[localIndex[idx].first] = false; // Reset flag to indicate not all data source are nan
54      }
55    }
56
57  }
58  else
59  {
60    for (int idx = 0; idx < nbLocalIndex; ++idx)
61    {
62      dataOut(localIndex[idx].first) += *(dataInput + idx) * localIndex[idx].second;
63    }
64  }
65}
66CATCH
67
68void CGenericAlgorithmTransformation::computePositionElements(CGrid* dst, CGrid* src)
69TRY
70{
71  int idxScalar = 0, idxAxis = 0, idxDomain = 0;
72  CArray<int,1> axisDomainOrderDst = dst->axis_domain_order;
73  for (int i = 0; i < axisDomainOrderDst.numElements(); ++i)
74  {
75    int dimElement = axisDomainOrderDst(i);
76    if (2 == dimElement)
77    {
78      elementPositionInGridDst2DomainPosition_[i] = idxDomain;
79      ++idxDomain;
80    }
81    else if (1 == dimElement)
82    {
83      elementPositionInGridDst2AxisPosition_[i] = idxAxis;
84      ++idxAxis;
85    }
86    else
87    {
88      elementPositionInGridDst2ScalarPosition_[i] = idxScalar;
89      ++idxScalar;
90    }
91  }
92
93  idxScalar = idxAxis = idxDomain = 0;
94  CArray<int,1> axisDomainOrderSrc = src->axis_domain_order;
95  for (int i = 0; i < axisDomainOrderSrc.numElements(); ++i)
96  {
97    int dimElement = axisDomainOrderSrc(i);
98    if (2 == dimElement)
99    {
100      elementPositionInGridSrc2DomainPosition_[i] = idxDomain;
101      ++idxDomain;
102    }
103    else if (1 == dimElement)
104    {
105      elementPositionInGridSrc2AxisPosition_[i] = idxAxis;
106      ++idxAxis;
107    }
108    else
109    {
110      elementPositionInGridSrc2ScalarPosition_[i] = idxScalar;
111      ++idxScalar;
112    }
113  }
114}
115CATCH
116
117bool CGenericAlgorithmTransformation::isDistributedTransformation(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst)
118TRY
119{
120
121  if (!isDistributedComputed_)
122  {
123    isDistributedComputed_=true ;
124    if (!eliminateRedondantSrc_) isDistributed_=true ;
125    else
126    {
127      CContext* context = CContext::getCurrent();
128      CContextClient* client = context->client;
129 
130      computePositionElements(gridSrc, gridDst);
131      std::vector<CScalar*> scalarListSrcP  = gridSrc->getScalars();
132      std::vector<CAxis*> axisListSrcP = gridSrc->getAxis();
133      std::vector<CDomain*> domainListSrcP = gridSrc->getDomains();
134      int distributed, distributed_glo ;
135 
136      CArray<int,1> axisDomainSrcOrder = gridSrc->axis_domain_order;
137      if (2 == axisDomainSrcOrder(elementPositionInGrid)) // It's domain
138      {
139        distributed=domainListSrcP[elementPositionInGridSrc2DomainPosition_[elementPositionInGrid]]->isDistributed() ;
140        MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, client->intraComm) ;
141   
142      }
143      else if (1 == axisDomainSrcOrder(elementPositionInGrid))//it's an axis
144      {
145        distributed=axisListSrcP[elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]]->isDistributed() ;
146        MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, client->intraComm) ;
147      }
148      else //it's a scalar
149      {
150        distributed_glo=false ;
151      } 
152      isDistributed_=distributed_glo ;
153    }
154  }
155  return isDistributed_ ;
156}
157CATCH
158
159/*!
160  This function computes the global indexes of grid source, which the grid destination is in demand.
161  \param[in] elementPositionInGrid position of an element in a grid .E.g: if grid is composed of domain and axis (in order),
162                then position of axis in grid is 1 and domain is positioned at 0.
163  \param[in] gridSrc Grid source
164  \param[in] gridDst Grid destination
165  \param[in\out] globaIndexWeightFromSrcToDst mapping of each global index source and weight to index destination
166*/
167void CGenericAlgorithmTransformation::computeGlobalSourceIndex(int elementPositionInGrid,
168                                                               CGrid* gridSrc,
169                                                               CGrid* gridDst,
170                                                               SourceDestinationIndexMap& globaIndexWeightFromSrcToDst)
171TRY
172 {
173  CContext* context = CContext::getCurrent();
174  CContextClient* client = context->client;
175  int nbClient = client->clientSize;
176
177  typedef std::unordered_map<int, std::vector<std::pair<int,double> > > SrcToDstMap;
178  int idx;
179
180  // compute position of elements on grids
181  computePositionElements(gridDst, gridSrc);
182  std::vector<CScalar*> scalarListDestP = gridDst->getScalars();
183  std::vector<CAxis*> axisListDestP = gridDst->getAxis();
184  std::vector<CDomain*> domainListDestP = gridDst->getDomains();
185  CArray<int,1> axisDomainDstOrder = gridDst->axis_domain_order;
186  std::vector<CScalar*> scalarListSrcP  = gridSrc->getScalars();
187  std::vector<CAxis*> axisListSrcP = gridSrc->getAxis();
188  std::vector<CDomain*> domainListSrcP = gridSrc->getDomains();
189  CArray<int,1> axisDomainSrcOrder = gridSrc->axis_domain_order; 
190 
191  bool isTransPosEmpty = transformationPosition_.empty();
192  CArray<size_t,1> transPos;
193  if (!isTransPosEmpty) transPos.resize(transformationMapping_.size());
194  std::set<size_t> allIndexSrc; // All index of source, which can be scattered among processes, need for doing transformation
195 
196  for (size_t idxTrans = 0; idxTrans < transformationMapping_.size(); ++idxTrans)
197  {
198    TransformationIndexMap::const_iterator itbTransMap = transformationMapping_[idxTrans].begin(), itTransMap,
199                                           iteTransMap = transformationMapping_[idxTrans].end();
200    TransformationWeightMap::const_iterator itbTransWeight = transformationWeight_[idxTrans].begin(), itTransWeight;
201
202    // Build mapping between global source element index and global destination element index.
203    itTransWeight = itbTransWeight;
204    for (itTransMap = itbTransMap; itTransMap != iteTransMap; ++itTransMap, ++itTransWeight)
205    {
206      const std::vector<int>& srcIndex = itTransMap->second;
207      for (idx = 0; idx < srcIndex.size(); ++idx)
208        allIndexSrc.insert(srcIndex[idx]);
209    }
210
211    if (!isTransPosEmpty)
212    {
213      TransformationPositionMap::const_iterator itPosMap = transformationPosition_[idxTrans].begin();
214      transPos(idxTrans) = itPosMap->second[0];
215    }
216  }
217
218  size_t indexSrcSize = 0;
219  CArray<size_t,1> indexSrc(allIndexSrc.size());
220  for (std::set<size_t>::iterator it = allIndexSrc.begin(); it != allIndexSrc.end(); ++it, ++indexSrcSize)
221    indexSrc(indexSrcSize) = *it;
222
223  // Flag to indicate whether we will recompute distribution of source global index  on processes
224  bool computeGlobalIndexOnProc = false; 
225  if (indexElementSrc_.size() != allIndexSrc.size())
226    computeGlobalIndexOnProc = true; 
227  else
228  {
229    for (std::set<size_t>::iterator it = allIndexSrc.begin(); it != allIndexSrc.end(); ++it)
230      if (0 == indexElementSrc_.count(*it))
231      {
232        computeGlobalIndexOnProc = true;
233        break;       
234      }
235  }
236
237  if (computeGlobalIndexOnProc)
238    indexElementSrc_.swap(allIndexSrc);
239     
240  int sendValue = (computeGlobalIndexOnProc) ? 1 : 0;
241  int recvValue = 0;
242  MPI_Allreduce(&sendValue, &recvValue, 1, MPI_INT, MPI_SUM, client->intraComm);
243  computeGlobalIndexOnProc = (0 < recvValue);
244
245//  CClientClientDHTInt::Index2VectorInfoTypeMap globalIndexOfTransformedElementOnProc;
246
247  if (computeGlobalIndexOnProc || !computedProcSrcNonTransformedElement_)
248  {   
249    {
250      CClientClientDHTInt::Index2VectorInfoTypeMap tmp ;
251      globalIndexOfTransformedElementOnProc_.swap(tmp) ;
252    }
253    // Find out global index source of transformed element on corresponding process.   
254    if (globalElementIndexOnProc_.empty())
255      globalElementIndexOnProc_.resize(axisDomainDstOrder.numElements());
256   
257    for (idx = 0; idx < axisDomainDstOrder.numElements(); ++idx)
258    {
259     
260      if (idx == elementPositionInGrid)
261        computeExchangeGlobalIndex(indexSrc, axisDomainSrcOrder(idx), globalIndexOfTransformedElementOnProc_); //globalElementIndexOnProc[idx]);
262      if (!computedProcSrcNonTransformedElement_)
263      {
264        if (2 == axisDomainDstOrder(idx)) // It's domain
265        {
266          if (idx != elementPositionInGrid)
267            computeExchangeDomainIndex(domainListDestP[elementPositionInGridDst2DomainPosition_[idx]],
268                                       domainListSrcP[elementPositionInGridSrc2DomainPosition_[idx]],
269                                       transPos,
270                                       globalElementIndexOnProc_[idx]);     
271
272        }
273        else if (1 == axisDomainDstOrder(idx))//it's an axis
274        {
275          if (idx != elementPositionInGrid)
276            computeExchangeAxisIndex(axisListDestP[elementPositionInGridDst2AxisPosition_[idx]],
277                                     axisListSrcP[elementPositionInGridSrc2AxisPosition_[idx]],
278                                     transPos,
279                                     globalElementIndexOnProc_[idx]);
280        }
281        else //it's a scalar
282        {
283          if (idx != elementPositionInGrid)
284            computeExchangeScalarIndex(scalarListDestP[elementPositionInGridDst2ScalarPosition_[idx]],
285                                       scalarListSrcP[elementPositionInGridSrc2ScalarPosition_[idx]],
286                                       transPos,
287                                       globalElementIndexOnProc_[idx]);
288
289        }
290      }
291    }
292
293    if (!isTransPosEmpty && !computedProcSrcNonTransformedElement_)
294    {
295      for (idx = 0; idx < globalElementIndexOnProc_.size(); ++idx)
296      {
297        if (idx != elementPositionInGrid)
298        {
299          std::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
300                                                                   ite = globalElementIndexOnProc_[idx].end();
301          for (it = itb; it != ite; ++it) it->second.resize(1);
302        }
303      }
304    }
305
306/*     
307    if (!computedProcSrcNonTransformedElement_)
308    {
309      for (idx = 0; idx < globalElementIndexOnProc_.size(); ++idx)
310      {
311        if (idx != elementPositionInGrid)
312        {
313          std::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
314                                                                   ite = globalElementIndexOnProc_[idx].end();
315          for (it = itb; it != ite; ++it) procOfNonTransformedElements_.insert(it->first);
316          if (procOfNonTransformedElements_.size() == nbClient)
317            break;
318        }
319      }
320    }
321   
322    // Processes contain the source index of transformed element
323    std::set<int> procOfTransformedElement;
324    CClientClientDHTInt::Index2VectorInfoTypeMap::iterator itIdxb = globalIndexOfTransformedElementOnProc.begin(),
325                                                           itIdxe = globalIndexOfTransformedElementOnProc.end(), itIdx;
326    for (itIdx = itIdxb; itIdx != itIdxe; ++itIdx)
327    {
328      std::vector<int>& tmp = itIdx->second;
329      for (int i = 0; i < tmp.size(); ++i)
330        procOfTransformedElement.insert(tmp[i]);
331      if (tmp.size() == nbClient)
332        break;
333    }                                                           
334   
335    std::set<int>& commonProc = (procOfTransformedElement.size() < procOfNonTransformedElements_.size()) ? procOfTransformedElement
336                              : (!procOfNonTransformedElements_.empty() ? procOfNonTransformedElements_ : procOfTransformedElement);
337   
338    std::vector<int> procContainSrcElementIdx(commonProc.size());
339    int count = 0;
340    for (std::set<int>::iterator it = commonProc.begin(); it != commonProc.end(); ++it)
341      procContainSrcElementIdx[count++] = *it;
342
343    procContainSrcElementIdx_.swap(procContainSrcElementIdx);   
344*/
345   
346    if (procElementList_.empty()) procElementList_.resize(axisDomainDstOrder.numElements()) ;
347    for (idx = 0; idx < axisDomainDstOrder.numElements(); ++idx)
348    {
349      std::set<int>& procList=procElementList_[idx] ;
350      std::set<int> commonTmp ;
351      if (idx == elementPositionInGrid)
352      {
353          set<int> tmpSet ; 
354          procList.swap(tmpSet) ;
355          CClientClientDHTInt::Index2VectorInfoTypeMap::iterator itIdxb = globalIndexOfTransformedElementOnProc_.begin(),
356                                                                 itIdxe = globalIndexOfTransformedElementOnProc_.end(), itIdx;
357          for (itIdx = itIdxb; itIdx != itIdxe; ++itIdx)
358          {
359             std::vector<int>& tmp = itIdx->second;
360             for (int i = 0; i < tmp.size(); ++i) procList.insert(tmp[i]);
361             if (tmp.size() == nbClient)
362             break;
363          }
364      }
365      else
366      {
367        if (!computedProcSrcNonTransformedElement_)
368        {
369          set<int> tmpSet ; 
370          procList.swap(tmpSet) ;
371          std::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
372                                                                   ite = globalElementIndexOnProc_[idx].end();
373          for (it = itb; it != ite; ++it)
374          {
375            procList.insert(it->first);
376            if (procList.size() == nbClient)  break;
377          }
378        }
379      }
380
381      if (idx==0) commonProc_= procList ;
382      else
383      {
384        for (std::set<int>::iterator it = commonProc_.begin(); it != commonProc_.end(); ++it)
385          if (procList.count(*it)==1) commonTmp.insert(*it) ;
386        commonProc_.swap(commonTmp) ;
387      }
388    }
389    std::vector<int> procContainSrcElementIdx(commonProc_.size());
390    int count = 0;
391    for (std::set<int>::iterator it = commonProc_.begin(); it != commonProc_.end(); ++it) procContainSrcElementIdx[count++] = *it;
392    procContainSrcElementIdx_.swap(procContainSrcElementIdx);
393   
394        // For the first time, surely we calculate proc containing non transformed elements
395    if (!computedProcSrcNonTransformedElement_) computedProcSrcNonTransformedElement_ = true;
396  }
397 
398  for (size_t idxTrans = 0; idxTrans < transformationMapping_.size(); ++idxTrans)
399  {
400    TransformationIndexMap::const_iterator itbTransMap = transformationMapping_[idxTrans].begin(), itTransMap,
401                                           iteTransMap = transformationMapping_[idxTrans].end();
402    TransformationWeightMap::const_iterator itbTransWeight = transformationWeight_[idxTrans].begin(), itTransWeight;
403    SrcToDstMap src2DstMap;
404    src2DstMap.rehash(std::ceil(transformationMapping_[idxTrans].size()/src2DstMap.max_load_factor()));
405
406    // Build mapping between global source element index and global destination element index.
407    std::unordered_map<int,std::vector<size_t> >().swap(globalElementIndexOnProc_[elementPositionInGrid]);
408    std::set<int> tmpCounter;
409    itTransWeight = itbTransWeight;
410    for (itTransMap = itbTransMap; itTransMap != iteTransMap; ++itTransMap, ++itTransWeight)
411    {
412      const std::vector<int>& srcIndex = itTransMap->second;
413      const std::vector<double>& weight = itTransWeight->second;
414      for (idx = 0; idx < srcIndex.size(); ++idx)
415      {
416        src2DstMap[srcIndex[idx]].push_back(make_pair(itTransMap->first, weight[idx]));
417        if (0 == tmpCounter.count(srcIndex[idx]))
418        {         
419          tmpCounter.insert(srcIndex[idx]);
420       
421          vector<int>& rankSrc = globalIndexOfTransformedElementOnProc_[srcIndex[idx]] ;
422          for (int n=0;n<rankSrc.size();++n)
423          {
424            if (commonProc_.count(rankSrc[n])==1) globalElementIndexOnProc_[elementPositionInGrid][rankSrc[n]].push_back(srcIndex[idx]);
425          }
426//          for (int j = 0; j < procContainSrcElementIdx_.size(); ++j)
427//            globalElementIndexOnProc_[elementPositionInGrid][procContainSrcElementIdx_[j]].push_back(srcIndex[idx]);
428        }
429      }
430    }
431 
432    if (!isTransPosEmpty)
433    {
434      for (idx = 0; idx < globalElementIndexOnProc_.size(); ++idx)
435      {
436        if (idx != elementPositionInGrid)
437        {
438          std::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
439                                                                   ite = globalElementIndexOnProc_[idx].end();
440          for (it = itb; it != ite; ++it) it->second[0] = transPos(idxTrans);
441        }
442      }
443    }
444
445    // Ok, now compute global index of grid source and ones of grid destination
446    computeGlobalGridIndexMapping(elementPositionInGrid,
447                                  procContainSrcElementIdx_, //srcRank,
448                                  src2DstMap,
449                                  gridSrc,
450                                  gridDst,
451                                  globalElementIndexOnProc_,
452                                  globaIndexWeightFromSrcToDst);
453  } 
454 }
455CATCH
456
457/*!
458  Compute mapping of global index of grid source and grid destination
459  \param [in] elementPositionInGrid position of element in grid. E.x: grid composed of domain and axis, domain has position 0 and axis 1.
460  \param [in] srcRank rank of client from which we demand global index of element source
461  \param [in] src2DstMap mapping of global index of element source and global index of element destination
462  \param [in] gridSrc Grid source
463  \param [in] gridDst Grid destination
464  \param [in] globalElementIndexOnProc Global index of element source on different client rank
465  \param [out] globaIndexWeightFromSrcToDst Mapping of global index of grid source and grid destination
466*/
467void CGenericAlgorithmTransformation::computeGlobalGridIndexMapping(int elementPositionInGrid,
468                                                                   const std::vector<int>& srcRank,
469                                                                   std::unordered_map<int, std::vector<std::pair<int,double> > >& src2DstMap,
470                                                                   CGrid* gridSrc,
471                                                                   CGrid* gridDst,
472                                                                   std::vector<std::unordered_map<int,std::vector<size_t> > >& globalElementIndexOnProc,
473                                                                   SourceDestinationIndexMap& globaIndexWeightFromSrcToDst)
474TRY
475{
476  SourceDestinationIndexMap globaIndexWeightFromSrcToDst_tmp ;
477 
478  CContext* context = CContext::getCurrent();
479  CContextClient* client=context->client;
480  int clientRank = client->clientRank;
481 
482  std::vector<CDomain*> domainListSrcP = gridSrc->getDomains();
483  std::vector<CAxis*> axisListSrcP = gridSrc->getAxis();
484  std::vector<CScalar*> scalarListSrcP = gridSrc->getScalars();
485  CArray<int,1> axisDomainSrcOrder = gridSrc->axis_domain_order;
486
487  size_t nbElement = axisDomainSrcOrder.numElements();
488  std::vector<size_t> nGlobSrc(nbElement);
489  size_t globalSrcSize = 1;
490  int domainIndex = 0, axisIndex = 0, scalarIndex = 0;
491  for (int idx = 0; idx < nbElement; ++idx)
492  {
493    nGlobSrc[idx] = globalSrcSize;
494    int elementDimension = axisDomainSrcOrder(idx);
495
496    // If this is a domain
497    if (2 == elementDimension)
498    {
499      globalSrcSize *= domainListSrcP[domainIndex]->nj_glo.getValue() * domainListSrcP[domainIndex]->ni_glo.getValue();
500      ++domainIndex;
501    }
502    else if (1 == elementDimension) // So it's an axis
503    {
504      globalSrcSize *= axisListSrcP[axisIndex]->n_glo.getValue();
505      ++axisIndex;
506    }
507    else
508    {
509      globalSrcSize *= 1;
510      ++scalarIndex;
511    }
512  }
513
514  std::vector<CDomain*> domainListDestP = gridDst->getDomains();
515  std::vector<CAxis*> axisListDestP = gridDst->getAxis();
516  std::vector<CScalar*> scalarListDestP = gridDst->getScalars();
517  CArray<int,1> axisDomainDstOrder = gridDst->axis_domain_order;
518
519  std::vector<size_t> nGlobDst(nbElement);
520  size_t globalDstSize = 1;
521  domainIndex = axisIndex = scalarIndex = 0;
522  set<size_t>  globalSrcStoreIndex ;
523 
524  for (int idx = 0; idx < nbElement; ++idx)
525  {
526    nGlobDst[idx] = globalDstSize;
527    int elementDimension = axisDomainDstOrder(idx);
528
529    // If this is a domain
530    if (2 == elementDimension)
531    {
532      globalDstSize *= domainListDestP[domainIndex]->nj_glo.getValue() * domainListDestP[domainIndex]->ni_glo.getValue();
533      ++domainIndex;
534    }
535    else if (1 == elementDimension) // So it's an axis
536    {
537      globalDstSize *= axisListDestP[axisIndex]->n_glo.getValue();
538      ++axisIndex;
539    }
540    else
541    {
542      globalDstSize *= 1;
543      ++scalarIndex;
544    }
545  }
546
547  std::map< std::pair<size_t,size_t>, int > rankMap ;
548  std::map< std::pair<size_t,size_t>, int >:: iterator rankMapIt ;
549 
550  for (int i = 0; i < srcRank.size(); ++i)
551  {
552    size_t ssize = 1;
553    int rankSrc = srcRank[i];
554    for (int idx = 0; idx < nbElement; ++idx)
555    {
556      ssize *= (globalElementIndexOnProc[idx][rankSrc]).size();
557    }
558
559    std::vector<int> idxLoop(nbElement,0);
560    std::vector<int> currentIndexSrc(nbElement, 0);
561    std::vector<int> currentIndexDst(nbElement, 0);
562    int innnerLoopSize = (globalElementIndexOnProc[0])[rankSrc].size();
563    size_t idx = 0;
564    while (idx < ssize)
565    {
566      for (int ind = 0; ind < nbElement; ++ind)
567      {
568        if (idxLoop[ind] == (globalElementIndexOnProc[ind])[rankSrc].size())
569        {
570          idxLoop[ind] = 0;
571          ++idxLoop[ind+1];
572        }
573
574        currentIndexDst[ind] = currentIndexSrc[ind] = (globalElementIndexOnProc[ind])[rankSrc][idxLoop[ind]];
575      }
576
577      for (int ind = 0; ind < innnerLoopSize; ++ind)
578      {
579        currentIndexDst[0] = currentIndexSrc[0] = (globalElementIndexOnProc[0])[rankSrc][ind];
580        int globalElementDstIndexSize = 0;
581        if (1 == src2DstMap.count(currentIndexSrc[elementPositionInGrid]))
582        {
583          globalElementDstIndexSize = src2DstMap[currentIndexSrc[elementPositionInGrid]].size();
584        }
585
586        std::vector<size_t> globalDstVecIndex(globalElementDstIndexSize,0);
587        size_t globalSrcIndex = 0;
588        for (int idxElement = 0; idxElement < nbElement; ++idxElement)
589        {
590          if (idxElement == elementPositionInGrid)
591          {
592            for (int k = 0; k < globalElementDstIndexSize; ++k)
593            {
594              globalDstVecIndex[k] += src2DstMap[currentIndexSrc[elementPositionInGrid]][k].first * nGlobDst[idxElement];
595            }
596          }
597          else
598          {
599            for (int k = 0; k < globalElementDstIndexSize; ++k)
600            {
601              globalDstVecIndex[k] += currentIndexDst[idxElement] * nGlobDst[idxElement];
602            }
603          }
604          globalSrcIndex += currentIndexSrc[idxElement] * nGlobSrc[idxElement];
605        }
606
607        for (int k = 0; k < globalElementDstIndexSize; ++k)
608        {
609         
610          globaIndexWeightFromSrcToDst_tmp[rankSrc][globalSrcIndex].push_back(make_pair(globalDstVecIndex[k],src2DstMap[currentIndexSrc[elementPositionInGrid]][k].second ));
611          rankMapIt=rankMap.find(make_pair(globalSrcIndex,globalDstVecIndex[k])) ;
612          if (rankMapIt==rankMap.end()) rankMap[make_pair(globalSrcIndex,globalDstVecIndex[k])] = rankSrc ;
613          else if (rankSrc==clientRank) rankMapIt->second = rankSrc ;
614        }
615        ++idxLoop[0];
616      }
617      idx += innnerLoopSize;
618    }
619  }
620
621  // eliminate redondant global src point owned by differrent processes.
622  // Avoid as possible to tranfer data from an other process if the src point is also owned by current process
623      int rankSrc ;
624      size_t globalSrcIndex ;
625      size_t globalDstIndex ;
626      double weight ;
627 
628      SourceDestinationIndexMap::iterator rankIt,rankIte ;
629      std::unordered_map<size_t, std::vector<std::pair<size_t,double> > >::iterator globalSrcIndexIt, globalSrcIndexIte ;
630      std::vector<std::pair<size_t,double> >::iterator vectIt,vectIte ;
631   
632      rankIt=globaIndexWeightFromSrcToDst_tmp.begin() ; rankIte=globaIndexWeightFromSrcToDst_tmp.end() ;
633      for(;rankIt!=rankIte;++rankIt)
634      {
635        rankSrc = rankIt->first ;
636        globalSrcIndexIt = rankIt->second.begin() ; globalSrcIndexIte = rankIt->second.end() ;
637        for(;globalSrcIndexIt!=globalSrcIndexIte;++globalSrcIndexIt)
638        { 
639          globalSrcIndex = globalSrcIndexIt->first ;
640          vectIt = globalSrcIndexIt->second.begin() ; vectIte = globalSrcIndexIt->second.end() ;
641          for(vectIt; vectIt!=vectIte; vectIt++)
642          {
643            globalDstIndex = vectIt->first ;
644            weight = vectIt->second ;
645            if (eliminateRedondantSrc_)
646            {
647              if (rankMap[make_pair(globalSrcIndex,globalDstIndex)] == rankSrc) 
648                globaIndexWeightFromSrcToDst[rankSrc][globalSrcIndex].push_back(make_pair(globalDstIndex,weight)) ;
649            }
650            else globaIndexWeightFromSrcToDst[rankSrc][globalSrcIndex].push_back(make_pair(globalDstIndex,weight)) ;
651         }
652       }
653     }
654}
655CATCH
656
657/*!
658  Find out proc and global index of axis source which axis destination is on demande
659  \param[in] scalar Scalar destination
660  \param[in] scalar Scalar source
661  \param[in] destGlobalIndexPositionInGrid Relative position of axis corresponds to other element of grid.
662  \param[out] globalScalarIndexOnProc Global index of axis source on different procs
663*/
664void CGenericAlgorithmTransformation::computeExchangeScalarIndex(CScalar* scalarDst,
665                                                                 CScalar* scalarSrc,
666                                                                 CArray<size_t,1>& destGlobalIndexPositionInGrid,
667                                                                 std::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc)
668TRY
669{
670  CContext* context = CContext::getCurrent();
671  CContextClient* client=context->client;
672  int clientRank = client->clientRank;
673  int clientSize = client->clientSize;
674
675  globalScalarIndexOnProc.rehash(std::ceil(clientSize/globalScalarIndexOnProc.max_load_factor()));
676  for (int idx = 0; idx < clientSize; ++idx)
677  {
678    globalScalarIndexOnProc[idx].push_back(0);
679  }
680}
681CATCH
682
683/*!
684  Find out proc and global index of axis source which axis destination is on demande
685  \param[in] axisDst Axis destination
686  \param[in] axisSrc Axis source
687  \param[in] destGlobalIndexPositionInGrid Relative position of axis corresponds to other element of grid.
688  \param[out] globalAxisIndexOnProc Global index of axis source on different procs
689*/
690void CGenericAlgorithmTransformation::computeExchangeAxisIndex(CAxis* axisDst,
691                                                               CAxis* axisSrc,
692                                                               CArray<size_t,1>& destGlobalIndexPositionInGrid,
693                                                               std::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc)
694TRY
695{
696  CContext* context = CContext::getCurrent();
697  CContextClient* client=context->client;
698  int clientRank = client->clientRank;
699  int clientSize = client->clientSize;
700
701  size_t globalIndex;
702  int nIndexSize = axisSrc->index.numElements();
703  CClientClientDHTInt::Index2VectorInfoTypeMap globalIndex2ProcRank;
704  globalIndex2ProcRank.rehash(std::ceil(nIndexSize/globalIndex2ProcRank.max_load_factor()));
705  for (int idx = 0; idx < nIndexSize; ++idx)
706  {
707    if (axisSrc->mask(idx))
708    {
709      globalIndex = axisSrc->index(idx);
710      globalIndex2ProcRank[globalIndex].push_back(clientRank);
711    }
712  }
713
714  CClientClientDHTInt dhtIndexProcRank(globalIndex2ProcRank, client->intraComm);
715  CArray<size_t,1> globalAxisIndex(axisDst->index.numElements());
716  for (int idx = 0; idx < globalAxisIndex.numElements(); ++idx)
717  {
718    globalAxisIndex(idx) = axisDst->index(idx);
719  }
720  dhtIndexProcRank.computeIndexInfoMapping(globalAxisIndex);
721
722  std::vector<int> countIndex(clientSize,0);
723  const CClientClientDHTInt::Index2VectorInfoTypeMap& computedGlobalIndexOnProc = dhtIndexProcRank.getInfoIndexMap();
724  CClientClientDHTInt::Index2VectorInfoTypeMap::const_iterator itb = computedGlobalIndexOnProc.begin(), it,
725                                                               ite = computedGlobalIndexOnProc.end();
726  for (it = itb; it != ite; ++it)
727  {
728    const std::vector<int>& procList = it->second;
729    for (int idx = 0; idx < procList.size(); ++idx) ++countIndex[procList[idx]];
730  }
731
732  globalAxisIndexOnProc.rehash(std::ceil(clientSize/globalAxisIndexOnProc.max_load_factor()));
733  for (int idx = 0; idx < clientSize; ++idx)
734  {
735    if (0 != countIndex[idx])
736    {
737      globalAxisIndexOnProc[idx].resize(countIndex[idx]);
738      countIndex[idx] = 0;
739    }
740  }
741
742  for (it = itb; it != ite; ++it)
743  {
744    const std::vector<int>& procList = it->second;
745    for (int idx = 0; idx < procList.size(); ++idx)
746    {
747      globalAxisIndexOnProc[procList[idx]][countIndex[procList[idx]]] = it->first;
748      ++countIndex[procList[idx]];
749    }
750  }
751}
752CATCH
753
754/*!
755  Find out proc and global index of domain source which domain destination is on demande
756  \param[in] domainDst Domain destination
757  \param[in] domainSrc Domain source
758  \param[in] destGlobalIndexPositionInGrid Relative position of domain corresponds to other element of grid.
759  \param[out] globalDomainIndexOnProc Global index of domain source on different procs
760*/
761void CGenericAlgorithmTransformation::computeExchangeDomainIndex(CDomain* domainDst,
762                                                                 CDomain* domainSrc,
763                                                                 CArray<size_t,1>& destGlobalIndexPositionInGrid,
764                                                                 std::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc)
765TRY
766{
767  CContext* context = CContext::getCurrent();
768  CContextClient* client=context->client;
769  int clientRank = client->clientRank;
770  int clientSize = client->clientSize;
771
772  int niGlobSrc = domainSrc->ni_glo.getValue();
773  size_t globalIndex;
774  int i_ind, j_ind;
775  int nIndexSize = (destGlobalIndexPositionInGrid.isEmpty()) ? domainSrc->i_index.numElements()
776                                                             : destGlobalIndexPositionInGrid.numElements();
777  CClientClientDHTInt::Index2VectorInfoTypeMap globalIndex2ProcRank;
778  globalIndex2ProcRank.rehash(std::ceil(nIndexSize/globalIndex2ProcRank.max_load_factor()));
779 
780  if (destGlobalIndexPositionInGrid.isEmpty())
781  {
782    for (int idx = 0; idx < nIndexSize; ++idx)
783    {
784      i_ind=domainSrc->i_index(idx) ;
785      j_ind=domainSrc->j_index(idx) ;
786
787      if (domainSrc->localMask(idx))
788      {
789        globalIndex = i_ind + j_ind * niGlobSrc;
790        globalIndex2ProcRank[globalIndex].resize(1);
791        globalIndex2ProcRank[globalIndex][0] = clientRank;
792      }
793    }
794  }
795  else
796  {
797    for (int idx = 0; idx < nIndexSize; ++idx)
798    {
799//      if (domainSrc->localMask(idx)) -> not necessairy, mask seem to be included in  destGlobalIndexPositionInGrid(idx)    (ym)
800        globalIndex2ProcRank[destGlobalIndexPositionInGrid(idx)].push_back(clientRank);
801    }
802  }
803
804  CArray<size_t,1> globalDomainIndex;
805  if (destGlobalIndexPositionInGrid.isEmpty())
806  {
807    int niGlobDst = domainDst->ni_glo.getValue();
808    globalDomainIndex.resize(domainDst->i_index.numElements());
809    nIndexSize = domainDst->i_index.numElements();
810
811    for (int idx = 0; idx < nIndexSize; ++idx)
812    {
813      i_ind=domainDst->i_index(idx) ;
814      j_ind=domainDst->j_index(idx) ;
815
816      globalDomainIndex(idx) = i_ind + j_ind * niGlobDst;
817    }
818  }
819  else
820  {
821    globalDomainIndex.reference(destGlobalIndexPositionInGrid);
822  }
823
824  CClientClientDHTInt dhtIndexProcRank(globalIndex2ProcRank, client->intraComm);
825  dhtIndexProcRank.computeIndexInfoMapping(globalDomainIndex);
826
827  std::vector<int> countIndex(clientSize,0);
828  const CClientClientDHTInt::Index2VectorInfoTypeMap& computedGlobalIndexOnProc = dhtIndexProcRank.getInfoIndexMap();
829  CClientClientDHTInt::Index2VectorInfoTypeMap::const_iterator itb = computedGlobalIndexOnProc.begin(), it,
830                                                               ite = computedGlobalIndexOnProc.end();
831  for (it = itb; it != ite; ++it)
832  {
833    const std::vector<int>& procList = it->second;
834    for (int idx = 0; idx < procList.size(); ++idx) ++countIndex[procList[idx]];
835  }
836
837  globalDomainIndexOnProc.rehash(std::ceil(clientSize/globalDomainIndexOnProc.max_load_factor()));
838  for (int idx = 0; idx < clientSize; ++idx)
839  {
840    if (0 != countIndex[idx])
841    {
842      globalDomainIndexOnProc[idx].resize(countIndex[idx]);
843      countIndex[idx] = 0;
844    }
845  }
846
847  for (it = itb; it != ite; ++it)
848  {
849    const std::vector<int>& procList = it->second;
850    for (int idx = 0; idx < procList.size(); ++idx)
851    {
852      globalDomainIndexOnProc[procList[idx]][countIndex[procList[idx]]] = it->first;
853      ++countIndex[procList[idx]];
854    }
855  }
856}
857CATCH
858
859void CGenericAlgorithmTransformation::computeTransformationMappingNonDistributed(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst,
860                                                                                 vector<int>& localSrc, vector<int>& localDst, vector<double>& weight,
861                                                                                 int& nlocalIndexDest)
862TRY
863{
864
865  CContext* context = CContext::getCurrent();
866  CContextClient* client = context->client;
867  int nbClient = client->clientSize;
868
869  computePositionElements(gridDst, gridSrc);
870  std::vector<CScalar*> scalarListDstP = gridDst->getScalars();
871  std::vector<CAxis*> axisListDstP = gridDst->getAxis();
872  std::vector<CDomain*> domainListDstP = gridDst->getDomains();
873  CArray<int,1> axisDomainDstOrder = gridDst->axis_domain_order;
874  std::vector<CScalar*> scalarListSrcP  = gridSrc->getScalars();
875  std::vector<CAxis*> axisListSrcP = gridSrc->getAxis();
876  std::vector<CDomain*> domainListSrcP = gridSrc->getDomains();
877  CArray<int,1> axisDomainSrcOrder = gridSrc->axis_domain_order; 
878
879  int nElement=axisDomainSrcOrder.numElements() ;
880  int indSrc=1 ;
881  int indDst=1 ;
882  vector<int> nIndexSrc(nElement) ;
883  vector<int> nIndexDst(nElement) ;
884  vector< CArray<bool,1>* > maskSrc(nElement) ;
885  vector< CArray<bool,1>* > maskDst(nElement) ;
886   
887  int nlocalIndexSrc=1 ;
888//  int nlocalIndexDest=1 ;
889  nlocalIndexDest=1 ;
890  CArray<bool,1> maskScalar(1) ;
891  maskScalar  = true ;
892 
893 
894  for(int i=0 ; i<nElement; i++)
895  {
896    int dimElement = axisDomainSrcOrder(i);
897    if (2 == dimElement) //domain
898    {
899      CDomain* domain=domainListSrcP[elementPositionInGridSrc2DomainPosition_[i]] ;
900      nIndexSrc[i] = domain->i_index.numElements() ;
901      maskSrc[i]=&domain->localMask ;
902    }
903    else if (1 == dimElement) //axis
904    {
905      CAxis* axis=axisListSrcP[elementPositionInGridSrc2AxisPosition_[i]] ;
906      nIndexSrc[i] = axis->index.numElements() ;
907      maskSrc[i]=&axis->mask ;
908    }
909    else  //scalar
910    {
911      nIndexSrc[i]=1 ;
912      maskSrc[i]=&maskScalar ;
913    }
914    nlocalIndexSrc=nlocalIndexSrc*nIndexSrc[i] ;
915  }
916
917
918
919  int offset=1 ;
920  for(int i=0 ; i<nElement; i++)
921  {
922    int dimElement = axisDomainDstOrder(i);
923    if (2 == dimElement) //domain
924    {
925      CDomain* domain=domainListDstP[elementPositionInGridDst2DomainPosition_[i]] ;
926      int nIndex=domain->i_index.numElements() ;
927      CArray<bool,1>& localMask=domain->localMask ;
928      int nbInd=0 ;
929      for(int j=0;j<nIndex;j++) if (localMask(j)) nbInd++ ;
930      nIndexDst[i] = nbInd ;
931      maskDst[i]=&domain->localMask ;
932    }
933    else if (1 == dimElement) //axis
934    {
935      CAxis* axis = axisListDstP[elementPositionInGridDst2AxisPosition_[i]] ;
936      int nIndex=axis->index.numElements() ;
937      CArray<bool,1>& localMask=axis->mask ;
938      int nbInd=0 ;
939      for(int j=0;j<nIndex;j++) if (localMask(j)) nbInd++ ;
940      nIndexDst[i] = nbInd ;
941      maskDst[i]=&axis->mask ;
942    }
943    else  //scalar
944    {
945      nIndexDst[i]=1 ;
946      maskDst[i]=&maskScalar ;
947    }
948    if (i<elementPositionInGrid) offset=offset*nIndexDst[i] ;
949    nlocalIndexDest=nlocalIndexDest*nIndexDst[i] ;
950  }
951
952  vector<int> dstLocalInd ;
953  int dimElement = axisDomainDstOrder(elementPositionInGrid);
954  if (2 == dimElement) //domain
955  {
956    CDomain* domain = domainListDstP[elementPositionInGridDst2DomainPosition_[elementPositionInGrid]] ;
957    int ni_glo=domain->ni_glo ;
958    int nj_glo=domain->nj_glo ;
959    int nindex_glo=ni_glo*nj_glo ;
960    dstLocalInd.resize(nindex_glo,-1) ;
961    int nIndex=domain->i_index.numElements() ;
962    CArray<bool,1>& localMask=domain->localMask ;
963    int unmaskedInd=0 ;
964    int globIndex ;
965    for(int i=0;i<nIndex;i++)
966    {
967      if (localMask(i))
968      {
969        globIndex=domain->j_index(i)*ni_glo+domain->i_index(i) ;
970        dstLocalInd[globIndex]=unmaskedInd ;
971        unmaskedInd++ ;
972      }
973    }
974  }
975  else if (1 == dimElement) //axis
976  {
977    CAxis* axis = axisListDstP[elementPositionInGridDst2AxisPosition_[elementPositionInGrid]] ;
978    int nindex_glo=axis->n_glo ;
979    dstLocalInd.resize(nindex_glo,-1) ;
980    int nIndex=axis->index.numElements() ;
981    CArray<bool,1>& localMask=axis->mask ; // axis mask must include later data_index
982    int unmaskedInd=0 ;
983    for(int i=0;i<nIndex;i++)
984    {
985      if (localMask(i))
986      {
987        dstLocalInd[axis->index(i)]=unmaskedInd ;
988        unmaskedInd++ ;
989      }
990    }
991  }
992  else  //scalar
993  {
994    dstLocalInd.resize(1) ; 
995    dstLocalInd[0]=0 ; 
996  }
997
998  vector<vector<vector<pair<int,double> > > > dstIndWeight(transformationMapping_.size()) ;
999   
1000  for(int t=0;t<transformationMapping_.size();++t)
1001  {
1002    TransformationIndexMap::const_iterator   itTransMap = transformationMapping_[t].begin(),
1003                                             iteTransMap = transformationMapping_[t].end();
1004    TransformationWeightMap::const_iterator itTransWeight = transformationWeight_[t].begin();
1005    dstIndWeight[t].resize(nIndexSrc[elementPositionInGrid]) ;
1006   
1007    for(;itTransMap!=iteTransMap;++itTransMap,++itTransWeight)
1008    {
1009      int dst=dstLocalInd[itTransMap->first] ;
1010      if (dst!=-1)
1011      {
1012        const vector<int>& srcs=itTransMap->second;
1013        const vector<double>& weights=itTransWeight->second;
1014        for(int i=0;i<srcs.size() ;i++) dstIndWeight[t][srcs[i]].push_back(pair<int,double>(dst*offset+t,weights[i])) ;
1015      }
1016    }
1017  }
1018  int srcInd=0 ; 
1019  int currentInd ;
1020  int t=0 ; 
1021  int srcIndCompressed=0 ;
1022 
1023  nonDistributedrecursiveFunct(nElement-1,true,elementPositionInGrid,maskSrc,maskDst, srcInd, srcIndCompressed, nIndexSrc, t, dstIndWeight, 
1024                               currentInd,localSrc,localDst,weight);
1025               
1026}
1027CATCH
1028
1029
1030void CGenericAlgorithmTransformation::nonDistributedrecursiveFunct(int currentPos, bool masked, int elementPositionInGrid,
1031                                                                   vector< CArray<bool,1>* >& maskSrc, vector< CArray<bool,1>* >& maskDst,
1032                                                                   int& srcInd, int& srcIndCompressed, vector<int>& nIndexSrc,
1033                                                                   int& t, vector<vector<vector<pair<int,double> > > >& dstIndWeight, int currentInd,
1034                                                                   vector<int>& localSrc, vector<int>& localDst, vector<double>& weight)
1035TRY
1036{
1037  int masked_ ;
1038  if (currentPos!=elementPositionInGrid)
1039  {
1040    if (currentPos!=0)
1041    {
1042      CArray<bool,1>& mask = *maskSrc[currentPos] ;
1043     
1044      for(int i=0;i<nIndexSrc[currentPos];i++)
1045      {
1046        masked_=masked ;
1047        if (!mask(i)) masked_=false ;
1048        nonDistributedrecursiveFunct(currentPos-1, masked_, elementPositionInGrid, maskSrc, maskDst, srcInd, srcIndCompressed, nIndexSrc, t,
1049                                     dstIndWeight, currentInd, localSrc, localDst, weight);
1050      }
1051    }
1052    else
1053    {
1054      CArray<bool,1>& mask = *maskSrc[currentPos] ;
1055      for(int i=0;i<nIndexSrc[currentPos];i++)
1056      {
1057        if (masked && mask(i))
1058        {
1059          if (dstIndWeight[t][currentInd].size()>0)
1060          {
1061            for(vector<pair<int,double> >::iterator it = dstIndWeight[t][currentInd].begin(); it!=dstIndWeight[t][currentInd].end(); ++it)
1062            {
1063              localSrc.push_back(srcIndCompressed) ;
1064              localDst.push_back(it->first) ;
1065              weight.push_back(it->second) ;
1066              (it->first)++ ;
1067            }
1068          }
1069          if (t < dstIndWeight.size()-1) t++ ;
1070            srcIndCompressed ++ ;
1071        }
1072        srcInd++ ;
1073      }
1074    }
1075  }
1076  else
1077  {
1078 
1079    if (currentPos!=0)
1080    {
1081
1082      CArray<bool,1>& mask = *maskSrc[currentPos] ;
1083      for(int i=0;i<nIndexSrc[currentPos];i++)
1084      {
1085        t=0 ;
1086        masked_=masked ;
1087        if (!mask(i)) masked_=false ; 
1088        nonDistributedrecursiveFunct(currentPos-1, masked_, elementPositionInGrid, maskSrc, maskDst, srcInd,
1089                                     srcIndCompressed, nIndexSrc, t, dstIndWeight , i,  localSrc, localDst, weight);
1090      }
1091    }
1092    else
1093    {
1094      for(int i=0;i<nIndexSrc[currentPos];i++)
1095      {
1096        if (masked)
1097        {
1098          t=0 ;       
1099          if (dstIndWeight[t][i].size()>0)
1100          {
1101            for(vector<pair<int,double> >::iterator it = dstIndWeight[t][i].begin(); it!=dstIndWeight[t][i].end(); ++it)
1102            {
1103              localSrc.push_back(srcIndCompressed) ;
1104              localDst.push_back(it->first) ;
1105              weight.push_back(it->second) ;
1106              (it->first)++ ;
1107            }
1108           }
1109          if (t < dstIndWeight.size()-1) t++ ;
1110          srcIndCompressed ++ ;
1111        }
1112        srcInd++ ;
1113      }
1114    }
1115  }
1116
1117}
1118CATCH
1119
1120/*!
1121  Compute index mapping between element source and element destination with an auxiliary inputs which determine
1122position of each mapped index in global index of grid destination.
1123  \param [in] dataAuxInputs auxiliary inputs
1124*/
1125void CGenericAlgorithmTransformation::computeIndexSourceMapping(const std::vector<CArray<double,1>* >& dataAuxInputs)
1126TRY
1127{
1128  computeIndexSourceMapping_(dataAuxInputs);
1129}
1130CATCH
1131
1132std::vector<StdString> CGenericAlgorithmTransformation::getIdAuxInputs()
1133TRY
1134{
1135  return idAuxInputs_;
1136}
1137CATCH
1138
1139CGenericAlgorithmTransformation::AlgoTransType CGenericAlgorithmTransformation::type()
1140TRY
1141{
1142  return type_;
1143}
1144CATCH
1145
1146}
Note: See TracBrowser for help on using the repository browser.