]> SALOME platform Git repositories - tools/medcoupling.git/blob - src/MEDCoupling/MEDCouplingTimeDiscretization.cxx
Salome HOME
Little refactoring of progeny mechanism to avoid if.
[tools/medcoupling.git] / src / MEDCoupling / MEDCouplingTimeDiscretization.cxx
1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Anthony Geay (CEA/DEN)
20
21 #include "MEDCouplingTimeDiscretization.hxx"
22 #include "MEDCouplingAutoRefCountObjectPtr.hxx"
23 #include "MEDCouplingMemArray.hxx"
24 #include "MEDCouplingMesh.hxx"
25
26 #include <cmath>
27 #include <sstream>
28 #include <iterator>
29 #include <algorithm>
30 #include <functional>
31
32 using namespace ParaMEDMEM;
33
34 const double MEDCouplingTimeDiscretization::TIME_TOLERANCE_DFT=1.e-12;
35
36 const char MEDCouplingNoTimeLabel::EXCEPTION_MSG[]="MEDCouplingNoTimeLabel::setTime : no time info attached.";
37
38 const char MEDCouplingNoTimeLabel::REPR[]="No time label defined.";
39
40 const char MEDCouplingWithTimeStep::EXCEPTION_MSG[]="No data on this time.";
41
42 const char MEDCouplingWithTimeStep::REPR[]="One time label.";
43
44 const char MEDCouplingConstOnTimeInterval::EXCEPTION_MSG[]="No data on this time.";
45
46 const char MEDCouplingConstOnTimeInterval::REPR[]="Constant on a time interval.";
47
48 const char MEDCouplingTwoTimeSteps::EXCEPTION_MSG[]="No data on this time.";
49
50 const char MEDCouplingLinearTime::REPR[]="Linear time between 2 time steps.";
51
52 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::New(TypeOfTimeDiscretization type)
53 {
54   switch(type)
55   {
56     case MEDCouplingNoTimeLabel::DISCRETIZATION:
57       return new MEDCouplingNoTimeLabel;
58     case MEDCouplingWithTimeStep::DISCRETIZATION:
59       return new MEDCouplingWithTimeStep;
60     case MEDCouplingConstOnTimeInterval::DISCRETIZATION:
61       return new MEDCouplingConstOnTimeInterval;
62     case MEDCouplingLinearTime::DISCRETIZATION:
63       return new MEDCouplingLinearTime;
64     default:
65       throw INTERP_KERNEL::Exception("Time discretization not implemented yet");
66   }
67 }
68
69 void MEDCouplingTimeDiscretization::copyTinyAttrFrom(const MEDCouplingTimeDiscretization& other)
70 {
71   _time_tolerance=other._time_tolerance;
72   _time_unit=other._time_unit;
73 }
74
75 void MEDCouplingTimeDiscretization::copyTinyStringsFrom(const MEDCouplingTimeDiscretization& other)
76 {
77   _time_unit=other._time_unit;
78   if(_array && other._array)
79     _array->copyStringInfoFrom(*other._array);
80 }
81
82 void MEDCouplingTimeDiscretization::checkCoherency() const
83 {
84   if(!_array)
85     throw INTERP_KERNEL::Exception("Field invalid because no values set !");
86   if(_time_tolerance<0.)
87     throw INTERP_KERNEL::Exception("time tolerance is expected to be greater than 0. !");
88 }
89
90 void MEDCouplingTimeDiscretization::updateTime() const
91 {
92   if(_array)
93     updateTimeWith(*_array);
94 }
95
96 std::size_t MEDCouplingTimeDiscretization::getHeapMemorySizeWithoutChildren() const
97 {
98   std::size_t ret(_time_unit.capacity());
99   return ret;
100 }
101
102 std::vector<const BigMemoryObject *> MEDCouplingTimeDiscretization::getDirectChildrenWithNull() const
103 {
104   std::vector<const BigMemoryObject *> ret;
105   ret.push_back(_array);
106   return ret;
107 }
108
109 bool MEDCouplingTimeDiscretization::areCompatible(const MEDCouplingTimeDiscretization *other) const
110 {
111   if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16)
112     return false;
113   if(_array==0 && other->_array==0)
114     return true;
115   if(_array==0 || other->_array==0)
116     return false;
117   if(_array->getNumberOfComponents()!=other->_array->getNumberOfComponents())
118     return false;
119   return true;
120 }
121
122 bool MEDCouplingTimeDiscretization::areStrictlyCompatible(const MEDCouplingTimeDiscretization *other, std::string& reason) const
123 {
124   std::ostringstream oss; oss.precision(15);
125   if(_time_unit!=other->_time_unit)
126     {
127       oss << "Field discretizations differ : this time unit = \"" << _time_unit << "\" and other time unit = \"" << other->_time_unit << "\" !";
128       reason=oss.str();
129       return false;
130     }
131   if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16)
132     {
133       oss << "Field discretizations differ : this time tolerance = \"" << _time_tolerance << "\" and other time tolerance = \"" << other->_time_tolerance << "\" !";
134       reason=oss.str();
135       return false;
136     }
137   if(_array==0 && other->_array==0)
138     return true;
139   if(_array==0 || other->_array==0)
140     {
141       reason="Field discretizations differ : Only one timediscretization between the two this and other has a DataArrayDouble for values defined";
142       return false;
143     }
144   if(_array->getNumberOfComponents()!=other->_array->getNumberOfComponents())
145     return false;
146   if(_array->getNumberOfTuples()!=other->_array->getNumberOfTuples())
147     return false;
148   return true;
149 }
150
151 bool MEDCouplingTimeDiscretization::areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const
152 {
153   if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16)
154     return false;
155   if(_array==0 && other->_array==0)
156     return true;
157   if(_array==0 || other->_array==0)
158     return false;
159   if(_array->getNumberOfTuples()!=other->_array->getNumberOfTuples())
160     return false;
161   return true;
162 }
163
164 bool MEDCouplingTimeDiscretization::areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretization *other) const
165 {
166   if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16)
167     return false;
168   if(_array==0 && other->_array==0)
169     return true;
170   if(_array==0 || other->_array==0)
171     return false;
172   int nbC1=_array->getNumberOfComponents();
173   int nbC2=other->_array->getNumberOfComponents();
174   int nbMin=std::min(nbC1,nbC2);
175   if(nbC1!=nbC2 && nbMin!=1)
176     return false;
177   return true;
178 }
179
180 bool MEDCouplingTimeDiscretization::areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretization *other) const
181 {
182   if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16)
183     return false;
184   if(_array==0 && other->_array==0)
185     return true;
186   if(_array==0 || other->_array==0)
187     return false;
188   int nbC1=_array->getNumberOfComponents();
189   int nbC2=other->_array->getNumberOfComponents();
190   if(nbC1!=nbC2 && nbC2!=1)
191     return false;
192   return true;
193 }
194
195 bool MEDCouplingTimeDiscretization::isEqualIfNotWhy(const MEDCouplingTimeDiscretization *other, double prec, std::string& reason) const
196 {
197   if(!areStrictlyCompatible(other,reason))
198     return false;
199   if(_array==other->_array)
200     return true;
201   return _array->isEqualIfNotWhy(*other->_array,prec,reason);
202 }
203
204 bool MEDCouplingTimeDiscretization::isEqual(const MEDCouplingTimeDiscretization *other, double prec) const
205 {
206   std::string reason;
207   return isEqualIfNotWhy(other,prec,reason);
208 }
209
210 bool MEDCouplingTimeDiscretization::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretization *other, double prec) const
211 {
212   std::string tmp;
213   if(!areStrictlyCompatible(other,tmp))
214     return false;
215   if(_array==other->_array)
216     return true;
217   return _array->isEqualWithoutConsideringStr(*other->_array,prec);
218 }
219
220 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::buildNewTimeReprFromThis(TypeOfTimeDiscretization type, bool deepCpy) const
221 {
222   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(type);
223   ret->setTimeUnit(getTimeUnit());
224   const DataArrayDouble *arrSrc=getArray();
225   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr;
226   if(arrSrc)
227     arr=arrSrc->performCpy(deepCpy);
228   ret->setArray(arr,0);
229   return ret;
230 }
231
232 void MEDCouplingTimeDiscretization::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
233 {
234   if(_array)
235     {
236       tinyInfo.push_back(_array->getNumberOfTuples());
237       tinyInfo.push_back(_array->getNumberOfComponents());
238     }
239   else
240     {
241       tinyInfo.push_back(-1);
242       tinyInfo.push_back(-1);
243     }
244 }
245
246 void MEDCouplingTimeDiscretization::resizeForUnserialization(const std::vector<int>& tinyInfoI, std::vector<DataArrayDouble *>& arrays)
247 {
248   arrays.resize(1);
249   if(_array!=0)
250     _array->decrRef();
251   DataArrayDouble *arr=0;
252   if(tinyInfoI[0]!=-1 && tinyInfoI[1]!=-1)
253     {
254       arr=DataArrayDouble::New();
255       arr->alloc(tinyInfoI[0],tinyInfoI[1]);
256     }
257   _array=arr;
258   arrays[0]=arr;
259 }
260
261 void MEDCouplingTimeDiscretization::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS)
262 {
263   _time_tolerance=tinyInfoD[0];
264   int nbOfCompo=_array->getNumberOfComponents();
265   for(int i=0;i<nbOfCompo;i++)
266     _array->setInfoOnComponent(i,tinyInfoS[i]);
267 }
268
269 void MEDCouplingTimeDiscretization::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
270 {
271   tinyInfo.push_back(_time_tolerance);
272 }
273
274 void MEDCouplingTimeDiscretization::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
275 {
276   int nbOfCompo=_array->getNumberOfComponents();
277   for(int i=0;i<nbOfCompo;i++)
278     tinyInfo.push_back(_array->getInfoOnComponent(i));
279 }
280
281 MEDCouplingTimeDiscretization::MEDCouplingTimeDiscretization():_time_tolerance(TIME_TOLERANCE_DFT),_array(0)
282 {
283 }
284
285 MEDCouplingTimeDiscretization::MEDCouplingTimeDiscretization(const MEDCouplingTimeDiscretization& other, bool deepCpy):_time_unit(other._time_unit),_time_tolerance(other._time_tolerance)
286 {
287   if(other._array)
288     _array=other._array->performCpy(deepCpy);
289   else
290     _array=0;
291 }
292
293 MEDCouplingTimeDiscretization::~MEDCouplingTimeDiscretization()
294 {
295   if(_array)
296     _array->decrRef();
297 }
298
299 void MEDCouplingTimeDiscretization::setArray(DataArrayDouble *array, TimeLabel *owner)
300 {
301   if(array!=_array)
302     {
303       if(_array)
304         _array->decrRef();
305       _array=array;
306       if(_array)
307         _array->incrRef();
308       if(owner)
309         owner->declareAsNew();
310     }
311 }
312
313 const DataArrayDouble *MEDCouplingTimeDiscretization::getEndArray() const
314 {
315   throw INTERP_KERNEL::Exception("getEndArray not available for this type of time discretization !");
316 }
317
318 DataArrayDouble *MEDCouplingTimeDiscretization::getEndArray()
319 {
320   throw INTERP_KERNEL::Exception("getEndArray not available for this type of time discretization !");
321 }
322
323 void MEDCouplingTimeDiscretization::setEndArray(DataArrayDouble *array, TimeLabel *owner)
324 {
325   throw INTERP_KERNEL::Exception("setEndArray not available for this type of time discretization !");
326 }
327
328 void MEDCouplingTimeDiscretization::setArrays(const std::vector<DataArrayDouble *>& arrays, TimeLabel *owner)
329 {
330   if(arrays.size()!=1)
331     throw INTERP_KERNEL::Exception("MEDCouplingTimeDiscretization::setArrays : number of arrays must be one.");
332   setArray(arrays.back(),owner);
333 }
334
335 void MEDCouplingTimeDiscretization::getArrays(std::vector<DataArrayDouble *>& arrays) const
336 {
337   arrays.resize(1);
338   arrays[0]=_array;
339 }
340
341 bool MEDCouplingTimeDiscretization::isBefore(const MEDCouplingTimeDiscretization *other) const
342 {
343   int iteration,order;
344   double time1=getEndTime(iteration,order)-_time_tolerance;
345   double time2=other->getStartTime(iteration,order)+other->getTimeTolerance();
346   return time1<=time2;
347 }
348
349 bool MEDCouplingTimeDiscretization::isStrictlyBefore(const MEDCouplingTimeDiscretization *other) const
350 {
351   int iteration,order;
352   double time1=getEndTime(iteration,order)+_time_tolerance;
353   double time2=other->getStartTime(iteration,order)-other->getTimeTolerance();
354   return time1<time2;
355 }
356
357 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::doublyContractedProduct() const
358 {
359   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
360   ret->setTimeUnit(getTimeUnit());
361   std::vector<DataArrayDouble *> arrays;
362   getArrays(arrays);
363   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
364   for(std::size_t j=0;j<arrays.size();j++)
365     {
366       if(arrays[j])
367         arrays2[j]=arrays[j]->doublyContractedProduct();
368       else
369         arrays2[j]=0;
370     }
371   std::vector<DataArrayDouble *> arrays3(arrays.size());
372   for(std::size_t j=0;j<arrays.size();j++)
373     arrays3[j]=arrays2[j];
374   ret->setArrays(arrays3,0);
375   return ret;
376 }
377
378 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::determinant() const
379 {
380   std::vector<DataArrayDouble *> arrays;
381   getArrays(arrays);
382   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
383   for(std::size_t j=0;j<arrays.size();j++)
384     {
385       if(arrays[j])
386         arrays2[j]=arrays[j]->determinant();
387       else
388         arrays2[j]=0;
389     }
390   std::vector<DataArrayDouble *> arrays3(arrays.size());
391   for(std::size_t j=0;j<arrays.size();j++)
392     arrays3[j]=arrays2[j];
393   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
394   ret->setTimeUnit(getTimeUnit());
395   ret->setArrays(arrays3,0);
396   return ret;
397 }
398
399 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::eigenValues() const
400 {
401   std::vector<DataArrayDouble *> arrays;
402   getArrays(arrays);
403   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
404   for(std::size_t j=0;j<arrays.size();j++)
405     {
406       if(arrays[j])
407         arrays2[j]=arrays[j]->eigenValues();
408       else
409         arrays2[j]=0;
410     }
411   std::vector<DataArrayDouble *> arrays3(arrays.size());
412   for(std::size_t j=0;j<arrays.size();j++)
413     arrays3[j]=arrays2[j];
414   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
415   ret->setTimeUnit(getTimeUnit());
416   ret->setArrays(arrays3,0);
417   return ret;
418 }
419
420 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::eigenVectors() const
421 {
422   std::vector<DataArrayDouble *> arrays;
423   getArrays(arrays);
424   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
425   for(std::size_t j=0;j<arrays.size();j++)
426     {
427       if(arrays[j])
428         arrays2[j]=arrays[j]->eigenVectors();
429       else
430         arrays2[j]=0;
431     }
432   std::vector<DataArrayDouble *> arrays3(arrays.size());
433   for(std::size_t j=0;j<arrays.size();j++)
434     arrays3[j]=arrays2[j];
435   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
436   ret->setTimeUnit(getTimeUnit());
437   ret->setArrays(arrays3,0);
438   return ret;
439 }
440
441 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::inverse() const
442 {
443   std::vector<DataArrayDouble *> arrays;
444   getArrays(arrays);
445   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
446   for(std::size_t j=0;j<arrays.size();j++)
447     {
448       if(arrays[j])
449         arrays2[j]=arrays[j]->inverse();
450       else
451         arrays2[j]=0;
452     }
453   std::vector<DataArrayDouble *> arrays3(arrays.size());
454   for(std::size_t j=0;j<arrays.size();j++)
455     arrays3[j]=arrays2[j];
456   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
457   ret->setTimeUnit(getTimeUnit());
458   ret->setArrays(arrays3,0);
459   return ret;
460 }
461
462 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::trace() const
463 {
464   std::vector<DataArrayDouble *> arrays;
465   getArrays(arrays);
466   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
467   for(std::size_t j=0;j<arrays.size();j++)
468     {
469       if(arrays[j])
470         arrays2[j]=arrays[j]->trace();
471       else
472         arrays2[j]=0;
473     }
474   std::vector<DataArrayDouble *> arrays3(arrays.size());
475   for(std::size_t j=0;j<arrays.size();j++)
476     arrays3[j]=arrays2[j];
477   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
478   ret->setTimeUnit(getTimeUnit());
479   ret->setArrays(arrays3,0);
480   return ret;
481 }
482
483 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::deviator() const
484 {
485   std::vector<DataArrayDouble *> arrays;
486   getArrays(arrays);
487   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
488   for(std::size_t j=0;j<arrays.size();j++)
489     {
490       if(arrays[j])
491         arrays2[j]=arrays[j]->deviator();
492       else
493         arrays2[j]=0;
494     }
495   std::vector<DataArrayDouble *> arrays3(arrays.size());
496   for(std::size_t j=0;j<arrays.size();j++)
497     arrays3[j]=arrays2[j];
498   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
499   ret->setTimeUnit(getTimeUnit());
500   ret->setArrays(arrays3,0);
501   return ret;
502 }
503
504 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::magnitude() const
505 {
506   std::vector<DataArrayDouble *> arrays;
507   getArrays(arrays);
508   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
509   for(std::size_t j=0;j<arrays.size();j++)
510     {
511       if(arrays[j])
512         arrays2[j]=arrays[j]->magnitude();
513       else
514         arrays2[j]=0;
515     }
516   std::vector<DataArrayDouble *> arrays3(arrays.size());
517   for(std::size_t j=0;j<arrays.size();j++)
518     arrays3[j]=arrays2[j];
519   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
520   ret->setTimeUnit(getTimeUnit());
521   ret->setArrays(arrays3,0);
522   return ret;
523 }
524
525 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::negate() const
526 {
527   std::vector<DataArrayDouble *> arrays;
528   getArrays(arrays);
529   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
530   for(std::size_t j=0;j<arrays.size();j++)
531     {
532       if(arrays[j])
533         arrays2[j]=arrays[j]->negate();
534       else
535         arrays2[j]=0;
536     }
537   std::vector<DataArrayDouble *> arrays3(arrays.size());
538   for(std::size_t j=0;j<arrays.size();j++)
539     arrays3[j]=arrays2[j];
540   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
541   ret->setTimeUnit(getTimeUnit());
542   ret->setArrays(arrays3,0);
543   return ret;
544 }
545
546 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::maxPerTuple() const
547 {
548   std::vector<DataArrayDouble *> arrays;
549   getArrays(arrays);
550   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
551   for(std::size_t j=0;j<arrays.size();j++)
552     {
553       if(arrays[j])
554         arrays2[j]=arrays[j]->maxPerTuple();
555       else
556         arrays2[j]=0;
557     }
558   std::vector<DataArrayDouble *> arrays3(arrays.size());
559   for(std::size_t j=0;j<arrays.size();j++)
560     arrays3[j]=arrays2[j];
561   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
562   ret->setTimeUnit(getTimeUnit());
563   ret->setArrays(arrays3,0);
564   return ret;
565 }
566
567 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::keepSelectedComponents(const std::vector<int>& compoIds) const
568 {
569   std::vector<DataArrayDouble *> arrays;
570   getArrays(arrays);
571   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
572   for(std::size_t j=0;j<arrays.size();j++)
573     {
574       if(arrays[j])
575         arrays2[j]=static_cast<DataArrayDouble *>(arrays[j]->keepSelectedComponents(compoIds));
576       else
577         arrays2[j]=0;
578     }
579   std::vector<DataArrayDouble *> arrays3(arrays.size());
580   for(std::size_t j=0;j<arrays.size();j++)
581     arrays3[j]=arrays2[j];
582   MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
583   ret->setTimeUnit(getTimeUnit());
584   ret->setArrays(arrays3,0);
585   return ret;
586 }
587
588 void MEDCouplingTimeDiscretization::setSelectedComponents(const MEDCouplingTimeDiscretization *other, const std::vector<int>& compoIds)
589 {
590   std::vector<DataArrayDouble *> arrays1,arrays2;
591   getArrays(arrays1);
592   other->getArrays(arrays2);
593   if(arrays1.size()!=arrays2.size())
594     throw INTERP_KERNEL::Exception("TimeDiscretization::setSelectedComponents : number of arrays mismatch !");
595   for(std::size_t i=0;i<arrays1.size();i++)
596     {
597       if(arrays1[i]!=0 && arrays2[i]!=0)
598         arrays1[i]->setSelectedComponents(arrays2[i],compoIds);
599       else if(arrays1[i]!=0 || arrays2[i]!=0)
600         throw INTERP_KERNEL::Exception("TimeDiscretization::setSelectedComponents : some time array in correspondance are not defined symetrically !");
601     }
602 }
603
604 void MEDCouplingTimeDiscretization::changeNbOfComponents(int newNbOfComp, double dftValue)
605 {
606   std::vector<DataArrayDouble *> arrays;
607   getArrays(arrays);
608   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
609   for(std::size_t j=0;j<arrays.size();j++)
610     {
611       if(arrays[j])
612         arrays2[j]=arrays[j]->changeNbOfComponents(newNbOfComp,dftValue);
613       else
614         arrays2[j]=0;
615     }
616   std::vector<DataArrayDouble *> arrays3(arrays.size());
617   for(std::size_t j=0;j<arrays.size();j++)
618     arrays3[j]=arrays2[j];
619   setArrays(arrays3,0);
620 }
621
622 void MEDCouplingTimeDiscretization::sortPerTuple(bool asc)
623 {
624   std::vector<DataArrayDouble *> arrays;
625   getArrays(arrays);
626   for(std::size_t j=0;j<arrays.size();j++)
627     {
628       if(arrays[j])
629         arrays[j]->sortPerTuple(asc);
630     }
631 }
632
633 void MEDCouplingTimeDiscretization::setUniformValue(int nbOfTuple, int nbOfCompo, double value)
634 {
635   std::vector<DataArrayDouble *> arrays;
636   getArrays(arrays);
637   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
638   for(std::size_t j=0;j<arrays.size();j++)
639     {
640       if(arrays[j])
641         {
642           arrays2[j]=arrays[j]->changeNbOfComponents(nbOfCompo,value);
643           arrays2[j]->fillWithValue(value);
644         }
645       else
646         {
647           arrays2[j]=DataArrayDouble::New();
648           arrays2[j]->alloc(nbOfTuple,nbOfCompo);
649           arrays2[j]->fillWithValue(value);
650         }
651     }
652   std::vector<DataArrayDouble *> arrays3(arrays.size());
653   for(std::size_t j=0;j<arrays.size();j++)
654     arrays3[j]=arrays2[j];
655   setArrays(arrays3,0);
656 }
657
658 void MEDCouplingTimeDiscretization::setOrCreateUniformValueOnAllComponents(int nbOfTuple, double value)
659 {
660   std::vector<DataArrayDouble *> arrays;
661   getArrays(arrays);
662   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
663   bool newArr=false;
664   for(std::size_t j=0;j<arrays.size();j++)
665     {
666       if(arrays[j])
667         {
668           arrays2[j]=arrays[j]; arrays2[j]->incrRef();
669           arrays2[j]->fillWithValue(value);
670         }
671       else
672         {
673           newArr=true;
674           arrays2[j]=DataArrayDouble::New();
675           arrays2[j]->alloc(nbOfTuple,1);
676           arrays2[j]->fillWithValue(value);
677         }
678     }
679   if(newArr)
680     {
681       std::vector<DataArrayDouble *> arrays3(arrays.size());
682       for(std::size_t j=0;j<arrays.size();j++)
683         arrays3[j]=arrays2[j];
684       setArrays(arrays3,0);
685     }
686 }
687
688 void MEDCouplingTimeDiscretization::applyLin(double a, double b, int compoId)
689 {
690   std::vector<DataArrayDouble *> arrays;
691   getArrays(arrays);
692   for(std::size_t j=0;j<arrays.size();j++)
693     {
694       if(arrays[j])
695         arrays[j]->applyLin(a,b,compoId);
696     }
697 }
698
699 void MEDCouplingTimeDiscretization::applyLin(double a, double b)
700 {
701   std::vector<DataArrayDouble *> arrays;
702   getArrays(arrays);
703   for(std::size_t j=0;j<arrays.size();j++)
704     {
705       if(arrays[j])
706         arrays[j]->applyLin(a,b);
707     }
708 }
709
710 void MEDCouplingTimeDiscretization::applyFunc(int nbOfComp, FunctionToEvaluate func)
711 {
712   std::vector<DataArrayDouble *> arrays;
713   getArrays(arrays);
714   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
715   for(std::size_t j=0;j<arrays.size();j++)
716     {
717       if(arrays[j])
718         arrays2[j]=arrays[j]->applyFunc(nbOfComp,func);
719       else
720         arrays2[j]=0;
721     }
722   std::vector<DataArrayDouble *> arrays3(arrays.size());
723   for(std::size_t j=0;j<arrays.size();j++)
724     arrays3[j]=arrays2[j];
725   setArrays(arrays3,0);
726 }
727
728 void MEDCouplingTimeDiscretization::applyFunc(int nbOfComp, const std::string& func)
729 {
730   std::vector<DataArrayDouble *> arrays;
731   getArrays(arrays);
732   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
733   for(std::size_t j=0;j<arrays.size();j++)
734     {
735       if(arrays[j])
736         arrays2[j]=arrays[j]->applyFunc(nbOfComp,func);
737       else
738         arrays2[j]=0;
739     }
740   std::vector<DataArrayDouble *> arrays3(arrays.size());
741   for(std::size_t j=0;j<arrays.size();j++)
742     arrays3[j]=arrays2[j];
743   setArrays(arrays3,0);
744 }
745
746 void MEDCouplingTimeDiscretization::applyFunc2(int nbOfComp, const std::string& func)
747 {
748   std::vector<DataArrayDouble *> arrays;
749   getArrays(arrays);
750   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
751   for(std::size_t j=0;j<arrays.size();j++)
752     {
753       if(arrays[j])
754         arrays2[j]=arrays[j]->applyFunc2(nbOfComp,func);
755       else
756         arrays2[j]=0;
757     }
758   std::vector<DataArrayDouble *> arrays3(arrays.size());
759   for(std::size_t j=0;j<arrays.size();j++)
760     arrays3[j]=arrays2[j];
761   setArrays(arrays3,0);
762 }
763
764 void MEDCouplingTimeDiscretization::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func)
765 {
766   std::vector<DataArrayDouble *> arrays;
767   getArrays(arrays);
768   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
769   for(std::size_t j=0;j<arrays.size();j++)
770     {
771       if(arrays[j])
772         arrays2[j]=arrays[j]->applyFunc3(nbOfComp,varsOrder,func);
773       else
774         arrays2[j]=0;
775     }
776   std::vector<DataArrayDouble *> arrays3(arrays.size());
777   for(std::size_t j=0;j<arrays.size();j++)
778     arrays3[j]=arrays2[j];
779   setArrays(arrays3,0);
780 }
781
782 void MEDCouplingTimeDiscretization::applyFunc(const std::string& func)
783 {
784   std::vector<DataArrayDouble *> arrays;
785   getArrays(arrays);
786   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
787   for(std::size_t j=0;j<arrays.size();j++)
788     {
789       if(arrays[j])
790         arrays2[j]=arrays[j]->applyFunc(func);
791       else
792         arrays2[j]=0;
793     }
794   std::vector<DataArrayDouble *> arrays3(arrays.size());
795   for(std::size_t j=0;j<arrays.size();j++)
796     arrays3[j]=arrays2[j];
797   setArrays(arrays3,0);
798 }
799
800 void MEDCouplingTimeDiscretization::applyFuncFast32(const std::string& func)
801 {
802   std::vector<DataArrayDouble *> arrays;
803   getArrays(arrays);
804   for(std::size_t j=0;j<arrays.size();j++)
805     {
806       if(arrays[j])
807         arrays[j]->applyFuncFast32(func);
808     }
809 }
810
811 void MEDCouplingTimeDiscretization::applyFuncFast64(const std::string& func)
812 {
813   std::vector<DataArrayDouble *> arrays;
814   getArrays(arrays);
815   for(std::size_t j=0;j<arrays.size();j++)
816     {
817       if(arrays[j])
818         arrays[j]->applyFuncFast64(func);
819     }
820 }
821
822 void MEDCouplingTimeDiscretization::fillFromAnalytic(const DataArrayDouble *loc, int nbOfComp, FunctionToEvaluate func)
823 {
824   std::vector<DataArrayDouble *> arrays;
825   getArrays(arrays);
826   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
827   for(std::size_t j=0;j<arrays.size();j++)
828     arrays2[j]=loc->applyFunc(nbOfComp,func);
829   std::vector<DataArrayDouble *> arrays3(arrays.size());
830   for(std::size_t j=0;j<arrays.size();j++)
831     arrays3[j]=arrays2[j];
832   setArrays(arrays3,0);
833 }
834
835 void MEDCouplingTimeDiscretization::fillFromAnalytic(const DataArrayDouble *loc, int nbOfComp, const std::string& func)
836 {
837   std::vector<DataArrayDouble *> arrays;
838   getArrays(arrays);
839   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
840   for(std::size_t j=0;j<arrays.size();j++)
841     arrays2[j]=loc->applyFunc(nbOfComp,func);
842   std::vector<DataArrayDouble *> arrays3(arrays.size());
843   for(std::size_t j=0;j<arrays.size();j++)
844     arrays3[j]=arrays2[j];
845   setArrays(arrays3,0);
846 }
847
848 void MEDCouplingTimeDiscretization::fillFromAnalytic2(const DataArrayDouble *loc, int nbOfComp, const std::string& func)
849 {
850   std::vector<DataArrayDouble *> arrays;
851   getArrays(arrays);
852   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
853   for(std::size_t j=0;j<arrays.size();j++)
854     arrays2[j]=loc->applyFunc2(nbOfComp,func);
855   std::vector<DataArrayDouble *> arrays3(arrays.size());
856   for(std::size_t j=0;j<arrays.size();j++)
857     arrays3[j]=arrays2[j];
858   setArrays(arrays3,0);
859 }
860
861 void MEDCouplingTimeDiscretization::fillFromAnalytic3(const DataArrayDouble *loc, int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func)
862 {
863   std::vector<DataArrayDouble *> arrays;
864   getArrays(arrays);
865   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
866   for(std::size_t j=0;j<arrays.size();j++)
867     arrays2[j]=loc->applyFunc3(nbOfComp,varsOrder,func);
868   std::vector<DataArrayDouble *> arrays3(arrays.size());
869   for(std::size_t j=0;j<arrays.size();j++)
870     arrays3[j]=arrays2[j];
871   setArrays(arrays3,0);
872 }
873
874 MEDCouplingNoTimeLabel::MEDCouplingNoTimeLabel()
875 {
876 }
877
878 MEDCouplingNoTimeLabel::MEDCouplingNoTimeLabel(const MEDCouplingTimeDiscretization& other, bool deepCpy):MEDCouplingTimeDiscretization(other,deepCpy)
879 {
880 }
881
882 std::string MEDCouplingNoTimeLabel::getStringRepr() const
883 {
884   std::ostringstream stream;
885   stream << REPR;
886   stream << "\nTime unit is : \"" << _time_unit << "\"";
887   return stream.str();
888 }
889
890 void MEDCouplingNoTimeLabel::synchronizeTimeWith(const MEDCouplingMesh *mesh)
891 {
892   throw INTERP_KERNEL::Exception("MEDCouplingNoTimeLabel::synchronizeTimeWith : impossible to synchronize time with a MEDCouplingMesh because the time discretization is incompatible with it !");
893 }
894
895 bool MEDCouplingNoTimeLabel::areCompatible(const MEDCouplingTimeDiscretization *other) const
896 {
897   if(!MEDCouplingTimeDiscretization::areCompatible(other))
898     return false;
899   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
900   return otherC!=0;
901 }
902
903 bool MEDCouplingNoTimeLabel::areStrictlyCompatible(const MEDCouplingTimeDiscretization *other, std::string& reason) const
904 {
905   if(!MEDCouplingTimeDiscretization::areStrictlyCompatible(other,reason))
906     return false;
907   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
908   bool ret=otherC!=0;
909   if(!ret)
910     reason.insert(0,"time discretization of this is NO_TIME, other has a different time discretization.");
911   return ret;
912 }
913
914 bool MEDCouplingNoTimeLabel::areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretization *other) const
915 {
916   if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForMul(other))
917     return false;
918   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
919   return otherC!=0;
920 }
921
922 bool MEDCouplingNoTimeLabel::areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretization *other) const
923 {
924   if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForDiv(other))
925     return false;
926   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
927   return otherC!=0;
928 }
929
930 bool MEDCouplingNoTimeLabel::areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const
931 {
932   if(!MEDCouplingTimeDiscretization::areCompatibleForMeld(other))
933     return false;
934   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
935   return otherC!=0;
936 }
937
938 bool MEDCouplingNoTimeLabel::isEqualIfNotWhy(const MEDCouplingTimeDiscretization *other, double prec, std::string& reason) const
939 {
940   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
941   if(!otherC)
942     {
943       reason="This has time discretization NO_TIME, other not.";
944       return false;
945     }
946   return MEDCouplingTimeDiscretization::isEqualIfNotWhy(other,prec,reason);
947 }
948
949 bool MEDCouplingNoTimeLabel::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretization *other, double prec) const
950 {
951   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
952   if(!otherC)
953     return false;
954   return MEDCouplingTimeDiscretization::isEqualWithoutConsideringStr(other,prec);
955 }
956
957 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::aggregate(const MEDCouplingTimeDiscretization *other) const
958 {
959   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
960   if(!otherC)
961     throw INTERP_KERNEL::Exception("NoTimeLabel::aggregation on mismatched time discretization !");
962   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Aggregate(getArray(),other->getArray());
963   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
964   ret->setArray(arr,0);
965   return ret;
966 }
967
968 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const
969 {
970   std::vector<const DataArrayDouble *> a(other.size());
971   int i=0;
972   for(std::vector<const MEDCouplingTimeDiscretization *>::const_iterator it=other.begin();it!=other.end();it++,i++)
973     {
974       const MEDCouplingNoTimeLabel *itC=dynamic_cast<const MEDCouplingNoTimeLabel *>(*it);
975       if(!itC)
976         throw INTERP_KERNEL::Exception("NoTimeLabel::aggregate on mismatched time discretization !");
977       a[i]=itC->getArray();
978     }
979   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Aggregate(a);
980   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
981   ret->setArray(arr,0);
982   return ret;
983 }
984
985 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::meld(const MEDCouplingTimeDiscretization *other) const
986 {
987   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
988   if(!otherC)
989     throw INTERP_KERNEL::Exception("NoTimeLabel::meld on mismatched time discretization !");
990   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Meld(getArray(),other->getArray());
991   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
992   ret->setTimeTolerance(getTimeTolerance());
993   ret->setArray(arr,0);
994   return ret;
995 }
996
997 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::dot(const MEDCouplingTimeDiscretization *other) const
998 {
999   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1000   if(!otherC)
1001     throw INTERP_KERNEL::Exception("NoTimeLabel::dot on mismatched time discretization !");
1002   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Dot(getArray(),other->getArray());
1003   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
1004   ret->setArray(arr,0);
1005   return ret;
1006 }
1007
1008 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::crossProduct(const MEDCouplingTimeDiscretization *other) const
1009 {
1010   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1011   if(!otherC)
1012     throw INTERP_KERNEL::Exception("NoTimeLabel::crossProduct on mismatched time discretization !");
1013   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::CrossProduct(getArray(),other->getArray());
1014   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
1015   ret->setArray(arr,0);
1016   return ret;
1017 }
1018
1019 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::max(const MEDCouplingTimeDiscretization *other) const
1020 {
1021   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1022   if(!otherC)
1023     throw INTERP_KERNEL::Exception("NoTimeLabel::max on mismatched time discretization !");
1024   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Max(getArray(),other->getArray());
1025   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
1026   ret->setArray(arr,0);
1027   return ret;
1028 }
1029
1030 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::min(const MEDCouplingTimeDiscretization *other) const
1031 {
1032   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1033   if(!otherC)
1034     throw INTERP_KERNEL::Exception("NoTimeLabel::max on mismatched time discretization !");
1035   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Min(getArray(),other->getArray());
1036   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
1037   ret->setArray(arr,0);
1038   return ret;
1039 }
1040
1041 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::add(const MEDCouplingTimeDiscretization *other) const
1042 {
1043   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1044   if(!otherC)
1045     throw INTERP_KERNEL::Exception("NoTimeLabel::add on mismatched time discretization !");
1046   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Add(getArray(),other->getArray());
1047   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
1048   ret->setArray(arr,0);
1049   return ret;
1050 }
1051
1052 void MEDCouplingNoTimeLabel::addEqual(const MEDCouplingTimeDiscretization *other)
1053 {
1054   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1055   if(!otherC)
1056     throw INTERP_KERNEL::Exception("NoTimeLabel::addEqual on mismatched time discretization !");
1057   if(!getArray())
1058     throw INTERP_KERNEL::Exception("MEDCouplingNoTimeLabel::addEqual : Data Array is NULL !");
1059   getArray()->addEqual(other->getArray());
1060 }
1061
1062 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::substract(const MEDCouplingTimeDiscretization *other) const
1063 {
1064   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1065   if(!otherC)
1066     throw INTERP_KERNEL::Exception("NoTimeLabel::substract on mismatched time discretization !");
1067   if(!getArray())
1068     throw INTERP_KERNEL::Exception("MEDCouplingNoTimeLabel::substract : Data Array is NULL !");
1069   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Substract(getArray(),other->getArray());
1070   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
1071   ret->setArray(arr,0);
1072   return ret;
1073 }
1074
1075 void MEDCouplingNoTimeLabel::substractEqual(const MEDCouplingTimeDiscretization *other)
1076 {
1077   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1078   if(!otherC)
1079     throw INTERP_KERNEL::Exception("NoTimeLabel::substractEqual on mismatched time discretization !");
1080   if(!getArray())
1081     throw INTERP_KERNEL::Exception("MEDCouplingNoTimeLabel::substractEqual : Data Array is NULL !");
1082   getArray()->substractEqual(other->getArray());
1083 }
1084
1085 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::multiply(const MEDCouplingTimeDiscretization *other) const
1086 {
1087   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1088   if(!otherC)
1089     throw INTERP_KERNEL::Exception("NoTimeLabel::multiply on mismatched time discretization !");
1090   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Multiply(getArray(),other->getArray());
1091   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
1092   ret->setArray(arr,0);
1093   return ret;
1094 }
1095
1096 void MEDCouplingNoTimeLabel::multiplyEqual(const MEDCouplingTimeDiscretization *other)
1097 {
1098   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1099   if(!otherC)
1100     throw INTERP_KERNEL::Exception("NoTimeLabel::multiplyEqual on mismatched time discretization !");
1101   if(!getArray())
1102     throw INTERP_KERNEL::Exception("MEDCouplingNoTimeLabel::multiplyEqual : Data Array is NULL !");
1103   getArray()->multiplyEqual(other->getArray());
1104 }
1105
1106 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::divide(const MEDCouplingTimeDiscretization *other) const
1107 {
1108   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1109   if(!otherC)
1110     throw INTERP_KERNEL::Exception("divide on mismatched time discretization !");
1111   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Divide(getArray(),other->getArray());
1112   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
1113   ret->setArray(arr,0);
1114   return ret;
1115 }
1116
1117 void MEDCouplingNoTimeLabel::divideEqual(const MEDCouplingTimeDiscretization *other)
1118 {
1119   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1120   if(!otherC)
1121     throw INTERP_KERNEL::Exception("NoTimeLabel::divideEqual on mismatched time discretization !");
1122   if(!getArray())
1123     throw INTERP_KERNEL::Exception("MEDCouplingNoTimeLabel::divideEqual : Data Array is NULL !");
1124   getArray()->divideEqual(other->getArray());
1125 }
1126
1127 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::pow(const MEDCouplingTimeDiscretization *other) const
1128 {
1129   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1130   if(!otherC)
1131     throw INTERP_KERNEL::Exception("pow on mismatched time discretization !");
1132   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Pow(getArray(),other->getArray());
1133   MEDCouplingNoTimeLabel *ret=new MEDCouplingNoTimeLabel;
1134   ret->setArray(arr,0);
1135   return ret;
1136 }
1137
1138 void MEDCouplingNoTimeLabel::powEqual(const MEDCouplingTimeDiscretization *other)
1139 {
1140   const MEDCouplingNoTimeLabel *otherC=dynamic_cast<const MEDCouplingNoTimeLabel *>(other);
1141   if(!otherC)
1142     throw INTERP_KERNEL::Exception("NoTimeLabel::powEqual on mismatched time discretization !");
1143   if(!getArray())
1144     throw INTERP_KERNEL::Exception("MEDCouplingNoTimeLabel::powEqual : Data Array is NULL !");
1145   getArray()->powEqual(other->getArray());
1146 }
1147
1148 MEDCouplingTimeDiscretization *MEDCouplingNoTimeLabel::performCpy(bool deepCpy) const
1149 {
1150   return new MEDCouplingNoTimeLabel(*this,deepCpy);
1151 }
1152
1153 void MEDCouplingNoTimeLabel::checkTimePresence(double time) const
1154 {
1155   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1156 }
1157
1158 std::vector< const DataArrayDouble *> MEDCouplingNoTimeLabel::getArraysForTime(double time) const
1159 {
1160   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1161 }
1162
1163 void MEDCouplingNoTimeLabel::getValueForTime(double time, const std::vector<double>& vals, double *res) const
1164 {
1165   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1166 }
1167
1168 bool MEDCouplingNoTimeLabel::isBefore(const MEDCouplingTimeDiscretization *other) const
1169 {
1170   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1171 }
1172
1173 bool MEDCouplingNoTimeLabel::isStrictlyBefore(const MEDCouplingTimeDiscretization *other) const
1174 {
1175   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1176 }
1177
1178 double MEDCouplingNoTimeLabel::getStartTime(int& iteration, int& order) const
1179 {
1180   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1181 }
1182
1183 double MEDCouplingNoTimeLabel::getEndTime(int& iteration, int& order) const
1184 {
1185   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1186 }
1187
1188 void MEDCouplingNoTimeLabel::setStartIteration(int it)
1189 {
1190   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1191 }
1192
1193 void MEDCouplingNoTimeLabel::setEndIteration(int it)
1194 {
1195   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1196 }
1197
1198 void MEDCouplingNoTimeLabel::setStartOrder(int order)
1199 {
1200   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1201 }
1202
1203 void MEDCouplingNoTimeLabel::setEndOrder(int order)
1204 {
1205   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1206 }
1207
1208 void MEDCouplingNoTimeLabel::setStartTimeValue(double time)
1209 {
1210   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1211 }
1212
1213 void MEDCouplingNoTimeLabel::setEndTimeValue(double time)
1214 {
1215   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1216 }
1217
1218 void MEDCouplingNoTimeLabel::setStartTime(double time, int iteration, int order)
1219 {
1220   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1221 }
1222
1223 void MEDCouplingNoTimeLabel::setEndTime(double time, int iteration, int order)
1224 {
1225   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1226 }
1227
1228 void MEDCouplingNoTimeLabel::getValueOnTime(int eltId, double time, double *value) const
1229 {
1230   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1231 }
1232
1233 void MEDCouplingNoTimeLabel::getValueOnDiscTime(int eltId, int iteration, int order, double *value) const
1234 {
1235   throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1236 }
1237
1238 /*!
1239  * idem getTinySerializationIntInformation except that it is for multi field fetch
1240  */
1241 void MEDCouplingNoTimeLabel::getTinySerializationIntInformation2(std::vector<int>& tinyInfo) const
1242 {
1243   tinyInfo.clear();
1244 }
1245
1246 /*!
1247  * idem getTinySerializationDbleInformation except that it is for multi field fetch
1248  */
1249 void MEDCouplingNoTimeLabel::getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const
1250 {
1251   tinyInfo.resize(1);
1252   tinyInfo[0]=_time_tolerance;
1253 }
1254
1255 /*!
1256  * idem finishUnserialization except that it is for multi field fetch
1257  */
1258 void MEDCouplingNoTimeLabel::finishUnserialization2(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD)
1259 {
1260   _time_tolerance=tinyInfoD[0];
1261 }
1262
1263 MEDCouplingWithTimeStep::MEDCouplingWithTimeStep(const MEDCouplingWithTimeStep& other, bool deepCpy):MEDCouplingTimeDiscretization(other,deepCpy),
1264     _time(other._time),_iteration(other._iteration),_order(other._order)
1265 {
1266 }
1267
1268 MEDCouplingWithTimeStep::MEDCouplingWithTimeStep():_time(0.),_iteration(-1),_order(-1)
1269 {
1270 }
1271
1272 std::string MEDCouplingWithTimeStep::getStringRepr() const
1273 {
1274   std::ostringstream stream;
1275   stream << REPR << " Time is defined by iteration=" << _iteration << " order=" << _order << " and time=" << _time << ".";
1276   stream << "\nTime unit is : \"" << _time_unit << "\"";
1277   return stream.str();
1278 }
1279
1280 void MEDCouplingWithTimeStep::synchronizeTimeWith(const MEDCouplingMesh *mesh)
1281 {
1282   if(!mesh)
1283     throw INTERP_KERNEL::Exception("MEDCouplingWithTimeStep::synchronizeTimeWith : mesh instance is NULL ! Impossible to synchronize time !");
1284   int it=-1,order=-1;
1285   double val=mesh->getTime(it,order);
1286   _time=val; _iteration=it; _order=order;
1287   std::string tUnit=mesh->getTimeUnit();
1288   _time_unit=tUnit;
1289 }
1290
1291 void MEDCouplingWithTimeStep::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
1292 {
1293   MEDCouplingTimeDiscretization::getTinySerializationIntInformation(tinyInfo);
1294   tinyInfo.push_back(_iteration);
1295   tinyInfo.push_back(_order);
1296 }
1297
1298 void MEDCouplingWithTimeStep::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
1299 {
1300   MEDCouplingTimeDiscretization::getTinySerializationDbleInformation(tinyInfo);
1301   tinyInfo.push_back(_time);
1302 }
1303
1304 void MEDCouplingWithTimeStep::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS)
1305 {
1306   MEDCouplingTimeDiscretization::finishUnserialization(tinyInfoI,tinyInfoD,tinyInfoS);
1307   _time=tinyInfoD[1];
1308   _iteration=tinyInfoI[2];
1309   _order=tinyInfoI[3];
1310 }
1311
1312 /*!
1313  * idem getTinySerializationIntInformation except that it is for multi field fetch
1314  */
1315 void MEDCouplingWithTimeStep::getTinySerializationIntInformation2(std::vector<int>& tinyInfo) const
1316 {
1317   tinyInfo.resize(2);
1318   tinyInfo[0]=_iteration;
1319   tinyInfo[1]=_order;
1320 }
1321
1322 /*!
1323  * idem getTinySerializationDbleInformation except that it is for multi field fetch
1324  */
1325 void MEDCouplingWithTimeStep::getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const
1326 {
1327   tinyInfo.resize(2);
1328   tinyInfo[0]=_time_tolerance;
1329   tinyInfo[1]=_time;
1330 }
1331
1332 /*!
1333  * idem finishUnserialization except that it is for multi field fetch
1334  */
1335 void MEDCouplingWithTimeStep::finishUnserialization2(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD)
1336 {
1337   _iteration=tinyInfoI[0];
1338   _order=tinyInfoI[1];
1339   _time_tolerance=tinyInfoD[0];
1340   _time=tinyInfoD[1];
1341 }
1342
1343 bool MEDCouplingWithTimeStep::areCompatible(const MEDCouplingTimeDiscretization *other) const
1344 {
1345   if(!MEDCouplingTimeDiscretization::areCompatible(other))
1346     return false;
1347   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1348   return otherC!=0;
1349 }
1350
1351 bool MEDCouplingWithTimeStep::areStrictlyCompatible(const MEDCouplingTimeDiscretization *other, std::string& reason) const
1352 {
1353   if(!MEDCouplingTimeDiscretization::areStrictlyCompatible(other,reason))
1354     return false;
1355   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1356   bool ret=otherC!=0;
1357   if(!ret)
1358     reason.insert(0,"time discretization of this is ONE_TIME, other has a different time discretization.");
1359   return ret;
1360 }
1361
1362 bool MEDCouplingWithTimeStep::areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretization *other) const
1363 {
1364   if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForMul(other))
1365     return false;
1366   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1367   return otherC!=0;
1368 }
1369
1370 bool MEDCouplingWithTimeStep::areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretization *other) const
1371 {
1372   if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForDiv(other))
1373     return false;
1374   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1375   return otherC!=0;
1376 }
1377
1378 bool MEDCouplingWithTimeStep::areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const
1379 {
1380   if(!MEDCouplingTimeDiscretization::areCompatibleForMeld(other))
1381     return false;
1382   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1383   return otherC!=0;
1384 }
1385
1386 bool MEDCouplingWithTimeStep::isEqualIfNotWhy(const MEDCouplingTimeDiscretization *other, double prec, std::string& reason) const
1387 {
1388   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1389   std::ostringstream oss; oss.precision(15);
1390   if(!otherC)
1391     {
1392       reason="This has time discretization ONE_TIME, other not.";
1393       return false;
1394     }
1395   if(_iteration!=otherC->_iteration)
1396     {
1397       oss << "iterations differ. this iteration=" << _iteration << " other iteration=" << otherC->_iteration;
1398       reason=oss.str();
1399       return false;
1400     }
1401   if(_order!=otherC->_order)
1402     {
1403       oss << "orders differ. this order=" << _order << " other order=" << otherC->_order;
1404       reason=oss.str();
1405       return false;
1406     }
1407   if(std::fabs(_time-otherC->_time)>_time_tolerance)
1408     {
1409       oss << "times differ. this time=" << _time << " other time=" << otherC->_time;
1410       reason=oss.str();
1411       return false;
1412     }
1413   return MEDCouplingTimeDiscretization::isEqualIfNotWhy(other,prec,reason);
1414 }
1415
1416 bool MEDCouplingWithTimeStep::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretization *other, double prec) const
1417 {
1418   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1419   if(!otherC)
1420     return false;
1421   if(_iteration!=otherC->_iteration)
1422     return false;
1423   if(_order!=otherC->_order)
1424     return false;
1425   if(std::fabs(_time-otherC->_time)>_time_tolerance)
1426     return false;
1427   return MEDCouplingTimeDiscretization::isEqualWithoutConsideringStr(other,prec);
1428 }
1429
1430 void MEDCouplingWithTimeStep::copyTinyAttrFrom(const MEDCouplingTimeDiscretization& other)
1431 {
1432   MEDCouplingTimeDiscretization::copyTinyAttrFrom(other);
1433   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(&other);
1434   if(!otherC)
1435     throw INTERP_KERNEL::Exception("MEDCouplingWithTimeStep::copyTinyAttrFrom : mismatch of time discretization !");
1436   _time=otherC->_time;
1437   _iteration=otherC->_iteration;
1438   _order=otherC->_order;
1439 }
1440
1441 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::aggregate(const MEDCouplingTimeDiscretization *other) const
1442 {
1443   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1444   if(!otherC)
1445     throw INTERP_KERNEL::Exception("WithTimeStep::aggregation on mismatched time discretization !");
1446   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Aggregate(getArray(),other->getArray());
1447   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1448   ret->setArray(arr,0);
1449   return ret;
1450 }
1451
1452 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const
1453 {
1454   std::vector<const DataArrayDouble *> a(other.size());
1455   int i=0;
1456   for(std::vector<const MEDCouplingTimeDiscretization *>::const_iterator it=other.begin();it!=other.end();it++,i++)
1457     {
1458       const MEDCouplingWithTimeStep *itC=dynamic_cast<const MEDCouplingWithTimeStep *>(*it);
1459       if(!itC)
1460         throw INTERP_KERNEL::Exception("WithTimeStep::aggregate on mismatched time discretization !");
1461       a[i]=itC->getArray();
1462     }
1463   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Aggregate(a);
1464   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1465   ret->setArray(arr,0);
1466   return ret;
1467 }
1468
1469 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::meld(const MEDCouplingTimeDiscretization *other) const
1470 {
1471   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1472   if(!otherC)
1473     throw INTERP_KERNEL::Exception("WithTimeStep::meld on mismatched time discretization !");
1474   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Meld(getArray(),other->getArray());
1475   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1476   ret->setArray(arr,0);
1477   return ret;
1478 }
1479
1480 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::dot(const MEDCouplingTimeDiscretization *other) const
1481 {
1482   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1483   if(!otherC)
1484     throw INTERP_KERNEL::Exception("WithTimeStep::dot on mismatched time discretization !");
1485   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1486   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Dot(getArray(),other->getArray());
1487   ret->setArray(arr,0);
1488   return ret;
1489 }
1490
1491 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::crossProduct(const MEDCouplingTimeDiscretization *other) const
1492 {
1493   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1494   if(!otherC)
1495     throw INTERP_KERNEL::Exception("WithTimeStep::crossProduct on mismatched time discretization !");
1496   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::CrossProduct(getArray(),other->getArray());
1497   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1498   ret->setArray(arr,0);
1499   return ret;
1500 }
1501
1502 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::max(const MEDCouplingTimeDiscretization *other) const
1503 {
1504   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1505   if(!otherC)
1506     throw INTERP_KERNEL::Exception("WithTimeStep::max on mismatched time discretization !");
1507   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Max(getArray(),other->getArray());
1508   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1509   ret->setArray(arr,0);
1510   return ret;
1511 }
1512
1513 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::min(const MEDCouplingTimeDiscretization *other) const
1514 {
1515   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1516   if(!otherC)
1517     throw INTERP_KERNEL::Exception("WithTimeStep::min on mismatched time discretization !");
1518   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Min(getArray(),other->getArray());
1519   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1520   ret->setArray(arr,0);
1521   return ret;
1522 }
1523
1524 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::add(const MEDCouplingTimeDiscretization *other) const
1525 {
1526   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1527   if(!otherC)
1528     throw INTERP_KERNEL::Exception("WithTimeStep::add on mismatched time discretization !");
1529   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Add(getArray(),other->getArray());
1530   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1531   ret->setArray(arr,0);
1532   int tmp1,tmp2;
1533   double tmp3=getStartTime(tmp1,tmp2);
1534   ret->setStartTime(tmp3,tmp1,tmp2);
1535   return ret;
1536 }
1537
1538 void MEDCouplingWithTimeStep::addEqual(const MEDCouplingTimeDiscretization *other)
1539 {
1540   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1541   if(!otherC)
1542     throw INTERP_KERNEL::Exception("WithTimeStep::addEqual on mismatched time discretization !");
1543   if(!getArray())
1544     throw INTERP_KERNEL::Exception("MEDCouplingWithTimeLabel::addEqual : Data Array is NULL !");
1545   getArray()->addEqual(other->getArray());
1546 }
1547
1548 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::substract(const MEDCouplingTimeDiscretization *other) const
1549 {
1550   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1551   if(!otherC)
1552     throw INTERP_KERNEL::Exception("WithTimeStep::substract on mismatched time discretization !");
1553   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Substract(getArray(),other->getArray());
1554   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1555   ret->setArray(arr,0);
1556   int tmp1,tmp2;
1557   double tmp3=getStartTime(tmp1,tmp2);
1558   ret->setStartTime(tmp3,tmp1,tmp2);
1559   return ret;
1560 }
1561
1562 void MEDCouplingWithTimeStep::substractEqual(const MEDCouplingTimeDiscretization *other)
1563 {
1564   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1565   if(!otherC)
1566     throw INTERP_KERNEL::Exception("WithTimeStep::substractEqual on mismatched time discretization !");
1567   if(!getArray())
1568     throw INTERP_KERNEL::Exception("MEDCouplingWithTimeLabel::substractEqual : Data Array is NULL !");
1569   getArray()->substractEqual(other->getArray());
1570 }
1571
1572 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::multiply(const MEDCouplingTimeDiscretization *other) const
1573 {
1574   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1575   if(!otherC)
1576     throw INTERP_KERNEL::Exception("WithTimeStep::multiply on mismatched time discretization !");
1577   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Multiply(getArray(),other->getArray());
1578   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1579   ret->setArray(arr,0);
1580   int tmp1,tmp2;
1581   double tmp3=getStartTime(tmp1,tmp2);
1582   ret->setStartTime(tmp3,tmp1,tmp2);
1583   return ret;
1584 }
1585
1586 void MEDCouplingWithTimeStep::multiplyEqual(const MEDCouplingTimeDiscretization *other)
1587 {
1588   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1589   if(!otherC)
1590     throw INTERP_KERNEL::Exception("WithTimeStep::multiplyEqual on mismatched time discretization !");
1591   if(!getArray())
1592     throw INTERP_KERNEL::Exception("MEDCouplingWithTimeLabel::multiplyEqual : Data Array is NULL !");
1593   getArray()->multiplyEqual(other->getArray());
1594 }
1595
1596 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::divide(const MEDCouplingTimeDiscretization *other) const
1597 {
1598   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1599   if(!otherC)
1600     throw INTERP_KERNEL::Exception("WithTimeStep::divide on mismatched time discretization !");
1601   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Divide(getArray(),other->getArray());
1602   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1603   ret->setArray(arr,0);
1604   int tmp1,tmp2;
1605   double tmp3=getStartTime(tmp1,tmp2);
1606   ret->setStartTime(tmp3,tmp1,tmp2);
1607   return ret;
1608 }
1609
1610 void MEDCouplingWithTimeStep::divideEqual(const MEDCouplingTimeDiscretization *other)
1611 {
1612   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1613   if(!otherC)
1614     throw INTERP_KERNEL::Exception("WithTimeStep::divideEqual on mismatched time discretization !");
1615   if(!getArray())
1616     throw INTERP_KERNEL::Exception("MEDCouplingWithTimeLabel::divideEqual : Data Array is NULL !");
1617   getArray()->divideEqual(other->getArray());
1618 }
1619
1620 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::pow(const MEDCouplingTimeDiscretization *other) const
1621 {
1622   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1623   if(!otherC)
1624     throw INTERP_KERNEL::Exception("WithTimeStep::pow on mismatched time discretization !");
1625   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Pow(getArray(),other->getArray());
1626   MEDCouplingWithTimeStep *ret=new MEDCouplingWithTimeStep;
1627   ret->setArray(arr,0);
1628   int tmp1,tmp2;
1629   double tmp3=getStartTime(tmp1,tmp2);
1630   ret->setStartTime(tmp3,tmp1,tmp2);
1631   return ret;
1632 }
1633
1634 void MEDCouplingWithTimeStep::powEqual(const MEDCouplingTimeDiscretization *other)
1635 {
1636   const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
1637   if(!otherC)
1638     throw INTERP_KERNEL::Exception("WithTimeStep::powEqual on mismatched time discretization !");
1639   if(!getArray())
1640     throw INTERP_KERNEL::Exception("MEDCouplingWithTimeLabel::powEqual : Data Array is NULL !");
1641   getArray()->powEqual(other->getArray());
1642 }
1643
1644 MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::performCpy(bool deepCpy) const
1645 {
1646   return new MEDCouplingWithTimeStep(*this,deepCpy);
1647 }
1648
1649 void MEDCouplingWithTimeStep::checkNoTimePresence() const
1650 {
1651   throw INTERP_KERNEL::Exception("No time specified on a field defined on one time");
1652 }
1653
1654 void MEDCouplingWithTimeStep::checkTimePresence(double time) const
1655 {
1656   if(std::fabs(time-_time)>_time_tolerance)
1657     {
1658       std::ostringstream stream;
1659       stream << "The field is defined on time " << _time << " with eps=" << _time_tolerance << " and asking time = " << time << " !";
1660       throw INTERP_KERNEL::Exception(stream.str().c_str());
1661     }
1662 }
1663
1664 std::vector< const DataArrayDouble *> MEDCouplingWithTimeStep::getArraysForTime(double time) const
1665 {
1666   if(std::fabs(time-_time)<=_time_tolerance)
1667     {
1668       std::vector< const DataArrayDouble *> ret(1);
1669       ret[0]=_array;
1670       return ret;
1671     }
1672   else
1673     throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1674 }
1675
1676 void MEDCouplingWithTimeStep::getValueForTime(double time, const std::vector<double>& vals, double *res) const
1677 {
1678   std::copy(vals.begin(),vals.end(),res);
1679 }
1680
1681 void MEDCouplingWithTimeStep::getValueOnTime(int eltId, double time, double *value) const
1682 {
1683   if(std::fabs(time-_time)<=_time_tolerance)
1684     if(_array)
1685       _array->getTuple(eltId,value);
1686     else
1687       throw INTERP_KERNEL::Exception("No array existing.");
1688   else
1689     throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1690 }
1691
1692 void MEDCouplingWithTimeStep::getValueOnDiscTime(int eltId, int iteration, int order, double *value) const
1693 {
1694   if(_iteration==iteration && _order==order)
1695     if(_array)
1696       _array->getTuple(eltId,value);
1697     else
1698       throw INTERP_KERNEL::Exception("No array existing.");
1699   else
1700     throw INTERP_KERNEL::Exception("No data on this discrete time.");
1701 }
1702
1703 MEDCouplingConstOnTimeInterval::MEDCouplingConstOnTimeInterval():_start_time(0.),_end_time(0.),_start_iteration(-1),_end_iteration(-1),_start_order(-1),_end_order(-1)
1704 {
1705 }
1706
1707 void MEDCouplingConstOnTimeInterval::copyTinyAttrFrom(const MEDCouplingTimeDiscretization& other)
1708 {
1709   MEDCouplingTimeDiscretization::copyTinyAttrFrom(other);
1710   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(&other);
1711   if(!otherC)
1712     throw INTERP_KERNEL::Exception("MEDCouplingConstOnTimeInterval::copyTinyAttrFrom : mismatch of time discretization !");
1713   _start_time=otherC->_start_time;
1714   _end_time=otherC->_end_time;
1715   _start_iteration=otherC->_start_iteration;
1716   _end_iteration=otherC->_end_iteration;
1717   _start_order=otherC->_start_order;
1718   _end_order=otherC->_end_order;
1719 }
1720
1721 void MEDCouplingConstOnTimeInterval::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
1722 {
1723   MEDCouplingTimeDiscretization::getTinySerializationIntInformation(tinyInfo);
1724   tinyInfo.push_back(_start_iteration);
1725   tinyInfo.push_back(_start_order);
1726   tinyInfo.push_back(_end_iteration);
1727   tinyInfo.push_back(_end_order);
1728 }
1729
1730 void MEDCouplingConstOnTimeInterval::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
1731 {
1732   MEDCouplingTimeDiscretization::getTinySerializationDbleInformation(tinyInfo);
1733   tinyInfo.push_back(_start_time);
1734   tinyInfo.push_back(_end_time);
1735 }
1736
1737 void MEDCouplingConstOnTimeInterval::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS)
1738 {
1739   MEDCouplingTimeDiscretization::finishUnserialization(tinyInfoI,tinyInfoD,tinyInfoS);
1740   _start_time=tinyInfoD[1];
1741   _end_time=tinyInfoD[2];
1742   _start_iteration=tinyInfoI[2];
1743   _start_order=tinyInfoI[3];
1744   _end_iteration=tinyInfoI[4];
1745   _end_order=tinyInfoI[5];
1746 }
1747
1748 /*!
1749  * idem getTinySerializationIntInformation except that it is for multi field fetch
1750  */
1751 void MEDCouplingConstOnTimeInterval::getTinySerializationIntInformation2(std::vector<int>& tinyInfo) const
1752 {
1753   tinyInfo.resize(4);
1754   tinyInfo[0]=_start_iteration;
1755   tinyInfo[1]=_start_order;
1756   tinyInfo[2]=_end_iteration;
1757   tinyInfo[3]=_end_order;
1758 }
1759
1760 /*!
1761  * idem getTinySerializationDbleInformation except that it is for multi field fetch
1762  */
1763 void MEDCouplingConstOnTimeInterval::getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const
1764 {
1765   tinyInfo.resize(3);
1766   tinyInfo[0]=_time_tolerance;
1767   tinyInfo[1]=_start_time;
1768   tinyInfo[2]=_end_time;
1769 }
1770
1771 /*!
1772  * idem finishUnserialization except that it is for multi field fetch
1773  */
1774 void MEDCouplingConstOnTimeInterval::finishUnserialization2(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD)
1775 {
1776   _start_iteration=tinyInfoI[0];
1777   _start_order=tinyInfoI[1];
1778   _end_iteration=tinyInfoI[2];
1779   _end_order=tinyInfoI[3];
1780   _time_tolerance=tinyInfoD[0];
1781   _start_time=tinyInfoD[1];
1782   _end_time=tinyInfoD[2];
1783 }
1784
1785 MEDCouplingConstOnTimeInterval::MEDCouplingConstOnTimeInterval(const MEDCouplingConstOnTimeInterval& other, bool deepCpy):
1786       MEDCouplingTimeDiscretization(other,deepCpy),_start_time(other._start_time),_end_time(other._end_time),_start_iteration(other._start_iteration),
1787       _end_iteration(other._end_iteration),_start_order(other._start_order),_end_order(other._end_order)
1788 {
1789 }
1790
1791 std::string MEDCouplingConstOnTimeInterval::getStringRepr() const
1792 {
1793   std::ostringstream stream;
1794   stream << REPR << " Time interval is defined by :\niteration_start=" << _start_iteration << " order_start=" << _start_order << " and time_start=" << _start_time << "\n";
1795   stream << "iteration_end=" << _end_iteration << " order_end=" << _end_order << " and end_time=" << _end_time << "\n";
1796   stream << "\nTime unit is : \"" << _time_unit << "\"";
1797   return stream.str();
1798 }
1799
1800 void MEDCouplingConstOnTimeInterval::synchronizeTimeWith(const MEDCouplingMesh *mesh)
1801 {
1802   if(!mesh)
1803     throw INTERP_KERNEL::Exception("MEDCouplingWithTimeStep::synchronizeTimeWith : mesh instance is NULL ! Impossible to synchronize time !");
1804   int it=-1,order=-1;
1805   double val=mesh->getTime(it,order);
1806   _start_time=val; _start_iteration=it; _start_order=order;
1807   _end_time=val; _end_iteration=it; _end_order=order;
1808   std::string tUnit=mesh->getTimeUnit();
1809   _time_unit=tUnit;
1810 }
1811
1812 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::performCpy(bool deepCpy) const
1813 {
1814   return new MEDCouplingConstOnTimeInterval(*this,deepCpy);
1815 }
1816
1817 std::vector< const DataArrayDouble *> MEDCouplingConstOnTimeInterval::getArraysForTime(double time) const
1818 {
1819   if(time>_start_time-_time_tolerance && time<_end_time+_time_tolerance)
1820     {
1821       std::vector< const DataArrayDouble *> ret(1);
1822       ret[0]=_array;
1823       return ret;
1824     }
1825   else
1826     throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1827 }
1828
1829 void MEDCouplingConstOnTimeInterval::getValueForTime(double time, const std::vector<double>& vals, double *res) const
1830 {
1831   std::copy(vals.begin(),vals.end(),res);
1832 }
1833
1834 bool MEDCouplingConstOnTimeInterval::areCompatible(const MEDCouplingTimeDiscretization *other) const
1835 {
1836   if(!MEDCouplingTimeDiscretization::areCompatible(other))
1837     return false;
1838   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
1839   return otherC!=0;
1840 }
1841
1842 bool MEDCouplingConstOnTimeInterval::areStrictlyCompatible(const MEDCouplingTimeDiscretization *other, std::string& reason) const
1843 {
1844   if(!MEDCouplingTimeDiscretization::areStrictlyCompatible(other,reason))
1845     return false;
1846   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
1847   bool ret=otherC!=0;
1848   if(!ret)
1849     reason.insert(0,"time discretization of this is CONST_ON_TIME_INTERVAL, other has a different time discretization.");
1850   return ret;
1851 }
1852
1853 bool MEDCouplingConstOnTimeInterval::areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretization *other) const
1854 {
1855   if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForMul(other))
1856     return false;
1857   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
1858   return otherC!=0;
1859 }
1860
1861 bool MEDCouplingConstOnTimeInterval::areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretization *other) const
1862 {
1863   if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForDiv(other))
1864     return false;
1865   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
1866   return otherC!=0;
1867 }
1868
1869 bool MEDCouplingConstOnTimeInterval::areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const
1870 {
1871   if(!MEDCouplingTimeDiscretization::areCompatibleForMeld(other))
1872     return false;
1873   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
1874   return otherC!=0;
1875 }
1876
1877 bool MEDCouplingConstOnTimeInterval::isEqualIfNotWhy(const MEDCouplingTimeDiscretization *other, double prec, std::string& reason) const
1878 {
1879   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
1880   std::ostringstream oss; oss.precision(15);
1881   if(!otherC)
1882     {
1883       reason="This has time discretization CONST_ON_TIME_INTERVAL, other not.";
1884       return false;
1885     }
1886   if(_start_iteration!=otherC->_start_iteration)
1887     {
1888       oss << "start iterations differ. this start iteration=" << _start_iteration << " other start iteration=" << otherC->_start_iteration;
1889       reason=oss.str();
1890       return false;
1891     }
1892   if(_start_order!=otherC->_start_order)
1893     {
1894       oss << "start orders differ. this start order=" << _start_order << " other start order=" << otherC->_start_order;
1895       reason=oss.str();
1896       return false;
1897     }
1898   if(std::fabs(_start_time-otherC->_start_time)>_time_tolerance)
1899     {
1900       oss << "start times differ. this start time=" << _start_time << " other start time=" << otherC->_start_time;
1901       reason=oss.str();
1902       return false;
1903     }
1904   if(_end_iteration!=otherC->_end_iteration)
1905     {
1906       oss << "end iterations differ. this end iteration=" << _end_iteration << " other end iteration=" << otherC->_end_iteration;
1907       reason=oss.str();
1908       return false;
1909     }
1910   if(_end_order!=otherC->_end_order)
1911     {
1912       oss << "end orders differ. this end order=" << _end_order << " other end order=" << otherC->_end_order;
1913       reason=oss.str();
1914       return false;
1915     }
1916   if(std::fabs(_end_time-otherC->_end_time)>_time_tolerance)
1917     {
1918       oss << "end times differ. this end time=" << _end_time << " other end time=" << otherC->_end_time;
1919       reason=oss.str();
1920       return false;
1921     }
1922   return MEDCouplingTimeDiscretization::isEqualIfNotWhy(other,prec,reason);
1923 }
1924
1925 bool MEDCouplingConstOnTimeInterval::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretization *other, double prec) const
1926 {
1927   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
1928   if(!otherC)
1929     return false;
1930   if(_start_iteration!=otherC->_start_iteration)
1931     return false;
1932   if(_start_order!=otherC->_start_order)
1933     return false;
1934   if(std::fabs(_start_time-otherC->_start_time)>_time_tolerance)
1935     return false;
1936   if(_end_iteration!=otherC->_end_iteration)
1937     return false;
1938   if(_end_order!=otherC->_end_order)
1939     return false;
1940   if(std::fabs(_end_time-otherC->_end_time)>_time_tolerance)
1941     return false;
1942   return MEDCouplingTimeDiscretization::isEqualWithoutConsideringStr(other,prec);
1943 }
1944
1945 void MEDCouplingConstOnTimeInterval::getValueOnTime(int eltId, double time, double *value) const
1946 {
1947   if(time>_start_time-_time_tolerance && time<_end_time+_time_tolerance)
1948     if(_array)
1949       _array->getTuple(eltId,value);
1950     else
1951       throw INTERP_KERNEL::Exception("No array existing.");
1952   else
1953     throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1954 }
1955
1956 void MEDCouplingConstOnTimeInterval::getValueOnDiscTime(int eltId, int iteration, int order, double *value) const
1957 {
1958   if(iteration>=_start_iteration && iteration<=_end_iteration)
1959     if(_array)
1960       _array->getTuple(eltId,value);
1961     else
1962       throw INTERP_KERNEL::Exception("No array existing.");
1963   else
1964     throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
1965 }
1966
1967 void MEDCouplingConstOnTimeInterval::checkNoTimePresence() const
1968 {
1969   throw INTERP_KERNEL::Exception("No time specified on a field defined as constant on one time interval");
1970 }
1971
1972 void MEDCouplingConstOnTimeInterval::checkTimePresence(double time) const
1973 {
1974   if(time<_start_time-_time_tolerance || time>_end_time+_time_tolerance)
1975     {
1976       std::ostringstream stream;
1977       stream << "The field is defined between times " << _start_time << " and " << _end_time << " worderh tolerance ";
1978       stream << _time_tolerance << " and trying to access on time = " << time;
1979       throw INTERP_KERNEL::Exception(stream.str().c_str());
1980     }
1981 }
1982
1983 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::aggregate(const MEDCouplingTimeDiscretization *other) const
1984 {
1985   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
1986   if(!otherC)
1987     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::aggregation on mismatched time discretization !");
1988   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Aggregate(getArray(),other->getArray());
1989   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
1990   ret->setArray(arr,0);
1991   return ret;
1992 }
1993
1994 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const
1995 {
1996   std::vector<const DataArrayDouble *> a(other.size());
1997   int i=0;
1998   for(std::vector<const MEDCouplingTimeDiscretization *>::const_iterator it=other.begin();it!=other.end();it++,i++)
1999     {
2000       const MEDCouplingConstOnTimeInterval *itC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(*it);
2001       if(!itC)
2002         throw INTERP_KERNEL::Exception("ConstOnTimeInterval::aggregate on mismatched time discretization !");
2003       a[i]=itC->getArray();
2004     }
2005   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Aggregate(a);
2006   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2007   ret->setArray(arr,0);
2008   return ret;
2009 }
2010
2011 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::meld(const MEDCouplingTimeDiscretization *other) const
2012 {
2013   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2014   if(!otherC)
2015     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::meld on mismatched time discretization !");
2016   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Meld(getArray(),other->getArray());
2017   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2018   ret->setTimeTolerance(getTimeTolerance());
2019   ret->setArray(arr,0);
2020   return ret;
2021 }
2022
2023 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::dot(const MEDCouplingTimeDiscretization *other) const
2024 {
2025   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2026   if(!otherC)
2027     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::dot on mismatched time discretization !");
2028   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Dot(getArray(),other->getArray());
2029   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2030   ret->setArray(arr,0);
2031   return ret;
2032 }
2033
2034 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::crossProduct(const MEDCouplingTimeDiscretization *other) const
2035 {
2036   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2037   if(!otherC)
2038     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::crossProduct on mismatched time discretization !");
2039   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::CrossProduct(getArray(),other->getArray());
2040   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2041   ret->setArray(arr,0);
2042   return ret;
2043 }
2044
2045 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::max(const MEDCouplingTimeDiscretization *other) const
2046 {
2047   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2048   if(!otherC)
2049     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::max on mismatched time discretization !");
2050   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Max(getArray(),other->getArray());
2051   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2052   ret->setArray(arr,0);
2053   return ret;
2054 }
2055
2056 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::min(const MEDCouplingTimeDiscretization *other) const
2057 {
2058   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2059   if(!otherC)
2060     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::min on mismatched time discretization !");
2061   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Min(getArray(),other->getArray());
2062   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2063   ret->setArray(arr,0);
2064   return ret;
2065 }
2066
2067 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::add(const MEDCouplingTimeDiscretization *other) const
2068 {
2069   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2070   if(!otherC)
2071     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::add on mismatched time discretization !");
2072   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Add(getArray(),other->getArray());
2073   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2074   ret->setArray(arr,0);
2075   int tmp1,tmp2;
2076   double tmp3=getStartTime(tmp1,tmp2);
2077   ret->setStartTime(tmp3,tmp1,tmp2);
2078   tmp3=getEndTime(tmp1,tmp2);
2079   ret->setEndTime(tmp3,tmp1,tmp2);
2080   return ret;
2081 }
2082
2083 void MEDCouplingConstOnTimeInterval::addEqual(const MEDCouplingTimeDiscretization *other)
2084 {
2085   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2086   if(!otherC)
2087     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::addEqual on mismatched time discretization !");
2088   if(!getArray())
2089     throw INTERP_KERNEL::Exception("MEDCouplingConstOnTimeInterval::substractaddEqual : Data Array is NULL !");
2090   getArray()->addEqual(other->getArray());
2091 }
2092
2093 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::substract(const MEDCouplingTimeDiscretization *other) const
2094 {
2095   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2096   if(!otherC)
2097     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::substract on mismatched time discretization !");
2098   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Substract(getArray(),other->getArray());
2099   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2100   ret->setArray(arr,0);
2101   int tmp1,tmp2;
2102   double tmp3=getStartTime(tmp1,tmp2);
2103   ret->setStartTime(tmp3,tmp1,tmp2);
2104   tmp3=getEndTime(tmp1,tmp2);
2105   ret->setEndTime(tmp3,tmp1,tmp2);
2106   return ret;
2107 }
2108
2109 void MEDCouplingConstOnTimeInterval::substractEqual(const MEDCouplingTimeDiscretization *other)
2110 {
2111   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2112   if(!otherC)
2113     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::substractEqual on mismatched time discretization !");
2114   if(!getArray())
2115     throw INTERP_KERNEL::Exception("MEDCouplingConstOnTimeInterval::substractEqual : Data Array is NULL !");
2116   getArray()->substractEqual(other->getArray());
2117 }
2118
2119 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::multiply(const MEDCouplingTimeDiscretization *other) const
2120 {
2121   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2122   if(!otherC)
2123     throw INTERP_KERNEL::Exception("multiply on mismatched time discretization !");
2124   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Multiply(getArray(),other->getArray());
2125   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2126   ret->setArray(arr,0);
2127   int tmp1,tmp2;
2128   double tmp3=getStartTime(tmp1,tmp2);
2129   ret->setStartTime(tmp3,tmp1,tmp2);
2130   tmp3=getEndTime(tmp1,tmp2);
2131   ret->setEndTime(tmp3,tmp1,tmp2);
2132   return ret;
2133 }
2134
2135 void MEDCouplingConstOnTimeInterval::multiplyEqual(const MEDCouplingTimeDiscretization *other)
2136 {
2137   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2138   if(!otherC)
2139     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::multiplyEqual on mismatched time discretization !");
2140   if(!getArray())
2141     throw INTERP_KERNEL::Exception("MEDCouplingConstOnTimeInterval::multiplyEqual : Data Array is NULL !");
2142   getArray()->multiplyEqual(other->getArray());
2143 }
2144
2145 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::divide(const MEDCouplingTimeDiscretization *other) const
2146 {
2147   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2148   if(!otherC)
2149     throw INTERP_KERNEL::Exception("divide on mismatched time discretization !");
2150   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Divide(getArray(),other->getArray());
2151   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2152   ret->setArray(arr,0);
2153   int tmp1,tmp2;
2154   double tmp3=getStartTime(tmp1,tmp2);
2155   ret->setStartTime(tmp3,tmp1,tmp2);
2156   tmp3=getEndTime(tmp1,tmp2);
2157   ret->setEndTime(tmp3,tmp1,tmp2);
2158   return ret;
2159 }
2160
2161 void MEDCouplingConstOnTimeInterval::divideEqual(const MEDCouplingTimeDiscretization *other)
2162 {
2163   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2164   if(!otherC)
2165     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::divideEqual on mismatched time discretization !");
2166   if(!getArray())
2167     throw INTERP_KERNEL::Exception("MEDCouplingConstOnTimeInterval::divideEqual : Data Array is NULL !");
2168   getArray()->divideEqual(other->getArray());
2169 }
2170
2171 MEDCouplingTimeDiscretization *MEDCouplingConstOnTimeInterval::pow(const MEDCouplingTimeDiscretization *other) const
2172 {
2173   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2174   if(!otherC)
2175     throw INTERP_KERNEL::Exception("pow on mismatched time discretization !");
2176   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Pow(getArray(),other->getArray());
2177   MEDCouplingConstOnTimeInterval *ret=new MEDCouplingConstOnTimeInterval;
2178   ret->setArray(arr,0);
2179   int tmp1,tmp2;
2180   double tmp3=getStartTime(tmp1,tmp2);
2181   ret->setStartTime(tmp3,tmp1,tmp2);
2182   tmp3=getEndTime(tmp1,tmp2);
2183   ret->setEndTime(tmp3,tmp1,tmp2);
2184   return ret;
2185 }
2186
2187 void MEDCouplingConstOnTimeInterval::powEqual(const MEDCouplingTimeDiscretization *other)
2188 {
2189   const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
2190   if(!otherC)
2191     throw INTERP_KERNEL::Exception("ConstOnTimeInterval::powEqual on mismatched time discretization !");
2192   if(!getArray())
2193     throw INTERP_KERNEL::Exception("MEDCouplingConstOnTimeInterval::powEqual : Data Array is NULL !");
2194   getArray()->powEqual(other->getArray());
2195 }
2196
2197 MEDCouplingTwoTimeSteps::MEDCouplingTwoTimeSteps(const MEDCouplingTwoTimeSteps& other, bool deepCpy):MEDCouplingTimeDiscretization(other,deepCpy),
2198     _start_time(other._start_time),_end_time(other._end_time),
2199     _start_iteration(other._start_iteration),_end_iteration(other._end_iteration),
2200     _start_order(other._start_order),_end_order(other._end_order)
2201 {
2202   if(other._end_array)
2203     _end_array=other._end_array->performCpy(deepCpy);
2204   else
2205     _end_array=0;
2206 }
2207
2208 void MEDCouplingTwoTimeSteps::updateTime() const
2209 {
2210   MEDCouplingTimeDiscretization::updateTime();
2211   if(_end_array)
2212     updateTimeWith(*_end_array);
2213 }
2214
2215 void MEDCouplingTwoTimeSteps::synchronizeTimeWith(const MEDCouplingMesh *mesh)
2216 {
2217   if(!mesh)
2218     throw INTERP_KERNEL::Exception("MEDCouplingTwoTimeSteps::synchronizeTimeWith : mesh instance is NULL ! Impossible to synchronize time !");
2219   int it=-1,order=-1;
2220   double val=mesh->getTime(it,order);
2221   _start_time=val; _start_iteration=it; _start_order=order;
2222   _end_time=val; _end_iteration=it; _end_order=order;
2223   std::string tUnit=mesh->getTimeUnit();
2224   _time_unit=tUnit;
2225 }
2226
2227 std::size_t MEDCouplingTwoTimeSteps::getHeapMemorySizeWithoutChildren() const
2228 {
2229   return MEDCouplingTimeDiscretization::getHeapMemorySizeWithoutChildren();
2230 }
2231
2232 std::vector<const BigMemoryObject *> MEDCouplingTwoTimeSteps::getDirectChildrenWithNull() const
2233 {
2234   std::vector<const BigMemoryObject *> ret(MEDCouplingTimeDiscretization::getDirectChildrenWithNull());
2235   ret.push_back(_end_array);
2236   return ret;
2237 }
2238
2239 void MEDCouplingTwoTimeSteps::copyTinyAttrFrom(const MEDCouplingTimeDiscretization& other)
2240 {
2241   MEDCouplingTimeDiscretization::copyTinyAttrFrom(other);
2242   const MEDCouplingTwoTimeSteps *otherC=dynamic_cast<const MEDCouplingTwoTimeSteps *>(&other);
2243   if(!otherC)
2244     throw INTERP_KERNEL::Exception("MEDCouplingTwoTimeSteps::copyTinyAttrFrom : mismatch of time discretization !");
2245   _start_time=otherC->_start_time;
2246   _end_time=otherC->_end_time;
2247   _start_iteration=otherC->_start_iteration;
2248   _end_iteration=otherC->_end_iteration;
2249   _start_order=otherC->_start_order;
2250   _end_order=otherC->_end_order;
2251 }
2252
2253 void MEDCouplingTwoTimeSteps::copyTinyStringsFrom(const MEDCouplingTimeDiscretization& other)
2254 {
2255   MEDCouplingTimeDiscretization::copyTinyStringsFrom(other);
2256   const MEDCouplingTwoTimeSteps *otherC=dynamic_cast<const MEDCouplingTwoTimeSteps *>(&other);
2257   if(!otherC)
2258     throw INTERP_KERNEL::Exception("Trying to operate copyTinyStringsFrom on different field type (two times//one time) !");
2259   if(_end_array && otherC->_end_array)
2260     _end_array->copyStringInfoFrom(*otherC->_end_array);
2261 }
2262
2263 const DataArrayDouble *MEDCouplingTwoTimeSteps::getEndArray() const
2264 {
2265   return _end_array;
2266 }
2267
2268 DataArrayDouble *MEDCouplingTwoTimeSteps::getEndArray()
2269 {
2270   return _end_array;
2271 }
2272
2273 void MEDCouplingTwoTimeSteps::checkCoherency() const
2274 {
2275   MEDCouplingTimeDiscretization::checkCoherency();
2276   if(!_end_array)
2277     throw INTERP_KERNEL::Exception("No end array specified !");
2278   if(_array->getNumberOfComponents()!=_end_array->getNumberOfComponents())
2279     throw INTERP_KERNEL::Exception("The number of components mismatch between the start and the end arrays !");
2280   if(_array->getNumberOfTuples()!=_end_array->getNumberOfTuples())
2281     throw INTERP_KERNEL::Exception("The number of tuples mismatch between the start and the end arrays !");
2282 }
2283
2284 bool MEDCouplingTwoTimeSteps::isEqualIfNotWhy(const MEDCouplingTimeDiscretization *other, double prec, std::string& reason) const
2285 {
2286   std::ostringstream oss;
2287   const MEDCouplingTwoTimeSteps *otherC=dynamic_cast<const MEDCouplingTwoTimeSteps *>(other);
2288   if(!otherC)
2289     {
2290       reason="This has time discretization LINEAR_TIME, other not.";
2291       return false;
2292     }
2293   if(_start_iteration!=otherC->_start_iteration)
2294     {
2295       oss << "start iterations differ. this start iteration=" << _start_iteration << " other start iteration=" << otherC->_start_iteration;
2296       reason=oss.str();
2297       return false;
2298     }
2299   if(_start_order!=otherC->_start_order)
2300     {
2301       oss << "start orders differ. this start order=" << _start_order << " other start order=" << otherC->_start_order;
2302       reason=oss.str();
2303       return false;
2304     }
2305   if(std::fabs(_start_time-otherC->_start_time)>_time_tolerance)
2306     {
2307       oss << "start times differ. this start time=" << _start_time << " other start time=" << otherC->_start_time;
2308       reason=oss.str();
2309       return false;
2310     }
2311   if(_end_iteration!=otherC->_end_iteration)
2312     {
2313       oss << "end iterations differ. this end iteration=" << _end_iteration << " other end iteration=" << otherC->_end_iteration;
2314       reason=oss.str();
2315       return false;
2316     }
2317   if(_end_order!=otherC->_end_order)
2318     {
2319       oss << "end orders differ. this end order=" << _end_order << " other end order=" << otherC->_end_order;
2320       reason=oss.str();
2321       return false;
2322     }
2323   if(std::fabs(_end_time-otherC->_end_time)>_time_tolerance)
2324     {
2325       oss << "end times differ. this end time=" << _end_time << " other end time=" << otherC->_end_time;
2326       reason=oss.str();
2327       return false;
2328     }
2329   if(_end_array!=otherC->_end_array)
2330     if(!_end_array->isEqualIfNotWhy(*otherC->_end_array,prec,reason))
2331       {
2332         reason.insert(0,"end arrays differ for linear time.");
2333         return false;
2334       }
2335   return MEDCouplingTimeDiscretization::isEqualIfNotWhy(other,prec,reason);
2336 }
2337
2338 bool MEDCouplingTwoTimeSteps::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretization *other, double prec) const
2339 {
2340   const MEDCouplingTwoTimeSteps *otherC=dynamic_cast<const MEDCouplingTwoTimeSteps *>(other);
2341   if(!otherC)
2342     return false;
2343   if(_start_iteration!=otherC->_start_iteration)
2344     return false;
2345   if(_end_iteration!=otherC->_end_iteration)
2346     return false;
2347   if(_start_order!=otherC->_start_order)
2348     return false;
2349   if(_end_order!=otherC->_end_order)
2350     return false;
2351   if(std::fabs(_start_time-otherC->_start_time)>_time_tolerance)
2352     return false;
2353   if(std::fabs(_end_time-otherC->_end_time)>_time_tolerance)
2354     return false;
2355   if(_end_array!=otherC->_end_array)
2356     if(!_end_array->isEqualWithoutConsideringStr(*otherC->_end_array,prec))
2357       return false;
2358   return MEDCouplingTimeDiscretization::isEqualWithoutConsideringStr(other,prec);
2359 }
2360
2361 MEDCouplingTwoTimeSteps::MEDCouplingTwoTimeSteps():_start_time(0.),_end_time(0.),_start_iteration(-1),_end_iteration(-1),_start_order(-1),_end_order(-1),_end_array(0)
2362 {
2363 }
2364
2365 MEDCouplingTwoTimeSteps::~MEDCouplingTwoTimeSteps()
2366 {
2367   if(_end_array)
2368     _end_array->decrRef();
2369 }
2370
2371 void MEDCouplingTwoTimeSteps::checkNoTimePresence() const
2372 {
2373   throw INTERP_KERNEL::Exception("The field presents a time to be specified in every access !");
2374 }
2375
2376 void MEDCouplingTwoTimeSteps::checkTimePresence(double time) const
2377 {
2378   if(time<_start_time-_time_tolerance || time>_end_time+_time_tolerance)
2379     {
2380       std::ostringstream stream;
2381       stream << "The field is defined between times " << _start_time << " and " << _end_time << " worderh tolerance ";
2382       stream << _time_tolerance << " and trying to access on time = " << time;
2383       throw INTERP_KERNEL::Exception(stream.str().c_str());
2384     }
2385 }
2386
2387 void MEDCouplingTwoTimeSteps::getArrays(std::vector<DataArrayDouble *>& arrays) const
2388 {
2389   arrays.resize(2);
2390   arrays[0]=_array;
2391   arrays[1]=_end_array;
2392 }
2393
2394 void MEDCouplingTwoTimeSteps::setEndArray(DataArrayDouble *array, TimeLabel *owner)
2395 {
2396   if(array!=_end_array)
2397     {
2398       if(_end_array)
2399         _end_array->decrRef();
2400       _end_array=array;
2401       if(_end_array)
2402         _end_array->incrRef();
2403       if(owner)
2404         owner->declareAsNew();
2405     }
2406 }
2407
2408 void MEDCouplingTwoTimeSteps::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
2409 {
2410   MEDCouplingTimeDiscretization::getTinySerializationIntInformation(tinyInfo);
2411   tinyInfo.push_back(_start_iteration);
2412   tinyInfo.push_back(_start_order);
2413   tinyInfo.push_back(_end_iteration);
2414   tinyInfo.push_back(_end_order);
2415   if(_end_array)
2416     {
2417       tinyInfo.push_back(_end_array->getNumberOfTuples());
2418       tinyInfo.push_back(_end_array->getNumberOfComponents());
2419     }
2420   else
2421     {
2422       tinyInfo.push_back(-1);
2423       tinyInfo.push_back(-1);
2424     }
2425 }
2426
2427 void MEDCouplingTwoTimeSteps::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
2428 {
2429   MEDCouplingTimeDiscretization::getTinySerializationDbleInformation(tinyInfo);
2430   tinyInfo.push_back(_start_time);
2431   tinyInfo.push_back(_end_time);
2432 }
2433
2434 void MEDCouplingTwoTimeSteps::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
2435 {
2436   int nbOfCompo=_array->getNumberOfComponents();
2437   for(int i=0;i<nbOfCompo;i++)
2438     tinyInfo.push_back(_array->getInfoOnComponent(i));
2439   for(int i=0;i<nbOfCompo;i++)
2440     tinyInfo.push_back(_end_array->getInfoOnComponent(i));
2441 }
2442
2443 void MEDCouplingTwoTimeSteps::resizeForUnserialization(const std::vector<int>& tinyInfoI, std::vector<DataArrayDouble *>& arrays)
2444 {
2445   arrays.resize(2);
2446   if(_array!=0)
2447     _array->decrRef();
2448   if(_end_array!=0)
2449     _end_array->decrRef();
2450   DataArrayDouble *arr=0;
2451   if(tinyInfoI[0]!=-1 && tinyInfoI[1]!=-1)
2452     {
2453       arr=DataArrayDouble::New();
2454       arr->alloc(tinyInfoI[0],tinyInfoI[1]);
2455     }
2456   _array=arr;
2457   arrays[0]=arr;
2458   arr=0;
2459   if(tinyInfoI[6]!=-1 && tinyInfoI[7]!=-1)
2460     {
2461       arr=DataArrayDouble::New();
2462       arr->alloc(tinyInfoI[6],tinyInfoI[7]);
2463     }
2464   _end_array=arr;
2465   arrays[1]=arr;
2466 }
2467
2468 void MEDCouplingTwoTimeSteps::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS)
2469 {
2470   MEDCouplingTimeDiscretization::finishUnserialization(tinyInfoI,tinyInfoD,tinyInfoS);
2471   _start_time=tinyInfoD[1];
2472   _end_time=tinyInfoD[2];
2473   _start_iteration=tinyInfoI[2];
2474   _start_order=tinyInfoI[3];
2475   _end_iteration=tinyInfoI[4];
2476   _end_order=tinyInfoI[5];
2477 }
2478
2479 /*!
2480  * idem getTinySerializationIntInformation except that it is for multi field fetch
2481  */
2482 void MEDCouplingTwoTimeSteps::getTinySerializationIntInformation2(std::vector<int>& tinyInfo) const
2483 {
2484   tinyInfo.resize(4);
2485   tinyInfo[0]=_start_iteration;
2486   tinyInfo[1]=_start_order;
2487   tinyInfo[2]=_end_iteration;
2488   tinyInfo[3]=_end_order;
2489 }
2490
2491 /*!
2492  * idem getTinySerializationDbleInformation except that it is for multi field fetch
2493  */
2494 void MEDCouplingTwoTimeSteps::getTinySerializationDbleInformation2(std::vector<double>& tinyInfo) const
2495 {
2496   tinyInfo.resize(3);
2497   tinyInfo[0]=_time_tolerance;
2498   tinyInfo[1]=_start_time;
2499   tinyInfo[2]=_end_time;
2500 }
2501
2502 /*!
2503  * idem finishUnserialization except that it is for multi field fetch
2504  */
2505 void MEDCouplingTwoTimeSteps::finishUnserialization2(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD)
2506 {
2507   _start_iteration=tinyInfoI[0];
2508   _start_order=tinyInfoI[1];
2509   _end_iteration=tinyInfoI[2];
2510   _end_order=tinyInfoI[3];
2511   _time_tolerance=tinyInfoD[0];
2512   _start_time=tinyInfoD[1];
2513   _end_time=tinyInfoD[2];
2514 }
2515
2516 std::vector< const DataArrayDouble *> MEDCouplingTwoTimeSteps::getArraysForTime(double time) const
2517 {
2518   if(time>_start_time-_time_tolerance && time<_end_time+_time_tolerance)
2519     {
2520       std::vector< const DataArrayDouble *> ret(2);
2521       ret[0]=_array;
2522       ret[1]=_end_array;
2523       return ret;
2524     }
2525   else
2526     throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
2527 }
2528
2529 void MEDCouplingTwoTimeSteps::setArrays(const std::vector<DataArrayDouble *>& arrays, TimeLabel *owner)
2530 {
2531   if(arrays.size()!=2)
2532     throw INTERP_KERNEL::Exception("MEDCouplingTwoTimeSteps::setArrays : number of arrays must be two.");
2533   setArray(arrays.front(),owner);
2534   setEndArray(arrays.back(),owner);
2535 }
2536
2537 MEDCouplingLinearTime::MEDCouplingLinearTime(const MEDCouplingLinearTime& other, bool deepCpy):MEDCouplingTwoTimeSteps(other,deepCpy)
2538 {
2539 }
2540
2541 MEDCouplingLinearTime::MEDCouplingLinearTime()
2542 {
2543 }
2544
2545 std::string MEDCouplingLinearTime::getStringRepr() const
2546 {
2547   std::ostringstream stream;
2548   stream << REPR << " Time interval is defined by :\niteration_start=" << _start_iteration << " order_start=" << _start_order << " and time_start=" << _start_time << "\n";
2549   stream << "iteration_end=" << _end_iteration << " order_end=" << _end_order << " and end_time=" << _end_time << "\n";
2550   stream << "Time unit is : \"" << _time_unit << "\"";
2551   return stream.str();
2552 }
2553
2554 void MEDCouplingLinearTime::checkCoherency() const
2555 {
2556   MEDCouplingTwoTimeSteps::checkCoherency();
2557   if(std::fabs(_start_time-_end_time)<_time_tolerance)
2558     throw INTERP_KERNEL::Exception("Start time and end time are equals regarding time tolerance.");
2559 }
2560
2561 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::performCpy(bool deepCpy) const
2562 {
2563   return new MEDCouplingLinearTime(*this,deepCpy);
2564 }
2565
2566 bool MEDCouplingLinearTime::areCompatible(const MEDCouplingTimeDiscretization *other) const
2567 {
2568   if(!MEDCouplingTimeDiscretization::areCompatible(other))
2569     return false;
2570   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2571   if(otherC==0)
2572     return false;
2573   if(_end_array==0 && otherC->_end_array==0)
2574     return true;
2575   if(_end_array==0 || otherC->_end_array==0)
2576     return false;
2577   if(_end_array->getNumberOfComponents()!=otherC->_end_array->getNumberOfComponents())
2578     return false;
2579   return true;
2580 }
2581
2582 bool MEDCouplingLinearTime::areStrictlyCompatible(const MEDCouplingTimeDiscretization *other, std::string& reason) const
2583 {
2584   if(!MEDCouplingTimeDiscretization::areStrictlyCompatible(other,reason))
2585     return false;
2586   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2587   bool ret=otherC!=0;
2588   if(!ret)
2589     reason.insert(0,"time discretization of this is LINEAR_TIME, other has a different time discretization.");
2590   return ret;
2591 }
2592
2593 bool MEDCouplingLinearTime::areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretization *other) const
2594 {
2595   if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForMul(other))
2596     return false;
2597   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2598   return otherC!=0;
2599 }
2600
2601 bool MEDCouplingLinearTime::areStrictlyCompatibleForDiv(const MEDCouplingTimeDiscretization *other) const
2602 {
2603   if(!MEDCouplingTimeDiscretization::areStrictlyCompatibleForDiv(other))
2604     return false;
2605   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2606   if(otherC==0)
2607     return false;
2608   if(_end_array==0 && otherC->_end_array==0)
2609     return true;
2610   if(_end_array==0 || otherC->_end_array==0)
2611     return false;
2612   int nbC1=_end_array->getNumberOfComponents();
2613   int nbC2=otherC->_end_array->getNumberOfComponents();
2614   if(nbC1!=nbC2 && nbC2!=1)
2615     return false;
2616   return true;
2617 }
2618
2619 bool MEDCouplingLinearTime::areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const
2620 {
2621   if(!MEDCouplingTimeDiscretization::areCompatibleForMeld(other))
2622     return false;
2623   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2624   return otherC!=0;
2625 }
2626
2627 /*!
2628  * vals is expected to be of size 2*_array->getNumberOfTuples()==_array->getNumberOfTuples()+_end_array->getNumberOfTuples()
2629  */
2630 void MEDCouplingLinearTime::getValueForTime(double time, const std::vector<double>& vals, double *res) const
2631 {
2632   double alpha=(_end_time-time)/(_end_time-_start_time);
2633   std::size_t nbComp=vals.size()/2;
2634   std::transform(vals.begin(),vals.begin()+nbComp,res,std::bind2nd(std::multiplies<double>(),alpha));
2635   std::vector<double> tmp(nbComp);
2636   std::transform(vals.begin()+nbComp,vals.end(),tmp.begin(),std::bind2nd(std::multiplies<double>(),1-alpha));
2637   std::transform(tmp.begin(),tmp.end(),res,res,std::plus<double>());
2638 }
2639
2640 void MEDCouplingLinearTime::getValueOnTime(int eltId, double time, double *value) const
2641 {
2642   double alpha=(_end_time-time)/(_end_time-_start_time);
2643   int nbComp;
2644   if(_array)
2645     _array->getTuple(eltId,value);
2646   else
2647     throw INTERP_KERNEL::Exception("No start array existing.");
2648   nbComp=_array->getNumberOfComponents();
2649   std::transform(value,value+nbComp,value,std::bind2nd(std::multiplies<double>(),alpha));
2650   std::vector<double> tmp(nbComp);
2651   if(_end_array)
2652     _end_array->getTuple(eltId,&tmp[0]);
2653   else
2654     throw INTERP_KERNEL::Exception("No end array existing.");
2655   std::transform(tmp.begin(),tmp.end(),tmp.begin(),std::bind2nd(std::multiplies<double>(),1-alpha));
2656   std::transform(tmp.begin(),tmp.end(),value,value,std::plus<double>());
2657 }
2658
2659 void MEDCouplingLinearTime::getValueOnDiscTime(int eltId, int iteration, int order, double *value) const
2660 {
2661   if(iteration==_start_iteration && order==_start_order)
2662     {
2663       if(_array)
2664         _array->getTuple(eltId,value);
2665       else
2666         throw INTERP_KERNEL::Exception("iteration order match with start time but no start array existing.");
2667     }
2668   if(iteration==_end_iteration && order==_end_order)
2669     {
2670       if(_end_array)
2671         _end_array->getTuple(eltId,value);
2672       else
2673         throw INTERP_KERNEL::Exception("iteration order match with end time but no end array existing.");
2674     }
2675   else
2676     throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
2677 }
2678
2679 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::aggregate(const MEDCouplingTimeDiscretization *other) const
2680 {
2681   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2682   if(!otherC)
2683     throw INTERP_KERNEL::Exception("LinearTime::aggregation on mismatched time discretization !");
2684   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Aggregate(getArray(),other->getArray());
2685   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Aggregate(getEndArray(),other->getEndArray());
2686   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2687   ret->setArray(arr1,0);
2688   ret->setEndArray(arr2,0);
2689   return ret;
2690 }
2691
2692 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::aggregate(const std::vector<const MEDCouplingTimeDiscretization *>& other) const
2693 {
2694   std::vector<const DataArrayDouble *> a(other.size());
2695   std::vector<const DataArrayDouble *> b(other.size());
2696   int i=0;
2697   for(std::vector<const MEDCouplingTimeDiscretization *>::const_iterator it=other.begin();it!=other.end();it++,i++)
2698     {
2699       const MEDCouplingLinearTime *itC=dynamic_cast<const MEDCouplingLinearTime *>(*it);
2700       if(!itC)
2701         throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::aggregate on mismatched time discretization !");
2702       a[i]=itC->getArray();
2703       b[i]=itC->getEndArray();
2704     }
2705   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::Aggregate(a);
2706   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Aggregate(b);
2707   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2708   ret->setArray(arr,0);
2709   ret->setEndArray(arr2,0);
2710   return ret;
2711 }
2712
2713 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::meld(const MEDCouplingTimeDiscretization *other) const
2714 {
2715   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2716   if(!otherC)
2717     throw INTERP_KERNEL::Exception("LinearTime::meld on mismatched time discretization !");
2718   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Meld(getArray(),other->getArray());
2719   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Meld(getEndArray(),other->getEndArray());
2720   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2721   ret->setTimeTolerance(getTimeTolerance());
2722   ret->setArray(arr1,0);
2723   ret->setEndArray(arr2,0);
2724   return ret;
2725 }
2726
2727 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::dot(const MEDCouplingTimeDiscretization *other) const
2728 {
2729   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2730   if(!otherC)
2731     throw INTERP_KERNEL::Exception("LinearTime::dot on mismatched time discretization !");
2732   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Dot(getArray(),other->getArray());
2733   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Dot(getEndArray(),other->getEndArray());
2734   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2735   ret->setArray(arr1,0);
2736   ret->setEndArray(arr2,0);
2737   return ret;
2738 }
2739
2740 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::crossProduct(const MEDCouplingTimeDiscretization *other) const
2741 {
2742   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2743   if(!otherC)
2744     throw INTERP_KERNEL::Exception("LinearTime::crossProduct on mismatched time discretization !");
2745   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::CrossProduct(getArray(),other->getArray());
2746   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::CrossProduct(getEndArray(),other->getEndArray());
2747   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2748   ret->setArray(arr1,0);
2749   ret->setEndArray(arr2,0);
2750   return ret;
2751 }
2752
2753 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::max(const MEDCouplingTimeDiscretization *other) const
2754 {
2755   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2756   if(!otherC)
2757     throw INTERP_KERNEL::Exception("LinearTime::max on mismatched time discretization !");
2758   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2759   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Max(getArray(),other->getArray());
2760   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Max(getEndArray(),other->getEndArray());
2761   ret->setArray(arr1,0);
2762   ret->setEndArray(arr2,0);
2763   return ret;
2764 }
2765
2766 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::min(const MEDCouplingTimeDiscretization *other) const
2767 {
2768   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2769   if(!otherC)
2770     throw INTERP_KERNEL::Exception("LinearTime::min on mismatched time discretization !");
2771   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Min(getArray(),other->getArray());
2772   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Min(getEndArray(),other->getEndArray());
2773   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2774   ret->setArray(arr1,0);
2775   ret->setEndArray(arr2,0);
2776   return ret;
2777 }
2778
2779 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::add(const MEDCouplingTimeDiscretization *other) const
2780 {
2781   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2782   if(!otherC)
2783     throw INTERP_KERNEL::Exception("LinearTime::add on mismatched time discretization !");
2784   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Add(getArray(),other->getArray());
2785   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Add(getEndArray(),other->getEndArray());
2786   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2787   ret->setArray(arr1,0);
2788   ret->setEndArray(arr2,0);
2789   return ret;
2790 }
2791
2792 void MEDCouplingLinearTime::addEqual(const MEDCouplingTimeDiscretization *other)
2793 {
2794   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2795   if(!otherC)
2796     throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
2797   if(!getArray())
2798     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::addEqual : Data Array is NULL !");
2799   if(!getEndArray())
2800     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::addEqual : Data Array (end) is NULL !");
2801   getArray()->addEqual(other->getArray());
2802   getEndArray()->addEqual(other->getEndArray());
2803 }
2804
2805 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::substract(const MEDCouplingTimeDiscretization *other) const
2806 {
2807   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2808   if(!otherC)
2809     throw INTERP_KERNEL::Exception("LinearTime::substract on mismatched time discretization !");
2810   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Substract(getArray(),other->getArray());
2811   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Substract(getEndArray(),other->getEndArray());
2812   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2813   ret->setArray(arr1,0);
2814   ret->setEndArray(arr2,0);
2815   return ret;
2816 }
2817
2818 void MEDCouplingLinearTime::substractEqual(const MEDCouplingTimeDiscretization *other)
2819 {
2820   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2821   if(!otherC)
2822     throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
2823   if(!getArray())
2824     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::substractEqual : Data Array is NULL !");
2825   if(!getEndArray())
2826     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::substractEqual : Data Array (end) is NULL !");
2827   getArray()->substractEqual(other->getArray());
2828   getEndArray()->substractEqual(other->getEndArray());
2829 }
2830
2831 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::multiply(const MEDCouplingTimeDiscretization *other) const
2832 {
2833   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2834   if(!otherC)
2835     throw INTERP_KERNEL::Exception("LinearTime::multiply on mismatched time discretization !");
2836   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Multiply(getArray(),other->getArray());
2837   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Multiply(getEndArray(),other->getEndArray());
2838   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2839   ret->setArray(arr1,0);
2840   ret->setEndArray(arr2,0);
2841   return ret;
2842 }
2843
2844 void MEDCouplingLinearTime::multiplyEqual(const MEDCouplingTimeDiscretization *other)
2845 {
2846   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2847   if(!otherC)
2848     throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
2849   if(!getArray())
2850     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::multiplyEqual : Data Array is NULL !");
2851   if(!getEndArray())
2852     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::multiplyEqual : Data Array (end) is NULL !");
2853   getArray()->multiplyEqual(other->getArray());
2854   getEndArray()->multiplyEqual(other->getEndArray());
2855 }
2856
2857 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::divide(const MEDCouplingTimeDiscretization *other) const
2858 {
2859   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2860   if(!otherC)
2861     throw INTERP_KERNEL::Exception("LinearTime::divide on mismatched time discretization !");
2862   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Divide(getArray(),other->getArray());
2863   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Divide(getEndArray(),other->getEndArray());
2864   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2865   ret->setArray(arr1,0);
2866   ret->setEndArray(arr2,0);
2867   return ret;
2868 }
2869
2870 void MEDCouplingLinearTime::divideEqual(const MEDCouplingTimeDiscretization *other)
2871 {
2872   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2873   if(!otherC)
2874     throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
2875   if(!getArray())
2876     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::divideEqual : Data Array is NULL !");
2877   if(!getEndArray())
2878     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::divideEqual : Data Array (end) is NULL !");
2879   getArray()->divideEqual(other->getArray());
2880   getEndArray()->divideEqual(other->getEndArray());
2881 }
2882
2883 MEDCouplingTimeDiscretization *MEDCouplingLinearTime::pow(const MEDCouplingTimeDiscretization *other) const
2884 {
2885   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2886   if(!otherC)
2887     throw INTERP_KERNEL::Exception("LinearTime::pow on mismatched time discretization !");
2888   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr1=DataArrayDouble::Pow(getArray(),other->getArray());
2889   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=DataArrayDouble::Pow(getEndArray(),other->getEndArray());
2890   MEDCouplingLinearTime *ret=new MEDCouplingLinearTime;
2891   ret->setArray(arr1,0);
2892   ret->setEndArray(arr2,0);
2893   return ret;
2894 }
2895
2896 void MEDCouplingLinearTime::powEqual(const MEDCouplingTimeDiscretization *other)
2897 {
2898   const MEDCouplingLinearTime *otherC=dynamic_cast<const MEDCouplingLinearTime *>(other);
2899   if(!otherC)
2900     throw INTERP_KERNEL::Exception("LinearTime::addEqual on mismatched time discretization !");
2901   if(!getArray())
2902     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::powEqual : Data Array is NULL !");
2903   if(!getEndArray())
2904     throw INTERP_KERNEL::Exception("MEDCouplingLinearTime::powEqual : Data Array (end) is NULL !");
2905   getArray()->powEqual(other->getArray());
2906   getEndArray()->powEqual(other->getEndArray());
2907 }