]> SALOME platform Git repositories - modules/med.git/blob - medtool/src/MEDLoader/MEDFileParameter.cxx
Salome HOME
Move medtool folder to MED base repository
[modules/med.git] / medtool / src / MEDLoader / MEDFileParameter.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 "MEDFileParameter.hxx"
22 #include "MEDFileUtilities.hxx"
23 #include "MEDFileSafeCaller.txx"
24 #include "MEDLoaderBase.hxx"
25
26 #include "InterpKernelAutoPtr.hxx"
27
28 #include <set>
29
30 using namespace ParaMEDMEM;
31
32 MEDFileParameter1TS::MEDFileParameter1TS(int iteration, int order, double time):_iteration(iteration),_order(order),_time(time)
33 {
34 }
35
36 MEDFileParameter1TS::MEDFileParameter1TS():_iteration(-1),_order(-1),_time(0.)
37 {
38 }
39
40 bool MEDFileParameter1TS::isEqual(const MEDFileParameter1TS *other, double eps, std::string& what) const
41 {
42   std::ostringstream oss;
43   if(!other)
44     { what="Other is null"; return false; }
45   if(_iteration!=other->_iteration)
46     { oss << "iteration number mismatches " << _iteration << " != " << other->_iteration; what=oss.str(); return false; }
47   if(_order!=other->_order)
48     { oss << "order number mismatches " << _iteration << " != " << other->_iteration; what=oss.str(); return false; }
49   if(fabs(_time-other->_time)>eps)
50     { oss << "time mismatches " << _time << " != " << other->_time << " eps=" << eps; what=oss.str(); return false; }
51   return true;
52 }
53
54 MEDFileParameter1TS *MEDFileParameterDouble1TSWTI::deepCpy() const
55 {
56   return new MEDFileParameterDouble1TSWTI(*this);
57 }
58
59 bool MEDFileParameterDouble1TSWTI::isEqual(const MEDFileParameter1TS *other, double eps, std::string& what) const
60 {
61   if(!MEDFileParameter1TS::isEqual(other,eps,what))
62     return false;
63   const MEDFileParameterDouble1TSWTI *otherC=dynamic_cast<const MEDFileParameterDouble1TSWTI *>(other);
64   if(!otherC)
65     { what="IsEqual fails because this is double parameter other no !"; return false; }
66   if(fabs(_arr-otherC->_arr)>eps)
67     { std::ostringstream oss; oss << "value differ " << _arr << " != " << otherC->_arr << " (eps=" << eps << ")"; return false; }
68   return true;
69 }
70
71 std::size_t MEDFileParameterDouble1TSWTI::getHeapMemorySizeWithoutChildren() const
72 {
73   return sizeof(MEDFileParameterDouble1TSWTI);
74 }
75
76 std::vector<const BigMemoryObject *> MEDFileParameterDouble1TSWTI::getDirectChildrenWithNull() const
77 {
78   return std::vector<const BigMemoryObject *>();
79 }
80
81 std::string MEDFileParameterDouble1TSWTI::simpleRepr() const
82 {
83   std::ostringstream oss;
84   simpleRepr2(0,oss);
85   return oss.str();
86 }
87
88 void MEDFileParameterDouble1TSWTI::simpleRepr2(int bkOffset, std::ostream& oss) const
89 {
90   std::string startOfLine(bkOffset,' ');
91   oss << startOfLine << "ParameterDoubleItem with (iteration,order) = (" << _iteration << "," << _order << ")" << std::endl;
92   oss << startOfLine << "Time associacited = " << _time << std::endl;
93   oss << startOfLine << "The value is ***** " << _arr <<  " *****" << std::endl;
94 }
95
96 MEDFileParameterDouble1TSWTI *MEDFileParameterDouble1TSWTI::New(int iteration, int order, double time)
97 {
98   return new MEDFileParameterDouble1TSWTI(iteration,order,time);
99 }
100
101 MEDFileParameterDouble1TSWTI::MEDFileParameterDouble1TSWTI():_arr(std::numeric_limits<double>::max())
102 {
103 }
104
105 MEDFileParameterDouble1TSWTI::MEDFileParameterDouble1TSWTI(int iteration, int order, double time):MEDFileParameter1TS(iteration,order,time)
106 {
107 }
108
109 void MEDFileParameterDouble1TSWTI::finishLoading(med_idt fid, const std::string& name, int dt, int it, int nbOfSteps)
110 {
111   std::ostringstream oss; oss << "MEDFileParameterDouble1TS::finishLoading : no specified time step (" << dt << "," << it << ") ! Time steps available : ";
112   for(int i=0;i<nbOfSteps;i++)
113     {
114       int locDt,locIt;
115       double tim;
116       MEDFILESAFECALLERRD0(MEDparameterComputationStepInfo,(fid,name.c_str(),i+1,&locDt,&locIt,&tim));
117       if(dt==locDt && it==locIt)
118         {
119           _iteration=locDt; _order=locIt; _time=tim;
120           MEDFILESAFECALLERRD0(MEDparameterValueRd,(fid,name.c_str(),_iteration,_order,reinterpret_cast<unsigned char *const>(&_arr)));
121           return ;
122         }
123       else
124         {
125           oss << "(" << locDt << "," << locIt << ")";
126           if(i!=nbOfSteps-1)
127             oss << ", ";
128         }
129     }
130   throw INTERP_KERNEL::Exception(oss.str().c_str());
131 }
132
133 void MEDFileParameterDouble1TSWTI::readValue(med_idt fid, const std::string& name)
134 {
135   MEDFILESAFECALLERRD0(MEDparameterValueRd,(fid,name.c_str(),_iteration,_order,reinterpret_cast<unsigned char *const>(&_arr)));
136 }
137
138 void MEDFileParameterDouble1TSWTI::finishLoading(med_idt fid, const std::string& name, int timeStepId)
139 {
140   int locDt,locIt;
141   double dt;
142   MEDFILESAFECALLERRD0(MEDparameterComputationStepInfo,(fid,name.c_str(),timeStepId+1,&locDt,&locIt,&dt));
143   _iteration=locDt; _order=locIt; _time=dt;
144   MEDFILESAFECALLERRD0(MEDparameterValueRd,(fid,name.c_str(),_iteration,_order,reinterpret_cast<unsigned char *const>(&_arr)));
145 }
146
147 void MEDFileParameterDouble1TSWTI::writeLL(med_idt fid, const std::string& name, const MEDFileWritable& mw) const
148 {
149   char nameW[MED_NAME_SIZE+1];
150   MEDLoaderBase::safeStrCpy(name.c_str(),MED_NAME_SIZE,nameW,mw.getTooLongStrPolicy());
151   MEDFILESAFECALLERWR0(MEDparameterValueWr,(fid,nameW,_iteration,_order,_time,reinterpret_cast<const unsigned char *>(&_arr)));
152 }
153
154 std::size_t MEDFileParameterTinyInfo::getHeapMemSizeOfStrings() const
155 {
156   return _dt_unit.capacity()+_name.capacity()+_desc_name.capacity();
157 }
158
159 bool MEDFileParameterTinyInfo::isEqualStrings(const MEDFileParameterTinyInfo& other, std::string& what) const
160 {
161   std::ostringstream oss;
162   if(_name!=other._name)
163     { oss << "name differ ! this=" << _name << " and other=" << other._name; what=oss.str(); return false; }
164   if(_desc_name!=other._desc_name)
165     { oss << "name differ ! this=" << _desc_name << " and other=" << other._desc_name; what=oss.str(); return false; }
166   if(_dt_unit!=other._dt_unit)
167     { oss << "unit of time differ ! this=" << _dt_unit << " and other=" << other._dt_unit; what=oss.str(); return false; }
168   return true;
169 }
170
171 void MEDFileParameterTinyInfo::writeLLHeader(med_idt fid, med_parameter_type typ) const
172 {
173   char nameW[MED_NAME_SIZE+1],descW[MED_COMMENT_SIZE+1],dtunitW[MED_SNAME_SIZE+1];
174   MEDLoaderBase::safeStrCpy(_name.c_str(),MED_NAME_SIZE,nameW,getTooLongStrPolicy());
175   MEDLoaderBase::safeStrCpy(_desc_name.c_str(),MED_COMMENT_SIZE,descW,getTooLongStrPolicy());
176   MEDLoaderBase::safeStrCpy(_dt_unit.c_str(),MED_SNAME_SIZE,dtunitW,getTooLongStrPolicy());
177   MEDFILESAFECALLERWR0(MEDparameterCr,(fid,nameW,typ,descW,dtunitW));
178 }
179
180 void MEDFileParameterTinyInfo::mainRepr(int bkOffset, std::ostream& oss) const
181 {
182   std::string startOfLine(bkOffset,' ');
183   oss << startOfLine << "Parameter with name \"" << _name << "\"" << std::endl;
184   oss << startOfLine << "Parameter with description \"" << _desc_name << "\"" << std::endl;
185   oss << startOfLine << "Parameter with unit name \"" << _dt_unit << "\"" << std::endl;
186 }
187
188 MEDFileParameterDouble1TS *MEDFileParameterDouble1TS::New()
189 {
190   return new MEDFileParameterDouble1TS;
191 }
192
193 MEDFileParameterDouble1TS *MEDFileParameterDouble1TS::New(const std::string& fileName)
194 {
195   return new MEDFileParameterDouble1TS(fileName);
196 }
197
198 MEDFileParameterDouble1TS *MEDFileParameterDouble1TS::New(const std::string& fileName, const std::string& paramName)
199 {
200   return new MEDFileParameterDouble1TS(fileName,paramName);
201 }
202
203 MEDFileParameterDouble1TS *MEDFileParameterDouble1TS::New(const std::string& fileName, const std::string& paramName, int dt, int it)
204 {
205   return new MEDFileParameterDouble1TS(fileName,paramName,dt,it);
206 }
207
208 MEDFileParameterDouble1TS::MEDFileParameterDouble1TS()
209 {
210 }
211
212 MEDFileParameterDouble1TS::MEDFileParameterDouble1TS(const std::string& fileName, const std::string& paramName, int dt, int it)
213 {
214   MEDFileUtilities::CheckFileForRead(fileName);
215   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
216   int nbPar=MEDnParameter(fid);
217   std::ostringstream oss; oss << "MEDFileParameterDouble1TS : no double param name \"" << paramName << "\" ! Double Parameters available are : ";
218   INTERP_KERNEL::AutoPtr<char> pName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
219   INTERP_KERNEL::AutoPtr<char> descName=MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE);
220   INTERP_KERNEL::AutoPtr<char> unitName=MEDLoaderBase::buildEmptyString(MED_SNAME_SIZE);
221   med_parameter_type paramType;
222   for(int i=0;i<nbPar;i++)
223     {
224       int nbOfSteps;
225       MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,&paramType,descName,unitName,&nbOfSteps));
226       std::string paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
227       if(paramNameCpp==paramName && paramType==MED_FLOAT64)
228         {
229           _dt_unit=MEDLoaderBase::buildStringFromFortran(unitName,MED_SNAME_SIZE);
230           _name=paramNameCpp;
231           _desc_name=MEDLoaderBase::buildStringFromFortran(descName,MED_COMMENT_SIZE);
232           finishLoading(fid,_name,dt,it,nbOfSteps);
233           return ;
234         }
235       else
236         {
237           oss << paramNameCpp;
238           if(i!=nbPar-1) oss << ", ";
239         }
240     }
241   throw INTERP_KERNEL::Exception(oss.str().c_str());
242 }
243
244 MEDFileParameterDouble1TS::MEDFileParameterDouble1TS(const std::string& fileName, const std::string& paramName)
245 {
246   MEDFileUtilities::CheckFileForRead(fileName);
247   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
248   int nbPar=MEDnParameter(fid);
249   std::ostringstream oss; oss << "MEDFileParameterDouble1TS : no double param name \"" << paramName << "\" ! Double Parameters available are : ";
250   INTERP_KERNEL::AutoPtr<char> pName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
251   INTERP_KERNEL::AutoPtr<char> descName=MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE);
252   INTERP_KERNEL::AutoPtr<char> unitName=MEDLoaderBase::buildEmptyString(MED_SNAME_SIZE);
253   med_parameter_type paramType;
254   for(int i=0;i<nbPar;i++)
255     {
256       int nbOfSteps;
257       MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,&paramType,descName,unitName,&nbOfSteps));
258       std::string paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
259       if(paramNameCpp==paramName && paramType==MED_FLOAT64)
260         {
261           if(nbOfSteps>0)
262             {
263               _dt_unit=MEDLoaderBase::buildStringFromFortran(unitName,MED_SNAME_SIZE);
264               _name=paramNameCpp;
265               _desc_name=MEDLoaderBase::buildStringFromFortran(descName,MED_COMMENT_SIZE);
266               finishLoading(fid,_name,0);
267               return ;
268             }
269           else
270             {
271               std::ostringstream oss2; oss2 << "Param name \"" << paramName << "\" exists but no time steps on it !";
272               throw INTERP_KERNEL::Exception(oss2.str().c_str());
273             }
274         }
275       else
276         {
277           oss << paramNameCpp;
278           if(i!=nbPar-1) oss << ", ";
279         }
280     }
281   throw INTERP_KERNEL::Exception(oss.str().c_str());
282 }
283
284 MEDFileParameterDouble1TS::MEDFileParameterDouble1TS(const std::string& fileName)
285 {
286   MEDFileUtilities::CheckFileForRead(fileName);
287   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
288   int nbPar=MEDnParameter(fid);
289   if(nbPar<1)
290     {
291       std::ostringstream oss2; oss2 << "No parameter in file \"" << fileName << "\" !";  
292       throw INTERP_KERNEL::Exception(oss2.str().c_str());
293     }
294   INTERP_KERNEL::AutoPtr<char> pName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
295   INTERP_KERNEL::AutoPtr<char> descName=MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE);
296   INTERP_KERNEL::AutoPtr<char> unitName=MEDLoaderBase::buildEmptyString(MED_SNAME_SIZE);
297   med_parameter_type paramType;
298   int nbOfSteps;
299   MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,1,pName,&paramType,descName,unitName,&nbOfSteps));
300   std::string paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
301   if(paramType==MED_FLOAT64)
302     {
303       if(nbOfSteps>0)
304         {
305           _dt_unit=MEDLoaderBase::buildStringFromFortran(unitName,MED_SNAME_SIZE);
306           _name=paramNameCpp;
307           _desc_name=MEDLoaderBase::buildStringFromFortran(descName,MED_COMMENT_SIZE);
308           finishLoading(fid,_name,0);
309           return ;
310         }
311       else
312         {
313           std::ostringstream oss2; oss2 << "Double param name \"" << paramNameCpp << "\" exists in file \""<< fileName << "\"but no time steps on it !";
314           throw INTERP_KERNEL::Exception(oss2.str().c_str());
315         }
316     }
317   else
318     {
319       std::ostringstream oss2; oss2 << "First parameter in file \"" << fileName << "\" is not double !";  
320       throw INTERP_KERNEL::Exception(oss2.str().c_str());
321     }
322 }
323
324 bool MEDFileParameterDouble1TS::isEqual(const MEDFileParameter1TS *other, double eps, std::string& what) const
325 {
326   if(!MEDFileParameterDouble1TSWTI::isEqual(other,eps,what))
327     return false;
328   const MEDFileParameterDouble1TS *otherC=dynamic_cast<const MEDFileParameterDouble1TS *>(other);
329   if(!otherC)
330     { what="Other is not of type MEDFileParameterDouble1TS as this"; return false; }
331   if(!isEqualStrings(*otherC,what))
332     return false;
333   return true;
334 }
335
336 MEDFileParameter1TS *MEDFileParameterDouble1TS::deepCpy() const
337 {
338   return new MEDFileParameterDouble1TS(*this);
339 }
340
341 std::string MEDFileParameterDouble1TS::simpleRepr() const
342 {
343   std::ostringstream oss;
344   MEDFileParameterTinyInfo::mainRepr(0,oss);
345   MEDFileParameterDouble1TSWTI::simpleRepr2(0,oss);
346   return oss.str();
347 }
348
349 std::size_t MEDFileParameterDouble1TS::getHeapMemorySizeWithoutChildren() const
350 {
351   return getHeapMemSizeOfStrings()+sizeof(MEDFileParameterDouble1TS);
352 }
353
354 std::vector<const BigMemoryObject *> MEDFileParameterDouble1TS::getDirectChildrenWithNull() const
355 {
356   return std::vector<const BigMemoryObject *>();
357 }
358
359 void MEDFileParameterDouble1TS::write(const std::string& fileName, int mode) const
360 {
361   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
362   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
363   MEDFileParameterTinyInfo::writeLLHeader(fid,MED_FLOAT64);
364   MEDFileParameterDouble1TSWTI::writeLL(fid,_name,*this);
365 }
366
367 MEDFileParameterMultiTS *MEDFileParameterMultiTS::New()
368 {
369   return new MEDFileParameterMultiTS;
370 }
371
372 MEDFileParameterMultiTS *MEDFileParameterMultiTS::New(const std::string& fileName)
373 {
374   return new MEDFileParameterMultiTS(fileName);
375 }
376
377 MEDFileParameterMultiTS *MEDFileParameterMultiTS::New(const std::string& fileName, const std::string& paramName)
378 {
379   return new MEDFileParameterMultiTS(fileName,paramName);
380 }
381
382 MEDFileParameterMultiTS::MEDFileParameterMultiTS()
383 {
384 }
385
386 MEDFileParameterMultiTS::MEDFileParameterMultiTS(const MEDFileParameterMultiTS& other, bool deepCopy):MEDFileParameterTinyInfo(other),_param_per_ts(other._param_per_ts)
387 {
388   if(deepCopy)
389     for(std::size_t i=0;i<_param_per_ts.size();i++)
390       {
391         const MEDFileParameter1TS *elt=_param_per_ts[i];
392         if(elt)
393           _param_per_ts[i]=elt->deepCpy();
394       }
395 }
396
397 MEDFileParameterMultiTS::MEDFileParameterMultiTS(const std::string& fileName)
398 {
399   MEDFileUtilities::CheckFileForRead(fileName);
400   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
401   int nbPar=MEDnParameter(fid);
402   if(nbPar<1)
403     {
404       std::ostringstream oss; oss << "MEDFileParameterMultiTS : no parameter in file \"" << fileName << "\" !" ;
405       throw INTERP_KERNEL::Exception(oss.str().c_str());
406     }
407   INTERP_KERNEL::AutoPtr<char> pName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
408   INTERP_KERNEL::AutoPtr<char> descName=MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE);
409   INTERP_KERNEL::AutoPtr<char> unitName=MEDLoaderBase::buildEmptyString(MED_SNAME_SIZE);
410   med_parameter_type paramType;
411   int nbOfSteps;
412   MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,1,pName,&paramType,descName,unitName,&nbOfSteps));
413   std::string paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
414   _dt_unit=MEDLoaderBase::buildStringFromFortran(unitName,MED_SNAME_SIZE);
415   _name=paramNameCpp;
416   _desc_name=MEDLoaderBase::buildStringFromFortran(descName,MED_COMMENT_SIZE);
417   finishLoading(fid,paramType,nbOfSteps);
418 }
419
420 MEDFileParameterMultiTS::MEDFileParameterMultiTS(const std::string& fileName, const std::string& paramName)
421 {
422   MEDFileUtilities::CheckFileForRead(fileName);
423   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
424   int nbPar=MEDnParameter(fid);
425   std::ostringstream oss; oss << "MEDFileParameterDouble1TS : no double param name \"" << paramName << "\" ! Double Parameters available are : ";
426   INTERP_KERNEL::AutoPtr<char> pName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
427   INTERP_KERNEL::AutoPtr<char> descName=MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE);
428   INTERP_KERNEL::AutoPtr<char> unitName=MEDLoaderBase::buildEmptyString(MED_SNAME_SIZE);
429   med_parameter_type paramType;
430   for(int i=0;i<nbPar;i++)
431     {
432       int nbOfSteps;
433       MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,&paramType,descName,unitName,&nbOfSteps));
434       std::string paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
435       if(paramNameCpp==paramName)
436         {
437           if(nbOfSteps>0)
438             {
439               _dt_unit=MEDLoaderBase::buildStringFromFortran(unitName,MED_SNAME_SIZE);
440               _name=paramNameCpp;
441               _desc_name=MEDLoaderBase::buildStringFromFortran(descName,MED_COMMENT_SIZE);
442               finishLoading(fid,paramType,nbOfSteps);
443               return ;
444             }
445           else
446             {
447               std::ostringstream oss2; oss2 << "Param name \"" << paramName << "\" exists but no time steps on it !";
448               throw INTERP_KERNEL::Exception(oss2.str().c_str());
449             }
450         }
451       else
452         {
453           oss << paramNameCpp;
454           if(i!=nbPar-1) oss << ", ";
455         }
456     }
457   throw INTERP_KERNEL::Exception(oss.str().c_str());
458 }
459
460 void MEDFileParameterMultiTS::finishLoading(med_idt fid, med_parameter_type typ, int nbOfSteps)
461 {
462   _param_per_ts.resize(nbOfSteps);
463   for(int i=0;i<nbOfSteps;i++)
464     {
465       int dt,it;
466       double tim;
467       MEDFILESAFECALLERRD0(MEDparameterComputationStepInfo,(fid,_name.c_str(),i+1,&dt,&it,&tim));
468       switch(typ)
469       {
470         case MED_FLOAT64:
471           _param_per_ts[i]=MEDFileParameterDouble1TSWTI::New(dt,it,tim);
472           _param_per_ts[i]->readValue(fid,_name.c_str());
473           break;
474           /*case MED_INT32;
475          _param_per_ts[i]=;
476          break;*/
477         default:
478           throw INTERP_KERNEL::Exception("MEDFileParameterMultiTS::finishLoading : supporting only FLOAT64 !");
479       }
480     }
481 }
482
483 std::size_t MEDFileParameterMultiTS::getHeapMemorySizeWithoutChildren() const
484 {
485   std::size_t ret(sizeof(MEDFileParameterMultiTS));
486   ret+=sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS>)*_param_per_ts.capacity();
487   return ret;
488 }
489
490 std::vector<const BigMemoryObject *> MEDFileParameterMultiTS::getDirectChildrenWithNull() const
491 {
492   std::vector<const BigMemoryObject *> ret;
493   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
494     ret.push_back((const MEDFileParameter1TS *)*it);
495   return ret;
496 }
497
498 MEDFileParameterMultiTS *MEDFileParameterMultiTS::deepCpy() const
499 {
500   return new MEDFileParameterMultiTS(*this,true);
501 }
502
503 bool MEDFileParameterMultiTS::isEqual(const MEDFileParameterMultiTS *other, double eps, std::string& what) const
504 {
505   if(!other)
506     { what="other is null !"; return false; }
507   if(_param_per_ts.size()!=other->_param_per_ts.size())
508     { what="number of time steps differs !"; return false; }
509   std::ostringstream oss;
510   for(std::size_t i=0;i<_param_per_ts.size();i++)
511     {
512       const MEDFileParameter1TS *a(_param_per_ts[i]),*b(other->_param_per_ts[i]);
513       if((a && !b) || (!a && b))
514         { oss << "At time step id #" << i << " pointer is defined on one side not in the other !"; what=oss.str(); return false; }
515       if(a)
516         if(!a->isEqual(b,eps,what))
517           { oss << " At time step id #" << i << " non equality !"; what+=oss.str(); return false; }
518     }
519   return true;
520 }
521
522 void MEDFileParameterMultiTS::write(const std::string& fileName, int mode) const
523 {
524   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
525   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
526   writeLL(fid,*this);
527 }
528
529 void MEDFileParameterMultiTS::writeLL(med_idt fid, const MEDFileWritable& mw) const
530 {
531   std::set<med_parameter_type> diffType;
532   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
533     {
534       const MEDFileParameter1TS *elt(*it);
535       if(dynamic_cast<const MEDFileParameterDouble1TSWTI *>(elt))
536         diffType.insert(MED_FLOAT64);
537     }
538   if(diffType.size()>1)
539     throw INTERP_KERNEL::Exception("MEDFileParameterMultiTS::writeLL : impossible to mix type of data in parameters in MED file ! Only float64 or only int32 ...");
540   if(diffType.empty())
541     return;
542   med_parameter_type typ=*diffType.begin();
543   MEDFileParameterTinyInfo::writeLLHeader(fid,typ);
544   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
545     {
546       const MEDFileParameter1TS *elt(*it);
547       if(elt)
548         elt->writeLL(fid,_name,mw);
549     }
550 }
551
552 std::string MEDFileParameterMultiTS::simpleRepr() const
553 {
554   std::ostringstream oss;
555   simpleRepr2(0,oss);
556   return oss.str();
557 }
558
559 void MEDFileParameterMultiTS::simpleRepr2(int bkOffset, std::ostream& oss) const
560 {
561   MEDFileParameterTinyInfo::mainRepr(bkOffset,oss);
562   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
563     {
564       const MEDFileParameter1TS *elt(*it);
565       if(elt)
566         elt->simpleRepr2(bkOffset+2,oss);
567     }
568 }
569
570 void MEDFileParameterMultiTS::appendValue(int dt, int it, double time, double val)
571 {
572   MEDCouplingAutoRefCountObjectPtr<MEDFileParameterDouble1TSWTI> elt=MEDFileParameterDouble1TSWTI::New(dt,it,time);
573   elt->setValue(val);
574   MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> elt2((MEDFileParameterDouble1TSWTI*)elt); elt2->incrRef();
575   _param_per_ts.push_back(elt2);
576 }
577
578 double MEDFileParameterMultiTS::getDoubleValue(int iteration, int order) const
579 {
580   int pos=getPosOfTimeStep(iteration,order);
581   const MEDFileParameter1TS *elt=_param_per_ts[pos];
582   if(!elt)
583     {
584       std::ostringstream oss; oss << "MEDFileParameterMultiTS::getDoubleValue : time iteration it=" << iteration << " order=" << order;
585       oss << " exists but elt is empty !"; 
586       throw INTERP_KERNEL::Exception(oss.str().c_str());
587     }
588   const MEDFileParameterDouble1TSWTI *eltC=dynamic_cast<const MEDFileParameterDouble1TSWTI *>(elt);
589   if(!eltC)
590     {
591       std::ostringstream oss; oss << "MEDFileParameterMultiTS::getDoubleValue : time iteration it=" << iteration << " order=" << order;
592       oss << " exists but not double !"; 
593     }
594   return eltC->getValue();
595 }
596
597 int MEDFileParameterMultiTS::getPosOfTimeStep(int iteration, int order) const
598 {
599   int ret=0;
600   std::ostringstream oss; oss << "MEDFileParameterMultiTS::getPosOfTimeStep : no such iteration=" << iteration << " order=" << order << " ! Possibilities are :";
601   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++,ret++)
602     {
603       const MEDFileParameter1TS *elt(*it);
604       if(elt)
605         {
606           if(elt->getIteration()==iteration && elt->getOrder()==order)
607             return ret;
608           else
609             oss << "(" << elt->getIteration() << "," << elt->getOrder() << "), ";
610         }
611     }
612   throw INTERP_KERNEL::Exception(oss.str().c_str());
613 }
614
615 int MEDFileParameterMultiTS::getPosGivenTime(double time, double eps) const
616 {
617   int ret=0;
618   std::ostringstream oss; oss << "MEDFileParameterMultiTS::getPosGivenTime : no such time=" << time << " ! Possibilities are :";
619   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++,ret++)
620     {
621       const MEDFileParameter1TS *elt(*it);
622       if(elt)
623         {
624           if(fabs(elt->getTimeValue()-time)<=eps)
625             return ret;
626           else
627             oss << elt->getTimeValue() << ", ";
628         }
629     }
630   throw INTERP_KERNEL::Exception(oss.str().c_str());
631 }
632
633 /*!
634  * \return an internal pointer that can be null. Warning the caller is \b not responsible of the returned pointer.
635  */
636 MEDFileParameter1TS *MEDFileParameterMultiTS::getTimeStepAtPos(int posId) const
637 {
638   if(posId<0 || posId>=(int)_param_per_ts.size())
639     {
640       std::ostringstream oss; oss << "MEDFileParameterMultiTS::getTimeStepAtPos : invalid pos ! Should be in [0," << _param_per_ts.size() << ") !";
641       throw INTERP_KERNEL::Exception(oss.str().c_str());
642     }
643   return const_cast<MEDFileParameter1TS *>(static_cast<const MEDFileParameter1TS *>(_param_per_ts[posId]));
644 }
645
646 void MEDFileParameterMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
647 {
648   std::vector<bool> b(_param_per_ts.size(),true);
649   int len=(int)_param_per_ts.size();
650   for(const int *w=startIds;w!=endIds;w++)
651     if(*w>=0 && *w<len)
652       b[*w]=false;
653     else
654       {
655         std::ostringstream oss; oss << "MEDFileParameterMultiTS::eraseTimeStepIds : At pos #" << std::distance(startIds,w) << " value is " << *w << " should be in [0," << len << ") !"; throw INTERP_KERNEL::Exception(oss.str().c_str());
656       }
657   std::size_t newNb=std::count(b.begin(),b.end(),true);
658   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> > paramPerTs(newNb);
659   std::size_t j=0;
660   for(std::size_t i=0;i<_param_per_ts.size();i++)
661     if(b[i])
662       paramPerTs[j++]=_param_per_ts[i];
663   _param_per_ts=paramPerTs;
664 }
665
666 int MEDFileParameterMultiTS::getNumberOfTS() const
667 {
668   return (int) getIterations().size();
669 }
670
671 std::vector< std::pair<int,int> > MEDFileParameterMultiTS::getIterations() const
672 {
673   std::vector< std::pair<int,int> > ret;
674   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
675     {
676       const MEDFileParameter1TS *elt(*it);
677       if(elt)
678         ret.push_back(std::pair<int,int>(elt->getIteration(),elt->getOrder()));
679     }
680   return ret;
681 }
682
683 /*!
684  * \param [out] ret1
685  */
686 std::vector< std::pair<int,int> > MEDFileParameterMultiTS::getTimeSteps(std::vector<double>& ret1) const
687 {
688   std::vector< std::pair<int,int> > ret0;
689   ret1.clear();
690   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
691     {
692       const MEDFileParameter1TS *elt(*it);
693       if(elt)
694         {
695           ret0.push_back(std::pair<int,int>(elt->getIteration(),elt->getOrder()));
696           ret1.push_back(elt->getTimeValue());
697         }
698     }
699   return ret0;
700 }
701
702 MEDFileParameters *MEDFileParameters::New()
703 {
704   return new MEDFileParameters;
705 }
706
707 MEDFileParameters *MEDFileParameters::New(const std::string& fileName)
708 {
709   return new MEDFileParameters(fileName);
710 }
711
712 MEDFileParameters::MEDFileParameters(const std::string& fileName)
713 {
714   MEDFileUtilities::CheckFileForRead(fileName);
715   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
716   int nbPar=MEDnParameter(fid);
717   _params.resize(nbPar);
718   INTERP_KERNEL::AutoPtr<char> pName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
719   INTERP_KERNEL::AutoPtr<char> descName=MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE);
720   INTERP_KERNEL::AutoPtr<char> unitName=MEDLoaderBase::buildEmptyString(MED_SNAME_SIZE);
721   med_parameter_type paramType;
722   for(int i=0;i<nbPar;i++)
723     {
724       int nbOfSteps;
725       MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,&paramType,descName,unitName,&nbOfSteps));
726       std::string paramNameCpp=MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE);
727       _params[i]=MEDFileParameterMultiTS::New(fileName,paramNameCpp);
728     }
729 }
730
731 MEDFileParameters::MEDFileParameters()
732 {
733 }
734
735 std::size_t MEDFileParameters::getHeapMemorySizeWithoutChildren() const
736 {
737   std::size_t ret(sizeof(MEDFileParameters));
738   ret+=sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileParameterMultiTS>)*_params.capacity();
739   return ret;
740 }
741
742 std::vector<const BigMemoryObject *> MEDFileParameters::getDirectChildrenWithNull() const
743 {
744   std::vector<const BigMemoryObject *> ret;
745   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++)
746     ret.push_back((const MEDFileParameterMultiTS *)*it);
747   return ret;
748 }
749
750 MEDFileParameters *MEDFileParameters::deepCpy() const
751 {
752   return new MEDFileParameters(*this,true);
753 }
754
755 bool MEDFileParameters::isEqual(const MEDFileParameters *other, double eps, std::string& what) const
756 {
757   if(!other)
758     { what="other is null !"; return false; }
759   if(_params.size()!=other->_params.size())
760     { what="number of parameters differs !"; return false; }
761   std::ostringstream oss;
762   for(std::size_t i=0;i<_params.size();i++)
763     {
764       const MEDFileParameterMultiTS *a(_params[i]),*b(other->_params[i]);
765       if((a && !b) || (!a && b))
766         { oss << "At param with id #" << i << " pointer is defined on one side not in the other !"; what=oss.str(); return false; }
767       if(a)
768         if(!a->isEqual(b,eps,what))
769           { oss << " At param with id #" << i << " non equality !"; what+=oss.str(); return false; }
770     }
771   return true;
772 }
773
774 MEDFileParameters::MEDFileParameters(const MEDFileParameters& other, bool deepCopy):MEDFileWritable(other),_params(other._params)
775 {
776   if(deepCopy)
777     for(std::size_t i=0;i<_params.size();i++)
778       {
779         const MEDFileParameterMultiTS *elt=_params[i];
780         if(elt)
781           _params[i]=elt->deepCpy();
782       }
783 }
784
785 void MEDFileParameters::write(const std::string& fileName, int mode) const
786 {
787   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
788   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
789   writeLL(fid);
790 }
791
792 void MEDFileParameters::writeLL(med_idt fid) const
793 {
794   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++)
795     {
796       const MEDFileParameterMultiTS *elt(*it);
797       if(elt)
798         elt->writeLL(fid,*this);
799     }
800 }
801
802 std::vector<std::string> MEDFileParameters::getParamsNames() const
803 {
804   std::vector<std::string> ret(_params.size());
805   int i=0;
806   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++,i++)
807     {
808       const MEDFileParameterMultiTS *p=(*it);
809       if(p)
810         {
811           ret[i]=p->getName();
812         }
813       else
814         {
815           std::ostringstream oss; oss << "MEDFileParameters::getParamsNames : At rank #" << i << " param is not defined !";
816           throw INTERP_KERNEL::Exception(oss.str().c_str());
817         }
818     }
819   return ret;
820 }
821
822 std::string MEDFileParameters::simpleRepr() const
823 {
824   std::ostringstream oss;
825   simpleReprWithoutHeader(oss);
826   return oss.str();
827 }
828
829 void MEDFileParameters::simpleReprWithoutHeader(std::ostream& oss) const
830 {
831   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++)
832     {
833       const MEDFileParameterMultiTS *elt(*it);
834       if(elt)
835         elt->simpleRepr2(2,oss);
836     }
837 }
838
839 void MEDFileParameters::resize(int newSize)
840 {
841   if(newSize<0)
842     throw INTERP_KERNEL::Exception("MEDFileParameters::resize : should be positive !");
843   _params.resize(newSize);
844 }
845
846 void MEDFileParameters::pushParam(MEDFileParameterMultiTS *param)
847 {
848   if(param)
849     param->incrRef();
850   MEDCouplingAutoRefCountObjectPtr<MEDFileParameterMultiTS> elt(param);
851   _params.push_back(elt);
852 }
853
854 void MEDFileParameters::setParamAtPos(int i, MEDFileParameterMultiTS *param)
855 {
856   if(i<0)
857     throw INTERP_KERNEL::Exception("MEDFileParameters::setParamAtPos : should be positive !");
858   if(i>=(int)_params.size())
859     _params.resize(i+1);
860   if(param)
861     param->incrRef();
862   MEDCouplingAutoRefCountObjectPtr<MEDFileParameterMultiTS> elt(param);
863   _params[i]=elt;
864 }
865
866 /*!
867  * \return an internal pointer that can be null. Warning the caller is \b not responsible of the returned pointer.
868  */
869 MEDFileParameterMultiTS *MEDFileParameters::getParamAtPos(int i) const
870 {
871   if(i<0 || i>=(int)_params.size())
872     {
873       std::ostringstream oss; oss << "MEDFileParameters::getParamAtPos : should be in [0," << _params.size() << ") !";
874       throw INTERP_KERNEL::Exception(oss.str().c_str());
875     }
876   const MEDFileParameterMultiTS *elt=_params[i];
877   return const_cast<MEDFileParameterMultiTS *>(elt);
878 }
879
880 /*!
881  * \return an internal pointer that can be null. Warning the caller is \b not responsible of the returned pointer.
882  */
883 MEDFileParameterMultiTS *MEDFileParameters::getParamWithName(const std::string& paramName) const
884 {
885   int pos=getPosFromParamName(paramName);
886   return getParamAtPos(pos);
887 }
888
889 void MEDFileParameters::destroyParamAtPos(int i)
890 {
891   if(i<0 || i>=(int)_params.size())
892     {
893       std::ostringstream oss; oss << "MEDFileParameters::destroyParamAtPos : should be in [0," << _params.size() << ") !";
894       throw INTERP_KERNEL::Exception(oss.str().c_str());
895     }
896   _params[i]=MEDCouplingAutoRefCountObjectPtr<MEDFileParameterMultiTS>(0);
897 }
898
899 int MEDFileParameters::getPosFromParamName(const std::string& paramName) const
900 {
901   std::ostringstream oss; oss << "MEDFileParameters::getPosFromParamName : no such name=" << paramName << " ! Possibilities are :";
902   int ret=0;
903   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++,ret++)
904     {
905       const MEDFileParameterMultiTS *elt(*it);
906       if(elt)
907         {
908           if(std::string(elt->getName())==paramName)
909             return ret;
910           else
911             oss << elt->getName() << ", ";
912         }
913     }
914   throw INTERP_KERNEL::Exception(oss.str().c_str());
915 }
916
917 int MEDFileParameters::getNumberOfParams() const
918 {
919   return (int)_params.size();
920 }