src/MEDLoader/MEDFileParameter.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 "MEDFileParameter.hxx"
  22 #include "MEDFileSafeCaller.txx"
  23 #include "MEDLoaderBase.hxx"
  24 #include "MEDFileBasis.hxx"
  25
  26 #include "InterpKernelAutoPtr.hxx"
  27
  28 #include <set>
  29
  30 using namespace MEDCoupling;
  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::deepCopy() 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       med_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=FromMedInt<int>(locDt); _order=FromMedInt<int>(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   med_int locDt,locIt;
 141   double dt;
 142   MEDFILESAFECALLERRD0(MEDparameterComputationStepInfo,(fid,name.c_str(),timeStepId+1,&locDt,&locIt,&dt));
 143   _iteration=FromMedInt<int>(locDt); _order=FromMedInt<int>(locIt); _time=dt;
 144   MEDFILESAFECALLERRD0(MEDparameterValueRd,(fid,name.c_str(),_iteration,_order,reinterpret_cast<unsigned char *const>(&_arr)));
 145 }
 146
 147 void MEDFileParameterDouble1TSWTI::writeAdvanced(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   med_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       med_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,FromMedInt<int>(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   med_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       med_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   med_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   med_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::deepCopy() 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::writeAdvanced(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   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
 375   return New(fid);
 376 }
 377
 378 MEDFileParameterMultiTS *MEDFileParameterMultiTS::New(med_idt fid)
 379 {
 380   return new MEDFileParameterMultiTS(fid);
 381 }
 382
 383 MEDFileParameterMultiTS *MEDFileParameterMultiTS::New(const std::string& fileName, const std::string& paramName)
 384 {
 385   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
 386   return New(fid,paramName);
 387 }
 388
 389 MEDFileParameterMultiTS *MEDFileParameterMultiTS::New(med_idt fid, const std::string& paramName)
 390 {
 391   return new MEDFileParameterMultiTS(fid,paramName);
 392 }
 393
 394 MEDFileParameterMultiTS::MEDFileParameterMultiTS()
 395 {
 396 }
 397
 398 MEDFileParameterMultiTS::MEDFileParameterMultiTS(const MEDFileParameterMultiTS& other, bool deepCopy):MEDFileParameterTinyInfo(other),_param_per_ts(other._param_per_ts)
 399 {
 400   if(deepCopy)
 401     for(std::size_t i=0;i<_param_per_ts.size();i++)
 402       {
 403         const MEDFileParameter1TS *elt=_param_per_ts[i];
 404         if(elt)
 405           _param_per_ts[i]=elt->deepCopy();
 406       }
 407 }
 408
 409 MEDFileParameterMultiTS::MEDFileParameterMultiTS(med_idt fid)
 410 {
 411   med_int nbPar(MEDnParameter(fid));
 412   if(nbPar<1)
 413     {
 414       std::ostringstream oss; oss << "MEDFileParameterMultiTS : no parameter in file \"" << FileNameFromFID(fid) << "\" !" ;
 415       throw INTERP_KERNEL::Exception(oss.str().c_str());
 416     }
 417   INTERP_KERNEL::AutoPtr<char> pName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 418   INTERP_KERNEL::AutoPtr<char> descName(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE));
 419   INTERP_KERNEL::AutoPtr<char> unitName(MEDLoaderBase::buildEmptyString(MED_SNAME_SIZE));
 420   med_parameter_type paramType;
 421   med_int nbOfSteps;
 422   MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,1,pName,&paramType,descName,unitName,&nbOfSteps));
 423   std::string paramNameCpp(MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE));
 424   _dt_unit=MEDLoaderBase::buildStringFromFortran(unitName,MED_SNAME_SIZE);
 425   _name=paramNameCpp;
 426   _desc_name=MEDLoaderBase::buildStringFromFortran(descName,MED_COMMENT_SIZE);
 427   finishLoading(fid,paramType,FromMedInt<int>(nbOfSteps));
 428 }
 429
 430 MEDFileParameterMultiTS::MEDFileParameterMultiTS(med_idt fid, const std::string& paramName)
 431 {
 432   med_int nbPar(MEDnParameter(fid));
 433   std::ostringstream oss; oss << "MEDFileParameterDouble1TS : no double param name \"" << paramName << "\" ! Double Parameters available are : ";
 434   INTERP_KERNEL::AutoPtr<char> pName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 435   INTERP_KERNEL::AutoPtr<char> descName(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE));
 436   INTERP_KERNEL::AutoPtr<char> unitName(MEDLoaderBase::buildEmptyString(MED_SNAME_SIZE));
 437   med_parameter_type paramType;
 438   for(int i=0;i<nbPar;i++)
 439     {
 440       med_int nbOfSteps;
 441       MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,&paramType,descName,unitName,&nbOfSteps));
 442       std::string paramNameCpp(MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE));
 443       if(paramNameCpp==paramName)
 444         {
 445           if(nbOfSteps>0)
 446             {
 447               _dt_unit=MEDLoaderBase::buildStringFromFortran(unitName,MED_SNAME_SIZE);
 448               _name=paramNameCpp;
 449               _desc_name=MEDLoaderBase::buildStringFromFortran(descName,MED_COMMENT_SIZE);
 450               finishLoading(fid,paramType,FromMedInt<int>(nbOfSteps));
 451               return ;
 452             }
 453           else
 454             {
 455               std::ostringstream oss2; oss2 << "Param name \"" << paramName << "\" exists but no time steps on it !";
 456               throw INTERP_KERNEL::Exception(oss2.str().c_str());
 457             }
 458         }
 459       else
 460         {
 461           oss << paramNameCpp;
 462           if(i!=nbPar-1) oss << ", ";
 463         }
 464     }
 465   throw INTERP_KERNEL::Exception(oss.str().c_str());
 466 }
 467
 468 void MEDFileParameterMultiTS::finishLoading(med_idt fid, med_parameter_type typ, int nbOfSteps)
 469 {
 470   _param_per_ts.resize(nbOfSteps);
 471   for(int i=0;i<nbOfSteps;i++)
 472     {
 473       med_int dt,it;
 474       double tim;
 475       MEDFILESAFECALLERRD0(MEDparameterComputationStepInfo,(fid,_name.c_str(),i+1,&dt,&it,&tim));
 476       switch(typ)
 477       {
 478         case MED_FLOAT64:
 479           _param_per_ts[i]=MEDFileParameterDouble1TSWTI::New(FromMedInt<int>(dt),FromMedInt<int>(it),tim);
 480           _param_per_ts[i]->readValue(fid,_name.c_str());
 481           break;
 482           /*case MED_INT32;
 483          _param_per_ts[i]=;
 484          break;*/
 485         default:
 486           throw INTERP_KERNEL::Exception("MEDFileParameterMultiTS::finishLoading : supporting only FLOAT64 !");
 487       }
 488     }
 489 }
 490
 491 std::size_t MEDFileParameterMultiTS::getHeapMemorySizeWithoutChildren() const
 492 {
 493   std::size_t ret(sizeof(MEDFileParameterMultiTS));
 494   ret+=sizeof(MCAuto<MEDFileParameter1TS>)*_param_per_ts.capacity();
 495   return ret;
 496 }
 497
 498 std::vector<const BigMemoryObject *> MEDFileParameterMultiTS::getDirectChildrenWithNull() const
 499 {
 500   std::vector<const BigMemoryObject *> ret;
 501   for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
 502     ret.push_back((const MEDFileParameter1TS *)*it);
 503   return ret;
 504 }
 505
 506 MEDFileParameterMultiTS *MEDFileParameterMultiTS::deepCopy() const
 507 {
 508   return new MEDFileParameterMultiTS(*this,true);
 509 }
 510
 511 bool MEDFileParameterMultiTS::isEqual(const MEDFileParameterMultiTS *other, double eps, std::string& what) const
 512 {
 513   if(!other)
 514     { what="other is null !"; return false; }
 515   if(_param_per_ts.size()!=other->_param_per_ts.size())
 516     { what="number of time steps differs !"; return false; }
 517   std::ostringstream oss;
 518   for(std::size_t i=0;i<_param_per_ts.size();i++)
 519     {
 520       const MEDFileParameter1TS *a(_param_per_ts[i]),*b(other->_param_per_ts[i]);
 521       if((a && !b) || (!a && b))
 522         { oss << "At time step id #" << i << " pointer is defined on one side not in the other !"; what=oss.str(); return false; }
 523       if(a)
 524         if(!a->isEqual(b,eps,what))
 525           { oss << " At time step id #" << i << " non equality !"; what+=oss.str(); return false; }
 526     }
 527   return true;
 528 }
 529
 530 void MEDFileParameterMultiTS::write(const std::string& fileName, int mode) const
 531 {
 532   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
 533   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
 534   writeAdvanced(fid,*this);
 535 }
 536
 537 void MEDFileParameterMultiTS::writeAdvanced(med_idt fid, const MEDFileWritable& mw) const
 538 {
 539   std::set<med_parameter_type> diffType;
 540   for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
 541     {
 542       const MEDFileParameter1TS *elt(*it);
 543       if(dynamic_cast<const MEDFileParameterDouble1TSWTI *>(elt))
 544         diffType.insert(MED_FLOAT64);
 545     }
 546   if(diffType.size()>1)
 547     throw INTERP_KERNEL::Exception("MEDFileParameterMultiTS::writeAdvanced : impossible to mix type of data in parameters in MED file ! Only float64 or only int32 ...");
 548   if(diffType.empty())
 549     return;
 550   med_parameter_type typ(*diffType.begin());
 551   MEDFileParameterTinyInfo::writeLLHeader(fid,typ);
 552   for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
 553     {
 554       const MEDFileParameter1TS *elt(*it);
 555       if(elt)
 556         elt->writeAdvanced(fid,_name,mw);
 557     }
 558 }
 559
 560 std::string MEDFileParameterMultiTS::simpleRepr() const
 561 {
 562   std::ostringstream oss;
 563   simpleRepr2(0,oss);
 564   return oss.str();
 565 }
 566
 567 void MEDFileParameterMultiTS::simpleRepr2(int bkOffset, std::ostream& oss) const
 568 {
 569   MEDFileParameterTinyInfo::mainRepr(bkOffset,oss);
 570   for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
 571     {
 572       const MEDFileParameter1TS *elt(*it);
 573       if(elt)
 574         elt->simpleRepr2(bkOffset+2,oss);
 575     }
 576 }
 577
 578 void MEDFileParameterMultiTS::appendValue(int dt, int it, double time, double val)
 579 {
 580   MCAuto<MEDFileParameterDouble1TSWTI> elt=MEDFileParameterDouble1TSWTI::New(dt,it,time);
 581   elt->setValue(val);
 582   MCAuto<MEDFileParameter1TS> elt2((MEDFileParameterDouble1TSWTI*)elt); elt2->incrRef();
 583   _param_per_ts.push_back(elt2);
 584 }
 585
 586 double MEDFileParameterMultiTS::getDoubleValue(int iteration, int order) const
 587 {
 588   int pos=getPosOfTimeStep(iteration,order);
 589   const MEDFileParameter1TS *elt=_param_per_ts[pos];
 590   if(!elt)
 591     {
 592       std::ostringstream oss; oss << "MEDFileParameterMultiTS::getDoubleValue : time iteration it=" << iteration << " order=" << order;
 593       oss << " exists but elt is empty !";
 594       throw INTERP_KERNEL::Exception(oss.str().c_str());
 595     }
 596   const MEDFileParameterDouble1TSWTI *eltC=dynamic_cast<const MEDFileParameterDouble1TSWTI *>(elt);
 597   if(!eltC)
 598     {
 599       std::ostringstream oss; oss << "MEDFileParameterMultiTS::getDoubleValue : time iteration it=" << iteration << " order=" << order;
 600       oss << " exists but not double !";
 601     }
 602   return eltC->getValue();
 603 }
 604
 605 int MEDFileParameterMultiTS::getPosOfTimeStep(int iteration, int order) const
 606 {
 607   int ret=0;
 608   std::ostringstream oss; oss << "MEDFileParameterMultiTS::getPosOfTimeStep : no such iteration=" << iteration << " order=" << order << " ! Possibilities are :";
 609   for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++,ret++)
 610     {
 611       const MEDFileParameter1TS *elt(*it);
 612       if(elt)
 613         {
 614           if(elt->getIteration()==iteration && elt->getOrder()==order)
 615             return ret;
 616           else
 617             oss << "(" << elt->getIteration() << "," << elt->getOrder() << "), ";
 618         }
 619     }
 620   throw INTERP_KERNEL::Exception(oss.str().c_str());
 621 }
 622
 623 int MEDFileParameterMultiTS::getPosGivenTime(double time, double eps) const
 624 {
 625   int ret=0;
 626   std::ostringstream oss; oss << "MEDFileParameterMultiTS::getPosGivenTime : no such time=" << time << " ! Possibilities are :";
 627   for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++,ret++)
 628     {
 629       const MEDFileParameter1TS *elt(*it);
 630       if(elt)
 631         {
 632           if(fabs(elt->getTimeValue()-time)<=eps)
 633             return ret;
 634           else
 635             oss << elt->getTimeValue() << ", ";
 636         }
 637     }
 638   throw INTERP_KERNEL::Exception(oss.str().c_str());
 639 }
 640
 641 /*!
 642  * \return an internal pointer that can be null. Warning the caller is \b not responsible of the returned pointer.
 643  */
 644 MEDFileParameter1TS *MEDFileParameterMultiTS::getTimeStepAtPos(int posId) const
 645 {
 646   if(posId<0 || posId>=(int)_param_per_ts.size())
 647     {
 648       std::ostringstream oss; oss << "MEDFileParameterMultiTS::getTimeStepAtPos : invalid pos ! Should be in [0," << _param_per_ts.size() << ") !";
 649       throw INTERP_KERNEL::Exception(oss.str().c_str());
 650     }
 651   return const_cast<MEDFileParameter1TS *>(static_cast<const MEDFileParameter1TS *>(_param_per_ts[posId]));
 652 }
 653
 654 void MEDFileParameterMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
 655 {
 656   std::vector<bool> b(_param_per_ts.size(),true);
 657   int len=(int)_param_per_ts.size();
 658   for(const int *w=startIds;w!=endIds;w++)
 659     if(*w>=0 && *w<len)
 660       b[*w]=false;
 661     else
 662       {
 663         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());
 664       }
 665   std::size_t newNb=std::count(b.begin(),b.end(),true);
 666   std::vector< MCAuto<MEDFileParameter1TS> > paramPerTs(newNb);
 667   std::size_t j=0;
 668   for(std::size_t i=0;i<_param_per_ts.size();i++)
 669     if(b[i])
 670       paramPerTs[j++]=_param_per_ts[i];
 671   _param_per_ts=paramPerTs;
 672 }
 673
 674 int MEDFileParameterMultiTS::getNumberOfTS() const
 675 {
 676   return (int) getIterations().size();
 677 }
 678
 679 std::vector< std::pair<int,int> > MEDFileParameterMultiTS::getIterations() const
 680 {
 681   std::vector< std::pair<int,int> > ret;
 682   for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
 683     {
 684       const MEDFileParameter1TS *elt(*it);
 685       if(elt)
 686         ret.push_back(std::pair<int,int>(elt->getIteration(),elt->getOrder()));
 687     }
 688   return ret;
 689 }
 690
 691 /*!
 692  * \param [out] ret1
 693  */
 694 std::vector< std::pair<int,int> > MEDFileParameterMultiTS::getTimeSteps(std::vector<double>& ret1) const
 695 {
 696   std::vector< std::pair<int,int> > ret0;
 697   ret1.clear();
 698   for(std::vector< MCAuto<MEDFileParameter1TS> >::const_iterator it=_param_per_ts.begin();it!=_param_per_ts.end();it++)
 699     {
 700       const MEDFileParameter1TS *elt(*it);
 701       if(elt)
 702         {
 703           ret0.push_back(std::pair<int,int>(elt->getIteration(),elt->getOrder()));
 704           ret1.push_back(elt->getTimeValue());
 705         }
 706     }
 707   return ret0;
 708 }
 709
 710 MEDFileParameters *MEDFileParameters::New()
 711 {
 712   return new MEDFileParameters;
 713 }
 714
 715 MEDFileParameters *MEDFileParameters::New(const std::string& fileName)
 716 {
 717   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
 718   return New(fid);
 719 }
 720
 721 MEDFileParameters *MEDFileParameters::New(med_idt fid)
 722 {
 723   return new MEDFileParameters(fid);
 724 }
 725
 726 MEDFileParameters::MEDFileParameters(med_idt fid)
 727 {
 728   med_int nbPar=MEDnParameter(fid);
 729   _params.resize(nbPar);
 730   INTERP_KERNEL::AutoPtr<char> pName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 731   INTERP_KERNEL::AutoPtr<char> descName(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE));
 732   INTERP_KERNEL::AutoPtr<char> unitName(MEDLoaderBase::buildEmptyString(MED_SNAME_SIZE));
 733   med_parameter_type paramType;
 734   for(int i=0;i<nbPar;i++)
 735     {
 736       med_int nbOfSteps;
 737       MEDFILESAFECALLERRD0(MEDparameterInfo,(fid,i+1,pName,&paramType,descName,unitName,&nbOfSteps));
 738       std::string paramNameCpp(MEDLoaderBase::buildStringFromFortran(pName,MED_NAME_SIZE));
 739       _params[i]=MEDFileParameterMultiTS::New(fid,paramNameCpp);
 740     }
 741 }
 742
 743 MEDFileParameters::MEDFileParameters()
 744 {
 745 }
 746
 747 std::size_t MEDFileParameters::getHeapMemorySizeWithoutChildren() const
 748 {
 749   std::size_t ret(sizeof(MEDFileParameters));
 750   ret+=sizeof(MCAuto<MEDFileParameterMultiTS>)*_params.capacity();
 751   return ret;
 752 }
 753
 754 std::vector<const BigMemoryObject *> MEDFileParameters::getDirectChildrenWithNull() const
 755 {
 756   std::vector<const BigMemoryObject *> ret;
 757   for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++)
 758     ret.push_back((const MEDFileParameterMultiTS *)*it);
 759   return ret;
 760 }
 761
 762 MEDFileParameters *MEDFileParameters::deepCopy() const
 763 {
 764   return new MEDFileParameters(*this,true);
 765 }
 766
 767 bool MEDFileParameters::isEqual(const MEDFileParameters *other, double eps, std::string& what) const
 768 {
 769   if(!other)
 770     { what="other is null !"; return false; }
 771   if(_params.size()!=other->_params.size())
 772     { what="number of parameters differs !"; return false; }
 773   std::ostringstream oss;
 774   for(std::size_t i=0;i<_params.size();i++)
 775     {
 776       const MEDFileParameterMultiTS *a(_params[i]),*b(other->_params[i]);
 777       if((a && !b) || (!a && b))
 778         { oss << "At param with id #" << i << " pointer is defined on one side not in the other !"; what=oss.str(); return false; }
 779       if(a)
 780         if(!a->isEqual(b,eps,what))
 781           { oss << " At param with id #" << i << " non equality !"; what+=oss.str(); return false; }
 782     }
 783   return true;
 784 }
 785
 786 MEDFileParameters::MEDFileParameters(const MEDFileParameters& other, bool deepCopy):MEDFileWritableStandAlone(other),_params(other._params)
 787 {
 788   if(deepCopy)
 789     for(std::size_t i=0;i<_params.size();i++)
 790       {
 791         const MEDFileParameterMultiTS *elt=_params[i];
 792         if(elt)
 793           _params[i]=elt->deepCopy();
 794       }
 795 }
 796
 797 void MEDFileParameters::writeLL(med_idt fid) const
 798 {
 799   for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++)
 800     {
 801       const MEDFileParameterMultiTS *elt(*it);
 802       if(elt)
 803         elt->writeAdvanced(fid,*this);
 804     }
 805 }
 806
 807 std::vector<std::string> MEDFileParameters::getParamsNames() const
 808 {
 809   std::vector<std::string> ret(_params.size());
 810   int i=0;
 811   for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++,i++)
 812     {
 813       const MEDFileParameterMultiTS *p=(*it);
 814       if(p)
 815         {
 816           ret[i]=p->getName();
 817         }
 818       else
 819         {
 820           std::ostringstream oss; oss << "MEDFileParameters::getParamsNames : At rank #" << i << " param is not defined !";
 821           throw INTERP_KERNEL::Exception(oss.str().c_str());
 822         }
 823     }
 824   return ret;
 825 }
 826
 827 std::string MEDFileParameters::simpleRepr() const
 828 {
 829   std::ostringstream oss;
 830   simpleReprWithoutHeader(oss);
 831   return oss.str();
 832 }
 833
 834 void MEDFileParameters::simpleReprWithoutHeader(std::ostream& oss) const
 835 {
 836   for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++)
 837     {
 838       const MEDFileParameterMultiTS *elt(*it);
 839       if(elt)
 840         elt->simpleRepr2(2,oss);
 841     }
 842 }
 843
 844 void MEDFileParameters::resize(int newSize)
 845 {
 846   if(newSize<0)
 847     throw INTERP_KERNEL::Exception("MEDFileParameters::resize : should be positive !");
 848   _params.resize(newSize);
 849 }
 850
 851 void MEDFileParameters::pushParam(MEDFileParameterMultiTS *param)
 852 {
 853   if(param)
 854     param->incrRef();
 855   MCAuto<MEDFileParameterMultiTS> elt(param);
 856   _params.push_back(elt);
 857 }
 858
 859 void MEDFileParameters::setParamAtPos(int i, MEDFileParameterMultiTS *param)
 860 {
 861   if(i<0)
 862     throw INTERP_KERNEL::Exception("MEDFileParameters::setParamAtPos : should be positive !");
 863   if(i>=(int)_params.size())
 864     _params.resize(i+1);
 865   if(param)
 866     param->incrRef();
 867   MCAuto<MEDFileParameterMultiTS> elt(param);
 868   _params[i]=elt;
 869 }
 870
 871 /*!
 872  * \return an internal pointer that can be null. Warning the caller is \b not responsible of the returned pointer.
 873  */
 874 MEDFileParameterMultiTS *MEDFileParameters::getParamAtPos(int i) const
 875 {
 876   if(i<0 || i>=(int)_params.size())
 877     {
 878       std::ostringstream oss; oss << "MEDFileParameters::getParamAtPos : should be in [0," << _params.size() << ") !";
 879       throw INTERP_KERNEL::Exception(oss.str().c_str());
 880     }
 881   const MEDFileParameterMultiTS *elt=_params[i];
 882   return const_cast<MEDFileParameterMultiTS *>(elt);
 883 }
 884
 885 /*!
 886  * \return an internal pointer that can be null. Warning the caller is \b not responsible of the returned pointer.
 887  */
 888 MEDFileParameterMultiTS *MEDFileParameters::getParamWithName(const std::string& paramName) const
 889 {
 890   int pos=getPosFromParamName(paramName);
 891   return getParamAtPos(pos);
 892 }
 893
 894 void MEDFileParameters::destroyParamAtPos(int i)
 895 {
 896   if(i<0 || i>=(int)_params.size())
 897     {
 898       std::ostringstream oss; oss << "MEDFileParameters::destroyParamAtPos : should be in [0," << _params.size() << ") !";
 899       throw INTERP_KERNEL::Exception(oss.str().c_str());
 900     }
 901   _params[i]=MCAuto<MEDFileParameterMultiTS>(0);
 902 }
 903
 904 int MEDFileParameters::getPosFromParamName(const std::string& paramName) const
 905 {
 906   std::ostringstream oss; oss << "MEDFileParameters::getPosFromParamName : no such name=" << paramName << " ! Possibilities are :";
 907   int ret=0;
 908   for(std::vector< MCAuto<MEDFileParameterMultiTS> >::const_iterator it=_params.begin();it!=_params.end();it++,ret++)
 909     {
 910       const MEDFileParameterMultiTS *elt(*it);
 911       if(elt)
 912         {
 913           if(std::string(elt->getName())==paramName)
 914             return ret;
 915           else
 916             oss << elt->getName() << ", ";
 917         }
 918     }
 919   throw INTERP_KERNEL::Exception(oss.str().c_str());
 920 }
 921
 922 int MEDFileParameters::getNumberOfParams() const
 923 {
 924   return (int)_params.size();
 925 }