medtool/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx

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