]> SALOME platform Git repositories - tools/medcoupling.git/blob - src/MEDCoupling/MEDCouplingDefinitionTime.cxx
Salome HOME
Little refactoring of progeny mechanism to avoid if.
[tools/medcoupling.git] / src / MEDCoupling / MEDCouplingDefinitionTime.cxx
1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Anthony Geay (CEA/DEN)
20
21 #include "MEDCouplingDefinitionTime.hxx"
22 #include "MEDCouplingFieldDouble.hxx"
23
24 #include <cmath>
25
26 using namespace ParaMEDMEM;
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("Invalide time discretization ! NO_TIME ! Impossible to build a definition time slice !");
57     default:
58       throw INTERP_KERNEL::Exception("Invalide 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(std::size_t i=0;i<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],(int)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< MEDCouplingAutoRefCountObjectPtr<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< MEDCouplingAutoRefCountObjectPtr<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< MEDCouplingAutoRefCountObjectPtr<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