src/MEDCoupling/MEDCouplingDefinitionTime.cxx

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