src/MEDCoupling/MEDCouplingDefinitionTime.cxx

   1 // Copyright (C) 2007-2020  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 "MEDCouplingDefinitionTime.hxx"
  22 #include "MEDCouplingFieldDouble.hxx"
  23
  24 #include <cmath>
  25
  26 using namespace MEDCoupling;
  27
  28 const double MEDCouplingDefinitionTime::EPS_DFT=1e-15;
  29
  30 MEDCouplingDefinitionTimeSlice *MEDCouplingDefinitionTimeSlice::New(const MEDCouplingFieldDouble *f, int meshId, const std::vector<int>& arrId, int fieldId)
  31 {
  32   static const char msg[]="TimeSlice::New : mismatch of arrays number of a fieldDouble and its policy !!! Internal error !!!";
  33   if(!f)
  34     throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTimeSlice::New : empty field !");
  35   switch(f->getTimeDiscretization())
  36   {
  37     case ONE_TIME:
  38       {
  39         if(arrId.size()!=1)
  40           throw INTERP_KERNEL::Exception(msg);
  41         return new MEDCouplingDefinitionTimeSliceInst(f,meshId,arrId[0],fieldId);
  42       }
  43     case CONST_ON_TIME_INTERVAL:
  44       {
  45         if(arrId.size()!=1)
  46           throw INTERP_KERNEL::Exception(msg);
  47         return new MEDCouplingDefinitionTimeSliceCstOnTI(f,meshId,arrId[0],fieldId);
  48       }
  49     case LINEAR_TIME:
  50       {
  51         if(arrId.size()!=2)
  52           throw INTERP_KERNEL::Exception(msg);
  53         return new MEDCouplingDefinitionTimeSliceLT(f,meshId,arrId[0],arrId[1],fieldId);
  54       }
  55     case NO_TIME:
  56       throw INTERP_KERNEL::Exception("Invalid time discretization ! NO_TIME ! Impossible to build a definition time slice !");
  57     default:
  58       throw INTERP_KERNEL::Exception("Invalid time discretization : Not recognized !");
  59   }
  60 }
  61
  62 MEDCouplingDefinitionTimeSlice *MEDCouplingDefinitionTimeSlice::New(TypeOfTimeDiscretization type, const std::vector<int>& tiI, const std::vector<double>& tiD)
  63 {
  64   switch(type)
  65   {
  66     case ONE_TIME:
  67       return MEDCouplingDefinitionTimeSliceInst::New(tiI,tiD);
  68     case CONST_ON_TIME_INTERVAL:
  69       return MEDCouplingDefinitionTimeSliceCstOnTI::New(tiI,tiD);
  70     case LINEAR_TIME:
  71       return MEDCouplingDefinitionTimeSliceLT::New(tiI,tiD);
  72     default:
  73       throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTimeSlice::New : unrecognized time discretization type !");
  74   }
  75 }
  76
  77 bool MEDCouplingDefinitionTimeSlice::isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const
  78 {
  79   if(_mesh_id!=other._mesh_id)
  80     return false;
  81   if(_array_id!=other._array_id)
  82     return false;
  83   if(_field_id!=other._field_id)
  84     return false;
  85   return true;
  86 }
  87
  88 int MEDCouplingDefinitionTimeSlice::getStartId() const
  89 {
  90   return _array_id;
  91 }
  92
  93 int MEDCouplingDefinitionTimeSlice::getEndId() const
  94 {
  95   return _array_id;
  96 }
  97
  98 void MEDCouplingDefinitionTimeSlice::appendRepr(std::ostream& stream) const
  99 {
 100   stream << " *** MeshId : " << _mesh_id << " ArrayId : " << _array_id;
 101 }
 102
 103 MEDCouplingDefinitionTimeSlice::MEDCouplingDefinitionTimeSlice(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId):_mesh_id(meshId),_array_id(arrId),_field_id(fieldId)
 104 {
 105   int tmp1,tmp2;
 106   double t1=f->getStartTime(tmp1,tmp2);
 107   double t2=f->getEndTime(tmp1,tmp2);
 108   if(t2<t1)
 109     throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTimeSlice : End time strictly before Start time ...");
 110 }
 111
 112 std::size_t MEDCouplingDefinitionTimeSlice::getHeapMemorySizeWithoutChildren() const
 113 {
 114   return 0;
 115 }
 116
 117 std::vector<const BigMemoryObject *> MEDCouplingDefinitionTimeSlice::getDirectChildrenWithNull() const
 118 {
 119   return std::vector<const BigMemoryObject *>();
 120 }
 121
 122 bool MEDCouplingDefinitionTimeSlice::isFullyIncludedInMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const
 123 {
 124   double t1=getStartTime();
 125   double t2=getEndTime();
 126   double o1=other->getStartTime();
 127   double o2=other->getEndTime();
 128   return o1>t1-eps && o2<t2+eps;
 129 }
 130
 131 bool MEDCouplingDefinitionTimeSlice::isOverllapingWithMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const
 132 {
 133   double t1=getStartTime();
 134   double t2=getEndTime();
 135   double o1=other->getStartTime();
 136   double o2=other->getEndTime();
 137   return (o1<t1+eps && o2<t1+eps) || (o1>t2-eps && o2>t2-eps);
 138 }
 139
 140 bool MEDCouplingDefinitionTimeSlice::isAfterMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const
 141 {
 142   double t2=getEndTime();
 143   double o1=other->getStartTime();
 144   double o2=other->getEndTime();
 145   return (o1>t2-eps && o2>t2-eps);
 146 }
 147
 148 bool MEDCouplingDefinitionTimeSlice::isBeforeMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const
 149 {
 150   double t1=getStartTime();
 151   double o1=other->getStartTime();
 152   double o2=other->getEndTime();
 153   return (o1<t1+eps && o2<t1+eps);
 154 }
 155
 156 MEDCouplingDefinitionTimeSliceInst *MEDCouplingDefinitionTimeSliceInst::New(const std::vector<int>& tiI, const std::vector<double>& tiD)
 157 {
 158   MEDCouplingDefinitionTimeSliceInst *ret=new MEDCouplingDefinitionTimeSliceInst;
 159   ret->unserialize(tiI,tiD);
 160   return ret;
 161 }
 162
 163 void MEDCouplingDefinitionTimeSliceInst::getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const
 164 {
 165   tiI.resize(3);
 166   tiI[0]=_mesh_id; tiI[1]=_array_id; tiI[2]=_field_id;
 167   tiD.resize(1);
 168   tiD[0]=_instant;
 169 }
 170
 171 void MEDCouplingDefinitionTimeSliceInst::unserialize(const std::vector<int>& tiI, const std::vector<double>& tiD)
 172 {
 173   _mesh_id=tiI[0]; _array_id=tiI[1]; _field_id=tiI[2];
 174   _instant=tiD[0];
 175 }
 176
 177 TypeOfTimeDiscretization MEDCouplingDefinitionTimeSliceInst::getTimeType() const
 178 {
 179   return ONE_TIME;
 180 }
 181
 182 MEDCouplingDefinitionTimeSlice *MEDCouplingDefinitionTimeSliceInst::copy() const
 183 {
 184   return new MEDCouplingDefinitionTimeSliceInst(*this);
 185 }
 186
 187 bool MEDCouplingDefinitionTimeSliceInst::isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const
 188 {
 189   if(!MEDCouplingDefinitionTimeSlice::isEqual(other,eps))
 190     return false;
 191   const MEDCouplingDefinitionTimeSliceInst *otherC=dynamic_cast<const MEDCouplingDefinitionTimeSliceInst *>(&other);
 192   if(!otherC)
 193     return false;
 194   return fabs(otherC->_instant-_instant)<eps;
 195 }
 196
 197 void MEDCouplingDefinitionTimeSliceInst::getHotSpotsTime(std::vector<double>& ret) const
 198 {
 199   ret.resize(1);
 200   ret[0]=_instant;
 201 }
 202
 203 void MEDCouplingDefinitionTimeSliceInst::getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const
 204 {
 205   meshId=_mesh_id;
 206   arrId=_array_id;
 207   arrIdInField=0;
 208   fieldId=_field_id;
 209 }
 210
 211 bool MEDCouplingDefinitionTimeSliceInst::isContaining(double tmp, double eps) const
 212 {
 213   return fabs(tmp-_instant)<eps;
 214 }
 215
 216 void MEDCouplingDefinitionTimeSliceInst::appendRepr(std::ostream& stream) const
 217 {
 218   stream << "single point " << _instant;
 219   MEDCouplingDefinitionTimeSlice::appendRepr(stream);
 220 }
 221
 222 double MEDCouplingDefinitionTimeSliceInst::getStartTime() const
 223 {
 224   return _instant;
 225 }
 226
 227 double MEDCouplingDefinitionTimeSliceInst::getEndTime() const
 228 {
 229   return _instant;
 230 }
 231
 232 MEDCouplingDefinitionTimeSliceInst::MEDCouplingDefinitionTimeSliceInst(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId):MEDCouplingDefinitionTimeSlice(f,meshId,arrId,fieldId)
 233 {
 234   int tmp1,tmp2;
 235   double t1=f->getStartTime(tmp1,tmp2);
 236   double t2=f->getEndTime(tmp1,tmp2);
 237   double eps=f->getTimeTolerance();
 238   if(fabs(t1-t2)>eps)
 239     throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTimeSliceInst : times differs in this");
 240   _instant=t1;
 241 }
 242
 243 MEDCouplingDefinitionTimeSliceCstOnTI *MEDCouplingDefinitionTimeSliceCstOnTI::New(const std::vector<int>& tiI, const std::vector<double>& tiD)
 244 {
 245   MEDCouplingDefinitionTimeSliceCstOnTI *ret=new MEDCouplingDefinitionTimeSliceCstOnTI;
 246   ret->unserialize(tiI,tiD);
 247   return ret;
 248 }
 249
 250 MEDCouplingDefinitionTimeSlice *MEDCouplingDefinitionTimeSliceCstOnTI::copy() const
 251 {
 252   return new MEDCouplingDefinitionTimeSliceCstOnTI(*this);
 253 }
 254
 255 bool MEDCouplingDefinitionTimeSliceCstOnTI::isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const
 256 {
 257   if(!MEDCouplingDefinitionTimeSlice::isEqual(other,eps))
 258     return false;
 259   const MEDCouplingDefinitionTimeSliceCstOnTI *otherC=dynamic_cast<const MEDCouplingDefinitionTimeSliceCstOnTI *>(&other);
 260   if(!otherC)
 261     return false;
 262   if(fabs(otherC->_start-_start)>eps)
 263     return false;
 264   return fabs(otherC->_end-_end)<eps;
 265 }
 266
 267 void MEDCouplingDefinitionTimeSliceCstOnTI::getHotSpotsTime(std::vector<double>& ret) const
 268 {
 269   ret.resize(1);
 270   ret[0]=(_start+_end)/2.;
 271 }
 272
 273 void MEDCouplingDefinitionTimeSliceCstOnTI::getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const
 274 {
 275   meshId=_mesh_id;
 276   arrId=_array_id;
 277   arrIdInField=0;
 278   fieldId=_field_id;
 279 }
 280
 281 bool MEDCouplingDefinitionTimeSliceCstOnTI::isContaining(double tmp, double eps) const
 282 {
 283   return _start-eps<tmp && _end+eps>tmp;
 284 }
 285
 286 void MEDCouplingDefinitionTimeSliceCstOnTI::appendRepr(std::ostream& stream) const
 287 {
 288   stream << "Constant on time interval [" << _start << "," << _end << "]";
 289   MEDCouplingDefinitionTimeSlice::appendRepr(stream);
 290 }
 291
 292 double MEDCouplingDefinitionTimeSliceCstOnTI::getStartTime() const
 293 {
 294   return _start;
 295 }
 296
 297 double MEDCouplingDefinitionTimeSliceCstOnTI::getEndTime() const
 298 {
 299   return _end;
 300 }
 301
 302 void MEDCouplingDefinitionTimeSliceCstOnTI::getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const
 303 {
 304   tiI.resize(3);
 305   tiI[0]=_mesh_id; tiI[1]=_array_id; tiI[2]=_field_id;
 306   tiD.resize(2);
 307   tiD[0]=_start; tiD[1]=_end;
 308 }
 309
 310 void MEDCouplingDefinitionTimeSliceCstOnTI::unserialize(const std::vector<int>& tiI, const std::vector<double>& tiD)
 311 {
 312   _mesh_id=tiI[0]; _array_id=tiI[1]; _field_id=tiI[2];
 313   _start=tiD[0]; _end=tiD[1];
 314 }
 315
 316 TypeOfTimeDiscretization MEDCouplingDefinitionTimeSliceCstOnTI::getTimeType() const
 317 {
 318   return CONST_ON_TIME_INTERVAL;
 319 }
 320
 321 MEDCouplingDefinitionTimeSliceCstOnTI::MEDCouplingDefinitionTimeSliceCstOnTI(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId):MEDCouplingDefinitionTimeSlice(f,meshId,arrId,fieldId)
 322 {
 323   int tmp1,tmp2;
 324   double t1=f->getStartTime(tmp1,tmp2);
 325   double t2=f->getEndTime(tmp1,tmp2);
 326   _start=t1;
 327   _end=t2;
 328 }
 329
 330 MEDCouplingDefinitionTimeSliceLT *MEDCouplingDefinitionTimeSliceLT::New(const std::vector<int>& tiI, const std::vector<double>& tiD)
 331 {
 332   MEDCouplingDefinitionTimeSliceLT *ret=new MEDCouplingDefinitionTimeSliceLT;
 333   ret->unserialize(tiI,tiD);
 334   return ret;
 335 }
 336
 337 MEDCouplingDefinitionTimeSlice *MEDCouplingDefinitionTimeSliceLT::copy() const
 338 {
 339   return new MEDCouplingDefinitionTimeSliceLT(*this);
 340 }
 341
 342 bool MEDCouplingDefinitionTimeSliceLT::isEqual(const MEDCouplingDefinitionTimeSlice& other, double eps) const
 343 {
 344   if(!MEDCouplingDefinitionTimeSlice::isEqual(other,eps))
 345     return false;
 346   const MEDCouplingDefinitionTimeSliceLT *otherC=dynamic_cast<const MEDCouplingDefinitionTimeSliceLT *>(&other);
 347   if(!otherC)
 348     return false;
 349   if(_array_id_end!=otherC->_array_id_end)
 350     return false;
 351   if(fabs(otherC->_start-_start)>eps)
 352     return false;
 353   return fabs(otherC->_end-_end)<eps;
 354 }
 355
 356 void MEDCouplingDefinitionTimeSliceLT::getHotSpotsTime(std::vector<double>& ret) const
 357 {
 358   ret.resize(2);
 359   ret[0]=_start;
 360   ret[1]=_end;
 361 }
 362
 363 void MEDCouplingDefinitionTimeSliceLT::getIdsOnTime(double tm, double eps, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const
 364 {
 365   if(fabs(tm-_start)<eps)
 366     {
 367       meshId=_mesh_id;
 368       arrId=_array_id;
 369       arrIdInField=0;
 370       fieldId=_field_id;
 371       return ;
 372     }
 373   if(fabs(tm-_end)<eps)
 374     {
 375       meshId=_mesh_id;
 376       arrId=_array_id_end;
 377       arrIdInField=1;
 378       fieldId=_field_id;
 379       return ;
 380     }
 381   throw INTERP_KERNEL::Exception("LinearTime request not in boundary of this ! use hot spots !");
 382 }
 383
 384 bool MEDCouplingDefinitionTimeSliceLT::isContaining(double tmp, double eps) const
 385 {
 386   return _start-eps<tmp && _end+eps>tmp;
 387 }
 388
 389 void MEDCouplingDefinitionTimeSliceLT::appendRepr(std::ostream& stream) const
 390 {
 391   stream << "Linear on time interval [" << _start << "," << _end << "]";
 392   MEDCouplingDefinitionTimeSlice::appendRepr(stream);
 393   stream << " EndArrayId : " << _array_id_end;
 394 }
 395
 396 double MEDCouplingDefinitionTimeSliceLT::getStartTime() const
 397 {
 398   return _start;
 399 }
 400
 401 double MEDCouplingDefinitionTimeSliceLT::getEndTime() const
 402 {
 403   return _end;
 404 }
 405
 406 int MEDCouplingDefinitionTimeSliceLT::getEndId() const
 407 {
 408   return _array_id_end;
 409 }
 410
 411 void MEDCouplingDefinitionTimeSliceLT::getTinySerializationInformation(std::vector<int>& tiI, std::vector<double>& tiD) const
 412 {
 413   tiI.resize(4);
 414   tiI[0]=_mesh_id; tiI[1]=_array_id; tiI[2]=_field_id; tiI[3]=_array_id_end;
 415   tiD.resize(2);
 416   tiD[0]=_start; tiD[1]=_end;
 417 }
 418
 419 void MEDCouplingDefinitionTimeSliceLT::unserialize(const std::vector<int>& tiI, const std::vector<double>& tiD)
 420 {
 421   _mesh_id=tiI[0]; _array_id=tiI[1]; _field_id=tiI[2]; _array_id_end=tiI[3];
 422   _start=tiD[0]; _end=tiD[1];
 423 }
 424
 425 TypeOfTimeDiscretization MEDCouplingDefinitionTimeSliceLT::getTimeType() const
 426 {
 427   return LINEAR_TIME;
 428 }
 429
 430 MEDCouplingDefinitionTimeSliceLT::MEDCouplingDefinitionTimeSliceLT(const MEDCouplingFieldDouble *f, int meshId, int arrId, int arr2Id, int fieldId):MEDCouplingDefinitionTimeSlice(f,meshId,arrId,fieldId),_array_id_end(arr2Id)
 431 {
 432   int tmp1,tmp2;
 433   double t1=f->getStartTime(tmp1,tmp2);
 434   double t2=f->getEndTime(tmp1,tmp2);
 435   _start=t1;
 436   _end=t2;
 437 }
 438
 439 MEDCouplingDefinitionTime::MEDCouplingDefinitionTime():_eps(EPS_DFT)
 440 {
 441 }
 442
 443 MEDCouplingDefinitionTime::MEDCouplingDefinitionTime(const std::vector<const MEDCouplingFieldDouble *>& fs, const std::vector<int>& meshRefs, const std::vector<std::vector<int> >& arrRefs)
 444 {
 445   std::size_t sz=fs.size();
 446   if(sz!=arrRefs.size())
 447     throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime constructor : internal error ! should never happen !");
 448   _slices.resize(sz);
 449   for(int i=0;i<ToIdType(sz);i++)
 450     {
 451       if(arrRefs.empty())
 452         throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime constructor : A field is null in list impossible to build a time definition !");
 453       _slices[i]=MEDCouplingDefinitionTimeSlice::New(fs[i],meshRefs[i],arrRefs[i],i);
 454     }
 455   if(sz<=1)
 456     return ;
 457   const MEDCouplingDefinitionTimeSlice *ref=_slices[0];
 458   _eps=fs[0]->getTimeTolerance();
 459   for(std::size_t i=1;i<sz;i++)
 460     {
 461       if(!ref->isAfterMe(_slices[i],_eps))
 462         throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime constructors : the sequences of fields does NOT defines a stricly ascendant monotonic time sequence !");
 463       // double t1=ref->getEndTime();
 464       // double t2=_slices[i]->getStartTime();
 465       // if(fabs(t1-t2)<_eps)
 466       //   if(ref->getEndId() != _slices[i]->getStartId())
 467       //     throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime constructor : 2 slices refers to the same time and underlying arrays differs !");
 468       ref=_slices[i];
 469     }
 470 }
 471
 472 std::size_t MEDCouplingDefinitionTime::getHeapMemorySizeWithoutChildren() const
 473 {
 474   return _slices.capacity()*(sizeof(MEDCouplingDefinitionTimeSlice)+sizeof(int));
 475 }
 476
 477 std::vector<const BigMemoryObject *> MEDCouplingDefinitionTime::getDirectChildrenWithNull() const
 478 {
 479   return std::vector<const BigMemoryObject *>();
 480 }
 481
 482 void MEDCouplingDefinitionTime::assign(const MEDCouplingDefinitionTime& other)
 483 {
 484   std::size_t sz=other._slices.size();
 485   _slices.resize(sz);
 486   for(std::size_t i=0;i<sz;i++)
 487     _slices[i]=other._slices[i]->copy();
 488 }
 489
 490 bool MEDCouplingDefinitionTime::isEqual(const MEDCouplingDefinitionTime& other) const
 491 {
 492   std::size_t sz=_slices.size();
 493   if(sz!=other._slices.size())
 494     return false;
 495   for(std::size_t i=0;i<sz;i++)
 496     if(!_slices[i]->isEqual(*other._slices[i],_eps))
 497       return false;
 498   return true;
 499 }
 500
 501 void MEDCouplingDefinitionTime::getIdsOnTimeRight(double tm, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const
 502 {
 503   std::vector<int> meshIds;
 504   std::vector<int> arrIds;
 505   std::vector<int> arrIdsInField;
 506   std::vector<int> fieldIds;
 507   getIdsOnTime(tm,meshIds,arrIds,arrIdsInField,fieldIds);
 508   meshId=meshIds.back();
 509   arrId=arrIds.back();
 510   arrIdInField=arrIdsInField.back();
 511   fieldId=fieldIds.back();
 512 }
 513
 514 void MEDCouplingDefinitionTime::getIdsOnTimeLeft(double tm, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const
 515 {
 516   std::vector<int> meshIds;
 517   std::vector<int> arrIds;
 518   std::vector<int> arrIdsInField;
 519   std::vector<int> fieldIds;
 520   getIdsOnTime(tm,meshIds,arrIds,arrIdsInField,fieldIds);
 521   meshId=meshIds.front();
 522   arrId=arrIds.front();
 523   arrIdInField=arrIdsInField.front();
 524   fieldId=fieldIds.front();
 525 }
 526
 527 void MEDCouplingDefinitionTime::getIdsOnTime(double tm, std::vector<int>& meshIds, std::vector<int>& arrIds, std::vector<int>& arrIdsInField, std::vector<int>& fieldIds) const
 528 {
 529   std::vector<int> ids;
 530   int id=0;
 531   for(std::vector< MCAuto<MEDCouplingDefinitionTimeSlice> >::const_iterator it=_slices.begin();it!=_slices.end();it++,id++)
 532     if((*it)->isContaining(tm,_eps))
 533       ids.push_back(id);
 534   if(ids.empty())
 535     throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime::getIdsOnTime : No matching slice for such time !");
 536   std::size_t sz=ids.size();
 537   if(sz>2)
 538     throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime::getIdsOnTime : Too many slices match this time !");
 539   //
 540   meshIds.resize(sz);
 541   arrIds.resize(sz);
 542   arrIdsInField.resize(sz);
 543   fieldIds.resize(sz);
 544   for(std::size_t i=0;i<sz;i++)
 545     _slices[ids[i]]->getIdsOnTime(tm,_eps,meshIds[i],arrIds[i],arrIdsInField[i],fieldIds[i]);
 546 }
 547
 548 std::vector<double> MEDCouplingDefinitionTime::getHotSpotsTime() const
 549 {
 550   std::vector<double> ret;
 551   for(std::vector< MCAuto<MEDCouplingDefinitionTimeSlice> >::const_iterator it=_slices.begin();it!=_slices.end();it++)
 552     {
 553       std::vector<double> tmp;
 554       (*it)->getHotSpotsTime(tmp);
 555       if(!ret.empty())
 556         {
 557           if(fabs(ret.back()-tmp.front())>_eps)
 558             ret.insert(ret.end(),tmp.begin(),tmp.end());
 559           else
 560             ret.insert(ret.end(),tmp.begin()+1,tmp.end());
 561         }
 562       else
 563         ret.insert(ret.end(),tmp.begin(),tmp.end());
 564     }
 565   return ret;
 566 }
 567
 568 void MEDCouplingDefinitionTime::appendRepr(std::ostream& stream) const
 569 {
 570   stream << "Time definition :\n";
 571   for(std::vector< MCAuto<MEDCouplingDefinitionTimeSlice> >::const_iterator it=_slices.begin();it!=_slices.end();it++)
 572     {
 573       stream << " - ";
 574       (*it)->appendRepr(stream);
 575       stream << std::endl;
 576     }
 577 }
 578
 579 void MEDCouplingDefinitionTime::getTinySerializationInformation(std::vector<int>& tinyInfoI, std::vector<double>& tinyInfoD) const
 580 {
 581   int sz=(int)_slices.size();
 582   tinyInfoD.resize(1);
 583   tinyInfoD[0]=_eps;
 584   tinyInfoI.resize(3*sz+2);
 585   tinyInfoI[0]=sz;
 586   std::vector<int> coreData;
 587   for(int i=0;i<sz;i++)
 588     {
 589       std::vector<int> tmp1;
 590       std::vector<double> tmp2;
 591       tinyInfoI[i+2]=(int)_slices[i]->getTimeType();
 592       _slices[i]->getTinySerializationInformation(tmp1,tmp2);
 593       tinyInfoI[i+sz+2]=(int)tmp1.size();
 594       tinyInfoI[i+2*sz+2]=(int)tmp2.size();
 595       coreData.insert(coreData.end(),tmp1.begin(),tmp1.end());
 596       tinyInfoD.insert(tinyInfoD.end(),tmp2.begin(),tmp2.end());
 597     }
 598   tinyInfoI[1]=(int)coreData.size();
 599   tinyInfoI.insert(tinyInfoI.end(),coreData.begin(),coreData.end());
 600 }
 601
 602 void MEDCouplingDefinitionTime::unserialize(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD)
 603 {
 604   int sz=tinyInfoI[0];
 605   _slices.resize(sz);
 606   _eps=tinyInfoD[0];
 607   int offset1=0;
 608   int offset2=1;
 609   for(int i=0;i<sz;i++)
 610     {
 611       TypeOfTimeDiscretization ty=(TypeOfTimeDiscretization) tinyInfoI[i+2];
 612       int sz1=tinyInfoI[i+sz+2];
 613       int sz2=tinyInfoI[i+2*sz+2];
 614       std::vector<int> tmp1(tinyInfoI.begin()+3*sz+2+offset1,tinyInfoI.begin()+3*sz+2+offset1+sz1);
 615       std::vector<double> tmp2(tinyInfoD.begin()+offset2,tinyInfoD.begin()+offset2+sz2);
 616       MEDCouplingDefinitionTimeSlice *pt=MEDCouplingDefinitionTimeSlice::New(ty,tmp1,tmp2);
 617       _slices[i]=pt;
 618       offset1+=sz1;
 619       offset2+=sz2;
 620     }
 621 }
 622