src/MEDLoader/MEDFileField.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "MEDFileField.hxx"
  22 #include "MEDFileMesh.hxx"
  23 #include "MEDLoaderBase.hxx"
  24 #include "MEDFileUtilities.hxx"
  25
  26 #include "MEDCouplingFieldDouble.hxx"
  27 #include "MEDCouplingFieldDiscretization.hxx"
  28
  29 #include "InterpKernelAutoPtr.hxx"
  30 #include "CellModel.hxx"
  31
  32 #include <algorithm>
  33 #include <iterator>
  34
  35 extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
  36 extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
  37 extern med_geometry_type typmainoeud[1];
  38 extern med_geometry_type typmai3[32];
  39
  40 using namespace ParaMEDMEM;
  41
  42 const char MEDFileField1TSWithoutSDA::TYPE_STR[]="FLOAT64";
  43 const char MEDFileIntField1TSWithoutSDA::TYPE_STR[]="INT32";
  44
  45 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, const char *locName)
  46 {
  47   return new MEDFileFieldLoc(fid,locName);
  48 }
  49
  50 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, int id)
  51 {
  52   return new MEDFileFieldLoc(fid,id);
  53 }
  54
  55 MEDFileFieldLoc *MEDFileFieldLoc::New(const char *locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
  56 {
  57   return new MEDFileFieldLoc(locName,geoType,refCoo,gsCoo,w);
  58 }
  59
  60 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, const char *locName):_name(locName)
  61 {
  62   med_geometry_type geotype;
  63   med_geometry_type sectiongeotype;
  64   int nsectionmeshcell;
  65   INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  66   INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  67   MEDlocalizationInfoByName(fid,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
  68   _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+32,geotype)));
  69   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
  70   _nb_node_per_cell=cm.getNumberOfNodes();
  71   _ref_coo.resize(_dim*_nb_node_per_cell);
  72   _gs_coo.resize(_dim*_nb_gauss_pt);
  73   _w.resize(_nb_gauss_pt);
  74   MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
  75 }
  76
  77 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, int id)
  78 {
  79   med_geometry_type geotype;
  80   med_geometry_type sectiongeotype;
  81   int nsectionmeshcell;
  82   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  83   INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  84   INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  85   MEDlocalizationInfo(fid,id+1,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
  86   _name=locName;
  87   _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+32,geotype)));
  88   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
  89   _nb_node_per_cell=cm.getNumberOfNodes();
  90   _ref_coo.resize(_dim*_nb_node_per_cell);
  91   _gs_coo.resize(_dim*_nb_gauss_pt);
  92   _w.resize(_nb_gauss_pt);
  93   MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
  94 }
  95
  96 MEDFileFieldLoc::MEDFileFieldLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType,
  97                                  const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w):_name(locName),_geo_type(geoType),_ref_coo(refCoo),_gs_coo(gsCoo),
  98                                                                                                                                     _w(w)
  99 {
 100   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
 101   _dim=cm.getDimension();
 102   _nb_node_per_cell=cm.getNumberOfNodes();
 103   _nb_gauss_pt=_w.size();
 104 }
 105
 106 MEDFileFieldLoc *MEDFileFieldLoc::deepCpy() const
 107 {
 108   return new MEDFileFieldLoc(*this);
 109 }
 110
 111 std::size_t MEDFileFieldLoc::getHeapMemorySize() const
 112 {
 113   return (_ref_coo.capacity()+_gs_coo.capacity()+_w.capacity())*sizeof(double)+_name.capacity();
 114 }
 115
 116 void MEDFileFieldLoc::simpleRepr(std::ostream& oss) const
 117 {
 118   static const char OFF7[]="\n    ";
 119   oss << "\"" << _name << "\"" << OFF7;
 120   oss << "GeoType=" << INTERP_KERNEL::CellModel::GetCellModel(_geo_type).getRepr() << OFF7;
 121   oss << "Dimension=" << _dim << OFF7;
 122   oss << "Number of Gauss points=" << _nb_gauss_pt << OFF7;
 123   oss << "Number of nodes per cell=" << _nb_node_per_cell << OFF7;
 124   oss << "RefCoords="; std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 125   oss << "Weights="; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 126   oss << "GaussPtsCoords="; std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," ")); oss << std::endl;
 127 }
 128
 129 void MEDFileFieldLoc::setName(const char *name)
 130 {
 131   _name=name;
 132 }
 133
 134 bool MEDFileFieldLoc::isEqual(const MEDFileFieldLoc& other, double eps) const
 135 {
 136   if(_name!=other._name)
 137     return false;
 138   if(_dim!=other._dim)
 139     return false;
 140   if(_nb_gauss_pt!=other._nb_gauss_pt)
 141     return false;
 142   if(_nb_node_per_cell!=other._nb_node_per_cell)
 143     return false;
 144   if(_geo_type!=other._geo_type)
 145     return false;
 146   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_ref_coo,other._ref_coo,eps))
 147     return false;
 148   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_gs_coo,other._gs_coo,eps))
 149     return false;
 150   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_w,other._w,eps))
 151     return false;
 152
 153   return true;
 154 }
 155
 156 void MEDFileFieldLoc::writeLL(med_idt fid) const
 157 {
 158   MEDlocalizationWr(fid,_name.c_str(),typmai3[(int)_geo_type],_dim,&_ref_coo[0],MED_FULL_INTERLACE,_nb_gauss_pt,&_gs_coo[0],&_w[0],MED_NO_INTERPOLATION,MED_NO_MESH_SUPPORT);
 159 }
 160
 161 std::string MEDFileFieldLoc::repr() const
 162 {
 163   std::ostringstream oss; oss.precision(15);
 164   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
 165   oss << "Localization \"" << _name << "\" :\n" << "  - Geometric Type : " << cm.getRepr();
 166   oss << "\n  - Dimension : " << _dim << "\n  - Number of gauss points : ";
 167   oss << _nb_gauss_pt << "\n  - Number of nodes in cell : " << _nb_node_per_cell;
 168   oss << "\n  - Ref coords are : ";
 169   int sz=_ref_coo.size();
 170   if(sz%_dim==0)
 171     {
 172       int nbOfTuples=sz/_dim;
 173       for(int i=0;i<nbOfTuples;i++)
 174         {
 175           oss << "(";
 176           for(int j=0;j<_dim;j++)
 177             { oss << _ref_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 178           oss << ") ";
 179         }
 180     }
 181   else
 182     std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," "));
 183   oss << "\n  - Gauss coords in reference element : ";
 184   sz=_gs_coo.size();
 185   if(sz%_dim==0)
 186     {
 187       int nbOfTuples=sz/_dim;
 188       for(int i=0;i<nbOfTuples;i++)
 189         {
 190           oss << "(";
 191           for(int j=0;j<_dim;j++)
 192             { oss << _gs_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 193           oss << ") ";
 194         }
 195     }
 196   else
 197     std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," "));
 198   oss << "\n  - Weights of Gauss coords are : "; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," "));
 199   return oss.str();
 200 }
 201
 202 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 203 {
 204   _type=field->getTypeOfField();
 205   _start=start;
 206   switch(_type)
 207     {
 208     case ON_CELLS:
 209       {
 210         getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,offset,offset+nbOfCells,1);
 211         _end=_start+nbOfCells;
 212         _nval=nbOfCells;
 213         break;
 214       }
 215     case ON_GAUSS_NE:
 216       {
 217         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(field->getMesh());
 218         const int *arrPtr=arr->getConstPointer();
 219         getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,arrPtr[offset],arrPtr[offset+nbOfCells],1);
 220         _end=_start+(arrPtr[offset+nbOfCells]-arrPtr[offset]);
 221         _nval=nbOfCells;
 222         break;
 223       }
 224     case ON_GAUSS_PT:
 225       {
 226         const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
 227         const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
 228         const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
 229         if(!disc2)
 230           throw INTERP_KERNEL::Exception("assignFieldNoProfile : invalid call to this method ! Internal Error !");
 231         const DataArrayInt *dai=disc2->getArrayOfDiscIds();
 232         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai2=disc2->getOffsetArr(field->getMesh());
 233         const int *dai2Ptr=dai2->getConstPointer();
 234         int nbi=gsLoc.getWeights().size();
 235         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=dai->selectByTupleId2(offset,offset+nbOfCells,1);
 236         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
 237         const int *da3Ptr=da3->getConstPointer();
 238         if(da3->getNumberOfTuples()!=nbOfCells)
 239           {//profile : for gauss even in NoProfile !!!
 240             std::ostringstream oss; oss << "Pfl_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 241             _profile=oss.str();
 242             da3->setName(_profile.c_str());
 243             glob.appendProfile(da3);
 244           }
 245         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=DataArrayInt::New();
 246         _nval=da3->getNbOfElems();
 247         da4->alloc(_nval*nbi,1);
 248         int *da4Ptr=da4->getPointer();
 249         for(int i=0;i<_nval;i++)
 250           {
 251             int ref=dai2Ptr[offset+da3Ptr[i]];
 252             for(int j=0;j<nbi;j++)
 253               *da4Ptr++=ref+j;
 254           }
 255         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 256         _localization=oss2.str();
 257         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,da4);
 258         _end=_start+_nval*nbi;
 259         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 260         break;
 261       }
 262     default:
 263       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile : not implemented yet for such discretization type of field !");
 264     }
 265   start=_end;
 266 }
 267
 268 /*!
 269  * Leaf method of field with profile assignement. This method is the most general one. No optimization is done here.
 270  * \param [in] pflName input containing name of profile if any. 0 if no profile (except for GAUSS_PT where a no profile can hide a profile when splitted by loc_id).
 271  * \param [in] multiTypePfl is the end user profile specified in high level API
 272  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
 273  * \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
 274  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
 275  * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
 276  */
 277 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const DataArray *arrr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 278 {
 279   _profile.clear();
 280   _type=field->getTypeOfField();
 281   std::string pflName(multiTypePfl->getName());
 282   std::ostringstream oss; oss << pflName;
 283   if(_type!=ON_NODES) { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType()); oss << "_" <<  cm.getRepr(); } else { oss << "_NODE"; }
 284   if(locIds)
 285     {
 286       if(pflName.empty())
 287         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : existing profile with empty name !");
 288       if(_type!=ON_GAUSS_PT)
 289         {
 290           locIds->setName(oss.str().c_str());
 291           glob.appendProfile(locIds);
 292           _profile=oss.str();
 293         }
 294     }
 295   _start=start;
 296   switch(_type)
 297     {
 298     case ON_NODES:
 299       {
 300          _nval=idsInPfl->getNumberOfTuples();
 301          getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,arrr->getNumberOfTuples(),1);
 302          _end=_start+_nval;
 303          break;
 304       }
 305     case ON_CELLS:
 306       {
 307         _nval=idsInPfl->getNumberOfTuples();
 308         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,idsInPfl);
 309         _end=_start+_nval;
 310         break;
 311       }
 312     case ON_GAUSS_NE:
 313       {
 314         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(mesh);
 315         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr->deltaShiftIndex();
 316         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3=arr2->selectByTupleId(multiTypePfl->begin(),multiTypePfl->end());
 317         arr3->computeOffsets2();
 318         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=idsInPfl->buildExplicitArrByRanges(arr3);
 319         int trueNval=tmp->getNumberOfTuples();
 320         _nval=idsInPfl->getNumberOfTuples();
 321         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 322         _end=_start+trueNval;
 323         break;
 324       }
 325     case ON_GAUSS_PT:
 326       {
 327         const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
 328         if(!disc2)
 329           throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
 330         const DataArrayInt *da1=disc2->getArrayOfDiscIds();
 331         const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
 332         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da1->selectByTupleId(idsInPfl->begin(),idsInPfl->end());
 333         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
 334         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=idsInPfl->selectByTupleId(da3->begin(),da3->end());
 335         //
 336         MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPart(multiTypePfl->begin(),multiTypePfl->end());
 337         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=disc2->getOffsetArr(mesh2);
 338         //
 339         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=DataArrayInt::New();
 340         int trueNval=0;
 341         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 342           trueNval+=arr->getIJ(*pt+1,0)-arr->getIJ(*pt,0);
 343         tmp->alloc(trueNval,1);
 344         int *tmpPtr=tmp->getPointer();
 345         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 346           for(int j=arr->getIJ(*pt,0);j<arr->getIJ(*pt+1,0);j++)
 347             *tmpPtr++=j;
 348         //
 349         _nval=da4->getNumberOfTuples();
 350         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 351         _end=_start+trueNval;
 352         oss << "_loc_" << _loc_id;
 353         if(locIds)
 354           {
 355             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da5=locIds->selectByTupleId(da3->begin(),da3->end());
 356             da5->setName(oss.str().c_str());
 357             glob.appendProfile(da5);
 358             _profile=oss.str();
 359           }
 360         else
 361           {
 362             if(da3->getNumberOfTuples()!=nbOfEltsInWholeMesh || !da3->isIdentity())
 363               {
 364                 da3->setName(oss.str().c_str());
 365                 glob.appendProfile(da3);
 366                 _profile=oss.str();
 367               }
 368           }
 369         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 370         _localization=oss2.str();
 371         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 372         break;
 373       }
 374     default:
 375       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : not implemented yet for such discretization type of field !");
 376     }
 377   start=_end;
 378 }
 379
 380 void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
 381 {
 382   _start=start;
 383   _nval=arrr->getNumberOfTuples();
 384   getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,_nval,1);
 385   _end=_start+_nval;
 386   start=_end;
 387 }
 388
 389 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int profileIt) throw(INTERP_KERNEL::Exception)
 390 {
 391   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,profileIt);
 392 }
 393
 394 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId)
 395 {
 396   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,locId,std::string());
 397 }
 398
 399 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(const MEDFileFieldPerMeshPerTypePerDisc& other)
 400 {
 401   return new MEDFileFieldPerMeshPerTypePerDisc(other);
 402 }
 403
 404 std::size_t MEDFileFieldPerMeshPerTypePerDisc::getHeapMemorySize() const
 405 {
 406   return _profile.capacity()+_localization.capacity()+5*sizeof(int);
 407 }
 408
 409 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::deepCpy(MEDFileFieldPerMeshPerType *father) const throw(INTERP_KERNEL::Exception)
 410 {
 411   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> ret=new MEDFileFieldPerMeshPerTypePerDisc(*this);
 412   ret->_father=father;
 413   return ret.retn();
 414 }
 415
 416 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField atype, int profileIt) throw(INTERP_KERNEL::Exception)
 417 try:_type(atype),_father(fath)
 418   {
 419   }
 420 catch(INTERP_KERNEL::Exception& e)
 421 {
 422   throw e;
 423 }
 424
 425 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId, const std::string& dummy):_type(type),_father(fath),_loc_id(locId)
 426 {
 427 }
 428
 429 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc& other):_type(other._type),_father(0),_start(other._start),_end(other._end),_nval(other._nval),_profile(other._profile),_localization(other._localization),_loc_id(other._loc_id),_tmp_work1(other._tmp_work1)
 430 {
 431 }
 432
 433 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(0),_start(-std::numeric_limits<int>::max()),_end(-std::numeric_limits<int>::max()),
 434                                                                        _nval(-std::numeric_limits<int>::max()),_loc_id(-std::numeric_limits<int>::max())
 435 {
 436 }
 437
 438 const MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerTypePerDisc::getFather() const
 439 {
 440   return _father;
 441 }
 442
 443 void MEDFileFieldPerMeshPerTypePerDisc::loadOnlyStructureOfDataRecursively(med_idt fid, int profileIt, int& start, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 444 {
 445   INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 446   INTERP_KERNEL::AutoPtr<char> pflname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 447   std::string fieldName=nasc.getName();
 448   std::string meshName=getMeshName();
 449   int iteration=getIteration();
 450   int order=getOrder();
 451   TypeOfField type=getType();
 452   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 453   int profilesize,nbi;
 454   med_geometry_type mgeoti;
 455   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 456   _nval=MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,profileIt,MED_COMPACT_PFLMODE,
 457                                   pflname,&profilesize,locname,&nbi);
 458   _profile=MEDLoaderBase::buildStringFromFortran(pflname,MED_NAME_SIZE);
 459   _localization=MEDLoaderBase::buildStringFromFortran(locname,MED_NAME_SIZE);
 460   _start=start;
 461   _end=start+_nval*nbi;
 462   start=_end;
 463   if(type==ON_CELLS && !_localization.empty())
 464     {
 465       if(_localization!="MED_GAUSS_ELNO")//For compatibily with MED2.3
 466         setType(ON_GAUSS_PT);
 467       else
 468         {
 469           setType(ON_GAUSS_NE);
 470           _localization.clear();
 471         }
 472     }
 473 }
 474
 475 void MEDFileFieldPerMeshPerTypePerDisc::loadBigArray(med_idt fid, int profileIt, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 476 {
 477   std::string fieldName=nasc.getName();
 478   std::string meshName=getMeshName();
 479   int iteration=getIteration();
 480   int order=getOrder();
 481   TypeOfField type=getType();
 482   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 483   med_geometry_type mgeoti;
 484   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 485   if(_start>_end)
 486     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : internal error in range !");
 487   if(_start==_end)
 488     return ;
 489   DataArray *arr=getOrCreateAndGetArray();//arr is not null due to the spec of getOrCreateAndGetArray
 490   if(_start<0 || _start>=arr->getNumberOfTuples())
 491     {
 492       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << ") !";
 493       throw INTERP_KERNEL::Exception(oss.str().c_str());
 494     }
 495   if(_end<0 || _end>arr->getNumberOfTuples())
 496     {
 497       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << "] !";
 498       throw INTERP_KERNEL::Exception(oss.str().c_str());
 499     }
 500   med_int tmp1,nbi;
 501   INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 502   med_int nbValsInFile=MEDfieldnValueWithProfileByName(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile.c_str(),MED_COMPACT_PFLMODE,&tmp1,locname,&nbi);
 503   int nbOfCompo=arr->getNumberOfComponents();
 504   if(_end-_start!=nbValsInFile*nbi)
 505     {
 506       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : The number of tuples to read is " << nbValsInFile << "*" << nbi <<  " (nb integration points) ! But in data structure it values " << _end-_start << " is expected !";
 507       throw INTERP_KERNEL::Exception(oss.str().c_str());
 508     }
 509   DataArrayDouble *arrD=dynamic_cast<DataArrayDouble *>(arr);
 510   if(arrD)
 511     {
 512       double *startFeeding=arrD->getPointer()+_start*nbOfCompo;
 513       MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
 514                                  _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
 515       return ;
 516     }
 517   DataArrayInt *arrI=dynamic_cast<DataArrayInt *>(arr);
 518   if(arrI)
 519     {
 520       int *startFeeding=arrI->getPointer()+_start*nbOfCompo;
 521       MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
 522                                  _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
 523       return ;
 524     }
 525   throw INTERP_KERNEL::Exception("Error on array reading ! Unrecognized type of field ! Should be in FLOAT64 or INT32 !");
 526 }
 527
 528 /*!
 529  * Set a \c this->_start **and** \c this->_end keeping the same delta between the two.
 530  */
 531 void MEDFileFieldPerMeshPerTypePerDisc::setNewStart(int newValueOfStart) throw(INTERP_KERNEL::Exception)
 532 {
 533   int delta=_end-_start;
 534   _start=newValueOfStart;
 535   _end=_start+delta;
 536 }
 537
 538 int MEDFileFieldPerMeshPerTypePerDisc::getIteration() const
 539 {
 540   return _father->getIteration();
 541 }
 542
 543 int MEDFileFieldPerMeshPerTypePerDisc::getOrder() const
 544 {
 545   return _father->getOrder();
 546 }
 547
 548 double MEDFileFieldPerMeshPerTypePerDisc::getTime() const
 549 {
 550   return _father->getTime();
 551 }
 552
 553 std::string MEDFileFieldPerMeshPerTypePerDisc::getMeshName() const
 554 {
 555   return _father->getMeshName();
 556 }
 557
 558 void MEDFileFieldPerMeshPerTypePerDisc::simpleRepr(int bkOffset, std::ostream& oss, int id) const
 559 {
 560   const char startLine[]="    ## ";
 561   std::string startLine2(bkOffset,' ');
 562   startLine2+=startLine;
 563   MEDCouplingFieldDiscretization *tmp=MEDCouplingFieldDiscretization::New(_type);
 564   oss << startLine2 << "Localization #" << id << "." << std::endl;
 565   oss << startLine2 << "  Type=" << tmp->getRepr() << "." << std::endl;
 566   delete tmp;
 567   oss << startLine2 << "  This type discretization lies on profile : \"" << _profile << "\" and on the following localization : \"" << _localization << "\"." << std::endl;
 568   oss << startLine2 << "  This type discretization has " << _end-_start << " tuples (start=" << _start << ", end=" << _end << ")." << std::endl;
 569   oss << startLine2 << "  This type discretization has " << (_end-_start)/_nval << " integration points." << std::endl;
 570 }
 571
 572 TypeOfField MEDFileFieldPerMeshPerTypePerDisc::getType() const
 573 {
 574   return _type;
 575 }
 576
 577 void MEDFileFieldPerMeshPerTypePerDisc::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
 578 {
 579   types.insert(_type);
 580 }
 581
 582 void MEDFileFieldPerMeshPerTypePerDisc::setType(TypeOfField newType)
 583 {
 584   _type=newType;
 585 }
 586
 587 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerTypePerDisc::getGeoType() const
 588 {
 589   return _father->getGeoType();
 590 }
 591
 592 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfComponents() const
 593 {
 594   return _father->getNumberOfComponents();
 595 }
 596
 597 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfTuples() const
 598 {
 599   return _end-_start;
 600 }
 601
 602 DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray()
 603 {
 604   return _father->getOrCreateAndGetArray();
 605 }
 606
 607 const DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray() const
 608 {
 609   const MEDFileFieldPerMeshPerType *fath=_father;
 610   return fath->getOrCreateAndGetArray();
 611 }
 612
 613 const std::vector<std::string>& MEDFileFieldPerMeshPerTypePerDisc::getInfo() const
 614 {
 615   return _father->getInfo();
 616 }
 617
 618 std::string MEDFileFieldPerMeshPerTypePerDisc::getProfile() const
 619 {
 620   return _profile;
 621 }
 622
 623 void MEDFileFieldPerMeshPerTypePerDisc::setProfile(const char *newPflName)
 624 {
 625   _profile=newPflName;
 626 }
 627
 628 std::string MEDFileFieldPerMeshPerTypePerDisc::getLocalization() const
 629 {
 630   return _localization;
 631 }
 632
 633 void MEDFileFieldPerMeshPerTypePerDisc::setLocalization(const char *newLocName)
 634 {
 635   _localization=newLocName;
 636 }
 637
 638 void MEDFileFieldPerMeshPerTypePerDisc::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
 639 {
 640   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 641     {
 642       if(std::find((*it2).first.begin(),(*it2).first.end(),_profile)!=(*it2).first.end())
 643         {
 644           _profile=(*it2).second;
 645           return;
 646         }
 647     }
 648 }
 649
 650 void MEDFileFieldPerMeshPerTypePerDisc::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
 651 {
 652   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 653     {
 654       if(std::find((*it2).first.begin(),(*it2).first.end(),_localization)!=(*it2).first.end())
 655         {
 656           _localization=(*it2).second;
 657           return;
 658         }
 659     }
 660 }
 661
 662 void MEDFileFieldPerMeshPerTypePerDisc::getFieldAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<int,int> >& dads, std::vector<const DataArrayInt *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const
 663 {
 664   if(type!=_type)
 665     return ;
 666   dads.push_back(std::pair<int,int>(_start,_end));
 667   geoTypes.push_back(getGeoType());
 668   if(_profile.empty())
 669     pfls.push_back(0);
 670   else
 671     {
 672       pfls.push_back(glob->getProfile(_profile.c_str()));
 673     }
 674   if(_localization.empty())
 675     locs.push_back(-1);
 676   else
 677     {
 678       locs.push_back(glob->getLocalizationId(_localization.c_str()));
 679     }
 680 }
 681
 682 void MEDFileFieldPerMeshPerTypePerDisc::fillValues(int discId, int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
 683 {
 684   entries[startEntryId]=std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int> ,std::pair<int,int> >(std::pair<INTERP_KERNEL::NormalizedCellType,int>(getGeoType(),discId),std::pair<int,int>(_start,_end));
 685   startEntryId++;
 686 }
 687
 688 void MEDFileFieldPerMeshPerTypePerDisc::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
 689 {
 690   TypeOfField type=getType();
 691   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 692   med_geometry_type mgeoti;
 693   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 694   const DataArray *arr=getOrCreateAndGetArray();
 695   if(!arr)
 696     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : no array set !");
 697   const DataArrayDouble *arrD=dynamic_cast<const DataArrayDouble *>(arr);
 698   const DataArrayInt *arrI=dynamic_cast<const DataArrayInt *>(arr);
 699   const unsigned char *locToWrite=0;
 700   if(arrD)
 701     locToWrite=reinterpret_cast<const unsigned char *>(arrD->getConstPointer()+_start*arr->getNumberOfComponents());
 702   else if(arrI)
 703     locToWrite=reinterpret_cast<const unsigned char *>(arrI->getConstPointer()+_start*arr->getNumberOfComponents());
 704   else
 705     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : not recognized type of values ! Supported are FLOAT64 and INT32 !");
 706   MEDfieldValueWithProfileWr(fid,nasc.getName().c_str(),getIteration(),getOrder(),getTime(),menti,mgeoti,
 707                              MED_COMPACT_PFLMODE,_profile.c_str(),_localization.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,_nval,
 708                              locToWrite);
 709 }
 710
 711 void MEDFileFieldPerMeshPerTypePerDisc::getCoarseData(TypeOfField& type, std::pair<int,int>& dad, std::string& pfl, std::string& loc) const throw(INTERP_KERNEL::Exception)
 712 {
 713   type=_type;
 714   pfl=_profile;
 715   loc=_localization;
 716   dad.first=_start; dad.second=_end;
 717 }
 718
 719 /*!
 720  * \param [in] codeOfMesh is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
 721  *             This code corresponds to the distribution of types in the corresponding mesh.
 722  * \param [out] ptToFill memory zone where the output will be stored.
 723  * \return the size of data pushed into output param \a ptToFill
 724  */
 725 int MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode(int offset, const std::vector<int>& codeOfMesh, const MEDFileFieldGlobsReal& glob, int *ptToFill) const throw(INTERP_KERNEL::Exception)
 726 {
 727   _loc_id=offset;
 728   std::ostringstream oss;
 729   std::size_t nbOfType=codeOfMesh.size()/3;
 730   int found=-1;
 731   for(std::size_t i=0;i<nbOfType && found==-1;i++)
 732     if(getGeoType()==(INTERP_KERNEL::NormalizedCellType)codeOfMesh[3*i])
 733       found=(int)i;
 734   if(found==-1)
 735     {
 736       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 737       oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : not found geometric type " << cm.getRepr() << " in the referenced mesh of field !";
 738       throw INTERP_KERNEL::Exception(oss.str().c_str());
 739     }
 740   int *work=ptToFill;
 741   if(_profile.empty())
 742     {
 743       if(_nval!=codeOfMesh[3*found+1])
 744         {
 745           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 746           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << " number of elt ids in mesh is equal to " << _nval;
 747           oss << " whereas mesh has " << codeOfMesh[3*found+1] << " for this geometric type !";
 748           throw INTERP_KERNEL::Exception(oss.str().c_str());
 749         }
 750       for(int ii=codeOfMesh[3*found+2];ii<codeOfMesh[3*found+2]+_nval;ii++)
 751         *work++=ii;
 752     }
 753   else
 754     {
 755       const DataArrayInt *pfl=glob.getProfile(_profile.c_str());
 756       if(pfl->getNumberOfTuples()!=_nval)
 757         {
 758           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 759           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << ", field is defined on profile \"" << _profile << "\" and size of profile is ";
 760           oss << _nval;
 761           oss << pfl->getNumberOfTuples() << " whereas the number of ids is set to " << _nval << " for this geometric type !";
 762           throw INTERP_KERNEL::Exception(oss.str().c_str());
 763         }
 764       int offset2=codeOfMesh[3*found+2];
 765       for(const int *pflId=pfl->begin();pflId!=pfl->end();pflId++)
 766         {
 767           if(*pflId<codeOfMesh[3*found+1])
 768             *work++=offset2+*pflId;
 769         }
 770     }
 771   return _nval;
 772 }
 773
 774 int MEDFileFieldPerMeshPerTypePerDisc::fillTupleIds(int *ptToFill) const throw(INTERP_KERNEL::Exception)
 775 {
 776   for(int i=_start;i<_end;i++)
 777     *ptToFill++=i;
 778   return _end-_start;
 779 }
 780
 781 int MEDFileFieldPerMeshPerTypePerDisc::ConvertType(TypeOfField type, int locId) throw(INTERP_KERNEL::Exception)
 782 {
 783   switch(type)
 784     {
 785     case ON_CELLS:
 786       return -2;
 787     case ON_GAUSS_NE:
 788       return -1;
 789     case ON_GAUSS_PT:
 790       return locId;
 791     default:
 792       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::ConvertType : not managed type of field !");
 793     }
 794 }
 795
 796 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entries)
 797 {
 798   int id=0;
 799   std::map<std::pair<std::string,TypeOfField>,int> m;
 800   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > ret;
 801   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 802     if(m.find(std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType()))==m.end())
 803       m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]=id++;
 804   ret.resize(id);
 805   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 806     ret[m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]].push_back(*it);
 807   return ret;
 808 }
 809
 810 /*!
 811  * - \c this->_loc_id mutable attribute is used for elt id in mesh offsets.
 812  *
 813  * \param [in] offset the offset id used to take into account that \a result is not compulsary empty in input
 814  * \param [in] entriesOnSameDisc some entries **on same localization** if not the result can be invalid. The _start and _end on them are relative to \a arr parameter.
 815  * \param [in] explicitIdsInMesh ids in mesh of the considered chunk.
 816  * \param [in] newCode one of the input parameter to explicit the new geo type dispatch (in classical format same than those asked by MEDFileFields::renumberEntitiesLyingOnMesh)
 817  * \param [in,out] glob if necessary by the method, new profiles can be added to it
 818  * \param [in,out] arr after the call of this method \a arr is renumbered to be compliant with added entries to \a result.
 819  * \param [out] result All new entries will be appended on it.
 820  * \return false if the configuration of renumbering leads to an unnecessary resplit of input \a entriesOnSameDisc. If not true is returned (the most general case !)
 821  */
 822 bool MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(int offset, const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
 823                                                        const DataArrayInt *explicitIdsInMesh,
 824                                                        const std::vector<int>& newCode,
 825                                                        MEDFileFieldGlobsReal& glob, DataArrayDouble *arr,
 826                                                        std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >& result)
 827 {
 828   if(entriesOnSameDisc.empty())
 829     return false;
 830   TypeOfField type=entriesOnSameDisc[0]->getType();
 831   int szEntities=0,szTuples=0;
 832   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++)
 833     { szEntities+=(*it)->_nval; szTuples+=(*it)->_end-(*it)->_start; }
 834   int nbi=szTuples/szEntities;
 835   if(szTuples%szEntities!=0)
 836     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks : internal error the splitting into same dicretization failed !");
 837   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTuples=DataArrayInt::New(); renumTuples->alloc(szTuples,1);
 838   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ranges=MEDCouplingUMesh::ComputeRangesFromTypeDistribution(newCode);
 839   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk(entriesOnSameDisc.size());
 840   std::vector< const DataArrayInt * > newGeoTypesPerChunk2(entriesOnSameDisc.size());
 841   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk_bis(entriesOnSameDisc.size());
 842   std::vector< const DataArrayInt * > newGeoTypesPerChunk3(entriesOnSameDisc.size());
 843   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesPerChunk4=DataArrayInt::New(); newGeoTypesPerChunk4->alloc(szEntities,nbi);
 844   int id=0;
 845   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
 846     {
 847       int startOfEltIdOfChunk=(*it)->_start;
 848       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newEltIds=explicitIdsInMesh->substr(startOfEltIdOfChunk,startOfEltIdOfChunk+(*it)->_nval);
 849       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> rangeIdsForChunk=newEltIds->findRangeIdForEachTuple(ranges);
 850       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idsInRrangeForChunk=newEltIds->findIdInRangeForEachTuple(ranges);
 851       //
 852       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=rangeIdsForChunk->duplicateEachTupleNTimes(nbi); rangeIdsForChunk->rearrange(nbi);
 853       newGeoTypesPerChunk4->setPartOfValues1(tmp,(*it)->_tmp_work1-offset,(*it)->_tmp_work1+(*it)->_nval*nbi-offset,1,0,nbi,1);
 854       //
 855       newGeoTypesPerChunk[id]=rangeIdsForChunk; newGeoTypesPerChunk2[id]=rangeIdsForChunk;
 856       newGeoTypesPerChunk_bis[id]=idsInRrangeForChunk; newGeoTypesPerChunk3[id]=idsInRrangeForChunk;
 857     }
 858   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather=DataArrayInt::Aggregate(newGeoTypesPerChunk2); newGeoTypesPerChunk.clear(); newGeoTypesPerChunk2.clear();
 859   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather2=DataArrayInt::Aggregate(newGeoTypesPerChunk3); newGeoTypesPerChunk_bis.clear(); newGeoTypesPerChunk3.clear();
 860   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> diffVals=newGeoTypesEltIdsAllGather->getDifferentValues();
 861   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
 862   //
 863   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTupleIds=newGeoTypesPerChunk4->buildPermArrPerLevel();
 864   //
 865   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arrPart=arr->substr(offset,offset+szTuples);
 866   arrPart->renumberInPlace(renumTupleIds->begin());
 867   arr->setPartOfValues1(arrPart,offset,offset+szTuples,1,0,arrPart->getNumberOfComponents(),1);
 868   bool ret=false;
 869   const int *idIt=diffVals->begin();
 870   std::list<const MEDFileFieldPerMeshPerTypePerDisc *> li(entriesOnSameDisc.begin(),entriesOnSameDisc.end());
 871   int offset2=0;
 872   for(int i=0;i<diffVals->getNumberOfTuples();i++,idIt++)
 873     {
 874       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=newGeoTypesEltIdsAllGather->getIdsEqual(*idIt);
 875       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> subIds=newGeoTypesEltIdsAllGather2->selectByTupleId(ids->begin(),ids->end());
 876       int nbEntityElts=subIds->getNumberOfTuples();
 877       bool ret2;
 878       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
 879         NewObjectOnSameDiscThanPool(type,(INTERP_KERNEL::NormalizedCellType)newCode[3*(*idIt)],subIds,!subIds->isIdentity() || nbEntityElts!=newCode[3*(*idIt)+1],nbi,
 880                                     offset+offset2,
 881                                     li,glob,ret2);
 882       ret=ret || ret2;
 883       result.push_back(eltToAdd);
 884       offset2+=nbEntityElts*nbi;
 885     }
 886   ret=ret || li.empty();
 887   return ret;
 888 }
 889
 890 /*!
 891  * \param [in] typeF type of field of new chunk
 892  * \param [in] geoType the geometric type of the chunk
 893  * \param [in] idsOfMeshElt the entity ids of mesh (cells or nodes) of the new chunk.
 894  * \param [in] isPfl specifies if a profile is requested regarding size of \a idsOfMeshElt and the number of such entities regarding underlying mesh.
 895  * \param [in] nbi number of integration points
 896  * \param [in] offset The offset in the **global array of data**.
 897  * \param [in,out] entriesOnSameDisc the pool **on the same discretization** inside which it will be attempted to find an existing entry corresponding exactly
 898  *                 to the new chunk to create.
 899  * \param [in,out] glob the global shared info that will be requested for existing profiles or to append a new profile if needed.
 900  * \param [out] notInExisting If false the return newly allocated entry is not coming from \a entriesOnSameDisc. If true the output comes from copy of \a entriesOnSameDisc
 901  *              and corresponding entry erased from \a entriesOnSameDisc.
 902  * \return a newly allocated chunk
 903  */
 904 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewObjectOnSameDiscThanPool(TypeOfField typeF, INTERP_KERNEL::NormalizedCellType geoType, DataArrayInt *idsOfMeshElt,
 905                                                                                                   bool isPfl, int nbi, int offset,
 906                                                                                                   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
 907                                                                                                   MEDFileFieldGlobsReal& glob,
 908                                                                                                   bool &notInExisting) throw(INTERP_KERNEL::Exception)
 909 {
 910   int nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
 911   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>::iterator it=entriesOnSameDisc.begin();
 912   for(;it!=entriesOnSameDisc.end();it++)
 913     {
 914       if(((INTERP_KERNEL::NormalizedCellType)(*it)->_loc_id)==geoType && (*it)->_nval==nbMeshEntities)
 915         {
 916           if(!isPfl)
 917             {
 918               if((*it)->_profile.empty())
 919                 break;
 920               else
 921                 if(!(*it)->_profile.empty())
 922                   {
 923                     const DataArrayInt *pfl=glob.getProfile((*it)->_profile.c_str());
 924                     if(pfl->isEqualWithoutConsideringStr(*idsOfMeshElt))
 925                       break;
 926                   }
 927             }
 928         }
 929     }
 930   if(it==entriesOnSameDisc.end())
 931     {
 932       notInExisting=true;
 933       MEDFileFieldPerMeshPerTypePerDisc *ret=new MEDFileFieldPerMeshPerTypePerDisc;
 934       ret->_type=typeF;
 935       ret->_loc_id=(int)geoType;
 936       ret->_nval=nbMeshEntities;
 937       ret->_start=offset;
 938       ret->_end=ret->_start+ret->_nval*nbi;
 939       if(isPfl)
 940         {
 941           idsOfMeshElt->setName(glob.createNewNameOfPfl().c_str());
 942           glob.appendProfile(idsOfMeshElt);
 943           ret->_profile=idsOfMeshElt->getName();
 944         }
 945       //tony treatment of localization
 946       return ret;
 947     }
 948   else
 949     {
 950       notInExisting=false;
 951       MEDFileFieldPerMeshPerTypePerDisc *ret=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
 952       ret->_loc_id=(int)geoType;
 953       ret->setNewStart(offset);
 954       entriesOnSameDisc.erase(it);
 955       return ret;
 956     }
 957
 958 }
 959
 960 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 961 {
 962   return new MEDFileFieldPerMeshPerType(fid,fath,type,geoType,nasc);
 963 }
 964
 965 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::New(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType) throw(INTERP_KERNEL::Exception)
 966 {
 967   return new MEDFileFieldPerMeshPerType(fath,geoType);
 968 }
 969
 970 std::size_t MEDFileFieldPerMeshPerType::getHeapMemorySize() const
 971 {
 972   std::size_t ret=_field_pm_pt_pd.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc>);
 973   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
 974     ret+=(*it)->getHeapMemorySize();
 975   return ret;
 976 }
 977
 978 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::deepCpy(MEDFileFieldPerMesh *father) const throw(INTERP_KERNEL::Exception)
 979 {
 980   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> ret=new MEDFileFieldPerMeshPerType(*this);
 981   ret->_father=father;
 982   std::size_t i=0;
 983   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
 984     {
 985       if((const MEDFileFieldPerMeshPerTypePerDisc *)*it)
 986         ret->_field_pm_pt_pd[i]=(*it)->deepCpy((MEDFileFieldPerMeshPerType *)ret);
 987     }
 988   return ret.retn();
 989 }
 990
 991 void MEDFileFieldPerMeshPerType::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 992 {
 993   std::vector<int> pos=addNewEntryIfNecessary(field,offset,nbOfCells);
 994   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
 995     _field_pm_pt_pd[*it]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
 996 }
 997
 998 /*!
 999  * This method is the most general one. No optimization is done here.
1000  * \param [in] multiTypePfl is the end user profile specified in high level API
1001  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
1002  * \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
1003  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
1004  * \param [in] nbOfEltsInWholeMesh nb of elts of type \a this->_geo_type in \b WHOLE mesh
1005  * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
1006  */
1007 void MEDFileFieldPerMeshPerType::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1008 {
1009   std::vector<int> pos=addNewEntryIfNecessary(field,idsInPfl);
1010   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1011     _field_pm_pt_pd[*it]->assignFieldProfile(start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,arr,mesh,glob,nasc);
1012 }
1013
1014 void MEDFileFieldPerMeshPerType::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1015 {
1016   _field_pm_pt_pd.resize(1);
1017   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1018   _field_pm_pt_pd[0]->assignNodeFieldNoProfile(start,field,arr,glob);
1019 }
1020
1021 void MEDFileFieldPerMeshPerType::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1022 {
1023   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2=pfl->deepCpy();
1024   //
1025   _field_pm_pt_pd.resize(1);
1026   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1027   _field_pm_pt_pd[0]->assignFieldProfile(start,pfl,pfl2,pfl2,-1,field,arr,0,glob,nasc);//mesh is not requested so 0 is send.
1028 }
1029
1030 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, int offset, int nbOfCells) throw(INTERP_KERNEL::Exception)
1031 {
1032   TypeOfField type=field->getTypeOfField();
1033   if(type!=ON_GAUSS_PT)
1034     {
1035       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1036       int sz=_field_pm_pt_pd.size();
1037       bool found=false;
1038       for(int j=0;j<sz && !found;j++)
1039         {
1040           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1041             {
1042               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1043               found=true;
1044             }
1045         }
1046       if(!found)
1047         {
1048           _field_pm_pt_pd.resize(sz+1);
1049           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1050         }
1051       std::vector<int> ret(1,(int)sz);
1052       return ret;
1053     }
1054   else
1055     {
1056       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
1057       int sz2=ret2.size();
1058       std::vector<int> ret3(sz2);
1059       int k=0;
1060       for(int i=0;i<sz2;i++)
1061         {
1062           int sz=_field_pm_pt_pd.size();
1063           int locIdToFind=ret2[i];
1064           bool found=false;
1065           for(int j=0;j<sz && !found;j++)
1066             {
1067               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1068                 {
1069                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1070                   ret3[k++]=j;
1071                   found=true;
1072                 }
1073             }
1074           if(!found)
1075             {
1076               _field_pm_pt_pd.resize(sz+1);
1077               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1078               ret3[k++]=sz;
1079             }
1080         }
1081       return ret3;
1082     }
1083 }
1084
1085 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, int offset, int nbOfCells) throw(INTERP_KERNEL::Exception)
1086 {
1087   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1088   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1089   if(!disc2)
1090     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1091   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1092   if(!da)
1093     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss (no profile) : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1094   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleId2(offset,offset+nbOfCells,1);
1095   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1096   if(retTmp->presenceOfValue(-1))
1097     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1098   std::vector<int> ret(retTmp->begin(),retTmp->end());
1099   return ret;
1100 }
1101
1102 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells) throw(INTERP_KERNEL::Exception)
1103 {
1104   TypeOfField type=field->getTypeOfField();
1105   if(type!=ON_GAUSS_PT)
1106     {
1107       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1108       int sz=_field_pm_pt_pd.size();
1109       bool found=false;
1110       for(int j=0;j<sz && !found;j++)
1111         {
1112           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1113             {
1114               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1115               found=true;
1116             }
1117         }
1118       if(!found)
1119         {
1120           _field_pm_pt_pd.resize(sz+1);
1121           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1122         }
1123       std::vector<int> ret(1,0);
1124       return ret;
1125     }
1126   else
1127     {
1128       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,subCells);
1129       int sz2=ret2.size();
1130       std::vector<int> ret3(sz2);
1131       int k=0;
1132       for(int i=0;i<sz2;i++)
1133         {
1134           int sz=_field_pm_pt_pd.size();
1135           int locIdToFind=ret2[i];
1136           bool found=false;
1137           for(int j=0;j<sz && !found;j++)
1138             {
1139               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1140                 {
1141                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1142                   ret3[k++]=j;
1143                   found=true;
1144                 }
1145             }
1146           if(!found)
1147             {
1148               _field_pm_pt_pd.resize(sz+1);
1149               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1150               ret3[k++]=sz;
1151             }
1152         }
1153       return ret3;
1154     }
1155 }
1156
1157 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells) throw(INTERP_KERNEL::Exception)
1158 {
1159   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1160   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1161   if(!disc2)
1162     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1163   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1164   if(!da)
1165     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1166   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleIdSafe(subCells->getConstPointer(),subCells->getConstPointer()+subCells->getNumberOfTuples());
1167   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1168   if(retTmp->presenceOfValue(-1))
1169     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1170   std::vector<int> ret(retTmp->begin(),retTmp->end());
1171   return ret;
1172 }
1173
1174 const MEDFileFieldPerMesh *MEDFileFieldPerMeshPerType::getFather() const
1175 {
1176   return _father;
1177 }
1178
1179 void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
1180 {
1181   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1182   int curDim=(int)cm.getDimension();
1183   dim=std::max(dim,curDim);
1184 }
1185
1186 void MEDFileFieldPerMeshPerType::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
1187 {
1188   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1189     {
1190       (*it)->fillTypesOfFieldAvailable(types);
1191     }
1192 }
1193
1194 void MEDFileFieldPerMeshPerType::fillFieldSplitedByType(std::vector< std::pair<int,int> >& dads, std::vector<TypeOfField>& types, std::vector<std::string>& pfls, std::vector<std::string>& locs) const throw(INTERP_KERNEL::Exception)
1195 {
1196   int sz=_field_pm_pt_pd.size();
1197   dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
1198   for(int i=0;i<sz;i++)
1199     {
1200       _field_pm_pt_pd[i]->getCoarseData(types[i],dads[i],pfls[i],locs[i]);
1201     }
1202 }
1203
1204 int MEDFileFieldPerMeshPerType::getIteration() const
1205 {
1206   return _father->getIteration();
1207 }
1208
1209 int MEDFileFieldPerMeshPerType::getOrder() const
1210 {
1211   return _father->getOrder();
1212 }
1213
1214 double MEDFileFieldPerMeshPerType::getTime() const
1215 {
1216   return _father->getTime();
1217 }
1218
1219 std::string MEDFileFieldPerMeshPerType::getMeshName() const
1220 {
1221   return _father->getMeshName();
1222 }
1223
1224 void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1225 {
1226   const char startLine[]="  ## ";
1227   std::string startLine2(bkOffset,' ');
1228   std::string startLine3(startLine2);
1229   startLine3+=startLine;
1230   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1231     {
1232       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1233       oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry types " << cm.getRepr() << "." << std::endl;
1234     }
1235   else
1236     oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
1237   oss << startLine3 << "Entry is defined on " <<  _field_pm_pt_pd.size() << " localizations." << std::endl;
1238   int i=0;
1239   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1240     {
1241       const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
1242       if(cur)
1243         cur->simpleRepr(bkOffset,oss,i);
1244       else
1245         {
1246           oss << startLine2 << "    ## " << "Localization #" << i << " is empty !" << std::endl;
1247         }
1248     }
1249 }
1250
1251 void MEDFileFieldPerMeshPerType::getSizes(int& globalSz, int& nbOfEntries) const
1252 {
1253   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1254     {
1255       globalSz+=(*it)->getNumberOfTuples();
1256     }
1257   nbOfEntries+=(int)_field_pm_pt_pd.size();
1258 }
1259
1260 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
1261 {
1262   return _geo_type;
1263 }
1264
1265
1266 int MEDFileFieldPerMeshPerType::getNumberOfComponents() const
1267 {
1268   return _father->getNumberOfComponents();
1269 }
1270
1271 DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray()
1272 {
1273   return _father->getOrCreateAndGetArray();
1274 }
1275
1276 const DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray() const
1277 {
1278   const MEDFileFieldPerMesh *fath=_father;
1279   return fath->getOrCreateAndGetArray();
1280 }
1281
1282 const std::vector<std::string>& MEDFileFieldPerMeshPerType::getInfo() const
1283 {
1284   return _father->getInfo();
1285 }
1286
1287 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsed() const
1288 {
1289   std::vector<std::string> ret;
1290   std::set<std::string> ret2;
1291   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1292     {
1293       std::string tmp=(*it1)->getProfile();
1294       if(!tmp.empty())
1295         if(ret2.find(tmp)==ret2.end())
1296           {
1297             ret.push_back(tmp);
1298             ret2.insert(tmp);
1299           }
1300     }
1301   return ret;
1302 }
1303
1304 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsed() const
1305 {
1306   std::vector<std::string> ret;
1307   std::set<std::string> ret2;
1308   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1309     {
1310       std::string tmp=(*it1)->getLocalization();
1311       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1312         if(ret2.find(tmp)==ret2.end())
1313           {
1314             ret.push_back(tmp);
1315             ret2.insert(tmp);
1316           }
1317     }
1318   return ret;
1319 }
1320
1321 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsedMulti() const
1322 {
1323   std::vector<std::string> ret;
1324   std::set<std::string> ret2;
1325   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1326     {
1327       std::string tmp=(*it1)->getProfile();
1328       if(!tmp.empty())
1329         ret.push_back(tmp);
1330     }
1331   return ret;
1332 }
1333
1334 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsedMulti() const
1335 {
1336   std::vector<std::string> ret;
1337   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1338     {
1339       std::string tmp=(*it1)->getLocalization();
1340       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1341         ret.push_back(tmp);
1342     }
1343   return ret;
1344 }
1345
1346 void MEDFileFieldPerMeshPerType::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1347 {
1348   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1349     (*it1)->changePflsRefsNamesGen(mapOfModif);
1350 }
1351
1352 void MEDFileFieldPerMeshPerType::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1353 {
1354   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1355     (*it1)->changeLocsRefsNamesGen(mapOfModif);
1356 }
1357
1358 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) throw(INTERP_KERNEL::Exception)
1359 {
1360   if(_field_pm_pt_pd.empty())
1361     {
1362       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1363       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1364       throw INTERP_KERNEL::Exception(oss.str().c_str());
1365     }
1366   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1367     return _field_pm_pt_pd[locId];
1368   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1369   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1370   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1371   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1372   return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
1373 }
1374
1375 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) const throw(INTERP_KERNEL::Exception)
1376 {
1377   if(_field_pm_pt_pd.empty())
1378     {
1379       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1380       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1381       throw INTERP_KERNEL::Exception(oss.str().c_str());
1382     }
1383   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1384     return _field_pm_pt_pd[locId];
1385   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1386   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1387   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1388   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1389   return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
1390 }
1391
1392 void MEDFileFieldPerMeshPerType::getFieldAtLevel(int meshDim, TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<int,int> >& dads, std::vector<const DataArrayInt *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const
1393 {
1394   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1395     {
1396       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1397       if(meshDim!=(int)cm.getDimension())
1398         return ;
1399     }
1400   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1401     (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
1402 }
1403
1404 void MEDFileFieldPerMeshPerType::fillValues(int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
1405 {
1406   int i=0;
1407   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1408     {
1409       (*it)->fillValues(i,startEntryId,entries);
1410     }
1411 }
1412
1413 void MEDFileFieldPerMeshPerType::setLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves) throw(INTERP_KERNEL::Exception)
1414 {
1415   _field_pm_pt_pd=leaves;
1416   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1417     (*it)->setFather(this);
1418 }
1419
1420 /*!
1421  *  \param [in,out] globalNum a global numbering counter for the renumbering.
1422  *  \param [out] its - list of pair (start,stop) kept
1423  *  \return bool - false if the type of field \a tof is not contained in \a this.
1424  */
1425 bool MEDFileFieldPerMeshPerType::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its) throw(INTERP_KERNEL::Exception)
1426 {
1427   bool ret=false;
1428   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd;
1429   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1430     if((*it)->getType()==tof)
1431       {
1432         newPmPtPd.push_back(*it);
1433         std::pair<int,int> bgEnd; bgEnd.first=(*it)->getStart(); bgEnd.second=(*it)->getEnd();
1434         (*it)->setNewStart(globalNum);
1435         globalNum=(*it)->getEnd();
1436         its.push_back(bgEnd);
1437         ret=true;
1438       }
1439   if(ret)
1440     _field_pm_pt_pd=newPmPtPd;
1441   return ret;
1442 }
1443
1444 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType) throw(INTERP_KERNEL::Exception):_father(fath),_geo_type(geoType)
1445 {
1446 }
1447
1448 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception):_father(fath),_geo_type(geoType)
1449 {
1450   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1451   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1452   med_geometry_type mgeoti;
1453   med_entity_type menti=ConvertIntoMEDFileType(type,geoType,mgeoti);
1454   int nbProfiles=MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),menti,mgeoti,pflName,locName);
1455   _field_pm_pt_pd.resize(nbProfiles);
1456   for(int i=0;i<nbProfiles;i++)
1457     {
1458       _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,type,i+1);
1459     }
1460 }
1461
1462 void MEDFileFieldPerMeshPerType::loadOnlyStructureOfDataRecursively(med_idt fid, int &start, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1463 {
1464   int pflId=0;
1465   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,pflId++)
1466     {
1467       (*it)->loadOnlyStructureOfDataRecursively(fid,pflId+1,start,nasc);//tony
1468     }
1469 }
1470
1471 void MEDFileFieldPerMeshPerType::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1472 {
1473   int pflId=0;
1474   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,pflId++)
1475     {
1476       (*it)->loadBigArray(fid,pflId+1,nasc);//tony
1477     }
1478 }
1479
1480 void MEDFileFieldPerMeshPerType::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
1481 {
1482   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1483     {
1484       (*it)->copyOptionsFrom(*this);
1485       (*it)->writeLL(fid,nasc);
1486     }
1487 }
1488
1489 med_entity_type MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(TypeOfField ikType, INTERP_KERNEL::NormalizedCellType ikGeoType, med_geometry_type& medfGeoType)
1490 {
1491   switch(ikType)
1492     {
1493     case ON_CELLS:
1494       medfGeoType=typmai3[(int)ikGeoType];
1495       return MED_CELL;
1496     case ON_NODES:
1497       medfGeoType=MED_NONE;
1498       return MED_NODE;
1499     case ON_GAUSS_NE:
1500       medfGeoType=typmai3[(int)ikGeoType];
1501       return MED_NODE_ELEMENT;
1502     case ON_GAUSS_PT:
1503       medfGeoType=typmai3[(int)ikGeoType];
1504       return MED_CELL;
1505     default:
1506       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType : unexpected entity type ! internal error");
1507     }
1508   return MED_UNDEF_ENTITY_TYPE;
1509 }
1510
1511 MEDFileFieldPerMesh *MEDFileFieldPerMesh::NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1512 {
1513   return new MEDFileFieldPerMesh(fid,fath,meshCsit,meshIteration,meshOrder,nasc);
1514 }
1515
1516 MEDFileFieldPerMesh *MEDFileFieldPerMesh::New(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh)
1517 {
1518   return new MEDFileFieldPerMesh(fath,mesh);
1519 }
1520
1521 std::size_t MEDFileFieldPerMesh::getHeapMemorySize() const
1522 {
1523   std::size_t ret=_mesh_name.capacity()+_field_pm_pt.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType >);
1524   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1525     if((const MEDFileFieldPerMeshPerType *)*it)
1526       ret+=(*it)->getHeapMemorySize();
1527   return ret;
1528 }
1529
1530 MEDFileFieldPerMesh *MEDFileFieldPerMesh::deepCpy(MEDFileAnyTypeField1TSWithoutSDA *father) const throw(INTERP_KERNEL::Exception)
1531 {
1532   MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
1533   ret->_father=father;
1534   std::size_t i=0;
1535   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1536     {
1537       if((const MEDFileFieldPerMeshPerType *)*it)
1538         ret->_field_pm_pt[i]=(*it)->deepCpy((MEDFileFieldPerMesh *)(ret));
1539     }
1540   return ret.retn();
1541 }
1542
1543 void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1544 {
1545   std::string startLine(bkOffset,' ');
1546   oss << startLine << "## Field part (" << id << ") lying on mesh \"" << _mesh_name << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
1547   oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
1548   int i=0;
1549   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1550     {
1551       const MEDFileFieldPerMeshPerType *cur=*it;
1552       if(cur)
1553         cur->simpleRepr(bkOffset,oss,i);
1554       else
1555         {
1556           oss << startLine << "  ## Entry geometry type #" << i << " is empty !" << std::endl;
1557         }
1558     }
1559 }
1560
1561 void MEDFileFieldPerMesh::copyTinyInfoFrom(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
1562 {
1563   _mesh_name=mesh->getName();
1564   mesh->getTime(_mesh_iteration,_mesh_order);
1565 }
1566
1567 void MEDFileFieldPerMesh::assignFieldNoProfileNoRenum(int& start, const std::vector<int>& code, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1568 {
1569   int nbOfTypes=code.size()/3;
1570   int offset=0;
1571   for(int i=0;i<nbOfTypes;i++)
1572     {
1573       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1574       int nbOfCells=code[3*i+1];
1575       int pos=addNewEntryIfNecessary(type);
1576       _field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1577       offset+=nbOfCells;
1578     }
1579 }
1580
1581 /*!
1582  * This method is the most general one. No optimization is done here.
1583  * \param [in] multiTypePfl is the end user profile specified in high level API
1584  * \param [in] code is the code of \a mesh[multiTypePfl] mesh. It is of size of number of different geometric types into \a mesh[multiTypePfl].
1585  * \param [in] code2 is the code of the \b WHOLE mesh on the same level. So all types in \a code are in \a code2.
1586  * \param [in] idsInPflPerType is the selection into the \a multiTypePfl whole profile that corresponds to the given geometric type. This vector is always 3 times smaller than \a code.
1587  * \param [in] idsPerType is a vector containing the profiles needed to be created for MED file format. \b WARNING these processed MED file profiles can be subdivided again in case of Gauss points.
1588  * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
1589  */
1590 void MEDFileFieldPerMesh::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const std::vector<int>& code, const std::vector<int>& code2, const std::vector<DataArrayInt *>& idsInPflPerType, const std::vector<DataArrayInt *>& idsPerType, const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1591 {
1592   int nbOfTypes=code.size()/3;
1593   for(int i=0;i<nbOfTypes;i++)
1594     {
1595       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1596       int pos=addNewEntryIfNecessary(type);
1597       DataArrayInt *pfl=0;
1598       if(code[3*i+2]!=-1)
1599         pfl=idsPerType[code[3*i+2]];
1600       int nbOfTupes2=code2.size()/3;
1601       int found=0;
1602       for(;found<nbOfTupes2;found++)
1603         if(code[3*i]==code2[3*found])
1604           break;
1605       if(found==nbOfTupes2)
1606         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::assignFieldProfile : internal problem ! Should never happen ! Please report bug to anthony.geay@cea.fr !");
1607       _field_pm_pt[pos]->assignFieldProfile(start,multiTypePfl,idsInPflPerType[i],pfl,code2[3*found+1],field,arr,mesh,glob,nasc);
1608     }
1609 }
1610
1611 void MEDFileFieldPerMesh::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1612 {
1613   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1614   _field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
1615 }
1616
1617 void MEDFileFieldPerMesh::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1618 {
1619   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1620   _field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,arr,glob,nasc);
1621 }
1622
1623 void MEDFileFieldPerMesh::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1624 {
1625   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1626     (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1627 }
1628
1629 void MEDFileFieldPerMesh::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1630 {
1631   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1632     (*it)->loadBigArraysRecursively(fid,nasc);
1633 }
1634
1635 void MEDFileFieldPerMesh::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
1636 {
1637   int nbOfTypes=_field_pm_pt.size();
1638   for(int i=0;i<nbOfTypes;i++)
1639     {
1640       _field_pm_pt[i]->copyOptionsFrom(*this);
1641       _field_pm_pt[i]->writeLL(fid,nasc);
1642     }
1643 }
1644
1645 void MEDFileFieldPerMesh::getDimension(int& dim) const
1646 {
1647   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1648     (*it)->getDimension(dim);
1649 }
1650
1651 void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
1652 {
1653   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1654     (*it)->fillTypesOfFieldAvailable(types);
1655 }
1656
1657 std::vector< std::vector< std::pair<int,int> > > MEDFileFieldPerMesh::getFieldSplitedByType(std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> > & locs) const throw(INTERP_KERNEL::Exception)
1658 {
1659   int sz=_field_pm_pt.size();
1660   std::vector< std::vector<std::pair<int,int> > > ret(sz);
1661   types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
1662   for(int i=0;i<sz;i++)
1663     {
1664       types[i]=_field_pm_pt[i]->getGeoType();
1665       _field_pm_pt[i]->fillFieldSplitedByType(ret[i],typesF[i],pfls[i],locs[i]);
1666     }
1667   return ret;
1668 }
1669
1670 double MEDFileFieldPerMesh::getTime() const
1671 {
1672   int tmp1,tmp2;
1673   return _father->getTime(tmp1,tmp2);
1674 }
1675
1676 int MEDFileFieldPerMesh::getIteration() const
1677 {
1678   return _father->getIteration();
1679 }
1680
1681 int MEDFileFieldPerMesh::getOrder() const
1682 {
1683   return _father->getOrder();
1684 }
1685
1686 int MEDFileFieldPerMesh::getNumberOfComponents() const
1687 {
1688   return _father->getNumberOfComponents();
1689 }
1690
1691 DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray()
1692 {
1693   if(!_father)
1694     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1695   return _father->getOrCreateAndGetArray();
1696 }
1697
1698 const DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray() const
1699 {
1700   if(!_father)
1701     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1702   return _father->getOrCreateAndGetArray();
1703 }
1704
1705 const std::vector<std::string>& MEDFileFieldPerMesh::getInfo() const
1706 {
1707   return _father->getInfo();
1708 }
1709
1710 /*!
1711  * type,geoTypes,dads,pfls,locs are input parameters. They should have the same size.
1712  * Before the call of this method 'geoTypes','dads','pfls','locs' must be reorganized so that types in geoTypes are contiguous and ordered following typmai2 array.
1713  * It returns 2 output vectors :
1714  * - 'code' of size 3*sz where sz is the number of different values into 'geoTypes'
1715  * - 'notNullPfls' contains sz2 values that are extracted from 'pfls' in which null profiles have been removed.
1716  * 'code' and 'notNullPfls' are in MEDCouplingUMesh::checkTypeConsistencyAndContig format.
1717  */
1718 void MEDFileFieldPerMesh::SortArraysPerType(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<int,int> >& dads, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& locs, std::vector<int>& code, std::vector<DataArrayInt *>& notNullPfls)
1719 {
1720   int notNullPflsSz=0;
1721   int nbOfArrs=geoTypes.size();
1722   for(int i=0;i<nbOfArrs;i++)
1723     if(pfls[i])
1724       notNullPflsSz++;
1725   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
1726   int nbOfDiffGeoTypes=geoTypes3.size();
1727   code.resize(3*nbOfDiffGeoTypes);
1728   notNullPfls.resize(notNullPflsSz);
1729   notNullPflsSz=0;
1730   int j=0;
1731   for(int i=0;i<nbOfDiffGeoTypes;i++)
1732     {
1733       int startZone=j;
1734       INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
1735       std::vector<const DataArrayInt *> notNullTmp;
1736       if(pfls[j])
1737         notNullTmp.push_back(pfls[j]);
1738       j++;
1739       for(;j<nbOfArrs;j++)
1740         if(geoTypes[j]==refType)
1741           {
1742             if(pfls[j])
1743               notNullTmp.push_back(pfls[j]);
1744           }
1745         else
1746           break;
1747       std::vector< std::pair<int,int> > tmpDads(dads.begin()+startZone,dads.begin()+j);
1748       std::vector<const DataArrayInt *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
1749       std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
1750       code[3*i]=(int)refType;
1751       std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
1752       code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
1753       if(notNullTmp.empty())
1754         code[3*i+2]=-1;
1755       else
1756         {
1757           notNullPfls[notNullPflsSz]=DataArrayInt::Aggregate(notNullTmp);
1758           code[3*i+2]=notNullPflsSz++;
1759         }
1760     }
1761 }
1762
1763 /*!
1764  * 'dads' 'geoTypes' and 'locs' are input parameters that should have same size sz. sz should be >=1.
1765  */
1766 int MEDFileFieldPerMesh::ComputeNbOfElems(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs) throw(INTERP_KERNEL::Exception)
1767 {
1768   int sz=dads.size();
1769   int ret=0;
1770   for(int i=0;i<sz;i++)
1771     {
1772       if(locs[i]==-1)
1773         {
1774           if(type!=ON_GAUSS_NE)
1775             ret+=dads[i].second-dads[i].first;
1776           else
1777             {
1778               const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(geoTypes[i]);
1779               ret+=(dads[i].second-dads[i].first)/cm.getNumberOfNodes();
1780             }
1781         }
1782       else
1783         {
1784           int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
1785           ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
1786         }
1787     }
1788   return ret;
1789 }
1790
1791 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsed() const
1792 {
1793   std::vector<std::string> ret;
1794   std::set<std::string> ret2;
1795   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1796     {
1797       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
1798       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1799         if(ret2.find(*it2)==ret2.end())
1800           {
1801             ret.push_back(*it2);
1802             ret2.insert(*it2);
1803           }
1804     }
1805   return ret;
1806 }
1807
1808 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
1809 {
1810   std::vector<std::string> ret;
1811   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1812     {
1813       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
1814       ret.insert(ret.end(),tmp.begin(),tmp.end());
1815     }
1816   return ret;
1817 }
1818
1819 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsed() const
1820 {
1821   std::vector<std::string> ret;
1822   std::set<std::string> ret2;
1823   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1824     {
1825       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
1826       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1827         if(ret2.find(*it2)==ret2.end())
1828           {
1829             ret.push_back(*it2);
1830             ret2.insert(*it2);
1831           }
1832     }
1833   return ret;
1834 }
1835
1836 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
1837 {
1838   std::vector<std::string> ret;
1839   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1840     {
1841       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
1842       ret.insert(ret.end(),tmp.begin(),tmp.end());
1843     }
1844   return ret;
1845 }
1846
1847 bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
1848 {
1849   for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
1850     {
1851       if((*it).first==_mesh_name)
1852         {
1853           _mesh_name=(*it).second;
1854           return true;
1855         }
1856     }
1857   return false;
1858 }
1859
1860 bool MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
1861                                                       MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1862 {
1863   if(_mesh_name!=meshName)
1864     return false;
1865   std::set<INTERP_KERNEL::NormalizedCellType> typesToKeep;
1866   for(std::size_t i=0;i<oldCode.size()/3;i++) typesToKeep.insert((INTERP_KERNEL::NormalizedCellType)oldCode[3*i]);
1867   std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > > entries;
1868   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKept;
1869   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> otherEntries;
1870   getUndergroundDataArrayExt(entries);
1871   DataArray *arr0=getOrCreateAndGetArray();//tony
1872   if(!arr0)
1873     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values of field is null !");
1874   DataArrayDouble *arr=dynamic_cast<DataArrayDouble *>(arr0);//tony
1875   if(!arr0)
1876     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values is double ! Not managed for the moment !");
1877   int sz=0;
1878   if(!arr)
1879     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
1880   for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >::const_iterator it=entries.begin();it!=entries.end();it++)
1881     {
1882       if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
1883         {
1884           entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1885           sz+=(*it).second.second-(*it).second.first;
1886         }
1887       else
1888         otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1889     }
1890   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumDefrag=DataArrayInt::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
1891   ////////////////////
1892   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInMesh=DataArrayInt::New(); explicitIdsOldInMesh->alloc(sz,1);//sz is a majorant of the real size. A realloc will be done after
1893   int *workI2=explicitIdsOldInMesh->getPointer();
1894   int sz1=0,sz2=0,sid=1;
1895   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptML=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKept);
1896   // std::vector<int> tupleIdOfStartOfNewChuncksV(entriesKeptML.size());
1897   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator itL1=entriesKeptML.begin();itL1!=entriesKeptML.end();itL1++,sid++)
1898     {
1899       //  tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
1900       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInArr=DataArrayInt::New(); explicitIdsOldInArr->alloc(sz,1);
1901       int *workI=explicitIdsOldInArr->getPointer();
1902       for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
1903         {
1904           int delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
1905           (*itL2)->setLocId(sz2);
1906           (*itL2)->_tmp_work1=(*itL2)->getStart();
1907           int delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
1908         }
1909       renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
1910     }
1911   explicitIdsOldInMesh->reAlloc(sz2);
1912   int tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
1913   ////////////////////
1914   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
1915   // perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
1916   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
1917   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
1918     {
1919       otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
1920       otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
1921       otherEntriesNew.back()->setLocId((*it)->getGeoType());
1922     }
1923   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
1924   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
1925   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
1926     {
1927       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
1928       int newStart=elt->getLocId();
1929       elt->setLocId((*it)->getGeoType());
1930       elt->setNewStart(newStart);
1931       elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
1932       entriesKeptNew.push_back(elt);
1933       entriesKeptNew2.push_back(elt);
1934     }
1935   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
1936   // perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
1937   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
1938   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
1939   bool ret=false;
1940   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
1941     {
1942       sid=0;
1943       /*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
1944         {
1945           MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
1946           curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
1947           }*/
1948       ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
1949                                                             glob,arr2,otherEntriesNew) || ret;
1950     }
1951   if(!ret)
1952     return false;
1953   // Assign new dispatching
1954   assignNewLeaves(otherEntriesNew);
1955   arr->cpyFrom(*arr2);
1956   return true;
1957 }
1958
1959 /*!
1960  * \param [in,out] globalNum a global numbering counter for the renumbering.
1961  * \param [out] its - list of pair (start,stop) kept
1962  */
1963 void MEDFileFieldPerMesh::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its) throw(INTERP_KERNEL::Exception)
1964 {
1965   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > ret;
1966   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1967     {
1968       std::vector< std::pair<int,int> > its2;
1969       if((*it)->keepOnlySpatialDiscretization(tof,globalNum,its2))
1970         {
1971           ret.push_back(*it);
1972           its.insert(its.end(),its2.begin(),its2.end());
1973         }
1974     }
1975   _field_pm_pt=ret;
1976 }
1977
1978 void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves) throw(INTERP_KERNEL::Exception)
1979 {
1980   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > > types;
1981   for( std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
1982     types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
1983   //
1984   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > fieldPmPt(types.size());
1985   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
1986   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=fieldPmPt.begin();
1987   for(;it1!=types.end();it1++,it2++)
1988     {
1989       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
1990       elt->setLeaves((*it1).second);
1991       *it2=elt;
1992     }
1993   _field_pm_pt=fieldPmPt;
1994 }
1995
1996 void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1997 {
1998   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1999     (*it)->changePflsRefsNamesGen(mapOfModif);
2000 }
2001
2002 void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2003 {
2004   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2005     (*it)->changeLocsRefsNamesGen(mapOfModif);
2006 }
2007
2008 /*!
2009  * \param [in] mesh is the whole mesh
2010  */
2011 MEDCouplingFieldDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2012 {
2013   if(_field_pm_pt.empty())
2014     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2015   //
2016   std::vector< std::pair<int,int> > dads;
2017   std::vector<const DataArrayInt *> pfls;
2018   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2019   std::vector<int> locs,code;
2020   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2021   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2022     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2023   // Sort by types
2024   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2025   if(code.empty())
2026     {
2027       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2028       throw INTERP_KERNEL::Exception(oss.str().c_str());
2029     }
2030   //
2031   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2032   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2033   if(type!=ON_NODES)
2034     {
2035       DataArrayInt *arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2036       if(!arr)
2037         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2038       else
2039         {
2040           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr);
2041           return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl,arrOut,nasc);
2042         }
2043     }
2044   else
2045     {
2046       if(code.size()!=3)
2047         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2048       int nb=code[1];
2049       if(code[2]==-1)
2050         {
2051           if(nb!=mesh->getNumberOfNodes())
2052             {
2053               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2054               oss << " nodes in mesh !";
2055               throw INTERP_KERNEL::Exception(oss.str().c_str());
2056             }
2057           return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2058         }
2059       else
2060         return finishFieldNode2(glob,dads,locs,mesh,notNullPflsPerGeoType3[0],isPfl,arrOut,nasc);
2061     }
2062 }
2063
2064 DataArray *MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2065 {
2066   if(_field_pm_pt.empty())
2067     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2068   //
2069   std::vector<std::pair<int,int> > dads;
2070   std::vector<const DataArrayInt *> pfls;
2071   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2072   std::vector<int> locs,code;
2073   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2074   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2075     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2076   // Sort by types
2077   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2078   if(code.empty())
2079     {
2080       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2081       throw INTERP_KERNEL::Exception(oss.str().c_str());
2082     }
2083   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2084   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2085   if(type!=ON_NODES)
2086     {
2087       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2088       return finishField4(dads,arr,mesh->getNumberOfCells(),pfl);
2089     }
2090   else
2091     {
2092       if(code.size()!=3)
2093         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2094       int nb=code[1];
2095       if(code[2]==-1)
2096         {
2097           if(nb!=mesh->getNumberOfNodes())
2098             {
2099               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2100               oss << " nodes in mesh !";
2101               throw INTERP_KERNEL::Exception(oss.str().c_str());
2102             }
2103         }
2104       return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
2105     }
2106   //
2107   return 0;
2108 }
2109
2110 void MEDFileFieldPerMesh::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
2111 {
2112   int globalSz=0;
2113   int nbOfEntries=0;
2114   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2115     {
2116       (*it)->getSizes(globalSz,nbOfEntries);
2117     }
2118   entries.resize(nbOfEntries);
2119   nbOfEntries=0;
2120   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2121     {
2122       (*it)->fillValues(nbOfEntries,entries);
2123     }
2124 }
2125
2126 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
2127 {
2128   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2129     {
2130       if((*it)->getGeoType()==typ)
2131         return (*it)->getLeafGivenLocId(locId);
2132     }
2133   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2134   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2135   oss << "Possiblities are : ";
2136   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2137     {
2138       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2139       oss << "\"" << cm2.getRepr() << "\", ";
2140     }
2141   throw INTERP_KERNEL::Exception(oss.str().c_str());
2142 }
2143
2144 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
2145 {
2146   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2147     {
2148       if((*it)->getGeoType()==typ)
2149         return (*it)->getLeafGivenLocId(locId);
2150     }
2151   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2152   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2153   oss << "Possiblities are : ";
2154   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2155     {
2156       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2157       oss << "\"" << cm2.getRepr() << "\", ";
2158     }
2159   throw INTERP_KERNEL::Exception(oss.str().c_str());
2160 }
2161
2162 int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
2163 {
2164   int i=0;
2165   int pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
2166   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=_field_pm_pt.begin();
2167   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
2168     {
2169       INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
2170       if(type==curType)
2171         return i;
2172       else
2173         {
2174           int pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
2175           if(pos>pos2)
2176             it2=it+1;
2177         }
2178     }
2179   int ret=std::distance(_field_pm_pt.begin(),it2);
2180   _field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
2181   return ret;
2182 }
2183
2184 /*!
2185  * 'dads' and 'locs' input parameters have the same number of elements
2186  * \param [in] mesh is \b NOT the global mesh, but the possibly reduced mesh. \a mesh parameter will be directly aggregated in the returned field
2187  */
2188 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2189                                                          const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs,
2190                                                          const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2191 {
2192   isPfl=false;
2193   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(type,ONE_TIME);
2194   ret->setMesh(mesh); ret->setName(nasc.getName().c_str()); ret->setTime(getTime(),getIteration(),getOrder()); ret->setTimeUnit(nasc.getDtUnit().c_str());
2195   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2196   const std::vector<std::string>& infos=getInfo();
2197   da->setInfoOnComponents(infos);
2198   da->setName("");
2199   if(type==ON_GAUSS_PT)
2200     {
2201       int offset=0;
2202       int nbOfArrs=dads.size();
2203       for(int i=0;i<nbOfArrs;i++)
2204         {
2205           std::vector<std::pair<int,int> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
2206           const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
2207           int nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
2208           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> di=DataArrayInt::New();
2209           di->alloc(nbOfElems,1);
2210           di->iota(offset);
2211           const MEDFileFieldLoc& fl=glob->getLocalizationFromId(locs[i]);
2212           ret->setGaussLocalizationOnCells(di->getConstPointer(),di->getConstPointer()+nbOfElems,fl.getRefCoords(),fl.getGaussCoords(),fl.getGaussWeights());
2213           offset+=nbOfElems;
2214         }
2215     }
2216   arrOut=da;
2217   return ret.retn();
2218 }
2219
2220 /*!
2221  * This method is an extension of MEDFileFieldPerMesh::finishField method. It deals with profiles. This method should be called when type is different from ON_NODES.
2222  * 'dads', 'locs' and 'geoTypes' input parameters have the same number of elements.
2223  * No check of this is performed. 'da' array contains an array in old2New style to be applyied to mesh to obtain the right support.
2224  * The order of cells in the returned field is those imposed by the profile.
2225  * \param [in] mesh is the global mesh.
2226  */
2227 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2228                                                           const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2229                                                           const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
2230                                                           const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2231 {
2232   if(da->isIdentity())
2233     {
2234       int nbOfTuples=da->getNumberOfTuples();
2235       if(nbOfTuples==mesh->getNumberOfCells())
2236         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2237     }
2238   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m2=mesh->buildPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2239   m2->setName(mesh->getName());
2240   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(type,glob,dads,locs,m2,isPfl,arrOut,nasc);
2241   isPfl=true;
2242   return ret.retn();
2243 }
2244
2245 /*!
2246  * This method is the complement of MEDFileFieldPerMesh::finishField2 method except that this method works for node profiles.
2247  */
2248 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishFieldNode2(const MEDFileFieldGlobsReal *glob,
2249                                                               const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2250                                                               const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2251 {
2252   if(da->isIdentity())
2253     {
2254       int nbOfTuples=da->getNumberOfTuples();
2255       if(nbOfTuples==mesh->getNumberOfNodes())//No problem for NORM_ERROR because it is in context of node
2256         return finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2257     }
2258   // Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
2259   const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
2260   if(meshu)
2261     {
2262       if(meshu->getNodalConnectivity()==0)
2263         {
2264           MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2265           int nb=da->getNbOfElems();
2266           const int *ptr=da->getConstPointer();
2267           MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
2268           meshuc->allocateCells(nb);
2269           for(int i=0;i<nb;i++)
2270             meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
2271           meshuc->finishInsertingCells();
2272           ret->setMesh(meshuc);
2273           const MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
2274           if(!disc) throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::finishFieldNode2 : internal error, no discretization on field !");
2275           disc->checkCoherencyBetween(meshuc,arrOut);
2276           return ret.retn();
2277         }
2278     }
2279   //
2280   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2281   isPfl=true;
2282   DataArrayInt *arr2=0;
2283   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2284   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
2285   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3(arr2);
2286   int nnodes=mesh2->getNumberOfNodes();
2287   if(nnodes==(int)da->getNbOfElems())
2288     {
2289       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
2290       arrOut->renumberInPlace(da3->getConstPointer());
2291       mesh2->setName(mesh->getName());
2292       ret->setMesh(mesh2);
2293       return ret.retn();
2294     }
2295   else
2296     {
2297       std::ostringstream oss; oss << "MEDFileFieldPerMesh::finishFieldNode2 : The field on nodes lies on a node profile so that it is impossible to find a submesh having exactly the same nodes of that profile !!!";
2298       oss << "So it is impossible to return a well definied MEDCouplingFieldDouble instance on specified mesh on a specified meshDim !" << std::endl;
2299       oss << "To retrieve correctly such a field you have 3 possibilities :" << std::endl;
2300       oss << " - use an another meshDim compatible with the field on nodes (MED file does not have such information)" << std::endl;
2301       oss << " - use an another a meshDimRelToMax equal to 1 -> it will return a mesh with artificial cell POINT1 containing the profile !" << std::endl;
2302       oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
2303       throw INTERP_KERNEL::Exception(oss.str().c_str());
2304     }
2305   return 0;
2306 }
2307
2308 /*!
2309  * This method is the most light method of field retrieving.
2310  */
2311 DataArray *MEDFileFieldPerMesh::finishField4(const std::vector<std::pair<int,int> >& dads, const DataArrayInt *pflIn, int nbOfElems, DataArrayInt *&pflOut) const throw(INTERP_KERNEL::Exception)
2312 {
2313   if(!pflIn)
2314     {
2315       pflOut=DataArrayInt::New();
2316       pflOut->alloc(nbOfElems,1);
2317       pflOut->iota(0);
2318     }
2319   else
2320     {
2321       pflOut=const_cast<DataArrayInt*>(pflIn);
2322       pflOut->incrRef();
2323     }
2324   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> safePfl(pflOut);
2325   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2326   const std::vector<std::string>& infos=getInfo();
2327   int nbOfComp=infos.size();
2328   for(int i=0;i<nbOfComp;i++)
2329     da->setInfoOnComponent(i,infos[i].c_str());
2330   safePfl->incrRef();
2331   return da.retn();
2332 }
2333
2334 MEDFileFieldPerMesh::MEDFileFieldPerMesh(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception):_mesh_iteration(meshIteration),_mesh_order(meshOrder),
2335                                                                                                                                                                                                                  _mesh_csit(meshCsit),_father(fath)
2336 {
2337   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2338   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2339   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2340   for(int i=0;i<MED_N_CELL_FIXED_GEO;i++)
2341     {
2342       int nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL,typmai[i],_mesh_csit,meshName,pflName,locName);
2343       if(nbProfile>0)
2344         {
2345           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[i],nasc));
2346           _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2347         }
2348       nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[i],_mesh_csit,meshName,pflName,locName);
2349       if(nbProfile>0)
2350         {
2351           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_GAUSS_NE,typmai2[i],nasc));
2352           _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2353         }
2354     }
2355   int nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,_mesh_csit,meshName,pflName,locName);
2356   if(nbProfile>0)
2357     {
2358       _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc));
2359       _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2360     }
2361 }
2362
2363 MEDFileFieldPerMesh::MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh):_father(fath)
2364 {
2365   copyTinyInfoFrom(mesh);
2366 }
2367
2368 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int id, const char *pflName) throw(INTERP_KERNEL::Exception)
2369 {
2370   if(id>=(int)_pfls.size())
2371     _pfls.resize(id+1);
2372   _pfls[id]=DataArrayInt::New();
2373   int lgth=MEDprofileSizeByName(fid,pflName);
2374   _pfls[id]->setName(pflName);
2375   _pfls[id]->alloc(lgth,1);
2376   MEDprofileRd(fid,pflName,_pfls[id]->getPointer());
2377   _pfls[id]->applyLin(1,-1,0);//Converting into C format
2378 }
2379
2380 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int i)
2381 {
2382   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2383   int sz;
2384   MEDprofileInfo(fid,i+1,pflName,&sz);
2385   std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
2386   if(i>=(int)_pfls.size())
2387     _pfls.resize(i+1);
2388   _pfls[i]=DataArrayInt::New();
2389   _pfls[i]->alloc(sz,1);
2390   _pfls[i]->setName(pflCpp.c_str());
2391   MEDprofileRd(fid,pflName,_pfls[i]->getPointer());
2392   _pfls[i]->applyLin(1,-1,0);//Converting into C format
2393 }
2394
2395 void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const throw(INTERP_KERNEL::Exception)
2396 {
2397   int nbOfPfls=_pfls.size();
2398   for(int i=0;i<nbOfPfls;i++)
2399     {
2400       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cpy=_pfls[i]->deepCpy();
2401       cpy->applyLin(1,1,0);
2402       INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2403       MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
2404       MEDprofileWr(fid,pflName,_pfls[i]->getNumberOfTuples(),cpy->getConstPointer());
2405     }
2406   //
2407   int nbOfLocs=_locs.size();
2408   for(int i=0;i<nbOfLocs;i++)
2409     _locs[i]->writeLL(fid);
2410 }
2411
2412 void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps) throw(INTERP_KERNEL::Exception)
2413 {
2414   std::vector<std::string> pfls=getPfls();
2415   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
2416     {
2417       std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
2418       if(it2==pfls.end())
2419         {
2420           _pfls.push_back(*it);
2421         }
2422       else
2423         {
2424           int id=std::distance(pfls.begin(),it2);
2425           if(!(*it)->isEqual(*_pfls[id]))
2426             {
2427               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2428               throw INTERP_KERNEL::Exception(oss.str().c_str());
2429             }
2430         }
2431     }
2432   std::vector<std::string> locs=getLocs();
2433   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=other._locs.begin();it!=other._locs.end();it++)
2434     {
2435       std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
2436       if(it2==locs.end())
2437         {
2438           _locs.push_back(*it);
2439         }
2440       else
2441         {
2442           int id=std::distance(locs.begin(),it2);
2443           if(!(*it)->isEqual(*_locs[id],eps))
2444             {
2445               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2446               throw INTERP_KERNEL::Exception(oss.str().c_str());
2447             }
2448         }
2449     }
2450 }
2451
2452 void MEDFileFieldGlobs::checkGlobsPflsPartCoherency(const std::vector<std::string>& pflsUsed) const throw(INTERP_KERNEL::Exception)
2453 {
2454   for(std::vector<std::string>::const_iterator it=pflsUsed.begin();it!=pflsUsed.end();it++)
2455     getProfile((*it).c_str());
2456 }
2457
2458 void MEDFileFieldGlobs::checkGlobsLocsPartCoherency(const std::vector<std::string>& locsUsed) const throw(INTERP_KERNEL::Exception)
2459 {
2460   for(std::vector<std::string>::const_iterator it=locsUsed.begin();it!=locsUsed.end();it++)
2461     getLocalization((*it).c_str());
2462 }
2463
2464 void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real) throw(INTERP_KERNEL::Exception)
2465 {
2466   std::vector<std::string> profiles=real.getPflsReallyUsed();
2467   int sz=profiles.size();
2468   _pfls.resize(sz);
2469   for(int i=0;i<sz;i++)
2470     loadProfileInFile(fid,i,profiles[i].c_str());
2471   //
2472   std::vector<std::string> locs=real.getLocsReallyUsed();
2473   sz=locs.size();
2474   _locs.resize(sz);
2475   for(int i=0;i<sz;i++)
2476     _locs[i]=MEDFileFieldLoc::New(fid,locs[i].c_str());
2477 }
2478
2479 void MEDFileFieldGlobs::loadAllGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
2480 {
2481   int nProfil=MEDnProfile(fid);
2482   for(int i=0;i<nProfil;i++)
2483     loadProfileInFile(fid,i);
2484   int sz=MEDnLocalization(fid);
2485   _locs.resize(sz);
2486   for(int i=0;i<sz;i++)
2487     {
2488       _locs[i]=MEDFileFieldLoc::New(fid,i);
2489     }
2490 }
2491
2492 MEDFileFieldGlobs *MEDFileFieldGlobs::New(const char *fname)
2493 {
2494   return new MEDFileFieldGlobs(fname);
2495 }
2496
2497 MEDFileFieldGlobs *MEDFileFieldGlobs::New()
2498 {
2499   return new MEDFileFieldGlobs;
2500 }
2501
2502 std::size_t MEDFileFieldGlobs::getHeapMemorySize() const
2503 {
2504   std::size_t ret=_file_name.capacity()+_pfls.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<DataArrayInt>)+_locs.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>);
2505   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2506     ret+=(*it)->getHeapMemorySize();
2507   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2508     ret+=(*it)->getHeapMemorySize();
2509   return ret;
2510 }
2511
2512 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpy() const throw(INTERP_KERNEL::Exception)
2513 {
2514   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
2515   std::size_t i=0;
2516   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2517     {
2518       if((const DataArrayInt *)*it)
2519         ret->_pfls[i]=(*it)->deepCpy();
2520     }
2521   i=0;
2522   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2523     {
2524       if((const MEDFileFieldLoc*)*it)
2525         ret->_locs[i]=(*it)->deepCpy();
2526     }
2527   return ret.retn();
2528 }
2529
2530 /*!
2531  * \throw if a profile in \a pfls in not in \a this.
2532  * \throw if a localization in \a locs in not in \a this.
2533  * \sa MEDFileFieldGlobs::deepCpyPart
2534  */
2535 MEDFileFieldGlobs *MEDFileFieldGlobs::shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const throw(INTERP_KERNEL::Exception)
2536 {
2537   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2538   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2539     {
2540       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2541       if(!pfl)
2542         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! pfl null !");
2543       pfl->incrRef();
2544       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2(pfl);
2545       ret->_pfls.push_back(pfl2);
2546     }
2547   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2548     {
2549       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2550       if(!loc)
2551         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! loc null !");
2552       loc->incrRef();
2553       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> loc2(loc);
2554       ret->_locs.push_back(loc2);
2555     }
2556   ret->setFileName(getFileName());
2557   return ret.retn();
2558 }
2559
2560 /*!
2561  * \throw if a profile in \a pfls in not in \a this.
2562  * \throw if a localization in \a locs in not in \a this.
2563  * \sa MEDFileFieldGlobs::shallowCpyPart
2564  */
2565 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const throw(INTERP_KERNEL::Exception)
2566 {
2567   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2568   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2569     {
2570       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2571       if(!pfl)
2572         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! pfl null !");
2573       ret->_pfls.push_back(pfl->deepCpy());
2574     }
2575   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2576     {
2577       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2578       if(!loc)
2579         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! loc null !");
2580       ret->_locs.push_back(loc->deepCpy());
2581     }
2582   ret->setFileName(getFileName());
2583   return ret.retn();
2584 }
2585
2586 MEDFileFieldGlobs::MEDFileFieldGlobs(const char *fname):_file_name(fname)
2587 {
2588 }
2589
2590 MEDFileFieldGlobs::MEDFileFieldGlobs()
2591 {
2592 }
2593
2594 MEDFileFieldGlobs::~MEDFileFieldGlobs()
2595 {
2596 }
2597
2598 void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
2599 {
2600   oss << "Profiles :\n";
2601   std::size_t n=_pfls.size();
2602   for(std::size_t i=0;i<n;i++)
2603     {
2604       oss << "  - #" << i << " ";
2605       const DataArrayInt *pfl=_pfls[i];
2606       if(pfl)
2607         oss << "\"" << pfl->getName() << "\"\n";
2608       else
2609         oss << "EMPTY !\n";
2610     }
2611   n=_locs.size();
2612   oss << "Localizations :\n";
2613   for(std::size_t i=0;i<n;i++)
2614     {
2615       oss << "  - #" << i << " ";
2616       const MEDFileFieldLoc *loc=_locs[i];
2617       if(loc)
2618         loc->simpleRepr(oss);
2619       else
2620         oss<< "EMPTY !\n";
2621     }
2622 }
2623
2624 void MEDFileFieldGlobs::setFileName(const char *fileName)
2625 {
2626   _file_name=fileName;
2627 }
2628
2629 void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2630 {
2631   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
2632     {
2633       DataArrayInt *elt(*it);
2634       if(elt)
2635         {
2636           std::string name(elt->getName());
2637           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2638             {
2639               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2640                 {
2641                   elt->setName((*it2).second.c_str());
2642                   return;
2643                 }
2644             }
2645         }
2646     }
2647 }
2648
2649 void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2650 {
2651   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
2652     {
2653       MEDFileFieldLoc *elt(*it);
2654       if(elt)
2655         {
2656           std::string name(elt->getName());
2657           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2658             {
2659               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2660                 {
2661                   elt->setName((*it2).second.c_str());
2662                   return;
2663                 }
2664             }
2665         }
2666     }
2667 }
2668
2669 int MEDFileFieldGlobs::getNbOfGaussPtPerCell(int locId) const throw(INTERP_KERNEL::Exception)
2670 {
2671   if(locId<0 || locId>=(int)_locs.size())
2672     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getNbOfGaussPtPerCell : Invalid localization id !");
2673   return _locs[locId]->getNbOfGaussPtPerCell();
2674 }
2675
2676 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName) const throw(INTERP_KERNEL::Exception)
2677 {
2678   return getLocalizationFromId(getLocalizationId(locName));
2679 }
2680
2681 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) const throw(INTERP_KERNEL::Exception)
2682 {
2683   if(locId<0 || locId>=(int)_locs.size())
2684     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2685   return *_locs[locId];
2686 }
2687
2688 namespace ParaMEDMEMImpl
2689 {
2690   class LocFinder
2691   {
2692   public:
2693     LocFinder(const char *loc):_loc(loc) { }
2694     bool operator() (const MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>& loc) { return loc->isName(_loc); }
2695   private:
2696     const char *_loc;
2697   };
2698
2699   class PflFinder
2700   {
2701   public:
2702     PflFinder(const std::string& pfl):_pfl(pfl) { }
2703     bool operator() (const MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& pfl) { return _pfl==pfl->getName(); }
2704   private:
2705     const std::string& _pfl;
2706   };
2707 }
2708
2709 int MEDFileFieldGlobs::getLocalizationId(const char *loc) const throw(INTERP_KERNEL::Exception)
2710 {
2711   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),ParaMEDMEMImpl::LocFinder(loc));
2712   if(it==_locs.end())
2713     {
2714       std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
2715       for(it=_locs.begin();it!=_locs.end();it++)
2716         oss << "\"" << (*it)->getName() << "\", ";
2717       throw INTERP_KERNEL::Exception(oss.str().c_str());
2718     }
2719   return std::distance(_locs.begin(),it);
2720 }
2721
2722 /*!
2723  * The returned value is never null.
2724  */
2725 const DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName) const throw(INTERP_KERNEL::Exception)
2726 {
2727   std::string pflNameCpp(pflName);
2728   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2729   if(it==_pfls.end())
2730     {
2731       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2732       for(it=_pfls.begin();it!=_pfls.end();it++)
2733         oss << "\"" << (*it)->getName() << "\", ";
2734       throw INTERP_KERNEL::Exception(oss.str().c_str());
2735     }
2736   return *it;
2737 }
2738
2739 const DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) const throw(INTERP_KERNEL::Exception)
2740 {
2741   if(pflId<0 || pflId>=(int)_pfls.size())
2742     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2743   return _pfls[pflId];
2744 }
2745
2746 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) throw(INTERP_KERNEL::Exception)
2747 {
2748   if(locId<0 || locId>=(int)_locs.size())
2749     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2750   return *_locs[locId];
2751 }
2752
2753 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName) throw(INTERP_KERNEL::Exception)
2754 {
2755   return getLocalizationFromId(getLocalizationId(locName));
2756 }
2757
2758 /*!
2759  * The returned value is never null.
2760  */
2761 DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName) throw(INTERP_KERNEL::Exception)
2762 {
2763   std::string pflNameCpp(pflName);
2764   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2765   if(it==_pfls.end())
2766     {
2767       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2768       for(it=_pfls.begin();it!=_pfls.end();it++)
2769         oss << "\"" << (*it)->getName() << "\", ";
2770       throw INTERP_KERNEL::Exception(oss.str().c_str());
2771     }
2772   return *it;
2773 }
2774
2775 DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) throw(INTERP_KERNEL::Exception)
2776 {
2777   if(pflId<0 || pflId>=(int)_pfls.size())
2778     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2779   return _pfls[pflId];
2780 }
2781
2782 void MEDFileFieldGlobs::killProfileIds(const std::vector<int>& pflIds) throw(INTERP_KERNEL::Exception)
2783 {
2784   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newPfls;
2785   int i=0;
2786   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2787     {
2788       if(std::find(pflIds.begin(),pflIds.end(),i)==pflIds.end())
2789         newPfls.push_back(*it);
2790     }
2791   _pfls=newPfls;
2792 }
2793
2794 void MEDFileFieldGlobs::killLocalizationIds(const std::vector<int>& locIds) throw(INTERP_KERNEL::Exception)
2795 {
2796   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> > newLocs;
2797   int i=0;
2798   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2799     {
2800       if(std::find(locIds.begin(),locIds.end(),i)==locIds.end())
2801         newLocs.push_back(*it);
2802     }
2803   _locs=newLocs;
2804 }
2805
2806 std::vector<std::string> MEDFileFieldGlobs::getPfls() const
2807 {
2808   int sz=_pfls.size();
2809   std::vector<std::string> ret(sz);
2810   for(int i=0;i<sz;i++)
2811     ret[i]=_pfls[i]->getName();
2812   return ret;
2813 }
2814
2815 std::vector<std::string> MEDFileFieldGlobs::getLocs() const
2816 {
2817   int sz=_locs.size();
2818   std::vector<std::string> ret(sz);
2819   for(int i=0;i<sz;i++)
2820     ret[i]=_locs[i]->getName();
2821   return ret;
2822 }
2823
2824 bool MEDFileFieldGlobs::existsPfl(const char *pflName) const
2825 {
2826   std::vector<std::string> v=getPfls();
2827   std::string s(pflName);
2828   return std::find(v.begin(),v.end(),s)!=v.end();
2829 }
2830
2831 bool MEDFileFieldGlobs::existsLoc(const char *locName) const
2832 {
2833   std::vector<std::string> v=getLocs();
2834   std::string s(locName);
2835   return std::find(v.begin(),v.end(),s)!=v.end();
2836 }
2837
2838 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualProfiles() const
2839 {
2840   std::map<int,std::vector<int> > m;
2841   int i=0;
2842   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2843     {
2844       const DataArrayInt *tmp=(*it);
2845       if(tmp)
2846         {
2847           m[tmp->getHashCode()].push_back(i);
2848         }
2849     }
2850   std::vector< std::vector<int> > ret;
2851   for(std::map<int,std::vector<int> >::const_iterator it2=m.begin();it2!=m.end();it2++)
2852     {
2853       if((*it2).second.size()>1)
2854         {
2855           std::vector<int> ret0;
2856           bool equalityOrNot=false;
2857           for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
2858             {
2859               std::vector<int>::const_iterator it4=it3; it4++;
2860               for(;it4!=(*it2).second.end();it4++)
2861                 {
2862                   if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
2863                     {
2864                       if(!equalityOrNot)
2865                         ret0.push_back(*it3);
2866                       ret0.push_back(*it4);
2867                       equalityOrNot=true;
2868                     }
2869                 }
2870             }
2871           if(!ret0.empty())
2872             ret.push_back(ret0);
2873         }
2874     }
2875   return ret;
2876 }
2877
2878 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
2879 {
2880   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
2881 }
2882
2883 void MEDFileFieldGlobs::appendProfile(DataArrayInt *pfl) throw(INTERP_KERNEL::Exception)
2884 {
2885   std::string name(pfl->getName());
2886   if(name.empty())
2887     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
2888   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2889     if(name==(*it)->getName())
2890       {
2891         if(!pfl->isEqual(*(*it)))
2892           {
2893             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
2894             throw INTERP_KERNEL::Exception(oss.str().c_str());
2895           }
2896       }
2897   pfl->incrRef();
2898   _pfls.push_back(pfl);
2899 }
2900
2901 void MEDFileFieldGlobs::appendLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w) throw(INTERP_KERNEL::Exception)
2902 {
2903   std::string name(locName);
2904   if(name.empty())
2905     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
2906   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
2907   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2908     if((*it)->isName(locName))
2909       {
2910         if(!(*it)->isEqual(*obj,1e-12))
2911           {
2912             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
2913             throw INTERP_KERNEL::Exception(oss.str().c_str());
2914           }
2915       }
2916   _locs.push_back(obj);
2917 }
2918
2919 std::string MEDFileFieldGlobs::createNewNameOfPfl() const throw(INTERP_KERNEL::Exception)
2920 {
2921   std::vector<std::string> names=getPfls();
2922   return CreateNewNameNotIn("NewPfl_",names);
2923 }
2924
2925 std::string MEDFileFieldGlobs::createNewNameOfLoc() const throw(INTERP_KERNEL::Exception)
2926 {
2927   std::vector<std::string> names=getLocs();
2928   return CreateNewNameNotIn("NewLoc_",names);
2929 }
2930
2931 std::string MEDFileFieldGlobs::CreateNewNameNotIn(const char *prefix, const std::vector<std::string>& namesToAvoid) throw(INTERP_KERNEL::Exception)
2932 {
2933   for(std::size_t sz=0;sz<100000;sz++)
2934     {
2935       std::ostringstream tryName;
2936       tryName << prefix << sz;
2937       if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tryName.str())==namesToAvoid.end())
2938         return tryName.str();
2939     }
2940   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::CreateNewNameNotIn : impossible to create an additional profile limit of 100000 profiles reached !");
2941 }
2942
2943 /*!
2944  * Creates a MEDFileFieldGlobsReal on a given file name. Nothing is read here.
2945  *  \param [in] fname - the file name.
2946  */
2947 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal(const char *fname):_globals(MEDFileFieldGlobs::New(fname))
2948 {
2949 }
2950
2951 /*!
2952  * Creates an empty MEDFileFieldGlobsReal.
2953  */
2954 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal():_globals(MEDFileFieldGlobs::New())
2955 {
2956 }
2957
2958 std::size_t MEDFileFieldGlobsReal::getHeapMemorySize() const
2959 {
2960   std::size_t ret=0;
2961   if((const MEDFileFieldGlobs *)_globals)
2962     ret+=_globals->getHeapMemorySize();
2963   return ret;
2964 }
2965
2966 /*!
2967  * Returns a string describing profiles and Gauss points held in \a this.
2968  *  \return std::string - the description string.
2969  */
2970 void MEDFileFieldGlobsReal::simpleReprGlobs(std::ostream& oss) const
2971 {
2972   const MEDFileFieldGlobs *glob=_globals;
2973   std::ostringstream oss2; oss2 << glob;
2974   std::string stars(oss2.str().length(),'*');
2975   oss << "Globals information on fields (at " << oss2.str() << "):" << "\n************************************" << stars  << "\n\n";
2976   if(glob)
2977     glob->simpleRepr(oss);
2978   else
2979     oss << "NO GLOBAL INFORMATION !\n";
2980 }
2981
2982 void MEDFileFieldGlobsReal::resetContent()
2983 {
2984   _globals=MEDFileFieldGlobs::New();
2985 }
2986
2987 MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
2988 {
2989 }
2990
2991 /*!
2992  * Copies references to profiles and Gauss points from another MEDFileFieldGlobsReal.
2993  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
2994  */
2995 void MEDFileFieldGlobsReal::shallowCpyGlobs(const MEDFileFieldGlobsReal& other)
2996 {
2997   _globals=other._globals;
2998 }
2999
3000 /*!
3001  * Copies references to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3002  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3003  */
3004 void MEDFileFieldGlobsReal::shallowCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other) throw(INTERP_KERNEL::Exception)
3005 {
3006   const MEDFileFieldGlobs *otherg(other._globals);
3007   if(!otherg)
3008     return ;
3009   _globals=otherg->shallowCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3010 }
3011
3012 /*!
3013  * Copies deeply to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3014  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3015  */
3016 void MEDFileFieldGlobsReal::deepCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other) throw(INTERP_KERNEL::Exception)
3017 {
3018   const MEDFileFieldGlobs *otherg(other._globals);
3019   if(!otherg)
3020     return ;
3021   _globals=otherg->deepCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3022 }
3023
3024 void MEDFileFieldGlobsReal::deepCpyGlobs(const MEDFileFieldGlobsReal& other)
3025 {
3026   _globals=other._globals;
3027   if((const MEDFileFieldGlobs *)_globals)
3028     _globals=other._globals->deepCpy();
3029 }
3030
3031 /*!
3032  * Adds profiles and Gauss points held by another MEDFileFieldGlobsReal to \a this one.
3033  *  \param [in] other - the MEDFileFieldGlobsReal to copy data from.
3034  *  \param [in] eps - a precision used to compare Gauss points with same name held by
3035  *         \a this and \a other MEDFileFieldGlobsReal.
3036  *  \throw If \a this and \a other hold profiles with equal names but different ids.
3037  *  \throw If  \a this and \a other hold different Gauss points with equal names.
3038  */
3039 void MEDFileFieldGlobsReal::appendGlobs(const MEDFileFieldGlobsReal& other, double eps) throw(INTERP_KERNEL::Exception)
3040 {
3041   const MEDFileFieldGlobs *thisGlobals(_globals),*otherGlobals(other._globals);
3042   if(thisGlobals==otherGlobals)
3043     return ;
3044   if(!thisGlobals)
3045     {
3046       _globals=other._globals;
3047       return ;
3048     }
3049   _globals->appendGlobs(*other._globals,eps);
3050 }
3051
3052 void MEDFileFieldGlobsReal::checkGlobsCoherency() const throw(INTERP_KERNEL::Exception)
3053 {
3054   checkGlobsPflsPartCoherency();
3055   checkGlobsLocsPartCoherency();
3056 }
3057
3058 void MEDFileFieldGlobsReal::checkGlobsPflsPartCoherency() const throw(INTERP_KERNEL::Exception)
3059 {
3060   contentNotNull()->checkGlobsPflsPartCoherency(getPflsReallyUsed());
3061 }
3062
3063 void MEDFileFieldGlobsReal::checkGlobsLocsPartCoherency() const throw(INTERP_KERNEL::Exception)
3064 {
3065   contentNotNull()->checkGlobsLocsPartCoherency(getLocsReallyUsed());
3066 }
3067
3068 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id, const char *pflName) throw(INTERP_KERNEL::Exception)
3069 {
3070   contentNotNull()->loadProfileInFile(fid,id,pflName);
3071 }
3072
3073 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id)
3074 {
3075   contentNotNull()->loadProfileInFile(fid,id);
3076 }
3077
3078 void MEDFileFieldGlobsReal::loadGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
3079 {
3080   contentNotNull()->loadGlobals(fid,*this);
3081 }
3082
3083 void MEDFileFieldGlobsReal::loadAllGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
3084 {
3085   contentNotNull()->loadAllGlobals(fid);
3086 }
3087
3088 void MEDFileFieldGlobsReal::writeGlobals(med_idt fid, const MEDFileWritable& opt) const throw(INTERP_KERNEL::Exception)
3089 {
3090   contentNotNull()->writeGlobals(fid,opt);
3091 }
3092
3093 /*!
3094  * Returns names of all profiles. To get only used profiles call getPflsReallyUsed()
3095  * or getPflsReallyUsedMulti().
3096  *  \return std::vector<std::string> - a sequence of names of all profiles.
3097  */
3098 std::vector<std::string> MEDFileFieldGlobsReal::getPfls() const
3099 {
3100   return contentNotNull()->getPfls();
3101 }
3102
3103 /*!
3104  * Returns names of all localizations. To get only used localizations call getLocsReallyUsed()
3105  * or getLocsReallyUsedMulti().
3106  *  \return std::vector<std::string> - a sequence of names of all localizations.
3107  */
3108 std::vector<std::string> MEDFileFieldGlobsReal::getLocs() const
3109 {
3110   return contentNotNull()->getLocs();
3111 }
3112
3113 /*!
3114  * Checks if the profile with a given name exists.
3115  *  \param [in] pflName - the profile name of interest.
3116  *  \return bool - \c true if the profile named \a pflName exists.
3117  */
3118 bool MEDFileFieldGlobsReal::existsPfl(const char *pflName) const
3119 {
3120   return contentNotNull()->existsPfl(pflName);
3121 }
3122
3123 /*!
3124  * Checks if the localization with a given name exists.
3125  *  \param [in] locName - the localization name of interest.
3126  *  \return bool - \c true if the localization named \a locName exists.
3127  */
3128 bool MEDFileFieldGlobsReal::existsLoc(const char *locName) const
3129 {
3130   return contentNotNull()->existsLoc(locName);
3131 }
3132
3133 std::string MEDFileFieldGlobsReal::createNewNameOfPfl() const throw(INTERP_KERNEL::Exception)
3134 {
3135   return contentNotNull()->createNewNameOfPfl();
3136 }
3137
3138 std::string MEDFileFieldGlobsReal::createNewNameOfLoc() const throw(INTERP_KERNEL::Exception)
3139 {
3140   return contentNotNull()->createNewNameOfLoc();
3141 }
3142
3143 /*!
3144  * Sets the name of a MED file.
3145  *  \param [inout] fileName - the file name.
3146  */
3147 void MEDFileFieldGlobsReal::setFileName(const char *fileName)
3148 {
3149   contentNotNull()->setFileName(fileName);
3150 }
3151
3152 /*!
3153  * Finds equal profiles. Two profiles are considered equal if they contain the same ids
3154  * in the same order.
3155  *  \return std::vector< std::vector<int> > - a sequence of groups of equal profiles.
3156  *          Each item of this sequence is a vector containing ids of equal profiles.
3157  */
3158 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualProfiles() const
3159 {
3160   return contentNotNull()->whichAreEqualProfiles();
3161 }
3162
3163 /*!
3164  * Finds equal localizations.
3165  *  \param [in] eps - a precision used to compare real values of the localizations.
3166  *  \return std::vector< std::vector<int> > - a sequence of groups of equal localizations.
3167  *          Each item of this sequence is a vector containing ids of equal localizations.
3168  */
3169 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualLocs(double eps) const
3170 {
3171   return contentNotNull()->whichAreEqualLocs(eps);
3172 }
3173
3174 /*!
3175  * Renames the profiles. References to profiles (a reference is a profile name) are not changed.
3176  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3177  *        this sequence is a pair whose
3178  *        - the first item is a vector of profile names to replace by the second item,
3179  *        - the second item is a profile name to replace every profile name of the first item.
3180  */
3181 void MEDFileFieldGlobsReal::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3182 {
3183   contentNotNull()->changePflsNamesInStruct(mapOfModif);
3184 }
3185
3186 /*!
3187  * Renames the localizations. References to localizations (a reference is a localization name) are not changed.
3188  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3189  *        this sequence is a pair whose
3190  *        - the first item is a vector of localization names to replace by the second item,
3191  *        - the second item is a localization name to replace every localization name of the first item.
3192  */
3193 void MEDFileFieldGlobsReal::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3194 {
3195   contentNotNull()->changeLocsNamesInStruct(mapOfModif);
3196 }
3197
3198 /*!
3199  * Replaces references to some profiles (a reference is a profile name) by references
3200  * to other profiles and, contrary to changePflsRefsNamesGen(), renames the profiles
3201  * them-selves accordingly. <br>
3202  * This method is a generalization of changePflName().
3203  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3204  *        this sequence is a pair whose
3205  *        - the first item is a vector of profile names to replace by the second item,
3206  *        - the second item is a profile name to replace every profile of the first item.
3207  * \sa changePflsRefsNamesGen()
3208  * \sa changePflName()
3209  */
3210 void MEDFileFieldGlobsReal::changePflsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3211 {
3212   changePflsRefsNamesGen(mapOfModif);
3213   changePflsNamesInStruct(mapOfModif);
3214 }
3215
3216 /*!
3217  * Replaces references to some localizations (a reference is a localization name) by references
3218  * to other localizations and, contrary to changeLocsRefsNamesGen(), renames the localizations
3219  * them-selves accordingly. <br>
3220  * This method is a generalization of changeLocName().
3221  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3222  *        this sequence is a pair whose
3223  *        - the first item is a vector of localization names to replace by the second item,
3224  *        - the second item is a localization name to replace every localization of the first item.
3225  * \sa changeLocsRefsNamesGen()
3226  * \sa changeLocName()
3227  */
3228 void MEDFileFieldGlobsReal::changeLocsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3229 {
3230   changeLocsRefsNamesGen(mapOfModif);
3231   changeLocsNamesInStruct(mapOfModif);
3232 }
3233
3234 /*!
3235  * Renames the profile having a given name and updates references to this profile.
3236  *  \param [in] oldName - the name of the profile to rename.
3237  *  \param [in] newName - a new name of the profile.
3238  * \sa changePflsNames().
3239  */
3240 void MEDFileFieldGlobsReal::changePflName(const char *oldName, const char *newName) throw(INTERP_KERNEL::Exception)
3241 {
3242   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3243   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3244   mapOfModif[0]=p;
3245   changePflsNames(mapOfModif);
3246 }
3247
3248 /*!
3249  * Renames the localization having a given name and updates references to this localization.
3250  *  \param [in] oldName - the name of the localization to rename.
3251  *  \param [in] newName - a new name of the localization.
3252  * \sa changeLocsNames().
3253  */
3254 void MEDFileFieldGlobsReal::changeLocName(const char *oldName, const char *newName) throw(INTERP_KERNEL::Exception)
3255 {
3256   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3257   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3258   mapOfModif[0]=p;
3259   changeLocsNames(mapOfModif);
3260 }
3261
3262 /*!
3263  * Removes duplicated profiles. Returns a map used to update references to removed
3264  * profiles via changePflsRefsNamesGen().
3265  * Equal profiles are found using whichAreEqualProfiles().
3266  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3267  *          a sequence describing the performed replacements of profiles. Each element of
3268  *          this sequence is a pair whose
3269  *          - the first item is a vector of profile names replaced by the second item,
3270  *          - the second item is a profile name replacing every profile of the first item.
3271  */
3272 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipPflsNames() throw(INTERP_KERNEL::Exception)
3273 {
3274   std::vector< std::vector<int> > pseudoRet=whichAreEqualProfiles();
3275   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3276   int i=0;
3277   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3278     {
3279       std::vector< std::string > tmp((*it).size());
3280       int j=0;
3281       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3282         tmp[j]=std::string(getProfileFromId(*it2)->getName());
3283       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3284       ret[i]=p;
3285       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3286       killProfileIds(tmp2);
3287     }
3288   changePflsRefsNamesGen(ret);
3289   return ret;
3290 }
3291
3292 /*!
3293  * Removes duplicated localizations. Returns a map used to update references to removed
3294  * localizations via changeLocsRefsNamesGen().
3295  * Equal localizations are found using whichAreEqualLocs().
3296  *  \param [in] eps - a precision used to compare real values of the localizations.
3297  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3298  *          a sequence describing the performed replacements of localizations. Each element of
3299  *          this sequence is a pair whose
3300  *          - the first item is a vector of localization names replaced by the second item,
3301  *          - the second item is a localization name replacing every localization of the first item.
3302  */
3303 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipLocsNames(double eps) throw(INTERP_KERNEL::Exception)
3304 {
3305   std::vector< std::vector<int> > pseudoRet=whichAreEqualLocs(eps);
3306   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3307   int i=0;
3308   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3309     {
3310       std::vector< std::string > tmp((*it).size());
3311       int j=0;
3312       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3313         tmp[j]=std::string(getLocalizationFromId(*it2).getName());
3314       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3315       ret[i]=p;
3316       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3317       killLocalizationIds(tmp2);
3318     }
3319   changeLocsRefsNamesGen(ret);
3320   return ret;
3321 }
3322
3323 /*!
3324  * Returns number of Gauss points per cell in a given localization.
3325  *  \param [in] locId - an id of the localization of interest.
3326  *  \return int - the number of the Gauss points per cell.
3327  */
3328 int MEDFileFieldGlobsReal::getNbOfGaussPtPerCell(int locId) const throw(INTERP_KERNEL::Exception)
3329 {
3330   return contentNotNull()->getNbOfGaussPtPerCell(locId);
3331 }
3332
3333 /*!
3334  * Returns an id of a localization by its name.
3335  *  \param [in] loc - the localization name of interest.
3336  *  \return int - the id of the localization.
3337  *  \throw If there is no a localization named \a loc.
3338  */
3339 int MEDFileFieldGlobsReal::getLocalizationId(const char *loc) const throw(INTERP_KERNEL::Exception)
3340 {
3341   return contentNotNull()->getLocalizationId(loc);
3342 }
3343
3344 /*!
3345  * Returns the name of the MED file.
3346  *  \return const char * - the MED file name.
3347  */
3348 const char *MEDFileFieldGlobsReal::getFileName() const
3349 {
3350   return contentNotNull()->getFileName();
3351 }
3352
3353 std::string MEDFileFieldGlobsReal::getFileName2() const
3354 {
3355   return contentNotNull()->getFileName2();
3356 }
3357
3358 /*!
3359  * Returns a localization object by its name.
3360  *  \param [in] locName - the name of the localization of interest.
3361  *  \return const MEDFileFieldLoc& - the localization object having the name \a locName.
3362  *  \throw If there is no a localization named \a locName.
3363  */
3364 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName) const throw(INTERP_KERNEL::Exception)
3365 {
3366   return contentNotNull()->getLocalization(locName);
3367 }
3368
3369 /*!
3370  * Returns a localization object by its id.
3371  *  \param [in] locId - the id of the localization of interest.
3372  *  \return const MEDFileFieldLoc& - the localization object having the id \a locId.
3373  *  \throw If there is no a localization with id \a locId.
3374  */
3375 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) const throw(INTERP_KERNEL::Exception)
3376 {
3377   return contentNotNull()->getLocalizationFromId(locId);
3378 }
3379
3380 /*!
3381  * Returns a profile array by its name.
3382  *  \param [in] pflName - the name of the profile of interest.
3383  *  \return const DataArrayInt * - the profile array having the name \a pflName.
3384  *  \throw If there is no a profile named \a pflName.
3385  */
3386 const DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName) const throw(INTERP_KERNEL::Exception)
3387 {
3388   return contentNotNull()->getProfile(pflName);
3389 }
3390
3391 /*!
3392  * Returns a profile array by its id.
3393  *  \param [in] pflId - the id of the profile of interest.
3394  *  \return const DataArrayInt * - the profile array having the id \a pflId.
3395  *  \throw If there is no a profile with id \a pflId.
3396  */
3397 const DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) const throw(INTERP_KERNEL::Exception)
3398 {
3399   return contentNotNull()->getProfileFromId(pflId);
3400 }
3401
3402 /*!
3403  * Returns a localization object, apt for modification, by its id.
3404  *  \param [in] locId - the id of the localization of interest.
3405  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3406  *          having the id \a locId.
3407  *  \throw If there is no a localization with id \a locId.
3408  */
3409 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) throw(INTERP_KERNEL::Exception)
3410 {
3411   return contentNotNull()->getLocalizationFromId(locId);
3412 }
3413
3414 /*!
3415  * Returns a localization object, apt for modification, by its name.
3416  *  \param [in] locName - the name of the localization of interest.
3417  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3418  *          having the name \a locName.
3419  *  \throw If there is no a localization named \a locName.
3420  */
3421 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName) throw(INTERP_KERNEL::Exception)
3422 {
3423   return contentNotNull()->getLocalization(locName);
3424 }
3425
3426 /*!
3427  * Returns a profile array, apt for modification, by its name.
3428  *  \param [in] pflName - the name of the profile of interest.
3429  *  \return DataArrayInt * - a non-const pointer to the profile array having the name \a pflName.
3430  *  \throw If there is no a profile named \a pflName.
3431  */
3432 DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName) throw(INTERP_KERNEL::Exception)
3433 {
3434   return contentNotNull()->getProfile(pflName);
3435 }
3436
3437 /*!
3438  * Returns a profile array, apt for modification, by its id.
3439  *  \param [in] pflId - the id of the profile of interest.
3440  *  \return DataArrayInt * - a non-const pointer to the profile array having the id \a pflId.
3441  *  \throw If there is no a profile with id \a pflId.
3442  */
3443 DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) throw(INTERP_KERNEL::Exception)
3444 {
3445   return contentNotNull()->getProfileFromId(pflId);
3446 }
3447
3448 /*!
3449  * Removes profiles given by their ids. No data is updated to track this removal.
3450  *  \param [in] pflIds - a sequence of ids of the profiles to remove.
3451  */
3452 void MEDFileFieldGlobsReal::killProfileIds(const std::vector<int>& pflIds) throw(INTERP_KERNEL::Exception)
3453 {
3454   contentNotNull()->killProfileIds(pflIds);
3455 }
3456
3457 /*!
3458  * Removes localizations given by their ids. No data is updated to track this removal.
3459  *  \param [in] locIds - a sequence of ids of the localizations to remove.
3460  */
3461 void MEDFileFieldGlobsReal::killLocalizationIds(const std::vector<int>& locIds) throw(INTERP_KERNEL::Exception)
3462 {
3463   contentNotNull()->killLocalizationIds(locIds);
3464 }
3465
3466 /*!
3467  * Stores a profile array.
3468  *  \param [in] pfl - the profile array to store.
3469  *  \throw If the name of \a pfl is empty.
3470  *  \throw If a profile with the same name as that of \a pfl already exists but contains
3471  *         different ids.
3472  */
3473 void MEDFileFieldGlobsReal::appendProfile(DataArrayInt *pfl) throw(INTERP_KERNEL::Exception)
3474 {
3475   contentNotNull()->appendProfile(pfl);
3476 }
3477
3478 /*!
3479  * Adds a new localization of Gauss points.
3480  *  \param [in] locName - the name of the new localization.
3481  *  \param [in] geoType - a geometrical type of the reference cell.
3482  *  \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
3483  *         must be \c nbOfNodesPerCell * \c dimOfType.
3484  *  \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
3485  *         must be  _wg_.size() * \c dimOfType.
3486  *  \param [in] w - the weights of Gauss points.
3487  *  \throw If \a locName is empty.
3488  *  \throw If a localization with the name \a locName already exists but is
3489  *         different form the new one.
3490  */
3491 void MEDFileFieldGlobsReal::appendLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w) throw(INTERP_KERNEL::Exception)
3492 {
3493   contentNotNull()->appendLoc(locName,geoType,refCoo,gsCoo,w);
3494 }
3495
3496 MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() throw(INTERP_KERNEL::Exception)
3497 {
3498   MEDFileFieldGlobs *g(_globals);
3499   if(!g)
3500     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in not const !");
3501   return g;
3502 }
3503
3504 const MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() const throw(INTERP_KERNEL::Exception)
3505 {
3506   const MEDFileFieldGlobs *g(_globals);
3507   if(!g)
3508     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in const !");
3509   return g;
3510 }
3511
3512 //= MEDFileFieldNameScope
3513
3514 MEDFileFieldNameScope::MEDFileFieldNameScope()
3515 {
3516 }
3517
3518 MEDFileFieldNameScope::MEDFileFieldNameScope(const char *fieldName):_name(fieldName)
3519 {
3520 }
3521
3522 /*!
3523  * Returns the name of \a this field.
3524  *  \return std::string - a string containing the field name.
3525  */
3526 std::string MEDFileFieldNameScope::getName() const throw(INTERP_KERNEL::Exception)
3527 {
3528   return _name;
3529 }
3530
3531 /*!
3532  * Sets name of \a this field
3533  *  \param [in] name - the new field name.
3534  */
3535 void MEDFileFieldNameScope::setName(const char *fieldName) throw(INTERP_KERNEL::Exception)
3536 {
3537   _name=fieldName;
3538 }
3539
3540 std::string MEDFileFieldNameScope::getDtUnit() const throw(INTERP_KERNEL::Exception)
3541 {
3542   return _dt_unit;
3543 }
3544
3545 void MEDFileFieldNameScope::setDtUnit(const char *dtUnit) throw(INTERP_KERNEL::Exception)
3546 {
3547   _dt_unit=dtUnit;
3548 }
3549
3550 void MEDFileFieldNameScope::copyNameScope(const MEDFileFieldNameScope& other)
3551 {
3552   _name=other._name;
3553   _dt_unit=other._dt_unit;
3554 }
3555
3556 //= MEDFileAnyTypeField1TSWithoutSDA
3557
3558 void MEDFileAnyTypeField1TSWithoutSDA::deepCpyLeavesFrom(const MEDFileAnyTypeField1TSWithoutSDA& other) throw(INTERP_KERNEL::Exception)
3559 {
3560   _field_per_mesh.resize(other._field_per_mesh.size());
3561   std::size_t i=0;
3562   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
3563     {
3564       if((const MEDFileFieldPerMesh *)*it)
3565         _field_per_mesh[i]=(*it)->deepCpy(this);
3566     }
3567 }
3568
3569 /*!
3570  * Prints a string describing \a this field into a stream. This string is outputted
3571  * by \c print Python command.
3572  *  \param [in] bkOffset - number of white spaces printed at the beginning of each line.
3573  *  \param [in,out] oss - the out stream.
3574  *  \param [in] f1tsId - the field index within a MED file. If \a f1tsId < 0, the tiny
3575  *          info id printed, else, not.
3576  */
3577 void MEDFileAnyTypeField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
3578 {
3579   std::string startOfLine(bkOffset,' ');
3580   oss << startOfLine << "Field ";
3581   if(bkOffset==0)
3582     oss << "[Type=" << getTypeStr() << "] with name \"" << getName() << "\" ";
3583   oss << "on one time Step ";
3584   if(f1tsId>=0)
3585     oss << "(" << f1tsId << ") ";
3586   oss << "on iteration=" << _iteration << " order=" << _order << "." << std::endl;
3587   oss << startOfLine << "Time attached is : " << _dt << " [" << _dt_unit << "]." << std::endl;
3588   const DataArray *arr=getUndergroundDataArray();
3589   if(arr)
3590     {
3591       const std::vector<std::string> &comps=arr->getInfoOnComponents();
3592       if(f1tsId<0)
3593         {
3594           oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
3595           for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
3596             oss << startOfLine << "  -  \"" << (*it) << "\"" << std::endl;
3597         }
3598       if(arr->isAllocated())
3599         {
3600           oss << startOfLine << "Whole field contains " << arr->getNumberOfTuples() << " tuples." << std::endl;
3601         }
3602       else
3603         oss << startOfLine << "The array of the current field has not allocated yet !" << std::endl;
3604     }
3605   else
3606     {
3607       oss << startOfLine << "Field infos are empty ! Not defined yet !" << std::endl;
3608     }
3609   oss << startOfLine << "----------------------" << std::endl;
3610   if(!_field_per_mesh.empty())
3611     {
3612       int i=0;
3613       for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
3614         {
3615           const MEDFileFieldPerMesh *cur=(*it2);
3616           if(cur)
3617             cur->simpleRepr(bkOffset,oss,i);
3618           else
3619             oss << startOfLine << "Field per mesh #" << i << " is not defined !" << std::endl;
3620         }
3621     }
3622   else
3623     {
3624       oss << startOfLine << "Field is not defined on any meshes !" << std::endl;
3625     }
3626   oss << startOfLine << "----------------------" << std::endl;
3627 }
3628
3629 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitComponents() const throw(INTERP_KERNEL::Exception)
3630 {
3631   const DataArray *arr(getUndergroundDataArray());
3632   if(!arr)
3633     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitComponents : no array defined !");
3634   int nbOfCompo=arr->getNumberOfComponents();
3635   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfCompo);
3636   for(int i=0;i<nbOfCompo;i++)
3637     {
3638       ret[i]=deepCpy();
3639       std::vector<int> v(1,i);
3640       MEDCouplingAutoRefCountObjectPtr<DataArray> arr2=arr->keepSelectedComponents(v);
3641       ret[i]->setArray(arr2);
3642     }
3643   return ret;
3644 }
3645
3646 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order):MEDFileFieldNameScope(fieldName),_iteration(iteration),_order(order),_csit(csit),_nb_of_tuples_to_be_allocated(-2)
3647 {
3648 }
3649
3650 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA():_iteration(-1),_order(-1),_dt(0.),_csit(-1),_nb_of_tuples_to_be_allocated(-1)
3651 {
3652 }
3653
3654 /*!
3655  * Returns the maximal dimension of supporting elements. Returns -2 if \a this is
3656  * empty. Returns -1 if this in on nodes.
3657  *  \return int - the dimension of \a this.
3658  */
3659 int MEDFileAnyTypeField1TSWithoutSDA::getDimension() const
3660 {
3661   int ret=-2;
3662   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3663     (*it)->getDimension(ret);
3664   return ret;
3665 }
3666
3667 /*!
3668  * Returns the mesh name.
3669  *  \return std::string - a string holding the mesh name.
3670  *  \throw If \c _field_per_mesh.empty()
3671  */
3672 std::string MEDFileAnyTypeField1TSWithoutSDA::getMeshName() const throw(INTERP_KERNEL::Exception)
3673 {
3674   if(_field_per_mesh.empty())
3675     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshName : No field set !");
3676   return _field_per_mesh[0]->getMeshName();
3677 }
3678
3679 void MEDFileAnyTypeField1TSWithoutSDA::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
3680 {
3681   std::string oldName(getMeshName());
3682   std::vector< std::pair<std::string,std::string> > v(1);
3683   v[0].first=oldName; v[0].second=newMeshName;
3684   changeMeshNames(v);
3685 }
3686
3687 bool MEDFileAnyTypeField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
3688 {
3689   bool ret=false;
3690   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3691     {
3692       MEDFileFieldPerMesh *cur(*it);
3693       if(cur)
3694         ret=cur->changeMeshNames(modifTab) || ret;
3695     }
3696   return ret;
3697 }
3698
3699 /*!
3700  * Returns the number of iteration of the state of underlying mesh.
3701  *  \return int - the iteration number.
3702  *  \throw If \c _field_per_mesh.empty()
3703  */
3704 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIteration() const throw(INTERP_KERNEL::Exception)
3705 {
3706   if(_field_per_mesh.empty())
3707     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshIteration : No field set !");
3708   return _field_per_mesh[0]->getMeshIteration();
3709 }
3710
3711 /*!
3712  * Returns the order number of iteration of the state of underlying mesh.
3713  *  \return int - the order number.
3714  *  \throw If \c _field_per_mesh.empty()
3715  */
3716 int MEDFileAnyTypeField1TSWithoutSDA::getMeshOrder() const throw(INTERP_KERNEL::Exception)
3717 {
3718   if(_field_per_mesh.empty())
3719     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshOrder : No field set !");
3720   return _field_per_mesh[0]->getMeshOrder();
3721 }
3722
3723 /*!
3724  * Checks if \a this field is tagged by a given iteration number and a given
3725  * iteration order number.
3726  *  \param [in] iteration - the iteration number of interest.
3727  *  \param [in] order - the iteration order number of interest.
3728  *  \return bool - \c true if \a this->getIteration() == \a iteration &&
3729  *          \a this->getOrder() == \a order.
3730  */
3731 bool MEDFileAnyTypeField1TSWithoutSDA::isDealingTS(int iteration, int order) const
3732 {
3733   return iteration==_iteration && order==_order;
3734 }
3735
3736 /*!
3737  * Returns number of iteration and order number of iteration when
3738  * \a this field has been calculated.
3739  *  \return std::pair<int,int> - a pair of the iteration number and the iteration
3740  *          order number.
3741  */
3742 std::pair<int,int> MEDFileAnyTypeField1TSWithoutSDA::getDtIt() const
3743 {
3744   std::pair<int,int> p;
3745   fillIteration(p);
3746   return p;
3747 }
3748
3749 /*!
3750  * Returns number of iteration and order number of iteration when
3751  * \a this field has been calculated.
3752  *  \param [in,out] p - a pair returning the iteration number and the iteration
3753  *          order number.
3754  */
3755 void MEDFileAnyTypeField1TSWithoutSDA::fillIteration(std::pair<int,int>& p) const
3756 {
3757   p.first=_iteration;
3758   p.second=_order;
3759 }
3760
3761 /*!
3762  * Returns all types of spatial discretization of \a this field.
3763  *  \param [in,out] types - a sequence of types of \a this field.
3764  */
3765 void MEDFileAnyTypeField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
3766 {
3767   std::set<TypeOfField> types2;
3768   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3769     {
3770       (*it)->fillTypesOfFieldAvailable(types2);
3771     }
3772   std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
3773   std::copy(types2.begin(),types2.end(),bi);
3774 }
3775
3776 /*!
3777  * Returns all types of spatial discretization of \a this field.
3778  *  \return std::vector<TypeOfField> - a sequence of types of spatial discretization
3779  *          of \a this field.
3780  */
3781 std::vector<TypeOfField> MEDFileAnyTypeField1TSWithoutSDA::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
3782 {
3783   std::vector<TypeOfField> ret;
3784   fillTypesOfFieldAvailable(ret);
3785   return ret;
3786 }
3787
3788 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsed2() const
3789 {
3790   std::vector<std::string> ret;
3791   std::set<std::string> ret2;
3792   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3793     {
3794       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
3795       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3796         if(ret2.find(*it2)==ret2.end())
3797           {
3798             ret.push_back(*it2);
3799             ret2.insert(*it2);
3800           }
3801     }
3802   return ret;
3803 }
3804
3805 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsed2() const
3806 {
3807   std::vector<std::string> ret;
3808   std::set<std::string> ret2;
3809   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3810     {
3811       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
3812       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3813         if(ret2.find(*it2)==ret2.end())
3814           {
3815             ret.push_back(*it2);
3816             ret2.insert(*it2);
3817           }
3818     }
3819   return ret;
3820 }
3821
3822 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsedMulti2() const
3823 {
3824   std::vector<std::string> ret;
3825   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3826     {
3827       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
3828       ret.insert(ret.end(),tmp.begin(),tmp.end());
3829     }
3830   return ret;
3831 }
3832
3833 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsedMulti2() const
3834 {
3835   std::vector<std::string> ret;
3836   std::set<std::string> ret2;
3837   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3838     {
3839       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
3840       ret.insert(ret.end(),tmp.begin(),tmp.end());
3841     }
3842   return ret;
3843 }
3844
3845 void MEDFileAnyTypeField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3846 {
3847   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3848     (*it)->changePflsRefsNamesGen(mapOfModif);
3849 }
3850
3851 void MEDFileAnyTypeField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3852 {
3853   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3854     (*it)->changeLocsRefsNamesGen(mapOfModif);
3855 }
3856
3857 /*!
3858  * Returns all attributes of parts of \a this field lying on a given mesh.
3859  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
3860  * item of every of returned sequences refers to the _i_-th part of \a this field.
3861  * Thus all sequences returned by this method are of the same length equal to number
3862  * of different types of supporting entities.<br>
3863  * A field part can include sub-parts with several different spatial discretizations,
3864  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
3865  * for example. Hence, some of the returned sequences contains nested sequences, and an item
3866  * of a nested sequence corresponds to a type of spatial discretization.<br>
3867  * This method allows for iteration over MEDFile DataStructure without any overhead.
3868  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3869  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3870  *          not checked if \a mname == \c NULL).
3871  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
3872  *          a field part is returned.
3873  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
3874  *          This sequence is of the same length as \a types.
3875  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
3876  *          discretization. A profile name can be empty.
3877  *          Length of this and of nested sequences is the same as that of \a typesF.
3878  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
3879  *          discretization. A localization name can be empty.
3880  *          Length of this and of nested sequences is the same as that of \a typesF.
3881  *  \return std::vector< std::vector< std::pair<int,int> > > - a sequence holding a range
3882  *          of ids of tuples within the data array, per each type of spatial
3883  *          discretization within one mesh entity type.
3884  *          Length of this and of nested sequences is the same as that of \a typesF.
3885  *  \throw If no field is lying on \a mname.
3886  */
3887 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeField1TSWithoutSDA::getFieldSplitedByType(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
3888 {
3889   int meshId=0;
3890   if(mname)
3891     meshId=getMeshIdFromMeshName(mname);
3892   else
3893     if(_field_per_mesh.empty())
3894       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
3895   return _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3896 }
3897
3898 /*!
3899  * Returns dimensions of mesh elements \a this field lies on. The returned value is a
3900  * maximal absolute dimension and values returned via the out parameter \a levs are
3901  * dimensions relative to the maximal absolute dimension. <br>
3902  * This method is designed for MEDFileField1TS instances that have a discretization
3903  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS",
3904  * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT",
3905  * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE".
3906  * Only these 3 discretizations will be taken into account here. If \a this is
3907  * \ref ParaMEDMEM::ON_NODES "ON_NODES", -1 is returned and \a levs are empty.<br>
3908  * This method is useful to make the link between the dimension of the underlying mesh
3909  * and the levels of \a this, because it is possible that the highest dimension of \a this
3910  * field is not equal to the dimension of the underlying mesh.
3911  *
3912  * Let's consider the following case:
3913  * - mesh \a m1 has a meshDimension 3 and has non empty levels [0,-1,-2] with elements
3914  * TETRA4, HEXA8, TRI3 and SEG2.
3915  * - field \a f1 lies on \a m1 and is defined on 3D and 1D elements TETRA4 and SEG2.
3916  * - field \a f2 lies on \a m1 and is defined on 2D and 1D elements TRI3 and SEG2.
3917  *
3918  * In this case \a f1->getNonEmptyLevels() returns (3,[0,-2]) and \a
3919  * f2->getNonEmptyLevels() returns (2,[0,-1]). <br>
3920  * The returned values can be used for example to retrieve a MEDCouplingFieldDouble lying
3921  * on elements of a certain relative level by calling getFieldAtLevel(). \a meshDimRelToMax
3922  * parameter of getFieldAtLevel() is computed basing on the returned values as this:
3923  * <em> meshDimRelToMax = absDim - meshDim + relativeLev </em>.
3924  * For example<br>
3925  * to retrieve the highest level of
3926  * \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+0 ); // absDim - meshDim + relativeLev</em><br>
3927  * to retrieve the lowest level of \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+(-2) );</em><br>
3928  * to retrieve the highest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+0 );</em><br>
3929  * to retrieve the lowest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+(-1) )</em>.
3930  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3931  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3932  *          not checked if \a mname == \c NULL).
3933  *  \param [in,out] levs - a sequence returning the dimensions relative to the maximal
3934  *          absolute one. They are in decreasing order. This sequence is cleared before
3935  *          filling it in.
3936  *  \return int - the maximal absolute dimension of elements \a this fields lies on.
3937  *  \throw If no field is lying on \a mname.
3938  */
3939 int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
3940 {
3941   levs.clear();
3942   int meshId=getMeshIdFromMeshName(mname);
3943   std::vector<INTERP_KERNEL::NormalizedCellType> types;
3944   std::vector< std::vector<TypeOfField> > typesF;
3945   std::vector< std::vector<std::string> > pfls, locs;
3946   _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3947   if(types.empty())
3948     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getNonEmptyLevels : 'this' is empty !");
3949   std::set<INTERP_KERNEL::NormalizedCellType> st(types.begin(),types.end());
3950   if(st.size()==1 && (*st.begin())==INTERP_KERNEL::NORM_ERROR)
3951     return -1;
3952   st.erase(INTERP_KERNEL::NORM_ERROR);
3953   std::set<int> ret1;
3954   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
3955     {
3956       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
3957       ret1.insert((int)cm.getDimension());
3958     }
3959   int ret=*std::max_element(ret1.begin(),ret1.end());
3960   std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
3961   std::transform(levs.begin(),levs.end(),levs.begin(),std::bind2nd(std::plus<int>(),-ret));
3962   return ret;
3963 }
3964
3965 /*!
3966  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
3967  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
3968  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
3969  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
3970  */
3971 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
3972 {
3973   int mid=getMeshIdFromMeshName(mName);
3974   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
3975 }
3976
3977 /*!
3978  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
3979  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
3980  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
3981  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
3982  */
3983 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
3984 {
3985   int mid=getMeshIdFromMeshName(mName);
3986   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
3987 }
3988
3989 /*!
3990  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
3991  */
3992 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIdFromMeshName(const char *mName) const throw(INTERP_KERNEL::Exception)
3993 {
3994   if(_field_per_mesh.empty())
3995     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
3996   if(mName==0)
3997     return 0;
3998   std::string mName2(mName);
3999   int ret=0;
4000   std::vector<std::string> msg;
4001   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
4002     if(mName2==(*it)->getMeshName())
4003       return ret;
4004     else
4005       msg.push_back((*it)->getMeshName());
4006   std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
4007   oss << "Possible meshes are : ";
4008   for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
4009     oss << "\"" << (*it2) << "\" ";
4010   throw INTERP_KERNEL::Exception(oss.str().c_str());
4011 }
4012
4013 int MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
4014 {
4015   if(!mesh)
4016     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary : input mesh is NULL !");
4017   std::string tmp(mesh->getName());
4018   if(tmp.empty())
4019     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
4020   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();
4021   int i=0;
4022   for(;it!=_field_per_mesh.end();it++,i++)
4023     {
4024       if((*it)->getMeshName()==tmp)
4025         return i;
4026     }
4027   int sz=_field_per_mesh.size();
4028   _field_per_mesh.resize(sz+1);
4029   _field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
4030   return sz;
4031 }
4032
4033 bool MEDFileAnyTypeField1TSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
4034                                                             MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
4035 {
4036   bool ret=false;
4037   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4038     {
4039       MEDFileFieldPerMesh *fpm(*it);
4040       if(fpm)
4041         ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
4042     }
4043   return ret;
4044 }
4045
4046 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
4047 {
4048   std::vector<INTERP_KERNEL::NormalizedCellType> types;
4049   std::vector< std::vector<TypeOfField> > typesF;
4050   std::vector< std::vector<std::string> > pfls,locs;
4051   std::vector< std::vector<std::pair<int,int> > > bgEnd=getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs);
4052   std::set<TypeOfField> allEnt;
4053   for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++)
4054     for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4055       allEnt.insert(*it2);
4056   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(allEnt.size());
4057   std::set<TypeOfField>::const_iterator it3(allEnt.begin());
4058   for(std::size_t i=0;i<allEnt.size();i++,it3++)
4059     {
4060       std::vector< std::pair<int,int> > its;
4061       ret[i]=shallowCpy();
4062       int newLgth=ret[i]->keepOnlySpatialDiscretization(*it3,its);
4063       ret[i]->updateData(newLgth,its);
4064     }
4065   return ret;
4066 }
4067
4068 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlySpatialDiscretization(TypeOfField tof, std::vector< std::pair<int,int> >& its) throw(INTERP_KERNEL::Exception)
4069 {
4070   int globalCounter=0;
4071   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4072     (*it)->keepOnlySpatialDiscretization(tof,globalCounter,its);
4073   return globalCounter;
4074 }
4075
4076 void MEDFileAnyTypeField1TSWithoutSDA::updateData(int newLgth, const std::vector< std::pair<int,int> >& oldStartStops) throw(INTERP_KERNEL::Exception)
4077 {
4078   if(_nb_of_tuples_to_be_allocated>=0)
4079     {
4080       _nb_of_tuples_to_be_allocated=newLgth;
4081       return ;
4082     }
4083   if(_nb_of_tuples_to_be_allocated==-1)
4084     return ;
4085   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4086     {
4087       const DataArray *oldArr=getUndergroundDataArray();
4088       if(!oldArr || !oldArr->isAllocated())
4089         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 1 !");
4090       MEDCouplingAutoRefCountObjectPtr<DataArray> newArr=createNewEmptyDataArrayInstance();
4091       newArr->alloc(newLgth,getNumberOfComponents());
4092       int pos=0;
4093       for(std::vector< std::pair<int,int> >::const_iterator it=oldStartStops.begin();it!=oldStartStops.end();it++)
4094         {
4095           if((*it).second<(*it).first)
4096             throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : the range in the leaves was invalid !");
4097           newArr->setContigPartOfSelectedValues2(pos,oldArr,(*it).first,(*it).second,1);
4098           pos+=(*it).second-(*it).first;
4099         }
4100       setArray(newArr);
4101       return ;
4102     }
4103   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 2 !");
4104 }
4105
4106 void MEDFileAnyTypeField1TSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4107 {
4108   if(_field_per_mesh.empty())
4109     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : empty field !");
4110   if(_field_per_mesh.size()>1)
4111     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : In MED3.0 mode in writting mode only ONE underlying mesh supported !");
4112   _field_per_mesh[0]->copyOptionsFrom(opts);
4113   _field_per_mesh[0]->writeLL(fid,nasc);
4114 }
4115
4116 /*!
4117  * This methods returns true is the allocation has been needed leading to a modification of state in \a this->_nb_of_tuples_to_be_allocated.
4118  * If false is returned the memory allocation is not required.
4119  */
4120 bool MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile() throw(INTERP_KERNEL::Exception)
4121 {
4122   if(_nb_of_tuples_to_be_allocated>=0)
4123     {
4124       getOrCreateAndGetArray()->alloc(_nb_of_tuples_to_be_allocated,getNumberOfComponents());
4125       _nb_of_tuples_to_be_allocated=-2;
4126       return true;
4127     }
4128   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4129     return false;
4130   if(_nb_of_tuples_to_be_allocated==-1)
4131     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : trying to read from a file an empty instance ! Need to prepare the structure before !");
4132   if(_nb_of_tuples_to_be_allocated<-3)
4133     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4134
4135 }
4136
4137 void MEDFileAnyTypeField1TSWithoutSDA::loadOnlyStructureOfDataRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4138 {
4139   med_int numdt,numit;
4140   med_float dt;
4141   med_int nmesh;
4142   med_bool localMesh;
4143   med_int meshnumdt,meshnumit;
4144   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
4145   MEDfieldComputingStepInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&_dt);
4146   MEDfield23ComputingStepMeshInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&dt,&nmesh,meshName,&localMesh,&meshnumdt,&meshnumit);
4147   if(_iteration!=numdt || _order!=numit)
4148     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively : unexpected exception internal error !");
4149   _field_per_mesh.resize(nmesh);
4150   for(int i=0;i<nmesh;i++)
4151     _field_per_mesh[i]=MEDFileFieldPerMesh::NewOnRead(fid,this,i+1,meshnumdt,meshnumit,nasc);//tony
4152   _nb_of_tuples_to_be_allocated=0;
4153   for(int i=0;i<nmesh;i++)
4154     _field_per_mesh[i]->loadOnlyStructureOfDataRecursively(fid,_nb_of_tuples_to_be_allocated,nasc);
4155 }
4156
4157 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4158 {
4159   allocIfNecessaryTheArrayToReceiveDataFromFile();
4160   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4161     (*it)->loadBigArraysRecursively(fid,nasc);
4162 }
4163
4164 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4165 {
4166   if(allocIfNecessaryTheArrayToReceiveDataFromFile())
4167     for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4168       (*it)->loadBigArraysRecursively(fid,nasc);
4169 }
4170
4171 void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4172 {
4173   loadOnlyStructureOfDataRecursively(fid,nasc);
4174   loadBigArraysRecursively(fid,nasc);
4175 }
4176
4177 void MEDFileAnyTypeField1TSWithoutSDA::releaseArrays() throw(INTERP_KERNEL::Exception)
4178 {
4179   DataArray *thisArr(getUndergroundDataArray());
4180   if(thisArr && thisArr->isAllocated())
4181     {
4182       _nb_of_tuples_to_be_allocated=thisArr->getNumberOfTuples();
4183       thisArr->desallocate();
4184     }
4185 }
4186
4187 std::size_t MEDFileAnyTypeField1TSWithoutSDA::getHeapMemorySize() const
4188 {
4189   std::size_t ret=_dt_unit.capacity()+_field_per_mesh.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh >);
4190   if(getUndergroundDataArray())
4191     ret+=getUndergroundDataArray()->getHeapMemorySize();
4192   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4193     ret+=(*it)->getHeapMemorySize();
4194   return ret;
4195 }
4196
4197 /*!
4198  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
4199  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
4200  * "Sort By Type"), if not, an exception is thrown.
4201  *  \param [in] field - the field to add to \a this. The array of field \a field is ignored
4202  *  \param [in] arr - the array of values.
4203  *  \param [in,out] glob - the global data where profiles and localization present in
4204  *          \a field, if any, are added.
4205  *  \throw If the name of \a field is empty.
4206  *  \throw If the data array of \a field is not set.
4207  *  \throw If \a this->_arr is already allocated but has different number of components
4208  *         than \a field.
4209  *  \throw If the underlying mesh of \a field has no name.
4210  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
4211  */
4212 void MEDFileAnyTypeField1TSWithoutSDA::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4213 {
4214   const MEDCouplingMesh *mesh=field->getMesh();
4215   //
4216   TypeOfField type=field->getTypeOfField();
4217   std::vector<DataArrayInt *> dummy;
4218   int start=copyTinyInfoFrom(field,arr);
4219   int pos=addNewEntryIfNecessary(mesh);
4220   if(type!=ON_NODES)
4221     {
4222       std::vector<int> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
4223       _field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,arr,glob,nasc);
4224     }
4225   else
4226     _field_per_mesh[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
4227 }
4228
4229 /*!
4230  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
4231  * of a given mesh are used as the support of the given field (a real support is not used).
4232  * Elements of the given mesh must be sorted suitable for writing to MED file.
4233  * Order of underlying mesh entities of the given field specified by \a profile parameter
4234  * is not prescribed; this method permutes field values to have them sorted by element
4235  * type as required for writing to MED file. A new profile is added only if no equal
4236  * profile is missing.
4237  *  \param [in] field - the field to add to \a this. The field double values are ignored.
4238  *  \param [in] arrOfVals - the values of the field \a field used.
4239  *  \param [in] mesh - the supporting mesh of \a field.
4240  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
4241  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
4242  *  \param [in,out] glob - the global data where profiles and localization present in
4243  *          \a field, if any, are added.
4244  *  \throw If either \a field or \a mesh or \a profile has an empty name.
4245  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4246  *  \throw If the data array of \a field is not set.
4247  *  \throw If \a this->_arr is already allocated but has different number of components
4248  *         than \a field.
4249  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4250  *  \sa setFieldNoProfileSBT()
4251  */
4252 void MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4253 {
4254   TypeOfField type=field->getTypeOfField();
4255   int start=copyTinyInfoFrom(field,arrOfVals);
4256   std::vector<DataArrayInt *> idsInPflPerType;
4257   std::vector<DataArrayInt *> idsPerType;
4258   std::vector<int> code,code2;
4259   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4260   if(type!=ON_NODES)
4261     {
4262       m->splitProfilePerType(profile,code,idsInPflPerType,idsPerType);
4263       code2=m->getDistributionOfTypes();
4264       //
4265       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsInPflPerType2(idsInPflPerType.size());
4266       for(std::size_t i=0;i<idsInPflPerType.size();i++)
4267         idsInPflPerType2[i]=idsInPflPerType[i];
4268       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsPerType2(idsPerType.size());
4269       for(std::size_t i=0;i<idsPerType.size();i++)
4270         idsPerType2[i]=idsPerType[i];
4271       //
4272       int pos=addNewEntryIfNecessary(m);
4273       _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
4274     }
4275   else
4276     {
4277       int pos=addNewEntryIfNecessary(m);
4278       _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
4279     }
4280 }
4281
4282 /*!
4283  * \param [in] newNbOfTuples - The new nb of tuples to be allocated.
4284  */
4285 void MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile(int newNbOfTuples) throw(INTERP_KERNEL::Exception)
4286 {
4287   if(_nb_of_tuples_to_be_allocated>=0)
4288     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile : the object is expected to be appended to a data coming from a file but not loaded ! Load before appending data !");
4289   DataArray *arr(getOrCreateAndGetArray());
4290   arr->alloc(newNbOfTuples,arr->getNumberOfComponents());
4291   _nb_of_tuples_to_be_allocated=-3;
4292 }
4293
4294 /*!
4295  * Copies tiny info and allocates \a this->_arr instance of DataArrayDouble to
4296  * append data of a given MEDCouplingFieldDouble. So that the size of \a this->_arr becomes
4297  * larger by the size of \a field. Returns an id of the first not filled
4298  * tuple of \a this->_arr.
4299  *  \param [in] field - the field to copy the info on components and the name from.
4300  *  \return int - the id of first not initialized tuple of \a this->_arr.
4301  *  \throw If the name of \a field is empty.
4302  *  \throw If the data array of \a field is not set.
4303  *  \throw If \a this->_arr is already allocated but has different number of components
4304  *         than \a field.
4305  */
4306 int MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr) throw(INTERP_KERNEL::Exception)
4307 {
4308   if(!field)
4309     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
4310   std::string name(field->getName());
4311   setName(name.c_str());
4312   setDtUnit(field->getTimeUnit());
4313   if(name.empty())
4314     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
4315   if(!arr)
4316     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
4317   if(!arr->isAllocated())
4318     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : array is not allocated !");
4319   _dt=field->getTime(_iteration,_order);
4320   int nbOfComponents=arr->getNumberOfComponents();
4321   getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
4322   if(!getOrCreateAndGetArray()->isAllocated())
4323     {
4324       allocNotFromFile(arr->getNumberOfTuples());
4325       return 0;
4326     }
4327   else
4328     {
4329       int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
4330       int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
4331       getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
4332       _nb_of_tuples_to_be_allocated=-3;
4333       return oldNbOfTuples;
4334     }
4335 }
4336
4337 /*!
4338  * Returns number of components in \a this field
4339  *  \return int - the number of components.
4340  */
4341 int MEDFileAnyTypeField1TSWithoutSDA::getNumberOfComponents() const
4342 {
4343   return getOrCreateAndGetArray()->getNumberOfComponents();
4344 }
4345
4346 /*!
4347  * Change info on components in \a this.
4348  * \throw If size of \a infos is not equal to the number of components already in \a this.
4349  */
4350 void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos) throw(INTERP_KERNEL::Exception)
4351 {
4352   DataArray *arr=getOrCreateAndGetArray();
4353   arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
4354 }
4355
4356 /*!
4357  * Returns info on components of \a this field.
4358  *  \return const std::vector<std::string>& - a sequence of strings each being an
4359  *          information on _i_-th component.
4360  */
4361 const std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo() const
4362 {
4363   const DataArray *arr=getOrCreateAndGetArray();
4364   return arr->getInfoOnComponents();
4365 }
4366
4367 /*!
4368  * Returns a mutable info on components of \a this field.
4369  *  \return std::vector<std::string>& - a sequence of strings each being an
4370  *          information on _i_-th component.
4371  */
4372 std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo()
4373 {
4374   DataArray *arr=getOrCreateAndGetArray();
4375   return arr->getInfoOnComponents();
4376 }
4377
4378 /*!
4379  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4380  *  \param [in] type - a spatial discretization of the new field.
4381  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4382  *  \param [in] mName - a name of the supporting mesh.
4383  *  \param [in] renumPol - specifies how to permute values of the result field according to
4384  *          the optional numbers of cells and nodes, if any. The valid values are
4385  *          - 0 - do not permute.
4386  *          - 1 - permute cells.
4387  *          - 2 - permute nodes.
4388  *          - 3 - permute cells and nodes.
4389  *
4390  *  \param [in] glob - the global data storing profiles and localization.
4391  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4392  *          caller is to delete this field using decrRef() as it is no more needed.
4393  *  \throw If the MED file is not readable.
4394  *  \throw If there is no mesh named \a mName in the MED file.
4395  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4396  *  \throw If no field of \a this is lying on the mesh \a mName.
4397  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4398  */
4399 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4400 {
4401   MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4402   if(mName==0)
4403     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4404   else
4405     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4406   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4407 }
4408
4409 /*!
4410  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4411  *  \param [in] type - a spatial discretization of the new field.
4412  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4413  *  \param [in] renumPol - specifies how to permute values of the result field according to
4414  *          the optional numbers of cells and nodes, if any. The valid values are
4415  *          - 0 - do not permute.
4416  *          - 1 - permute cells.
4417  *          - 2 - permute nodes.
4418  *          - 3 - permute cells and nodes.
4419  *
4420  *  \param [in] glob - the global data storing profiles and localization.
4421  *  \param [in] mesh - the supporting mesh.
4422  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4423  *          caller is to delete this field using decrRef() as it is no more needed.
4424  *  \throw If the MED file is not readable.
4425  *  \throw If no field of \a this is lying on \a mesh.
4426  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4427  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4428  */
4429 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4430 {
4431   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax,false);
4432   const DataArrayInt *d=mesh->getNumberFieldAtLevel(meshDimRelToMax);
4433   const DataArrayInt *e=mesh->getNumberFieldAtLevel(1);
4434   if(meshDimRelToMax==1)
4435     (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
4436   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e,arrOut,nasc);
4437 }
4438
4439 /*!
4440  * Returns a new MEDCouplingFieldDouble of a given type lying on the top level cells of a
4441  * given mesh.
4442  *  \param [in] type - a spatial discretization of the new field.
4443  *  \param [in] mName - a name of the supporting mesh.
4444  *  \param [in] renumPol - specifies how to permute values of the result field according to
4445  *          the optional numbers of cells and nodes, if any. The valid values are
4446  *          - 0 - do not permute.
4447  *          - 1 - permute cells.
4448  *          - 2 - permute nodes.
4449  *          - 3 - permute cells and nodes.
4450  *
4451  *  \param [in] glob - the global data storing profiles and localization.
4452  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4453  *          caller is to delete this field using decrRef() as it is no more needed.
4454  *  \throw If the MED file is not readable.
4455  *  \throw If there is no mesh named \a mName in the MED file.
4456  *  \throw If there are no mesh entities in the mesh.
4457  *  \throw If no field values of the given \a type are available.
4458  */
4459 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4460 {
4461    MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4462   if(mName==0)
4463     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4464   else
4465     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4466   int absDim=getDimension();
4467   int meshDimRelToMax=absDim-mm->getMeshDimension();
4468   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4469 }
4470
4471 /*!
4472  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4473  *  \param [in] type - a spatial discretization of the new field.
4474  *  \param [in] renumPol - specifies how to permute values of the result field according to
4475  *          the optional numbers of cells and nodes, if any. The valid values are
4476  *          - 0 - do not permute.
4477  *          - 1 - permute cells.
4478  *          - 2 - permute nodes.
4479  *          - 3 - permute cells and nodes.
4480  *
4481  *  \param [in] glob - the global data storing profiles and localization.
4482  *  \param [in] mesh - the supporting mesh.
4483  *  \param [in] cellRenum - the cell numbers array used for permutation of the result
4484  *         field according to \a renumPol.
4485  *  \param [in] nodeRenum - the node numbers array used for permutation of the result
4486  *         field according to \a renumPol.
4487  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4488  *          caller is to delete this field using decrRef() as it is no more needed.
4489  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4490  *  \throw If no field of \a this is lying on \a mesh.
4491  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4492  */
4493 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, const DataArrayInt *cellRenum, const DataArrayInt *nodeRenum, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4494 {
4495   static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
4496   int meshId=getMeshIdFromMeshName(mesh->getName());
4497   bool isPfl=false;
4498   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl,arrOut,nasc);
4499   switch(renumPol)
4500     {
4501     case 0:
4502       {
4503         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4504         return ret.retn();
4505       }
4506     case 3:
4507     case 1:
4508       {
4509         if(isPfl)
4510           throw INTERP_KERNEL::Exception(msg1);
4511         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4512         if(cellRenum)
4513           {
4514             if((int)cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
4515               {
4516                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4517                 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
4518                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4519               }
4520             MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
4521             if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
4522             std::vector<DataArray *> arrOut2(1,arrOut);
4523             // 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
4524             disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
4525             (const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
4526           }
4527         if(renumPol==1)
4528           return ret.retn();
4529       }
4530     case 2:
4531       {
4532         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4533         if(isPfl)
4534           throw INTERP_KERNEL::Exception(msg1);
4535         if(nodeRenum)
4536           {
4537             if((int)nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
4538               {
4539                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4540                 oss << "\"" << nasc.getName() << "\" not defined on all nodes !";
4541                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4542               }
4543             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
4544             if(!dynamic_cast<DataArrayDouble *>((DataArray *)arrOut))
4545               throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : node renumbering not implemented for not double DataArrays !");
4546             ret->renumberNodes(nodeRenumSafe->getConstPointer());
4547           }
4548         return ret.retn();
4549       }
4550     default:
4551       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
4552     }
4553 }
4554
4555 /*!
4556  * Returns values and a profile of the field of a given type lying on a given support.
4557  *  \param [in] type - a spatial discretization of the field.
4558  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4559  *  \param [in] mesh - the supporting mesh.
4560  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
4561  *          field of interest lies on. If the field lies on all entities of the given
4562  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
4563  *          using decrRef() as it is no more needed.
4564  *  \param [in] glob - the global data storing profiles and localization.
4565  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
4566  *          field. The caller is to delete this array using decrRef() as it is no more needed.
4567  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4568  *  \throw If no field of \a this is lying on \a mesh.
4569  *  \throw If no field values of the given \a type are available.
4570  */
4571 DataArray *MEDFileAnyTypeField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4572 {
4573   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4574   int meshId=getMeshIdFromMeshName(mesh->getName());
4575   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob,nasc);
4576   ret->setName(nasc.getName().c_str());
4577   return ret.retn();
4578 }
4579
4580 //= MEDFileField1TSWithoutSDA
4581
4582 /*!
4583  * Throws if a given value is not a valid (non-extended) relative dimension.
4584  *  \param [in] meshDimRelToMax - the relative dimension value.
4585  *  \throw If \a meshDimRelToMax > 0.
4586  */
4587 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax) throw(INTERP_KERNEL::Exception)
4588 {
4589   if(meshDimRelToMax>0)
4590     throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
4591 }
4592
4593 /*!
4594  * Checks if elements of a given mesh are in the order suitable for writing
4595  * to the MED file. If this is not so, an exception is thrown. In a case of success, returns a
4596  * vector describing types of elements and their number.
4597  *  \param [in] mesh - the mesh to check.
4598  *  \return std::vector<int> - a vector holding for each element type (1) item of
4599  *          INTERP_KERNEL::NormalizedCellType, (2) number of elements, (3) -1.
4600  *          These values are in full-interlace mode.
4601  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4602  */
4603 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
4604 {
4605   if(!mesh)
4606     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
4607   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
4608   int nbOfTypes=geoTypes.size();
4609   std::vector<int> code(3*nbOfTypes);
4610   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr1=DataArrayInt::New();
4611   arr1->alloc(nbOfTypes,1);
4612   int *arrPtr=arr1->getPointer();
4613   std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
4614   for(int i=0;i<nbOfTypes;i++,it++)
4615     arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
4616   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
4617   const int *arrPtr2=arr2->getConstPointer();
4618   int i=0;
4619   for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
4620     {
4621       int pos=arrPtr2[i];
4622       int nbCells=mesh->getNumberOfCellsWithType(*it);
4623       code[3*pos]=(int)(*it);
4624       code[3*pos+1]=nbCells;
4625       code[3*pos+2]=-1;//no profiles
4626     }
4627   std::vector<const DataArrayInt *> idsPerType;//no profiles
4628   DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
4629   if(da)
4630     {
4631       da->decrRef();
4632       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
4633     }
4634   return code;
4635 }
4636
4637 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos)
4638 {
4639   return new MEDFileField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4640 }
4641
4642 /*!
4643  * Returns all attributes and values of parts of \a this field lying on a given mesh.
4644  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
4645  * item of every of returned sequences refers to the _i_-th part of \a this field.
4646  * Thus all sequences returned by this method are of the same length equal to number
4647  * of different types of supporting entities.<br>
4648  * A field part can include sub-parts with several different spatial discretizations,
4649  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
4650  * for example. Hence, some of the returned sequences contains nested sequences, and an item
4651  * of a nested sequence corresponds to a type of spatial discretization.<br>
4652  * This method allows for iteration over MEDFile DataStructure with a reduced overhead.
4653  * The overhead is due to selecting values into new instances of DataArrayDouble.
4654  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4655  *          for the case with only one underlying mesh. (Actually, the number of meshes is
4656  *          not checked if \a mname == \c NULL).
4657  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
4658  *          a field part is returned.
4659  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
4660  *          A field part can include sub-parts with several different spatial discretizations,
4661  *          \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and
4662  *          \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT" for example.
4663  *          This sequence is of the same length as \a types.
4664  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
4665  *          discretization. A profile name can be empty.
4666  *          Length of this and of nested sequences is the same as that of \a typesF.
4667  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
4668  *          discretization. A localization name can be empty.
4669  *          Length of this and of nested sequences is the same as that of \a typesF.
4670  *  \return std::vector< std::vector<DataArrayDouble *> > - a sequence holding arrays of values
4671  *          per each type of spatial discretization within one mesh entity type.
4672  *          The caller is to delete each DataArrayDouble using decrRef() as it is no more needed.
4673  *          Length of this and of nested sequences is the same as that of \a typesF.
4674  *  \throw If no field is lying on \a mname.
4675  */
4676 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TSWithoutSDA::getFieldSplitedByType2(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
4677 {
4678   int meshId=0;
4679   if(mname)
4680     meshId=getMeshIdFromMeshName(mname);
4681   else
4682     if(_field_per_mesh.empty())
4683       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
4684   std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
4685   int nbOfRet=ret0.size();
4686   std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
4687   for(int i=0;i<nbOfRet;i++)
4688     {
4689       const std::vector< std::pair<int,int> >& p=ret0[i];
4690       int nbOfRet1=p.size();
4691       ret[i].resize(nbOfRet1);
4692       for(int j=0;j<nbOfRet1;j++)
4693         {
4694           DataArrayDouble *tmp=_arr->selectByTupleId2(p[j].first,p[j].second,1);
4695           ret[i][j]=tmp;
4696         }
4697     }
4698   return ret;
4699 }
4700
4701 /*!
4702  * Returns a pointer to the underground DataArrayDouble instance. So the
4703  * caller should not decrRef() it. This method allows for a direct access to the field
4704  * values. This method is quite unusable if there is more than a nodal field or a cell
4705  * field on single geometric cell type.
4706  *  \return DataArrayDouble * - the pointer to the field values array.
4707  */
4708 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDouble() const throw(INTERP_KERNEL::Exception)
4709 {
4710   const DataArrayDouble *ret=_arr;
4711   if(ret)
4712     return const_cast<DataArrayDouble *>(ret);
4713   else
4714     return 0;
4715 }
4716
4717 const char *MEDFileField1TSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
4718 {
4719   return TYPE_STR;
4720 }
4721
4722 MEDFileIntField1TSWithoutSDA *MEDFileField1TSWithoutSDA::convertToInt() const throw(INTERP_KERNEL::Exception)
4723 {
4724   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA);
4725   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4726   ret->deepCpyLeavesFrom(*this);
4727   const DataArrayDouble *arr(_arr);
4728   if(arr)
4729     {
4730       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr->convertToIntArr());
4731       ret->setArray(arr2);
4732     }
4733   return ret.retn();
4734 }
4735
4736 /*!
4737  * Returns a pointer to the underground DataArrayDouble instance. So the
4738  * caller should not decrRef() it. This method allows for a direct access to the field
4739  * values. This method is quite unusable if there is more than a nodal field or a cell
4740  * field on single geometric cell type.
4741  *  \return DataArrayDouble * - the pointer to the field values array.
4742  */
4743 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
4744 {
4745   return getUndergroundDataArrayDouble();
4746 }
4747
4748 /*!
4749  * Returns a pointer to the underground DataArrayDouble instance and a
4750  * sequence describing parameters of a support of each part of \a this field. The
4751  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4752  * direct access to the field values. This method is intended for the field lying on one
4753  * mesh only.
4754  *  \param [in,out] entries - the sequence describing parameters of a support of each
4755  *         part of \a this field. Each item of this sequence consists of two parts. The
4756  *         first part describes a type of mesh entity and an id of discretization of a
4757  *         current field part. The second part describes a range of values [begin,end)
4758  *         within the returned array relating to the current field part.
4759  *  \return DataArrayDouble * - the pointer to the field values array.
4760  *  \throw If the number of underlying meshes is not equal to 1.
4761  *  \throw If no field values are available.
4762  *  \sa getUndergroundDataArray()
4763  */
4764 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDoubleExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4765 {
4766   if(_field_per_mesh.size()!=1)
4767     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
4768   if(_field_per_mesh[0]==0)
4769     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
4770   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
4771   return getUndergroundDataArrayDouble();
4772 }
4773
4774 /*!
4775  * Returns a pointer to the underground DataArrayDouble instance and a
4776  * sequence describing parameters of a support of each part of \a this field. The
4777  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4778  * direct access to the field values. This method is intended for the field lying on one
4779  * mesh only.
4780  *  \param [in,out] entries - the sequence describing parameters of a support of each
4781  *         part of \a this field. Each item of this sequence consists of two parts. The
4782  *         first part describes a type of mesh entity and an id of discretization of a
4783  *         current field part. The second part describes a range of values [begin,end)
4784  *         within the returned array relating to the current field part.
4785  *  \return DataArrayDouble * - the pointer to the field values array.
4786  *  \throw If the number of underlying meshes is not equal to 1.
4787  *  \throw If no field values are available.
4788  *  \sa getUndergroundDataArray()
4789  */
4790 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4791 {
4792   return getUndergroundDataArrayDoubleExt(entries);
4793 }
4794
4795 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4796                                                      const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4797 {
4798   DataArrayDouble *arr=getOrCreateAndGetArrayDouble();
4799   arr->setInfoAndChangeNbOfCompo(infos);
4800 }
4801
4802 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4803 {
4804 }
4805
4806 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
4807 {
4808   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA(*this));
4809   ret->deepCpyLeavesFrom(*this);
4810   return ret.retn();
4811 }
4812
4813 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
4814 {
4815   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret=static_cast<MEDFileField1TSWithoutSDA *>(shallowCpy());
4816   if((const DataArrayDouble *)_arr)
4817     ret->_arr=_arr->deepCpy();
4818   return ret.retn();
4819 }
4820
4821 void MEDFileField1TSWithoutSDA::setArray(DataArray *arr) throw(INTERP_KERNEL::Exception)
4822 {
4823   if(!arr)
4824     {
4825       _nb_of_tuples_to_be_allocated=-1;
4826       _arr=0;
4827       return ;
4828     }
4829   DataArrayDouble *arrC=dynamic_cast<DataArrayDouble *>(arr);
4830   if(!arrC)
4831     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayDouble !");
4832   else
4833     _nb_of_tuples_to_be_allocated=-3;
4834   arrC->incrRef();
4835   _arr=arrC;
4836 }
4837
4838 DataArray *MEDFileField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
4839 {
4840   return DataArrayDouble::New();
4841 }
4842
4843 DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble()
4844 {
4845   DataArrayDouble *ret=_arr;
4846   if(ret)
4847     return ret;
4848   _arr=DataArrayDouble::New();
4849   return _arr;
4850 }
4851
4852 DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray()
4853 {
4854   return getOrCreateAndGetArrayDouble();
4855 }
4856
4857 const DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble() const
4858 {
4859   const DataArrayDouble *ret=_arr;
4860   if(ret)
4861     return ret;
4862   DataArrayDouble *ret2=DataArrayDouble::New();
4863   const_cast<MEDFileField1TSWithoutSDA *>(this)->_arr=DataArrayDouble::New();
4864   return ret2;
4865 }
4866
4867 const DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray() const
4868 {
4869   return getOrCreateAndGetArrayDouble();
4870 }
4871
4872 //= MEDFileIntField1TSWithoutSDA
4873
4874 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order,
4875                                                                 const std::vector<std::string>& infos)
4876 {
4877   return new MEDFileIntField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4878 }
4879
4880 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4881 {
4882 }
4883
4884 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4885                                                            const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4886 {
4887   DataArrayInt *arr=getOrCreateAndGetArrayInt();
4888   arr->setInfoAndChangeNbOfCompo(infos);
4889 }
4890
4891 const char *MEDFileIntField1TSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
4892 {
4893   return TYPE_STR;
4894 }
4895
4896 MEDFileField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::convertToDouble() const throw(INTERP_KERNEL::Exception)
4897 {
4898   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
4899   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4900   ret->deepCpyLeavesFrom(*this);
4901   const DataArrayInt *arr(_arr);
4902   if(arr)
4903     {
4904       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2(arr->convertToDblArr());
4905       ret->setArray(arr2);
4906     }
4907   return ret.retn();
4908 }
4909
4910 /*!
4911  * Returns a pointer to the underground DataArrayInt instance. So the
4912  * caller should not decrRef() it. This method allows for a direct access to the field
4913  * values. This method is quite unusable if there is more than a nodal field or a cell
4914  * field on single geometric cell type.
4915  *  \return DataArrayInt * - the pointer to the field values array.
4916  */
4917 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
4918 {
4919   return getUndergroundDataArrayInt();
4920 }
4921
4922 /*!
4923  * Returns a pointer to the underground DataArrayInt instance. So the
4924  * caller should not decrRef() it. This method allows for a direct access to the field
4925  * values. This method is quite unusable if there is more than a nodal field or a cell
4926  * field on single geometric cell type.
4927  *  \return DataArrayInt * - the pointer to the field values array.
4928  */
4929 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayInt() const throw(INTERP_KERNEL::Exception)
4930 {
4931   const DataArrayInt *ret=_arr;
4932   if(ret)
4933     return const_cast<DataArrayInt *>(ret);
4934   else
4935     return 0;
4936 }
4937
4938 /*!
4939  * Returns a pointer to the underground DataArrayInt instance and a
4940  * sequence describing parameters of a support of each part of \a this field. The
4941  * caller should not decrRef() the returned DataArrayInt. This method allows for a
4942  * direct access to the field values. This method is intended for the field lying on one
4943  * mesh only.
4944  *  \param [in,out] entries - the sequence describing parameters of a support of each
4945  *         part of \a this field. Each item of this sequence consists of two parts. The
4946  *         first part describes a type of mesh entity and an id of discretization of a
4947  *         current field part. The second part describes a range of values [begin,end)
4948  *         within the returned array relating to the current field part.
4949  *  \return DataArrayInt * - the pointer to the field values array.
4950  *  \throw If the number of underlying meshes is not equal to 1.
4951  *  \throw If no field values are available.
4952  *  \sa getUndergroundDataArray()
4953  */
4954 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4955 {
4956   return getUndergroundDataArrayIntExt(entries);
4957 }
4958
4959 /*!
4960  * Returns a pointer to the underground DataArrayInt instance and a
4961  * sequence describing parameters of a support of each part of \a this field. The
4962  * caller should not decrRef() the returned DataArrayInt. This method allows for a
4963  * direct access to the field values. This method is intended for the field lying on one
4964  * mesh only.
4965  *  \param [in,out] entries - the sequence describing parameters of a support of each
4966  *         part of \a this field. Each item of this sequence consists of two parts. The
4967  *         first part describes a type of mesh entity and an id of discretization of a
4968  *         current field part. The second part describes a range of values [begin,end)
4969  *         within the returned array relating to the current field part.
4970  *  \return DataArrayInt * - the pointer to the field values array.
4971  *  \throw If the number of underlying meshes is not equal to 1.
4972  *  \throw If no field values are available.
4973  *  \sa getUndergroundDataArray()
4974  */
4975 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4976 {
4977   if(_field_per_mesh.size()!=1)
4978     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
4979   if(_field_per_mesh[0]==0)
4980     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
4981   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
4982   return getUndergroundDataArrayInt();
4983 }
4984
4985 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
4986 {
4987   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA(*this));
4988   ret->deepCpyLeavesFrom(*this);
4989   return ret.retn();
4990 }
4991
4992 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
4993 {
4994   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret=static_cast<MEDFileIntField1TSWithoutSDA *>(shallowCpy());
4995   if((const DataArrayInt *)_arr)
4996     ret->_arr=_arr->deepCpy();
4997   return ret.retn();
4998 }
4999
5000 void MEDFileIntField1TSWithoutSDA::setArray(DataArray *arr) throw(INTERP_KERNEL::Exception)
5001 {
5002   if(!arr)
5003     {
5004       _nb_of_tuples_to_be_allocated=-1;
5005       _arr=0;
5006       return ;
5007     }
5008   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>(arr);
5009   if(!arrC)
5010     throw INTERP_KERNEL::Exception("MEDFileIntField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayInt !");
5011   else
5012     _nb_of_tuples_to_be_allocated=-3;
5013   arrC->incrRef();
5014   _arr=arrC;
5015 }
5016
5017 DataArray *MEDFileIntField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
5018 {
5019   return DataArrayInt::New();
5020 }
5021
5022 DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt()
5023 {
5024   DataArrayInt *ret=_arr;
5025   if(ret)
5026     return ret;
5027   _arr=DataArrayInt::New();
5028   return _arr;
5029 }
5030
5031 DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray()
5032 {
5033   return getOrCreateAndGetArrayInt();
5034 }
5035
5036 const DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt() const
5037 {
5038   const DataArrayInt *ret=_arr;
5039   if(ret)
5040     return ret;
5041   DataArrayInt *ret2=DataArrayInt::New();
5042   const_cast<MEDFileIntField1TSWithoutSDA *>(this)->_arr=DataArrayInt::New();
5043   return ret2;
5044 }
5045
5046 const DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray() const
5047 {
5048   return getOrCreateAndGetArrayInt();
5049 }
5050
5051 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
5052 {
5053 }
5054
5055 //= MEDFileAnyTypeField1TS
5056
5057 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5058 {
5059   med_field_type typcha;
5060   //
5061   std::vector<std::string> infos;
5062   std::string dtunit,fieldName;
5063   LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
5064   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5065   switch(typcha)
5066     {
5067     case MED_FLOAT64:
5068       {
5069         ret=MEDFileField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5070         break;
5071       }
5072     case MED_INT32:
5073       {
5074         ret=MEDFileIntField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5075         break;
5076       }
5077     default:
5078       {
5079         std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fileName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
5080         throw INTERP_KERNEL::Exception(oss.str().c_str());
5081       }
5082     }
5083   ret->setDtUnit(dtunit.c_str());
5084   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5085   //
5086   med_int numdt,numit;
5087   med_float dt;
5088   MEDfieldComputingStepInfo(fid,fieldName.c_str(),1,&numdt,&numit,&dt);
5089   ret->setTime(numdt,numit,dt);
5090   ret->_csit=1;
5091   if(loadAll)
5092     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5093   else
5094     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5095   return ret.retn();
5096 }
5097
5098 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5099 try:MEDFileFieldGlobsReal(fileName)
5100 {
5101   MEDFileUtilities::CheckFileForRead(fileName);
5102   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5103   _content=BuildContentFrom(fid,fileName,loadAll);
5104   loadGlobals(fid);
5105 }
5106 catch(INTERP_KERNEL::Exception& e)
5107   {
5108     throw e;
5109   }
5110
5111 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5112 {
5113   med_field_type typcha;
5114   std::vector<std::string> infos;
5115   std::string dtunit;
5116   int iii=-1;
5117   int nbSteps=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5118   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5119   switch(typcha)
5120     {
5121     case MED_FLOAT64:
5122       {
5123         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5124         break;
5125       }
5126     case MED_INT32:
5127       {
5128         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5129         break;
5130       }
5131     default:
5132       {
5133         std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
5134         throw INTERP_KERNEL::Exception(oss.str().c_str());
5135       }
5136     }
5137   ret->setDtUnit(dtunit.c_str());
5138   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5139   //
5140   if(nbSteps<1)
5141     {
5142       std::ostringstream oss; oss << "MEDFileField1TS(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but there is no time steps on it !";
5143       throw INTERP_KERNEL::Exception(oss.str().c_str());
5144     }
5145   //
5146   med_int numdt,numit;
5147   med_float dt;
5148   MEDfieldComputingStepInfo(fid,fieldName,1,&numdt,&numit,&dt);
5149   ret->setTime(numdt,numit,dt);
5150   ret->_csit=1;
5151   if(loadAll)
5152     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5153   else
5154     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5155   return ret.retn();
5156 }
5157
5158 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5159 try:MEDFileFieldGlobsReal(fileName)
5160 {
5161   MEDFileUtilities::CheckFileForRead(fileName);
5162   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5163   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
5164   loadGlobals(fid);
5165 }
5166 catch(INTERP_KERNEL::Exception& e)
5167   {
5168     throw e;
5169   }
5170
5171 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c, const char *fileName) throw(INTERP_KERNEL::Exception)
5172 {
5173   if(!c)
5174     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
5175   if(dynamic_cast<const MEDFileField1TSWithoutSDA *>(c))
5176     {
5177       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New();
5178       ret->setFileName(fileName);
5179       ret->_content=c; c->incrRef();
5180       return ret.retn();
5181     }
5182   if(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(c))
5183     {
5184       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New();
5185       ret->setFileName(fileName);
5186       ret->_content=c; c->incrRef();
5187       return ret.retn();
5188     }
5189   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
5190 }
5191
5192 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5193 {
5194   MEDFileUtilities::CheckFileForRead(fileName);
5195   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5196   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
5197   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5198   ret->loadGlobals(fid);
5199   return ret.retn();
5200 }
5201
5202 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5203 {
5204   MEDFileUtilities::CheckFileForRead(fileName);
5205   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5206   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
5207   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5208   ret->loadGlobals(fid);
5209   return ret.retn();
5210 }
5211
5212 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5213 {
5214   MEDFileUtilities::CheckFileForRead(fileName);
5215   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5216   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5217   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5218   ret->loadGlobals(fid);
5219   return ret.retn();
5220 }
5221
5222 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5223 {
5224   med_field_type typcha;
5225   std::vector<std::string> infos;
5226   std::string dtunit;
5227   int iii=-1;
5228   int nbOfStep2=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5229   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5230   switch(typcha)
5231     {
5232     case MED_FLOAT64:
5233       {
5234         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5235         break;
5236       }
5237     case MED_INT32:
5238       {
5239         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5240         break;
5241       }
5242     default:
5243       {
5244         std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fileName,fieldName,iteration,order) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
5245         throw INTERP_KERNEL::Exception(oss.str().c_str());
5246       }
5247     }
5248   ret->setDtUnit(dtunit.c_str());
5249   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5250   //
5251   bool found=false;
5252   std::vector< std::pair<int,int> > dtits(nbOfStep2);
5253   for(int i=0;i<nbOfStep2 && !found;i++)
5254     {
5255       med_int numdt,numit;
5256       med_float dt;
5257       MEDfieldComputingStepInfo(fid,fieldName,i+1,&numdt,&numit,&dt);
5258       if(numdt==iteration && numit==order)
5259         {
5260           found=true;
5261           ret->_csit=i+1;
5262         }
5263       else
5264         dtits[i]=std::pair<int,int>(numdt,numit);
5265     }
5266   if(!found)
5267     {
5268       std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << fileName << "' ! Available iterations are : ";
5269       for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
5270         oss << "(" << (*iter).first << "," << (*iter).second << "), ";
5271       throw INTERP_KERNEL::Exception(oss.str().c_str());
5272     }
5273   if(loadAll)
5274     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5275   else
5276     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5277   return ret.retn();
5278 }
5279
5280 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5281 try:MEDFileFieldGlobsReal(fileName)
5282 {
5283   MEDFileUtilities::CheckFileForRead(fileName);
5284   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5285   _content=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5286   loadGlobals(fid);
5287 }
5288 catch(INTERP_KERNEL::Exception& e)
5289   {
5290     throw e;
5291   }
5292
5293 /*!
5294  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5295  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5296  *
5297  * \warning this is a shallow copy constructor
5298  */
5299 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent)
5300 {
5301   if(!shallowCopyOfContent)
5302     {
5303       const MEDFileAnyTypeField1TSWithoutSDA *otherPtr(&other);
5304       otherPtr->incrRef();
5305       _content=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(otherPtr);
5306     }
5307   else
5308     {
5309       _content=other.shallowCpy();
5310     }
5311 }
5312
5313 int MEDFileAnyTypeField1TS::LocateField2(med_idt fid, const char *fileName, int fieldIdCFormat, bool checkFieldId, std::string& fieldName, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut) throw(INTERP_KERNEL::Exception)
5314 {
5315   if(checkFieldId)
5316     {
5317       int nbFields=MEDnField(fid);
5318       if(fieldIdCFormat>=nbFields)
5319         {
5320           std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << fileName << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
5321           throw INTERP_KERNEL::Exception(oss.str().c_str());
5322         }
5323     }
5324   int ncomp=MEDfieldnComponent(fid,fieldIdCFormat+1);
5325   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5326   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5327   INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5328   INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5329   INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5330   med_bool localMesh;
5331   int nbOfStep;
5332   MEDfieldInfo(fid,fieldIdCFormat+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
5333   fieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
5334   dtunitOut=MEDLoaderBase::buildStringFromFortran(dtunit,MED_LNAME_SIZE);
5335   infos.clear(); infos.resize(ncomp);
5336   for(int j=0;j<ncomp;j++)
5337     infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
5338   return nbOfStep;
5339 }
5340
5341 /*!
5342  * This method throws an INTERP_KERNEL::Exception if \a fieldName field is not in file pointed by \a fid and with name \a fileName.
5343  *
5344  * \param [out]
5345  * \return in case of success the number of time steps available for the field with name \a fieldName.
5346  */
5347 int MEDFileAnyTypeField1TS::LocateField(med_idt fid, const char *fileName, const char *fieldName, int& posCFormat, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut) throw(INTERP_KERNEL::Exception)
5348 {
5349   int nbFields=MEDnField(fid);
5350   bool found=false;
5351   std::vector<std::string> fns(nbFields);
5352   int nbOfStep2=-1;
5353   for(int i=0;i<nbFields && !found;i++)
5354     {
5355       std::string tmp;
5356       nbOfStep2=LocateField2(fid,fileName,i,false,tmp,typcha,infos,dtunitOut);
5357       fns[i]=tmp;
5358       found=(tmp==fieldName);
5359       if(found)
5360         posCFormat=i;
5361     }
5362   if(!found)
5363     {
5364       std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << fileName << "' ! Available fields are : ";
5365       for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
5366         oss << "\"" << *it << "\" ";
5367       throw INTERP_KERNEL::Exception(oss.str().c_str());
5368     }
5369   return nbOfStep2;
5370 }
5371
5372 /*!
5373  * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5374  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5375  * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5376  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5377  * to keep a valid instance.
5378  * If \b this do not have any leaf that correspond to the request of the input parameter (\b mName, \b typ, \b locId) an INTERP_KERNEL::Exception will be thrown.
5379  * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
5380  * If \b newPflName already exists and that \b forceRenameOnGlob is false (the default) an INTERP_KERNEL::Exception will be thrown to avoid big confusion. In this case the called should rename before the profile name with name \b newPflName.
5381  *
5382  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
5383  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
5384  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5385  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5386  * \param [in] newLocName is the new localization name.
5387  * \param [in] forceRenameOnGlob specifies the behaviour in case of profile \b newPflName already exists. If true, the renaming is done without check. It can lead to major bug.
5388  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
5389  */
5390 void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newPflName, bool forceRenameOnGlob) throw(INTERP_KERNEL::Exception)
5391 {
5392   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5393   std::string oldPflName=disc->getProfile();
5394   std::vector<std::string> vv=getPflsReallyUsedMulti();
5395   int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
5396   if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
5397     {
5398       disc->setProfile(newPflName);
5399       DataArrayInt *pfl=getProfile(oldPflName.c_str());
5400       pfl->setName(newPflName);
5401     }
5402   else
5403     {
5404       std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
5405       throw INTERP_KERNEL::Exception(oss.str().c_str());
5406     }
5407 }
5408
5409 /*!
5410  * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5411  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5412  * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5413  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5414  * to keep a valid instance.
5415  * If \b this do not have any leaf that correspond to the request of the input parameter (\b mName, \b typ, \b locId) an INTERP_KERNEL::Exception will be thrown.
5416  * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
5417  * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
5418  * If \b newLocName already exists an INTERP_KERNEL::Exception will be thrown to avoid big confusion. In this case the called should rename before the profile name with name \b newLocName.
5419  *
5420  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
5421  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
5422  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5423  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5424  * \param [in] newLocName is the new localization name.
5425  * \param [in] forceRenameOnGlob specifies the behaviour in case of profile \b newLocName already exists. If true, the renaming is done without check. It can lead to major bug.
5426  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
5427  */
5428 void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newLocName, bool forceRenameOnGlob) throw(INTERP_KERNEL::Exception)
5429 {
5430   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5431   std::string oldLocName=disc->getLocalization();
5432   std::vector<std::string> vv=getLocsReallyUsedMulti();
5433   int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
5434   if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
5435     {
5436       disc->setLocalization(newLocName);
5437       MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
5438       loc.setName(newLocName);
5439     }
5440   else
5441     {
5442       std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
5443       throw INTERP_KERNEL::Exception(oss.str().c_str());
5444     }
5445 }
5446
5447 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() throw(INTERP_KERNEL::Exception)
5448 {
5449   MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5450   if(!ret)
5451     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : content is expected to be not null !");
5452   return ret;
5453 }
5454
5455 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() const throw(INTERP_KERNEL::Exception)
5456 {
5457   const MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5458   if(!ret)
5459     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : const content is expected to be not null !");
5460   return ret;
5461 }
5462
5463 /*!
5464  * Writes \a this field into a MED file specified by its name.
5465  *  \param [in] fileName - the MED file name.
5466  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
5467  * - 2 - erase; an existing file is removed.
5468  * - 1 - append; same data should not be present in an existing file.
5469  * - 0 - overwrite; same data present in an existing file is overwritten.
5470  *  \throw If the field name is not set.
5471  *  \throw If no field data is set.
5472  *  \throw If \a mode == 1 and the same data is present in an existing file.
5473  */
5474 void MEDFileAnyTypeField1TS::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
5475 {
5476   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
5477   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
5478   writeLL(fid);
5479 }
5480
5481 /*!
5482  * This method alloc the arrays and load potentially huge arrays contained in this field.
5483  * This method should be called when a MEDFileAnyTypeField1TS::New constructor has been with false as the last parameter.
5484  * This method can be also called to refresh or reinit values from a file.
5485  *
5486  * \throw If the fileName is not set or points to a non readable MED file.
5487  * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5488  */
5489 void MEDFileAnyTypeField1TS::loadArrays() throw(INTERP_KERNEL::Exception)
5490 {
5491   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5492   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
5493 }
5494
5495 /*!
5496  * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
5497  * But once data loaded once, this method does nothing.
5498  *
5499  * \throw If the fileName is not set or points to a non readable MED file.
5500  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::releaseArrays
5501  */
5502 void MEDFileAnyTypeField1TS::loadArraysIfNecessary() throw(INTERP_KERNEL::Exception)
5503 {
5504   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5505   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
5506 }
5507
5508 /*!
5509  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
5510  * This method does not release arrays set outside the context of a MED file.
5511  *
5512  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary
5513  */
5514 void MEDFileAnyTypeField1TS::releaseArrays() throw(INTERP_KERNEL::Exception)
5515 {
5516   contentNotNullBase()->releaseArrays();
5517 }
5518
5519 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
5520 {
5521   int nbComp=getNumberOfComponents();
5522   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5523   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5524   for(int i=0;i<nbComp;i++)
5525     {
5526       std::string info=getInfo()[i];
5527       std::string c,u;
5528       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
5529       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
5530       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
5531     }
5532   if(getName().empty())
5533     throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
5534   MEDfieldCr(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
5535   writeGlobals(fid,*this);
5536   contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
5537 }
5538
5539 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySize() const
5540 {
5541   std::size_t ret=0;
5542   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5543     ret+=_content->getHeapMemorySize();
5544   return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
5545 }
5546
5547 /*!
5548  * Returns a string describing \a this field. This string is outputted
5549  * by \c print Python command.
5550  */
5551 std::string MEDFileAnyTypeField1TS::simpleRepr() const
5552 {
5553   std::ostringstream oss;
5554   contentNotNullBase()->simpleRepr(0,oss,-1);
5555   simpleReprGlobs(oss);
5556   return oss.str();
5557 }
5558
5559 /*!
5560  * This method returns all profiles whose name is non empty used.
5561  * \b WARNING If profile is used several times it will be reported \b only \b once.
5562  * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
5563  */
5564 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
5565 {
5566   return contentNotNullBase()->getPflsReallyUsed2();
5567 }
5568
5569 /*!
5570  * This method returns all localizations whose name is non empty used.
5571  * \b WARNING If localization is used several times it will be reported \b only \b once.
5572  */
5573 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
5574 {
5575   return contentNotNullBase()->getLocsReallyUsed2();
5576 }
5577
5578 /*!
5579  * This method returns all profiles whose name is non empty used.
5580  * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
5581  */
5582 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
5583 {
5584   return contentNotNullBase()->getPflsReallyUsedMulti2();
5585 }
5586
5587 /*!
5588  * This method returns all localizations whose name is non empty used.
5589  * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
5590  */
5591 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
5592 {
5593   return contentNotNullBase()->getLocsReallyUsedMulti2();
5594 }
5595
5596 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5597 {
5598   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
5599 }
5600
5601 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5602 {
5603   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
5604 }
5605
5606 int MEDFileAnyTypeField1TS::getDimension() const
5607 {
5608   return contentNotNullBase()->getDimension();
5609 }
5610
5611 int MEDFileAnyTypeField1TS::getIteration() const
5612 {
5613   return contentNotNullBase()->getIteration();
5614 }
5615
5616 int MEDFileAnyTypeField1TS::getOrder() const
5617 {
5618   return contentNotNullBase()->getOrder();
5619 }
5620
5621 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
5622 {
5623   return contentNotNullBase()->getTime(iteration,order);
5624 }
5625
5626 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
5627 {
5628   contentNotNullBase()->setTime(iteration,order,val);
5629 }
5630
5631 std::string MEDFileAnyTypeField1TS::getName() const
5632 {
5633   return contentNotNullBase()->getName();
5634 }
5635
5636 void MEDFileAnyTypeField1TS::setName(const char *name)
5637 {
5638   contentNotNullBase()->setName(name);
5639 }
5640
5641 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
5642 {
5643   contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
5644 }
5645
5646 std::string MEDFileAnyTypeField1TS::getDtUnit() const throw(INTERP_KERNEL::Exception)
5647 {
5648   return contentNotNullBase()->getDtUnit();
5649 }
5650
5651 void MEDFileAnyTypeField1TS::setDtUnit(const char *dtUnit) throw(INTERP_KERNEL::Exception)
5652 {
5653   contentNotNullBase()->setDtUnit(dtUnit);
5654 }
5655
5656 std::string MEDFileAnyTypeField1TS::getMeshName() const throw(INTERP_KERNEL::Exception)
5657 {
5658   return contentNotNullBase()->getMeshName();
5659 }
5660
5661 void MEDFileAnyTypeField1TS::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
5662 {
5663   contentNotNullBase()->setMeshName(newMeshName);
5664 }
5665
5666 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
5667 {
5668   return contentNotNullBase()->changeMeshNames(modifTab);
5669 }
5670
5671 int MEDFileAnyTypeField1TS::getMeshIteration() const throw(INTERP_KERNEL::Exception)
5672 {
5673   return contentNotNullBase()->getMeshIteration();
5674 }
5675
5676 int MEDFileAnyTypeField1TS::getMeshOrder() const throw(INTERP_KERNEL::Exception)
5677 {
5678   return contentNotNullBase()->getMeshOrder();
5679 }
5680
5681 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
5682 {
5683   return contentNotNullBase()->getNumberOfComponents();
5684 }
5685
5686 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
5687 {
5688   return contentNotNullBase()->isDealingTS(iteration,order);
5689 }
5690
5691 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
5692 {
5693   return contentNotNullBase()->getDtIt();
5694 }
5695
5696 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
5697 {
5698   contentNotNullBase()->fillIteration(p);
5699 }
5700
5701 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
5702 {
5703   contentNotNullBase()->fillTypesOfFieldAvailable(types);
5704 }
5705
5706 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos) throw(INTERP_KERNEL::Exception)
5707 {
5708   contentNotNullBase()->setInfo(infos);
5709 }
5710
5711 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
5712 {
5713   return contentNotNullBase()->getInfo();
5714 }
5715 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
5716 {
5717   return contentNotNullBase()->getInfo();
5718 }
5719
5720 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
5721 {
5722   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5723 }
5724
5725 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
5726 {
5727   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5728 }
5729
5730 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
5731 {
5732   return contentNotNullBase()->getNonEmptyLevels(mname,levs);
5733 }
5734
5735 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
5736 {
5737   return contentNotNullBase()->getTypesOfFieldAvailable();
5738 }
5739
5740 std::vector< std::vector<std::pair<int,int> > > MEDFileAnyTypeField1TS::getFieldSplitedByType(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
5741                                                                                        std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5742 {
5743   return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
5744 }
5745
5746 /*!
5747  * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
5748  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5749  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
5750  */
5751 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const throw(INTERP_KERNEL::Exception)
5752 {
5753   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5754   if(!content)
5755     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
5756   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
5757   std::size_t sz(contentsSplit.size());
5758   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5759   for(std::size_t i=0;i<sz;i++)
5760     {
5761       ret[i]=shallowCpy();
5762       ret[i]->_content=contentsSplit[i];
5763     }
5764   return ret;
5765 }
5766
5767 /*!
5768  * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
5769  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5770  */
5771 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
5772 {
5773   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5774   if(!content)
5775     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
5776   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitDiscretizations();
5777   std::size_t sz(contentsSplit.size());
5778   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5779   for(std::size_t i=0;i<sz;i++)
5780     {
5781       ret[i]=shallowCpy();
5782       ret[i]->_content=contentsSplit[i];
5783     }
5784   return ret;
5785 }
5786
5787 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCpy() const throw(INTERP_KERNEL::Exception)
5788 {
5789   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=shallowCpy();
5790   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5791     ret->_content=_content->deepCpy();
5792   ret->deepCpyGlobs(*this);
5793   return ret.retn();
5794 }
5795
5796 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr) throw(INTERP_KERNEL::Exception)
5797 {
5798   return contentNotNullBase()->copyTinyInfoFrom(field,arr);
5799 }
5800
5801 //= MEDFileField1TS
5802
5803 /*!
5804  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5805  * the first field that has been read from a specified MED file.
5806  *  \param [in] fileName - the name of the MED file to read.
5807  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5808  *          is to delete this field using decrRef() as it is no more needed.
5809  *  \throw If reading the file fails.
5810  */
5811 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5812 {
5813   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,loadAll);
5814   ret->contentNotNull();
5815   return ret.retn();
5816 }
5817
5818 /*!
5819  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5820  * a given field that has been read from a specified MED file.
5821  *  \param [in] fileName - the name of the MED file to read.
5822  *  \param [in] fieldName - the name of the field to read.
5823  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5824  *          is to delete this field using decrRef() as it is no more needed.
5825  *  \throw If reading the file fails.
5826  *  \throw If there is no field named \a fieldName in the file.
5827  */
5828 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5829 {
5830   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,loadAll);
5831   ret->contentNotNull();
5832   return ret.retn();
5833 }
5834
5835 /*!
5836  * Returns a new instance of MEDFileField1TS holding data of a given time step of
5837  * a given field that has been read from a specified MED file.
5838  *  \param [in] fileName - the name of the MED file to read.
5839  *  \param [in] fieldName - the name of the field to read.
5840  *  \param [in] iteration - the iteration number of a required time step.
5841  *  \param [in] order - the iteration order number of required time step.
5842  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5843  *          is to delete this field using decrRef() as it is no more needed.
5844  *  \throw If reading the file fails.
5845  *  \throw If there is no field named \a fieldName in the file.
5846  *  \throw If the required time step is missing from the file.
5847  */
5848 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5849 {
5850   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,iteration,order,loadAll);
5851   ret->contentNotNull();
5852   return ret.retn();
5853 }
5854
5855 /*!
5856  * Returns a new instance of MEDFileField1TS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5857  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5858  *
5859  * Returns a new instance of MEDFileField1TS holding either a shallow copy
5860  * of a given MEDFileField1TSWithoutSDA ( \a other ) or \a other itself.
5861  * \warning this is a shallow copy constructor
5862  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
5863  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
5864  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5865  *          is to delete this field using decrRef() as it is no more needed.
5866  */
5867 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5868 {
5869   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(other,shallowCopyOfContent);
5870   ret->contentNotNull();
5871   return ret.retn();
5872 }
5873
5874 /*!
5875  * Returns a new empty instance of MEDFileField1TS.
5876  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5877  *          is to delete this field using decrRef() as it is no more needed.
5878  */
5879 MEDFileField1TS *MEDFileField1TS::New()
5880 {
5881   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS;
5882   ret->contentNotNull();
5883   return ret.retn();
5884 }
5885
5886 /*!
5887  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
5888  * following the given input policy.
5889  *
5890  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
5891  *                            By default (true) the globals are deeply copied.
5892  * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
5893  */
5894 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
5895 {
5896   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret;
5897   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5898   if(content)
5899     {
5900       const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
5901       if(!contc)
5902         throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
5903       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
5904       ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc,getFileName()));
5905     }
5906   else
5907     ret=MEDFileIntField1TS::New();
5908   if(deepCpyGlobs)
5909     ret->deepCpyGlobs(*this);
5910   else
5911     ret->shallowCpyGlobs(*this);
5912   return ret.retn();
5913 }
5914
5915 const MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() const throw(INTERP_KERNEL::Exception)
5916 {
5917   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
5918   if(!pt)
5919     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is null !");
5920   const MEDFileField1TSWithoutSDA *ret=dynamic_cast<const MEDFileField1TSWithoutSDA *>(pt);
5921   if(!ret)
5922     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
5923   return ret;
5924 }
5925
5926 MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() throw(INTERP_KERNEL::Exception)
5927 {
5928   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
5929   if(!pt)
5930     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is null !");
5931   MEDFileField1TSWithoutSDA *ret=dynamic_cast<MEDFileField1TSWithoutSDA *>(pt);
5932   if(!ret)
5933     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
5934   return ret;
5935 }
5936
5937 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MEDCouplingAutoRefCountObjectPtr<DataArray>& arr) throw(INTERP_KERNEL::Exception)
5938 {
5939   if(!f)
5940     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
5941   if(!((DataArray*)arr))
5942     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
5943   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
5944   if(!arrOutC)
5945     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
5946   f->setArray(arrOutC);
5947 }
5948
5949 DataArrayDouble *MEDFileField1TS::ReturnSafelyDataArrayDouble(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr) throw(INTERP_KERNEL::Exception)
5950 {
5951   if(!((DataArray*)arr))
5952     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : no array !");
5953   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
5954   if(!arrOutC)
5955     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
5956   arrOutC->incrRef();
5957   return arrOutC;
5958 }
5959
5960 MEDFileField1TS::MEDFileField1TS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5961 try:MEDFileAnyTypeField1TS(fileName,loadAll)
5962 {
5963 }
5964 catch(INTERP_KERNEL::Exception& e)
5965   { throw e; }
5966
5967 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5968 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
5969 {
5970 }
5971 catch(INTERP_KERNEL::Exception& e)
5972   { throw e; }
5973
5974 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5975 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
5976 {
5977 }
5978 catch(INTERP_KERNEL::Exception& e)
5979   { throw e; }
5980
5981 /*!
5982  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5983  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5984  *
5985  * \warning this is a shallow copy constructor
5986  */
5987 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5988 try:MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
5989 {
5990 }
5991 catch(INTERP_KERNEL::Exception& e)
5992   { throw e; }
5993
5994 MEDFileField1TS::MEDFileField1TS()
5995 {
5996   _content=new MEDFileField1TSWithoutSDA;
5997 }
5998
5999 /*!
6000  * Returns a new MEDCouplingFieldDouble of a given type lying on
6001  * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6002  * has not been constructed via file reading, an exception is thrown.
6003  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6004  *  \param [in] type - a spatial discretization of interest.
6005  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6006  *  \param [in] renumPol - specifies how to permute values of the result field according to
6007  *          the optional numbers of cells and nodes, if any. The valid values are
6008  *          - 0 - do not permute.
6009  *          - 1 - permute cells.
6010  *          - 2 - permute nodes.
6011  *          - 3 - permute cells and nodes.
6012  *
6013  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6014  *          caller is to delete this field using decrRef() as it is no more needed.
6015  *  \throw If \a this field has not been constructed via file reading.
6016  *  \throw If the MED file is not readable.
6017  *  \throw If there is no mesh in the MED file.
6018  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6019  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6020  *  \sa getFieldOnMeshAtLevel()
6021  */
6022 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
6023 {
6024   if(getFileName2().empty())
6025     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6026   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6027   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNull());
6028   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6029   return ret.retn();
6030 }
6031
6032 /*!
6033  * Returns a new MEDCouplingFieldDouble of a given type lying on
6034  * the top level cells of the first mesh in MED file. If \a this field
6035  * has not been constructed via file reading, an exception is thrown.
6036  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6037  *  \param [in] type - a spatial discretization of interest.
6038  *  \param [in] renumPol - specifies how to permute values of the result field according to
6039  *          the optional numbers of cells and nodes, if any. The valid values are
6040  *          - 0 - do not permute.
6041  *          - 1 - permute cells.
6042  *          - 2 - permute nodes.
6043  *          - 3 - permute cells and nodes.
6044  *
6045  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6046  *          caller is to delete this field using decrRef() as it is no more needed.
6047  *  \throw If \a this field has not been constructed via file reading.
6048  *  \throw If the MED file is not readable.
6049  *  \throw If there is no mesh in the MED file.
6050  *  \throw If no field values of the given \a type.
6051  *  \throw If no field values lying on the top level support.
6052  *  \sa getFieldAtLevel()
6053  */
6054 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const throw(INTERP_KERNEL::Exception)
6055 {
6056   if(getFileName2().empty())
6057     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6058   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6059   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNull());
6060   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6061   return ret.retn();
6062 }
6063
6064 /*!
6065  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6066  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6067  *  \param [in] type - a spatial discretization of the new field.
6068  *  \param [in] mesh - the supporting mesh.
6069  *  \param [in] renumPol - specifies how to permute values of the result field according to
6070  *          the optional numbers of cells and nodes, if any. The valid values are
6071  *          - 0 - do not permute.
6072  *          - 1 - permute cells.
6073  *          - 2 - permute nodes.
6074  *          - 3 - permute cells and nodes.
6075  *
6076  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6077  *          caller is to delete this field using decrRef() as it is no more needed.
6078  *  \throw If no field of \a this is lying on \a mesh.
6079  *  \throw If the mesh is empty.
6080  *  \throw If no field values of the given \a type are available.
6081  *  \sa getFieldAtLevel()
6082  *  \sa getFieldOnMeshAtLevel()
6083  */
6084 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
6085 {
6086   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6087   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull());
6088   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6089   return ret.retn();
6090 }
6091
6092 /*!
6093  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6094  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6095  *  \param [in] type - a spatial discretization of interest.
6096  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6097  *  \param [in] mesh - the supporting mesh.
6098  *  \param [in] renumPol - specifies how to permute values of the result field according to
6099  *          the optional numbers of cells and nodes, if any. The valid values are
6100  *          - 0 - do not permute.
6101  *          - 1 - permute cells.
6102  *          - 2 - permute nodes.
6103  *          - 3 - permute cells and nodes.
6104  *
6105  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6106  *          caller is to delete this field using decrRef() as it is no more needed.
6107  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6108  *  \throw If no field of \a this is lying on \a mesh.
6109  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6110  *  \sa getFieldAtLevel()
6111  *  \sa getFieldOnMeshAtLevel()
6112  */
6113 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
6114 {
6115   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6116   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull());
6117   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6118   return ret.retn();
6119 }
6120
6121 /*!
6122  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6123  * This method is called "Old" because in MED3 norm a field has only one meshName
6124  * attached, so this method is for readers of MED2 files. If \a this field
6125  * has not been constructed via file reading, an exception is thrown.
6126  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6127  *  \param [in] type - a spatial discretization of interest.
6128  *  \param [in] mName - a name of the supporting mesh.
6129  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6130  *  \param [in] renumPol - specifies how to permute values of the result field according to
6131  *          the optional numbers of cells and nodes, if any. The valid values are
6132  *          - 0 - do not permute.
6133  *          - 1 - permute cells.
6134  *          - 2 - permute nodes.
6135  *          - 3 - permute cells and nodes.
6136  *
6137  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6138  *          caller is to delete this field using decrRef() as it is no more needed.
6139  *  \throw If the MED file is not readable.
6140  *  \throw If there is no mesh named \a mName in the MED file.
6141  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6142  *  \throw If \a this field has not been constructed via file reading.
6143  *  \throw If no field of \a this is lying on the mesh named \a mName.
6144  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6145  *  \sa getFieldAtLevel()
6146  */
6147 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
6148 {
6149   if(getFileName2().empty())
6150     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6151   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6152   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
6153   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6154   return ret.retn();
6155 }
6156
6157 /*!
6158  * Returns values and a profile of the field of a given type lying on a given support.
6159  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6160  *  \param [in] type - a spatial discretization of the field.
6161  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6162  *  \param [in] mesh - the supporting mesh.
6163  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6164  *          field of interest lies on. If the field lies on all entities of the given
6165  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6166  *          using decrRef() as it is no more needed.
6167  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
6168  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6169  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6170  *  \throw If no field of \a this is lying on \a mesh.
6171  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6172  */
6173 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
6174 {
6175   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6176   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
6177 }
6178
6179 /*!
6180  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6181  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6182  * "Sort By Type"), if not, an exception is thrown.
6183  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6184  *  \param [in] field - the field to add to \a this.
6185  *  \throw If the name of \a field is empty.
6186  *  \throw If the data array of \a field is not set.
6187  *  \throw If the data array is already allocated but has different number of components
6188  *         than \a field.
6189  *  \throw If the underlying mesh of \a field has no name.
6190  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6191  */
6192 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
6193 {
6194   setFileName("");
6195   contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
6196 }
6197
6198 /*!
6199  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
6200  * of a given mesh are used as the support of the given field (a real support is not used).
6201  * Elements of the given mesh must be sorted suitable for writing to MED file.
6202  * Order of underlying mesh entities of the given field specified by \a profile parameter
6203  * is not prescribed; this method permutes field values to have them sorted by element
6204  * type as required for writing to MED file. A new profile is added only if no equal
6205  * profile is missing.
6206  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6207  *  \param [in] field - the field to add to \a this.
6208  *  \param [in] mesh - the supporting mesh of \a field.
6209  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
6210  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6211  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6212  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6213  *  \throw If the data array of \a field is not set.
6214  *  \throw If the data array of \a this is already allocated but has different number of
6215  *         components than \a field.
6216  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6217  *  \sa setFieldNoProfileSBT()
6218  */
6219 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
6220 {
6221   setFileName("");
6222   contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6223 }
6224
6225 MEDFileAnyTypeField1TS *MEDFileField1TS::shallowCpy() const throw(INTERP_KERNEL::Exception)
6226 {
6227   return new MEDFileField1TS(*this);
6228 }
6229
6230 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
6231 {
6232   return contentNotNull()->getUndergroundDataArrayDouble();
6233 }
6234
6235 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
6236 {
6237   return contentNotNull()->getUndergroundDataArrayDoubleExt(entries);
6238 }
6239
6240 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6241                                                                                       std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
6242 {
6243   return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
6244 }
6245
6246 //= MEDFileIntField1TS
6247
6248 MEDFileIntField1TS *MEDFileIntField1TS::New()
6249 {
6250   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS;
6251   ret->contentNotNull();
6252   return ret.retn();
6253 }
6254
6255 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
6256 {
6257   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,loadAll);
6258   ret->contentNotNull();
6259   return ret.retn();
6260 }
6261
6262 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
6263 {
6264   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,loadAll);
6265   ret->contentNotNull();
6266   return ret.retn();
6267 }
6268
6269 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
6270 {
6271   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,iteration,order,loadAll);
6272   ret->contentNotNull();
6273   return ret.retn();
6274 }
6275
6276 MEDFileIntField1TS *MEDFileIntField1TS::New(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent)
6277 {
6278   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(other,shallowCopyOfContent);
6279   ret->contentNotNull();
6280   return ret.retn();
6281 }
6282
6283 MEDFileIntField1TS::MEDFileIntField1TS()
6284 {
6285   _content=new MEDFileIntField1TSWithoutSDA;
6286 }
6287
6288 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
6289 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6290 {
6291 }
6292 catch(INTERP_KERNEL::Exception& e)
6293   { throw e; }
6294
6295 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
6296 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6297 {
6298 }
6299 catch(INTERP_KERNEL::Exception& e)
6300   { throw e; }
6301
6302 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
6303 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6304 {
6305 }
6306 catch(INTERP_KERNEL::Exception& e)
6307   { throw e; }
6308
6309 /*!
6310  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6311  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6312  *
6313  * \warning this is a shallow copy constructor
6314  */
6315 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6316 {
6317 }
6318
6319 MEDFileAnyTypeField1TS *MEDFileIntField1TS::shallowCpy() const throw(INTERP_KERNEL::Exception)
6320 {
6321   return new MEDFileIntField1TS(*this);
6322 }
6323
6324 /*!
6325  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
6326  * following the given input policy.
6327  *
6328  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6329  *                            By default (true) the globals are deeply copied.
6330  * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
6331  */
6332 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
6333 {
6334   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret;
6335   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6336   if(content)
6337     {
6338       const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
6339       if(!contc)
6340         throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
6341       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
6342       ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc,getFileName()));
6343     }
6344   else
6345     ret=MEDFileField1TS::New();
6346   if(deepCpyGlobs)
6347     ret->deepCpyGlobs(*this);
6348   else
6349     ret->shallowCpyGlobs(*this);
6350   return ret.retn();
6351 }
6352
6353 /*!
6354  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6355  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6356  * "Sort By Type"), if not, an exception is thrown.
6357  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6358  *  \param [in] field - the field to add to \a this. The field double values are ignored.
6359  *  \param [in] arrOfVals - the values of the field \a field used.
6360  *  \throw If the name of \a field is empty.
6361  *  \throw If the data array of \a field is not set.
6362  *  \throw If the data array is already allocated but has different number of components
6363  *         than \a field.
6364  *  \throw If the underlying mesh of \a field has no name.
6365  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6366  */
6367 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals) throw(INTERP_KERNEL::Exception)
6368 {
6369   setFileName("");
6370   contentNotNull()->setFieldNoProfileSBT(field,arrOfVals,*this,*contentNotNull());
6371 }
6372
6373 /*!
6374  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
6375  * of a given mesh are used as the support of the given field (a real support is not used).
6376  * Elements of the given mesh must be sorted suitable for writing to MED file.
6377  * Order of underlying mesh entities of the given field specified by \a profile parameter
6378  * is not prescribed; this method permutes field values to have them sorted by element
6379  * type as required for writing to MED file. A new profile is added only if no equal
6380  * profile is missing.
6381  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6382  *  \param [in] field - the field to add to \a this. The field double values are ignored.
6383  *  \param [in] arrOfVals - the values of the field \a field used.
6384  *  \param [in] mesh - the supporting mesh of \a field.
6385  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
6386  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6387  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6388  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6389  *  \throw If the data array of \a field is not set.
6390  *  \throw If the data array of \a this is already allocated but has different number of
6391  *         components than \a field.
6392  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6393  *  \sa setFieldNoProfileSBT()
6394  */
6395 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
6396 {
6397   setFileName("");
6398   contentNotNull()->setFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6399 }
6400
6401 const MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() const throw(INTERP_KERNEL::Exception)
6402 {
6403   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6404   if(!pt)
6405     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is null !");
6406   const MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(pt);
6407   if(!ret)
6408     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is not null but it is not of type int32 ! Reason is maybe that the read field has not the type INT32 !");
6409   return ret;
6410 }
6411
6412 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6413 {
6414   if(getFileName2().empty())
6415     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6416   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut2;
6417   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut2,*contentNotNull());
6418   DataArrayInt *arrOutC=dynamic_cast<DataArrayInt *>((DataArray *)arrOut2);
6419   if(!arrOutC)
6420     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : mismatch between dataArrays type and MEDFileIntField1TS ! Expected int32 !");
6421   arrOut=arrOutC;
6422   return ret.retn();
6423 }
6424
6425 DataArrayInt *MEDFileIntField1TS::ReturnSafelyDataArrayInt(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr) throw(INTERP_KERNEL::Exception)
6426 {
6427   if(!((DataArray *)arr))
6428     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is NULL !");
6429   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>((DataArray *)arr);
6430   if(!arrC)
6431     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is not of type INT32 !");
6432   arrC->incrRef();
6433   return arrC;
6434 }
6435
6436 /*!
6437  * Returns a new MEDCouplingFieldDouble of a given type lying on
6438  * the top level cells of the first mesh in MED file. If \a this field
6439  * has not been constructed via file reading, an exception is thrown.
6440  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6441  *  \param [in] type - a spatial discretization of interest.
6442  *  \param [out] arrOut - the DataArrayInt containing values of field.
6443  *  \param [in] renumPol - specifies how to permute values of the result field according to
6444  *          the optional numbers of cells and nodes, if any. The valid values are
6445  *          - 0 - do not permute.
6446  *          - 1 - permute cells.
6447  *          - 2 - permute nodes.
6448  *          - 3 - permute cells and nodes.
6449  *
6450  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6451  *          caller is to delete this field using decrRef() as it is no more needed.
6452  *  \throw If \a this field has not been constructed via file reading.
6453  *  \throw If the MED file is not readable.
6454  *  \throw If there is no mesh in the MED file.
6455  *  \throw If no field values of the given \a type.
6456  *  \throw If no field values lying on the top level support.
6457  *  \sa getFieldAtLevel()
6458  */
6459 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6460 {
6461   if(getFileName2().empty())
6462     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6463   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6464   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNull());
6465   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6466   return ret.retn();
6467 }
6468
6469 /*!
6470  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6471  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6472  *  \param [in] type - a spatial discretization of the new field.
6473  *  \param [in] mesh - the supporting mesh.
6474  *  \param [out] arrOut - the DataArrayInt containing values of field.
6475  *  \param [in] renumPol - specifies how to permute values of the result field according to
6476  *          the optional numbers of cells and nodes, if any. The valid values are
6477  *          - 0 - do not permute.
6478  *          - 1 - permute cells.
6479  *          - 2 - permute nodes.
6480  *          - 3 - permute cells and nodes.
6481  *
6482  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6483  *          caller is to delete this field using decrRef() as it is no more needed.
6484  *  \throw If no field of \a this is lying on \a mesh.
6485  *  \throw If the mesh is empty.
6486  *  \throw If no field values of the given \a type are available.
6487  *  \sa getFieldAtLevel()
6488  *  \sa getFieldOnMeshAtLevel()
6489  */
6490 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6491 {
6492   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6493   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNull());
6494   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6495   return ret.retn();
6496 }
6497
6498 /*!
6499  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6500  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6501  *  \param [in] type - a spatial discretization of interest.
6502  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6503  *  \param [out] arrOut - the DataArrayInt containing values of field.
6504  *  \param [in] mesh - the supporting mesh.
6505  *  \param [in] renumPol - specifies how to permute values of the result field according to
6506  *          the optional numbers of cells and nodes, if any. The valid values are
6507  *          - 0 - do not permute.
6508  *          - 1 - permute cells.
6509  *          - 2 - permute nodes.
6510  *          - 3 - permute cells and nodes.
6511  *
6512  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6513  *          caller is to delete this field using decrRef() as it is no more needed.
6514  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6515  *  \throw If no field of \a this is lying on \a mesh.
6516  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6517  *  \sa getFieldAtLevel()
6518  *  \sa getFieldOnMeshAtLevel()
6519  */
6520 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6521 {
6522   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6523   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNull());
6524   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6525   return ret.retn();
6526 }
6527
6528 /*!
6529  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6530  * This method is called "Old" because in MED3 norm a field has only one meshName
6531  * attached, so this method is for readers of MED2 files. If \a this field
6532  * has not been constructed via file reading, an exception is thrown.
6533  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6534  *  \param [in] type - a spatial discretization of interest.
6535  *  \param [in] mName - a name of the supporting mesh.
6536  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6537  *  \param [out] arrOut - the DataArrayInt containing values of field.
6538  *  \param [in] renumPol - specifies how to permute values of the result field according to
6539  *          the optional numbers of cells and nodes, if any. The valid values are
6540  *          - 0 - do not permute.
6541  *          - 1 - permute cells.
6542  *          - 2 - permute nodes.
6543  *          - 3 - permute cells and nodes.
6544  *
6545  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6546  *          caller is to delete this field using decrRef() as it is no more needed.
6547  *  \throw If the MED file is not readable.
6548  *  \throw If there is no mesh named \a mName in the MED file.
6549  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6550  *  \throw If \a this field has not been constructed via file reading.
6551  *  \throw If no field of \a this is lying on the mesh named \a mName.
6552  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6553  *  \sa getFieldAtLevel()
6554  */
6555 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6556 {
6557   if(getFileName2().empty())
6558     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6559   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6560   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNull());
6561   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6562   return ret.retn();
6563 }
6564
6565 /*!
6566  * Returns values and a profile of the field of a given type lying on a given support.
6567  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6568  *  \param [in] type - a spatial discretization of the field.
6569  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6570  *  \param [in] mesh - the supporting mesh.
6571  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6572  *          field of interest lies on. If the field lies on all entities of the given
6573  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6574  *          using decrRef() as it is no more needed.
6575  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
6576  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6577  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6578  *  \throw If no field of \a this is lying on \a mesh.
6579  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6580  */
6581 DataArrayInt *MEDFileIntField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
6582 {
6583   MEDCouplingAutoRefCountObjectPtr<DataArray> arr=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6584   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6585 }
6586
6587 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() throw(INTERP_KERNEL::Exception)
6588 {
6589   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6590   if(!pt)
6591     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is null !");
6592   MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<MEDFileIntField1TSWithoutSDA *>(pt);
6593   if(!ret)
6594     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is not null but it is not of type int32 ! Reason is maybe that the read field has not the type INT32 !");
6595   return ret;
6596 }
6597
6598 DataArrayInt *MEDFileIntField1TS::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
6599 {
6600   return contentNotNull()->getUndergroundDataArrayInt();
6601 }
6602
6603 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
6604
6605 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
6606 {
6607 }
6608
6609 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const char *fieldName):MEDFileFieldNameScope(fieldName)
6610 {
6611 }
6612
6613 /*!
6614  * \param [in] fieldId field id in C mode
6615  */
6616 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll) throw(INTERP_KERNEL::Exception)
6617 {
6618   med_field_type typcha;
6619   std::string dtunitOut;
6620   int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,"",fieldId,false,_name,typcha,_infos,dtunitOut);
6621   setDtUnit(dtunitOut.c_str());
6622   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll);
6623 }
6624
6625 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
6626 try:MEDFileFieldNameScope(fieldName),_infos(infos)
6627 {
6628   setDtUnit(dtunit.c_str());
6629   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll);
6630 }
6631 catch(INTERP_KERNEL::Exception& e)
6632 {
6633   throw e;
6634 }
6635
6636 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySize() const
6637 {
6638   std::size_t ret=_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA>);
6639   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6640     ret+=(*it).capacity();
6641   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6642     if((const MEDFileAnyTypeField1TSWithoutSDA *)(*it))
6643       ret+=(*it)->getHeapMemorySize();
6644   return ret;
6645 }
6646
6647 /*!
6648  * If one of the id in [ \a startIds , \a endIds ) points to a null element, there is not throw. Simply, this empty element is added as if it were not
6649  * NULL.
6650  */
6651 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const throw(INTERP_KERNEL::Exception)
6652 {
6653   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6654   ret->setInfo(_infos);
6655   int sz=(int)_time_steps.size();
6656   for(const int *id=startIds;id!=endIds;id++)
6657     {
6658       if(*id>=0 && *id<sz)
6659         {
6660           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
6661           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6662           if(tse)
6663             {
6664               tse->incrRef();
6665               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6666             }
6667           ret->pushBackTimeStep(tse2);
6668         }
6669       else
6670         {
6671           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
6672           oss << " ! Should be in [0," << sz << ") !";
6673           throw INTERP_KERNEL::Exception(oss.str().c_str());
6674         }
6675     }
6676   if(ret->getNumberOfTS()>0)
6677     ret->synchronizeNameScope();
6678   ret->copyNameScope(*this);
6679   return ret.retn();
6680 }
6681
6682 /*!
6683  * If one of the id in the input range points to a null element, there is not throw. Simply, this empty element is added as if it were not
6684  * NULL.
6685  */
6686 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
6687 {
6688   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
6689   int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
6690   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6691   ret->setInfo(_infos);
6692   int sz=(int)_time_steps.size();
6693   int j=bg;
6694   for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
6695     {
6696       if(j>=0 && j<sz)
6697         {
6698           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
6699           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6700           if(tse)
6701             {
6702               tse->incrRef();
6703               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6704             }
6705           ret->pushBackTimeStep(tse2);
6706         }
6707       else
6708         {
6709           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
6710           oss << " ! Should be in [0," << sz << ") !";
6711           throw INTERP_KERNEL::Exception(oss.str().c_str());
6712         }
6713     }
6714   if(ret->getNumberOfTS()>0)
6715     ret->synchronizeNameScope();
6716   ret->copyNameScope(*this);
6717   return ret.retn();
6718 }
6719
6720 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
6721 {
6722   int id=0;
6723   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6724   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6725     {
6726       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6727       if(!cur)
6728         continue;
6729       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6730       if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
6731         ids->pushBackSilent(id);
6732     }
6733   return buildFromTimeStepIds(ids->begin(),ids->end());
6734 }
6735
6736 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
6737 {
6738   int id=0;
6739   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6740   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6741     {
6742       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6743       if(!cur)
6744         continue;
6745       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6746       if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
6747         ids->pushBackSilent(id);
6748     }
6749   return buildFromTimeStepIds(ids->begin(),ids->end());
6750 }
6751
6752 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const throw(INTERP_KERNEL::Exception)
6753 {
6754   return _infos;
6755 }
6756
6757 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
6758 {
6759   _infos=info;
6760 }
6761
6762 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const throw(INTERP_KERNEL::Exception)
6763 {
6764   int ret=0;
6765   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
6766     {
6767       const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
6768       if(pt->isDealingTS(iteration,order))
6769         return ret;
6770     }
6771   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
6772   std::vector< std::pair<int,int> > vp=getIterations();
6773   for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
6774     oss << "(" << (*it2).first << "," << (*it2).second << ") ";
6775   throw INTERP_KERNEL::Exception(oss.str().c_str());
6776 }
6777
6778 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const throw(INTERP_KERNEL::Exception)
6779 {
6780   return *_time_steps[getTimeStepPos(iteration,order)];
6781 }
6782
6783 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) throw(INTERP_KERNEL::Exception)
6784 {
6785   return *_time_steps[getTimeStepPos(iteration,order)];
6786 }
6787
6788 std::string MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshName() const throw(INTERP_KERNEL::Exception)
6789 {
6790   if(_time_steps.empty())
6791     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
6792   return _time_steps[0]->getMeshName();
6793 }
6794
6795 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
6796 {
6797   std::string oldName(getMeshName());
6798   std::vector< std::pair<std::string,std::string> > v(1);
6799   v[0].first=oldName; v[0].second=newMeshName;
6800   changeMeshNames(v);
6801 }
6802
6803 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
6804 {
6805   bool ret=false;
6806   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6807     {
6808       MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6809       if(cur)
6810         ret=cur->changeMeshNames(modifTab) || ret;
6811     }
6812   return ret;
6813 }
6814
6815 /*!
6816  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
6817  */
6818 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
6819 {
6820   return getTimeStepEntry(iteration,order).getUndergroundDataArray();
6821 }
6822
6823 /*!
6824  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
6825  */
6826 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
6827 {
6828   return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
6829 }
6830
6831 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
6832                                                                 MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
6833 {
6834   bool ret=false;
6835   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6836     {
6837       MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
6838       if(f1ts)
6839         ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
6840     }
6841   return ret;
6842 }
6843
6844 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
6845 {
6846   std::string startLine(bkOffset,' ');
6847   oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
6848   if(fmtsId>=0)
6849     oss << " (" << fmtsId << ")";
6850   oss << " has the following name: \"" << _name << "\"." << std::endl;
6851   oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
6852   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6853     {
6854       oss << startLine << "  -  \"" << *it << "\"" << std::endl;
6855     }
6856   int i=0;
6857   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
6858     {
6859       std::string chapter(17,'0'+i);
6860       oss << startLine << chapter << std::endl;
6861       const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6862       if(cur)
6863         cur->simpleRepr(bkOffset+2,oss,i);
6864       else
6865         oss << startLine << "  Field on one time step #" << i << " is not defined !" << std::endl;
6866       oss << startLine << chapter << std::endl;
6867     }
6868 }
6869
6870 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const throw(INTERP_KERNEL::Exception)
6871 {
6872   std::size_t sz=_time_steps.size();
6873   std::vector< std::pair<int,int> > ret(sz);
6874   ret1.resize(sz);
6875   for(std::size_t i=0;i<sz;i++)
6876     {
6877       const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
6878       if(f1ts)
6879         {
6880           ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
6881         }
6882       else
6883         {
6884           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
6885           throw INTERP_KERNEL::Exception(oss.str().c_str());
6886         }
6887     }
6888   return ret;
6889 }
6890
6891 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>& tse) throw(INTERP_KERNEL::Exception)
6892 {
6893   MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
6894   if(!tse2)
6895     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
6896   checkCoherencyOfType(tse2);
6897   if(_time_steps.empty())
6898     {
6899       setName(tse2->getName().c_str());
6900       setInfo(tse2->getInfo());
6901     }
6902   checkThatComponentsMatch(tse2->getInfo());
6903   _time_steps.push_back(tse);
6904 }
6905
6906 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope() throw(INTERP_KERNEL::Exception)
6907 {
6908   std::size_t nbOfCompo=_infos.size();
6909   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6910     {
6911       MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6912       if(cur)
6913         {
6914           if((cur->getInfo()).size()!=nbOfCompo)
6915             {
6916               std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
6917               oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
6918               throw INTERP_KERNEL::Exception(oss.str().c_str());
6919             }
6920           cur->copyNameScope(*this);
6921         }
6922     }
6923 }
6924
6925 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll) throw(INTERP_KERNEL::Exception)
6926 {
6927   _time_steps.resize(nbPdt);
6928   for(int i=0;i<nbPdt;i++)
6929     {
6930       std::vector< std::pair<int,int> > ts;
6931       med_int numdt=0,numo=0;
6932       med_int meshIt=0,meshOrder=0;
6933       med_float dt=0.0;
6934       MEDfieldComputingStepMeshInfo(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder);
6935       switch(fieldTyp)
6936         {
6937         case MED_FLOAT64:
6938           {
6939             _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
6940             break;
6941           }
6942         case MED_INT32:
6943           {
6944             _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
6945             break;
6946           }
6947         default:
6948           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
6949         }
6950       if(loadAll)
6951         _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this);
6952       else
6953         _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this);
6954     }
6955 }
6956
6957 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const throw(INTERP_KERNEL::Exception)
6958 {
6959   if(_time_steps.empty())
6960     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
6961   checkThatNbOfCompoOfTSMatchThis();
6962   std::vector<std::string> infos(getInfo());
6963   int nbComp=infos.size();
6964   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
6965   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
6966   for(int i=0;i<nbComp;i++)
6967     {
6968       std::string info=infos[i];
6969       std::string c,u;
6970       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
6971       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
6972       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
6973     }
6974   if(_name.empty())
6975     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
6976   MEDfieldCr(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
6977   int nbOfTS=_time_steps.size();
6978   for(int i=0;i<nbOfTS;i++)
6979     _time_steps[i]->writeLL(fid,opts,*this);
6980 }
6981
6982 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
6983 {
6984   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6985     {
6986       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
6987       if(elt)
6988         elt->loadBigArraysRecursively(fid,nasc);
6989     }
6990 }
6991
6992 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
6993 {
6994   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6995     {
6996       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
6997       if(elt)
6998         elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
6999     }
7000 }
7001
7002 void MEDFileAnyTypeFieldMultiTSWithoutSDA::releaseArrays() throw(INTERP_KERNEL::Exception)
7003 {
7004   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7005     {
7006       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7007       if(elt)
7008         elt->releaseArrays();
7009     }
7010 }
7011
7012 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
7013 {
7014   return _time_steps.size();
7015 }
7016
7017 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS() throw(INTERP_KERNEL::Exception)
7018 {
7019   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  > newTS;
7020   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7021     {
7022       const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
7023       if(tmp)
7024         newTS.push_back(*it);
7025     }
7026   _time_steps=newTS;
7027 }
7028
7029 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
7030 {
7031   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7032   int maxId=(int)_time_steps.size();
7033   int ii=0;
7034   std::set<int> idsToDel;
7035   for(const int *id=startIds;id!=endIds;id++,ii++)
7036     {
7037       if(*id>=0 && *id<maxId)
7038         {
7039           idsToDel.insert(*id);
7040         }
7041       else
7042         {
7043           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
7044           throw INTERP_KERNEL::Exception(oss.str().c_str());
7045         }
7046     }
7047   for(int iii=0;iii<maxId;iii++)
7048     if(idsToDel.find(iii)==idsToDel.end())
7049       newTS.push_back(_time_steps[iii]);
7050   _time_steps=newTS;
7051 }
7052
7053 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step) throw(INTERP_KERNEL::Exception)
7054 {
7055   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
7056   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7057   if(nbOfEntriesToKill==0)
7058     return ;
7059   std::size_t sz=_time_steps.size();
7060   std::vector<bool> b(sz,true);
7061   int j=bg;
7062   for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
7063     b[j]=false;
7064   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7065   for(std::size_t i=0;i<sz;i++)
7066     if(b[i])
7067       newTS.push_back(_time_steps[i]);
7068   _time_steps=newTS;
7069 }
7070
7071 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
7072 {
7073   int ret=0;
7074   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
7075   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7076     {
7077       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7078       if(tmp)
7079         {
7080           int it2,ord;
7081           tmp->getTime(it2,ord);
7082           if(it2==iteration && order==ord)
7083             return ret;
7084           else
7085             oss << "(" << it2 << ","  << ord << "), ";
7086         }
7087     }
7088   throw INTERP_KERNEL::Exception(oss.str().c_str());
7089 }
7090
7091 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
7092 {
7093   int ret=0;
7094   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
7095   oss.precision(15);
7096   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7097     {
7098       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7099       if(tmp)
7100         {
7101           int it2,ord;
7102           double ti=tmp->getTime(it2,ord);
7103           if(fabs(time-ti)<eps)
7104             return ret;
7105           else
7106             oss << ti << ", ";
7107         }
7108     }
7109   throw INTERP_KERNEL::Exception(oss.str().c_str());
7110 }
7111
7112 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
7113 {
7114   int lgth=_time_steps.size();
7115   std::vector< std::pair<int,int> > ret(lgth);
7116   for(int i=0;i<lgth;i++)
7117     _time_steps[i]->fillIteration(ret[i]);
7118   return ret;
7119 }
7120
7121 /*!
7122  * This method has 3 inputs 'iteration' 'order' 'mname'. 'mname' can be null if the user is the general case where there is only one meshName lying on 'this'
7123  * This method returns two things.
7124  * - The absolute dimension of 'this' in first parameter.
7125  * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
7126  *   to the first output parameter. The values in 'levs' will be returned in decreasing order.
7127  *
7128  * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
7129  * Only these 3 discretizations will be taken into account here.
7130  *
7131  * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
7132  * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
7133  * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
7134  *
7135  * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
7136  * It is possible (even if it is not common) that the highest level in 'this' were not equal to the meshDimension of the underlying mesh in 'this'.
7137  *
7138  * Let's consider the typical following case :
7139  * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
7140  * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
7141  * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
7142  *   TETRA4 and SEG2
7143  * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
7144  *
7145  * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
7146  *
7147  * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
7148  * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
7149  * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
7150  * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
7151  */
7152 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
7153 {
7154   return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
7155 }
7156
7157 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const throw(INTERP_KERNEL::Exception)
7158 {
7159   if(pos<0 || pos>=(int)_time_steps.size())
7160     {
7161       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7162       throw INTERP_KERNEL::Exception(oss.str().c_str());
7163     }
7164   const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7165   if(item==0)
7166     {
7167       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7168       oss << "\nTry to use following method eraseEmptyTS !";
7169       throw INTERP_KERNEL::Exception(oss.str().c_str());
7170     }
7171   return item;
7172 }
7173
7174 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) throw(INTERP_KERNEL::Exception)
7175 {
7176   if(pos<0 || pos>=(int)_time_steps.size())
7177     {
7178       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7179       throw INTERP_KERNEL::Exception(oss.str().c_str());
7180     }
7181   MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7182   if(item==0)
7183     {
7184       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7185       oss << "\nTry to use following method eraseEmptyTS !";
7186       throw INTERP_KERNEL::Exception(oss.str().c_str());
7187     }
7188   return item;
7189 }
7190
7191 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
7192 {
7193   std::vector<std::string> ret;
7194   std::set<std::string> ret2;
7195   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7196     {
7197       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
7198       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7199         if(ret2.find(*it2)==ret2.end())
7200           {
7201             ret.push_back(*it2);
7202             ret2.insert(*it2);
7203           }
7204     }
7205   return ret;
7206 }
7207
7208 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
7209 {
7210   std::vector<std::string> ret;
7211   std::set<std::string> ret2;
7212   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7213     {
7214       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
7215       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7216         if(ret2.find(*it2)==ret2.end())
7217           {
7218             ret.push_back(*it2);
7219             ret2.insert(*it2);
7220           }
7221     }
7222   return ret;
7223 }
7224
7225 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
7226 {
7227   std::vector<std::string> ret;
7228   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7229     {
7230       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
7231       ret.insert(ret.end(),tmp.begin(),tmp.end());
7232     }
7233   return ret;
7234 }
7235
7236 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
7237 {
7238   std::vector<std::string> ret;
7239   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7240     {
7241       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
7242       ret.insert(ret.end(),tmp.begin(),tmp.end());
7243     }
7244   return ret;
7245 }
7246
7247 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7248 {
7249   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7250     (*it)->changePflsRefsNamesGen2(mapOfModif);
7251 }
7252
7253 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7254 {
7255   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7256     (*it)->changeLocsRefsNamesGen2(mapOfModif);
7257 }
7258
7259 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
7260 {
7261   int lgth=_time_steps.size();
7262   std::vector< std::vector<TypeOfField> > ret(lgth);
7263   for(int i=0;i<lgth;i++)
7264     _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
7265   return ret;
7266 }
7267
7268 /*!
7269  * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
7270  */
7271 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeFieldMultiTSWithoutSDA::getFieldSplitedByType(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
7272 {
7273   return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
7274 }
7275
7276 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
7277 {
7278   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
7279   std::size_t i=0;
7280   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7281     {
7282       if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
7283         ret->_time_steps[i]=(*it)->deepCpy();
7284     }
7285   return ret.retn();
7286 }
7287
7288 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const throw(INTERP_KERNEL::Exception)
7289 {
7290   std::size_t sz(_infos.size()),sz2(_time_steps.size());
7291   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
7292   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
7293   for(std::size_t i=0;i<sz;i++)
7294     {
7295       ret[i]=shallowCpy();
7296       ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
7297     }
7298   for(std::size_t i=0;i<sz2;i++)
7299     {
7300       std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
7301       if(ret1.size()!=sz)
7302         {
7303           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
7304           throw INTERP_KERNEL::Exception(oss.str().c_str());
7305         }
7306       ts[i]=ret1;
7307     }
7308   for(std::size_t i=0;i<sz;i++)
7309     for(std::size_t j=0;j<sz2;j++)
7310       ret[i]->_time_steps[j]=ts[j][i];
7311   return ret;
7312 }
7313
7314 /*!
7315  * This method splits into discretization each time steps in \a this.
7316  * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
7317  */
7318 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
7319 {
7320   std::size_t sz(_time_steps.size());
7321   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7322   for(std::size_t i=0;i<sz;i++)
7323     {
7324       const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7325       if(!timeStep)
7326         {
7327           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
7328           throw INTERP_KERNEL::Exception(oss.str().c_str());
7329         }
7330       items[i]=timeStep->splitDiscretizations();
7331     }
7332   //
7333   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
7334   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
7335   std::vector< TypeOfField > types;
7336   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7337     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7338       {
7339         std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
7340         if(ts.size()!=1)
7341           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
7342         std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
7343         if(it2==types.end())
7344           types.push_back(ts[0]);
7345       }
7346   ret.resize(types.size()); ret2.resize(types.size());
7347   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7348     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7349       {
7350         TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
7351         std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
7352         ret2[pos].push_back(*it1);
7353       }
7354   for(std::size_t i=0;i<types.size();i++)
7355     {
7356       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=createNew();
7357       for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
7358         elt->pushBackTimeStep(*it1);//also updates infos in elt
7359       ret[i]=elt;
7360       elt->MEDFileFieldNameScope::operator=(*this);
7361     }
7362   return ret;
7363 }
7364
7365 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr) throw(INTERP_KERNEL::Exception)
7366 {
7367   _name=field->getName();
7368   if(_name.empty())
7369     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
7370   if(!arr)
7371     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
7372   _infos=arr->getInfoOnComponents();
7373 }
7374
7375 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const throw(INTERP_KERNEL::Exception)
7376 {
7377   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
7378   if(_name!=field->getName())
7379     {
7380       std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
7381       oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
7382       throw INTERP_KERNEL::Exception(oss.str().c_str());
7383     }
7384   if(!arr)
7385     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
7386   checkThatComponentsMatch(arr->getInfoOnComponents());
7387 }
7388
7389 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const throw(INTERP_KERNEL::Exception)
7390 {
7391   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
7392   if(getInfo().size()!=compos.size())
7393     {
7394       std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
7395       oss << " number of components of element to append (" << compos.size() << ") !";
7396       throw INTERP_KERNEL::Exception(oss.str().c_str());
7397     }
7398   if(_infos!=compos)
7399     {
7400       std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
7401       std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
7402       oss << " But compo in input fields are : ";
7403       std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
7404       oss << " !";
7405       throw INTERP_KERNEL::Exception(oss.str().c_str());
7406     }
7407 }
7408
7409 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const throw(INTERP_KERNEL::Exception)
7410 {
7411   std::size_t sz=_infos.size();
7412   int j=0;
7413   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
7414     {
7415       const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7416       if(elt)
7417         if(elt->getInfo().size()!=sz)
7418           {
7419             std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
7420             oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
7421             throw INTERP_KERNEL::Exception(oss.str().c_str());
7422           }
7423     }
7424 }
7425
7426 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
7427 {
7428   if(!field)
7429     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7430   if(!_time_steps.empty())
7431     checkCoherencyOfTinyInfo(field,arr);
7432   MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
7433   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7434   objC->setFieldNoProfileSBT(field,arr,glob,*this);
7435   copyTinyInfoFrom(field,arr);
7436   _time_steps.push_back(obj);
7437 }
7438
7439 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
7440 {
7441   if(!field)
7442     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7443   if(!_time_steps.empty())
7444     checkCoherencyOfTinyInfo(field,arr);
7445   MEDFileField1TSWithoutSDA *objC=new MEDFileField1TSWithoutSDA;
7446   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7447   objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
7448   copyTinyInfoFrom(field,arr);
7449   _time_steps.push_back(obj);
7450 }
7451
7452 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ts) throw(INTERP_KERNEL::Exception)
7453 {
7454   int sz=(int)_time_steps.size();
7455   if(i<0 || i>=sz)
7456     {
7457       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
7458       throw INTERP_KERNEL::Exception(oss.str().c_str());
7459     }
7460   const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
7461   if(tsPtr)
7462     {
7463       if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
7464         {
7465           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() <<  " !";
7466           throw INTERP_KERNEL::Exception(oss.str().c_str());
7467         }
7468     }
7469   _time_steps[i]=ts;
7470 }
7471
7472 //= MEDFileFieldMultiTSWithoutSDA
7473
7474 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::New(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
7475 {
7476   return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7477 }
7478
7479 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
7480 {
7481 }
7482
7483 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7484 {
7485 }
7486
7487 /*!
7488  * \param [in] fieldId field id in C mode
7489  */
7490 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll) throw(INTERP_KERNEL::Exception)
7491 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7492 {
7493 }
7494 catch(INTERP_KERNEL::Exception& e)
7495   { throw e; }
7496
7497 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
7498 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7499 {
7500 }
7501 catch(INTERP_KERNEL::Exception& e)
7502 { throw e; }
7503
7504 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const throw(INTERP_KERNEL::Exception)
7505 {
7506   return new MEDFileField1TSWithoutSDA;
7507 }
7508
7509 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const throw(INTERP_KERNEL::Exception)
7510 {
7511   if(!f1ts)
7512     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7513   const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
7514   if(!f1tsC)
7515     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
7516 }
7517
7518 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
7519 {
7520   return MEDFileField1TSWithoutSDA::TYPE_STR;
7521 }
7522
7523 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
7524 {
7525   return new MEDFileFieldMultiTSWithoutSDA(*this);
7526 }
7527
7528 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const throw(INTERP_KERNEL::Exception)
7529 {
7530   return new MEDFileFieldMultiTSWithoutSDA;
7531 }
7532
7533 /*!
7534  * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
7535  * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
7536  */
7537 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
7538 {
7539   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
7540   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
7541   if(!myF1TSC)
7542     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
7543   return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
7544 }
7545
7546 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const throw(INTERP_KERNEL::Exception)
7547 {
7548   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
7549   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7550   int i=0;
7551   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7552     {
7553       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7554       if(eltToConv)
7555         {
7556           const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
7557           if(!eltToConvC)
7558             throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
7559           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
7560           ret->setIteration(i,elt);
7561         }
7562     }
7563   return ret.retn();
7564 }
7565
7566 //= MEDFileAnyTypeFieldMultiTS
7567
7568 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
7569 {
7570 }
7571
7572 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
7573 try:MEDFileFieldGlobsReal(fileName)
7574 {
7575   MEDFileUtilities::CheckFileForRead(fileName);
7576   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7577   _content=BuildContentFrom(fid,fileName,loadAll);
7578   loadGlobals(fid);
7579 }
7580 catch(INTERP_KERNEL::Exception& e)
7581   {
7582     throw e;
7583   }
7584
7585 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
7586 {
7587   med_field_type typcha;
7588   std::vector<std::string> infos;
7589   std::string dtunit;
7590   int i=-1;
7591   MEDFileAnyTypeField1TS::LocateField(fid,fileName,fieldName,i,typcha,infos,dtunit);
7592   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7593   switch(typcha)
7594     {
7595     case MED_FLOAT64:
7596       {
7597         ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll);
7598         break;
7599       }
7600     case MED_INT32:
7601       {
7602         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll);
7603         break;
7604       }
7605     default:
7606       {
7607         std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
7608         throw INTERP_KERNEL::Exception(oss.str().c_str());
7609       }
7610     }
7611   ret->setDtUnit(dtunit.c_str());
7612   return ret.retn();
7613 }
7614
7615 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
7616 {
7617   med_field_type typcha;
7618   //
7619   std::vector<std::string> infos;
7620   std::string dtunit,fieldName;
7621   MEDFileAnyTypeField1TS::LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
7622   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7623   switch(typcha)
7624     {
7625     case MED_FLOAT64:
7626       {
7627         ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll);
7628         break;
7629       }
7630     case MED_INT32:
7631       {
7632         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll);
7633         break;
7634       }
7635     default:
7636       {
7637         std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fileName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
7638         throw INTERP_KERNEL::Exception(oss.str().c_str());
7639       }
7640     }
7641   ret->setDtUnit(dtunit.c_str());
7642   return ret.retn();
7643 }
7644
7645 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, const char *fileName) throw(INTERP_KERNEL::Exception)
7646 {
7647   if(!c)
7648     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
7649   if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
7650     {
7651       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=MEDFileFieldMultiTS::New();
7652       ret->setFileName(fileName);
7653       ret->_content=c;  c->incrRef();
7654       return ret.retn();
7655     }
7656   if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
7657     {
7658       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=MEDFileIntFieldMultiTS::New();
7659       ret->setFileName(fileName);
7660       ret->_content=c;  c->incrRef();
7661       return ret.retn();
7662     }
7663   throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
7664 }
7665
7666 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
7667 try:MEDFileFieldGlobsReal(fileName)
7668 {
7669   MEDFileUtilities::CheckFileForRead(fileName);
7670   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7671   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
7672   loadGlobals(fid);
7673 }
7674 catch(INTERP_KERNEL::Exception& e)
7675   {
7676     throw e;
7677   }
7678
7679 //= MEDFileIntFieldMultiTSWithoutSDA
7680
7681 MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::New(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
7682 {
7683   return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7684 }
7685
7686 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
7687 {
7688 }
7689
7690 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7691 {
7692 }
7693
7694 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
7695 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7696 {
7697 }
7698 catch(INTERP_KERNEL::Exception& e)
7699 { throw e; }
7700
7701 /*!
7702  * \param [in] fieldId field id in C mode
7703  */
7704 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll) throw(INTERP_KERNEL::Exception)
7705 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7706 {
7707 }
7708 catch(INTERP_KERNEL::Exception& e)
7709   { throw e; }
7710
7711 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const throw(INTERP_KERNEL::Exception)
7712 {
7713   return new MEDFileIntField1TSWithoutSDA;
7714 }
7715
7716 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const throw(INTERP_KERNEL::Exception)
7717 {
7718   if(!f1ts)
7719     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7720   const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
7721   if(!f1tsC)
7722     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
7723 }
7724
7725 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
7726 {
7727   return MEDFileIntField1TSWithoutSDA::TYPE_STR;
7728 }
7729
7730 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
7731 {
7732   return new MEDFileIntFieldMultiTSWithoutSDA(*this);
7733 }
7734
7735 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const throw(INTERP_KERNEL::Exception)
7736 {
7737   return new MEDFileIntFieldMultiTSWithoutSDA;
7738 }
7739
7740 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const throw(INTERP_KERNEL::Exception)
7741 {
7742   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
7743   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7744   int i=0;
7745   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7746     {
7747       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7748       if(eltToConv)
7749         {
7750           const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
7751           if(!eltToConvC)
7752             throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
7753           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
7754           ret->setIteration(i,elt);
7755         }
7756     }
7757   return ret.retn();
7758 }
7759
7760 //= MEDFileAnyTypeFieldMultiTS
7761
7762 /*!
7763  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
7764  * that has been read from a specified MED file.
7765  *  \param [in] fileName - the name of the MED file to read.
7766  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7767  *          is to delete this field using decrRef() as it is no more needed.
7768  *  \throw If reading the file fails.
7769  */
7770 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
7771 {
7772   MEDFileUtilities::CheckFileForRead(fileName);
7773   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7774   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
7775   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7776   ret->loadGlobals(fid);
7777   return ret.retn();
7778 }
7779
7780 /*!
7781  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
7782  * that has been read from a specified MED file.
7783  *  \param [in] fileName - the name of the MED file to read.
7784  *  \param [in] fieldName - the name of the field to read.
7785  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7786  *          is to delete this field using decrRef() as it is no more needed.
7787  *  \throw If reading the file fails.
7788  *  \throw If there is no field named \a fieldName in the file.
7789  */
7790 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
7791 {
7792   MEDFileUtilities::CheckFileForRead(fileName);
7793   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7794   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
7795   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7796   ret->loadGlobals(fid);
7797   return ret.retn();
7798 }
7799
7800 /*!
7801  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
7802  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
7803  *
7804  * \warning this is a shallow copy constructor
7805  */
7806 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
7807 {
7808   if(!shallowCopyOfContent)
7809     {
7810       const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
7811       otherPtr->incrRef();
7812       _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
7813     }
7814   else
7815     {
7816       _content=other.shallowCpy();
7817     }
7818 }
7819
7820 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() throw(INTERP_KERNEL::Exception)
7821 {
7822   MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7823   if(!ret)
7824     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
7825   return ret;
7826 }
7827
7828 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const throw(INTERP_KERNEL::Exception)
7829 {
7830   const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7831   if(!ret)
7832     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
7833   return ret;
7834 }
7835
7836 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
7837 {
7838   return contentNotNullBase()->getPflsReallyUsed2();
7839 }
7840
7841 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
7842 {
7843   return contentNotNullBase()->getLocsReallyUsed2();
7844 }
7845
7846 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
7847 {
7848   return contentNotNullBase()->getPflsReallyUsedMulti2();
7849 }
7850
7851 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
7852 {
7853   return contentNotNullBase()->getLocsReallyUsedMulti2();
7854 }
7855
7856 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7857 {
7858   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
7859 }
7860
7861 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7862 {
7863   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
7864 }
7865
7866 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
7867 {
7868   return contentNotNullBase()->getNumberOfTS();
7869 }
7870
7871 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS() throw(INTERP_KERNEL::Exception)
7872 {
7873   contentNotNullBase()->eraseEmptyTS();
7874 }
7875
7876 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
7877 {
7878   contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
7879 }
7880
7881 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step) throw(INTERP_KERNEL::Exception)
7882 {
7883   contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
7884 }
7885
7886 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const throw(INTERP_KERNEL::Exception)
7887 {
7888   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
7889   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7890   ret->_content=c;
7891   return ret.retn();
7892 }
7893
7894 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
7895 {
7896   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
7897   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7898   ret->_content=c;
7899   return ret.retn();
7900 }
7901
7902 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
7903 {
7904   return contentNotNullBase()->getIterations();
7905 }
7906
7907 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts) throw(INTERP_KERNEL::Exception)
7908 {
7909   for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
7910     pushBackTimeStep(*it);
7911 }
7912
7913 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts) throw(INTERP_KERNEL::Exception)
7914 {
7915   if(!f1ts)
7916     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
7917   checkCoherencyOfType(f1ts);
7918   f1ts->incrRef();
7919   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
7920   MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
7921   c->incrRef();
7922   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
7923   if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
7924     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
7925   _content->pushBackTimeStep(cSafe);
7926   appendGlobs(*f1ts,1e-12);
7927 }
7928
7929 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope() throw(INTERP_KERNEL::Exception)
7930 {
7931   contentNotNullBase()->synchronizeNameScope();
7932 }
7933
7934 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
7935 {
7936   return contentNotNullBase()->getPosOfTimeStep(iteration,order);
7937 }
7938
7939 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
7940 {
7941   return contentNotNullBase()->getPosGivenTime(time,eps);
7942 }
7943
7944 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
7945 {
7946   return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
7947 }
7948
7949 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
7950 {
7951   return contentNotNullBase()->getTypesOfFieldAvailable();
7952 }
7953
7954 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeFieldMultiTS::getFieldSplitedByType(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
7955 {
7956   return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
7957 }
7958
7959 std::string MEDFileAnyTypeFieldMultiTS::getName() const
7960 {
7961   return contentNotNullBase()->getName();
7962 }
7963
7964 void MEDFileAnyTypeFieldMultiTS::setName(const char *name)
7965 {
7966   contentNotNullBase()->setName(name);
7967 }
7968
7969 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const throw(INTERP_KERNEL::Exception)
7970 {
7971   return contentNotNullBase()->getDtUnit();
7972 }
7973
7974 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const char *dtUnit) throw(INTERP_KERNEL::Exception)
7975 {
7976   contentNotNullBase()->setDtUnit(dtUnit);
7977 }
7978
7979 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
7980 {
7981   contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
7982 }
7983
7984 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const throw(INTERP_KERNEL::Exception)
7985 {
7986   return contentNotNullBase()->getTimeSteps(ret1);
7987 }
7988
7989 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const throw(INTERP_KERNEL::Exception)
7990 {
7991   return contentNotNullBase()->getMeshName();
7992 }
7993
7994 void MEDFileAnyTypeFieldMultiTS::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
7995 {
7996   contentNotNullBase()->setMeshName(newMeshName);
7997 }
7998
7999 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
8000 {
8001   return contentNotNullBase()->changeMeshNames(modifTab);
8002 }
8003
8004 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const throw(INTERP_KERNEL::Exception)
8005 {
8006   return contentNotNullBase()->getInfo();
8007 }
8008
8009 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
8010 {
8011   return contentNotNullBase()->setInfo(info);
8012 }
8013
8014 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const throw(INTERP_KERNEL::Exception)
8015 {
8016   const std::vector<std::string> ret=getInfo();
8017   return (int)ret.size();
8018 }
8019
8020 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
8021 {
8022   writeGlobals(fid,*this);
8023   contentNotNullBase()->writeLL(fid,*this);
8024 }
8025
8026 /*!
8027  * Writes \a this field into a MED file specified by its name.
8028  *  \param [in] fileName - the MED file name.
8029  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
8030  * - 2 - erase; an existing file is removed.
8031  * - 1 - append; same data should not be present in an existing file.
8032  * - 0 - overwrite; same data present in an existing file is overwritten.
8033  *  \throw If the field name is not set.
8034  *  \throw If no field data is set.
8035  *  \throw If \a mode == 1 and the same data is present in an existing file.
8036  */
8037 void MEDFileAnyTypeFieldMultiTS::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
8038 {
8039   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
8040   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
8041   writeLL(fid);
8042 }
8043
8044 /*!
8045  * This method alloc the arrays and load potentially huge arrays contained in this field.
8046  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
8047  * This method can be also called to refresh or reinit values from a file.
8048  *
8049  * \throw If the fileName is not set or points to a non readable MED file.
8050  */
8051 void MEDFileAnyTypeFieldMultiTS::loadArrays() throw(INTERP_KERNEL::Exception)
8052 {
8053   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8054   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
8055 }
8056
8057 /*!
8058  * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
8059  * But once data loaded once, this method does nothing.
8060  *
8061  * \throw If the fileName is not set or points to a non readable MED file.
8062  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::releaseArrays
8063  */
8064 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary() throw(INTERP_KERNEL::Exception)
8065 {
8066   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8067   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
8068 }
8069
8070 /*!
8071  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
8072  * This method does not release arrays set outside the context of a MED file.
8073  *
8074  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
8075  */
8076 void MEDFileAnyTypeFieldMultiTS::releaseArrays() throw(INTERP_KERNEL::Exception)
8077 {
8078   contentNotNullBase()->releaseArrays();
8079 }
8080
8081 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
8082 {
8083   std::ostringstream oss;
8084   contentNotNullBase()->simpleRepr(0,oss,-1);
8085   simpleReprGlobs(oss);
8086   return oss.str();
8087 }
8088
8089 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySize() const
8090 {
8091   std::size_t ret=0;
8092   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)_content)
8093     ret+=_content->getHeapMemorySize();
8094   return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
8095 }
8096
8097 /*!
8098  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
8099  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8100  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
8101  */
8102 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const throw(INTERP_KERNEL::Exception)
8103 {
8104   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8105   if(!content)
8106     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
8107   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
8108   std::size_t sz(contentsSplit.size());
8109   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8110   for(std::size_t i=0;i<sz;i++)
8111     {
8112       ret[i]=shallowCpy();
8113       ret[i]->_content=contentsSplit[i];
8114     }
8115   return ret;
8116 }
8117
8118 /*!
8119  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
8120  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8121  */
8122 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
8123 {
8124   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8125   if(!content)
8126     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
8127   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitDiscretizations();
8128   std::size_t sz(contentsSplit.size());
8129   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8130   for(std::size_t i=0;i<sz;i++)
8131     {
8132       ret[i]=shallowCpy();
8133       ret[i]->_content=contentsSplit[i];
8134     }
8135   return ret;
8136 }
8137
8138 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCpy() const throw(INTERP_KERNEL::Exception)
8139 {
8140   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8141   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8142     ret->_content=_content->deepCpy();
8143   ret->deepCpyGlobs(*this);
8144   return ret.retn();
8145 }
8146
8147 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
8148 {
8149   return _content;
8150 }
8151
8152 /*!
8153  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8154  *  \param [in] iteration - the iteration number of a required time step.
8155  *  \param [in] order - the iteration order number of required time step.
8156  *  \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
8157  *          delete this field using decrRef() as it is no more needed.
8158  *  \throw If there is no required time step in \a this field.
8159  */
8160 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
8161 {
8162   int pos=getPosOfTimeStep(iteration,order);
8163   return getTimeStepAtPos(pos);
8164 }
8165
8166 /*!
8167  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8168  *  \param [in] time - the time of the time step of interest.
8169  *  \param [in] eps - a precision used to compare time values.
8170  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8171  *          delete this field using decrRef() as it is no more needed.
8172  *  \throw If there is no required time step in \a this field.
8173  */
8174 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
8175 {
8176   int pos=getPosGivenTime(time,eps);
8177   return getTimeStepAtPos(pos);
8178 }
8179
8180 /*!
8181  * This method groups not null items in \a vectFMTS per time step series. Two time series are considered equal if the list of their pair of integers iteration,order are equal.
8182  * The float64 value of time attached to the pair of integers are not considered here.
8183  *
8184  * \param [in] vectFMTS - vector of not null fields defined on a same global data pointer.
8185  * \throw If there is a null pointer in \a vectFMTS.
8186  */
8187 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS) throw(INTERP_KERNEL::Exception)
8188 {
8189   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries : presence of null instance in input vector !";
8190   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8191   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8192   while(!lstFMTS.empty())
8193     {
8194       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8195       MEDFileAnyTypeFieldMultiTS *curIt(*it);
8196       if(!curIt)
8197         throw INTERP_KERNEL::Exception(msg);
8198       std::vector< std::pair<int,int> > refIts=curIt->getIterations();
8199       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8200       elt.push_back(curIt); it=lstFMTS.erase(it);
8201       while(it!=lstFMTS.end())
8202         {
8203           curIt=*it;
8204           if(!curIt)
8205             throw INTERP_KERNEL::Exception(msg);
8206           std::vector< std::pair<int,int> > curIts=curIt->getIterations();
8207           if(refIts==curIts)
8208             { elt.push_back(curIt); it=lstFMTS.erase(it);}
8209           else
8210             it++;
8211         }
8212       ret.push_back(elt);
8213     }
8214   return ret;
8215 }
8216
8217 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator() throw(INTERP_KERNEL::Exception)
8218 {
8219   return new MEDFileAnyTypeFieldMultiTSIterator(this);
8220 }
8221
8222 //= MEDFileFieldMultiTS
8223
8224 /*!
8225  * Returns a new empty instance of MEDFileFieldMultiTS.
8226  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8227  *          is to delete this field using decrRef() as it is no more needed.
8228  */
8229 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
8230 {
8231   return new MEDFileFieldMultiTS;
8232 }
8233
8234 /*!
8235  * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
8236  * that has been read from a specified MED file.
8237  *  \param [in] fileName - the name of the MED file to read.
8238  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8239  *          is to delete this field using decrRef() as it is no more needed.
8240  *  \throw If reading the file fails.
8241  */
8242 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
8243 {
8244   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,loadAll);
8245   ret->contentNotNull();//to check that content type matches with \a this type.
8246   return ret.retn();
8247 }
8248
8249 /*!
8250  * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
8251  * that has been read from a specified MED file.
8252  *  \param [in] fileName - the name of the MED file to read.
8253  *  \param [in] fieldName - the name of the field to read.
8254  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8255  *          is to delete this field using decrRef() as it is no more needed.
8256  *  \throw If reading the file fails.
8257  *  \throw If there is no field named \a fieldName in the file.
8258  */
8259 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
8260 {
8261   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,fieldName,loadAll);
8262   ret->contentNotNull();//to check that content type matches with \a this type.
8263   return ret.retn();
8264 }
8265
8266 /*!
8267  * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8268  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8269  *
8270  * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
8271  * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8272  * \warning this is a shallow copy constructor
8273  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
8274  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8275  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8276  *          is to delete this field using decrRef() as it is no more needed.
8277  */
8278 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8279 {
8280   return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
8281 }
8282
8283 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const throw(INTERP_KERNEL::Exception)
8284 {
8285   return new MEDFileFieldMultiTS(*this);
8286 }
8287
8288 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const throw(INTERP_KERNEL::Exception)
8289 {
8290   if(!f1ts)
8291     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8292   const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
8293   if(!f1tsC)
8294     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8295 }
8296
8297 /*!
8298  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
8299  * following the given input policy.
8300  *
8301  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8302  *                            By default (true) the globals are deeply copied.
8303  * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
8304  */
8305 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
8306 {
8307   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret;
8308   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8309   if(content)
8310     {
8311       const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
8312       if(!contc)
8313         throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
8314       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
8315       ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc,getFileName()));
8316     }
8317   else
8318     ret=MEDFileIntFieldMultiTS::New();
8319   if(deepCpyGlobs)
8320     ret->deepCpyGlobs(*this);
8321   else
8322     ret->shallowCpyGlobs(*this);
8323   return ret.retn();
8324 }
8325
8326 /*!
8327  * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
8328  *  \param [in] pos - a time step id.
8329  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8330  *          delete this field using decrRef() as it is no more needed.
8331  *  \throw If \a pos is not a valid time step id.
8332  */
8333 MEDFileAnyTypeField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const throw(INTERP_KERNEL::Exception)
8334 {
8335   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8336   if(!item)
8337     {
8338       std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8339       throw INTERP_KERNEL::Exception(oss.str().c_str());
8340     }
8341   const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
8342   if(itemC)
8343     {
8344       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
8345       ret->shallowCpyGlobs(*this);
8346       return ret.retn();
8347     }
8348   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
8349   throw INTERP_KERNEL::Exception(oss.str().c_str());
8350 }
8351
8352 /*!
8353  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8354  * mesh entities of a given dimension of the first mesh in MED file.
8355  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8356  *  \param [in] type - a spatial discretization of interest.
8357  *  \param [in] iteration - the iteration number of a required time step.
8358  *  \param [in] order - the iteration order number of required time step.
8359  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8360  *  \param [in] renumPol - specifies how to permute values of the result field according to
8361  *          the optional numbers of cells and nodes, if any. The valid values are
8362  *          - 0 - do not permute.
8363  *          - 1 - permute cells.
8364  *          - 2 - permute nodes.
8365  *          - 3 - permute cells and nodes.
8366  *
8367  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8368  *          caller is to delete this field using decrRef() as it is no more needed.
8369  *  \throw If the MED file is not readable.
8370  *  \throw If there is no mesh in the MED file.
8371  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8372  *  \throw If no field values of the required parameters are available.
8373  */
8374 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
8375 {
8376   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8377   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8378   if(!myF1TSC)
8379     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
8380   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8381   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNullBase());
8382   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8383   return ret.retn();
8384 }
8385
8386 /*!
8387  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8388  * the top level cells of the first mesh in MED file.
8389  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8390  *  \param [in] type - a spatial discretization of interest.
8391  *  \param [in] iteration - the iteration number of a required time step.
8392  *  \param [in] order - the iteration order number of required time step.
8393  *  \param [in] renumPol - specifies how to permute values of the result field according to
8394  *          the optional numbers of cells and nodes, if any. The valid values are
8395  *          - 0 - do not permute.
8396  *          - 1 - permute cells.
8397  *          - 2 - permute nodes.
8398  *          - 3 - permute cells and nodes.
8399  *
8400  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8401  *          caller is to delete this field using decrRef() as it is no more needed.
8402  *  \throw If the MED file is not readable.
8403  *  \throw If there is no mesh in the MED file.
8404  *  \throw If no field values of the required parameters are available.
8405  */
8406 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const throw(INTERP_KERNEL::Exception)
8407 {
8408   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8409   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8410   if(!myF1TSC)
8411     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
8412   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8413   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNullBase());
8414   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8415   return ret.retn();
8416 }
8417
8418 /*!
8419  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8420  * a given support.
8421  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8422  *  \param [in] type - a spatial discretization of interest.
8423  *  \param [in] iteration - the iteration number of a required time step.
8424  *  \param [in] order - the iteration order number of required time step.
8425  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8426  *  \param [in] mesh - the supporting mesh.
8427  *  \param [in] renumPol - specifies how to permute values of the result field according to
8428  *          the optional numbers of cells and nodes, if any. The valid values are
8429  *          - 0 - do not permute.
8430  *          - 1 - permute cells.
8431  *          - 2 - permute nodes.
8432  *          - 3 - permute cells and nodes.
8433  *
8434  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8435  *          caller is to delete this field using decrRef() as it is no more needed.
8436  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8437  *  \throw If no field of \a this is lying on \a mesh.
8438  *  \throw If no field values of the required parameters are available.
8439  */
8440 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
8441 {
8442   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8443   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8444   if(!myF1TSC)
8445     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8446   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8447   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
8448   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8449   return ret.retn();
8450 }
8451
8452 /*!
8453  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8454  * given support.
8455  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8456  *  \param [in] type - a spatial discretization of the new field.
8457  *  \param [in] iteration - the iteration number of a required time step.
8458  *  \param [in] order - the iteration order number of required time step.
8459  *  \param [in] mesh - the supporting mesh.
8460  *  \param [in] renumPol - specifies how to permute values of the result field according to
8461  *          the optional numbers of cells and nodes, if any. The valid values are
8462  *          - 0 - do not permute.
8463  *          - 1 - permute cells.
8464  *          - 2 - permute nodes.
8465  *          - 3 - permute cells and nodes.
8466  *
8467  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8468  *          caller is to delete this field using decrRef() as it is no more needed.
8469  *  \throw If no field of \a this is lying on \a mesh.
8470  *  \throw If no field values of the required parameters are available.
8471  */
8472 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
8473 {
8474   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8475   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8476   if(!myF1TSC)
8477     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8478   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8479   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
8480   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8481   return ret.retn();
8482 }
8483
8484 /*!
8485  * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
8486  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8487  * This method is useful for MED2 file format when field on different mesh was autorized.
8488  */
8489 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const char *mname, int iteration, int order, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
8490 {
8491   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8492   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8493   if(!myF1TSC)
8494     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
8495   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8496   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
8497   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8498   return ret.retn();
8499 }
8500
8501 /*!
8502  * Returns values and a profile of the field of a given type, of a given time step,
8503  * lying on a given support.
8504  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8505  *  \param [in] type - a spatial discretization of the field.
8506  *  \param [in] iteration - the iteration number of a required time step.
8507  *  \param [in] order - the iteration order number of required time step.
8508  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8509  *  \param [in] mesh - the supporting mesh.
8510  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8511  *          field of interest lies on. If the field lies on all entities of the given
8512  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8513  *          using decrRef() as it is no more needed.
8514  *  \param [in] glob - the global data storing profiles and localization.
8515  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
8516  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8517  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8518  *  \throw If no field of \a this is lying on \a mesh.
8519  *  \throw If no field values of the required parameters are available.
8520  */
8521 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
8522 {
8523   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8524   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8525   if(!myF1TSC)
8526     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
8527   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8528   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
8529 }
8530
8531 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const throw(INTERP_KERNEL::Exception)
8532 {
8533   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8534   if(!pt)
8535     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
8536   const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
8537   if(!ret)
8538     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
8539   return ret;
8540 }
8541
8542  MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() throw(INTERP_KERNEL::Exception)
8543 {
8544   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8545   if(!pt)
8546     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
8547   MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
8548   if(!ret)
8549     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
8550   return ret;
8551 }
8552
8553 /*!
8554  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8555  * the given field is checked if its elements are sorted suitable for writing to MED file
8556  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8557  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8558  *  \param [in] field - the field to add to \a this.
8559  *  \throw If the name of \a field is empty.
8560  *  \throw If the data array of \a field is not set.
8561  *  \throw If existing time steps have different name or number of components than \a field.
8562  *  \throw If the underlying mesh of \a field has no name.
8563  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8564  */
8565 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
8566 {
8567   const DataArrayDouble *arr=0;
8568   if(field)
8569     arr=field->getArray();
8570   contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
8571 }
8572
8573 /*!
8574  * Adds a MEDCouplingFieldDouble to \a this as another time step. Specified entities of
8575  * a given dimension of a given mesh are used as the support of the given field.
8576  * Elements of the given mesh must be sorted suitable for writing to MED file.
8577  * Order of underlying mesh entities of the given field specified by \a profile parameter
8578  * is not prescribed; this method permutes field values to have them sorted by element
8579  * type as required for writing to MED file.
8580  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8581  *  \param [in] field - the field to add to \a this.
8582  *  \param [in] mesh - the supporting mesh of \a field.
8583  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
8584  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
8585  *  \throw If either \a field or \a mesh or \a profile has an empty name.
8586  *  \throw If existing time steps have different name or number of components than \a field.
8587  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8588  *  \throw If the data array of \a field is not set.
8589  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
8590  */
8591 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
8592 {
8593   const DataArrayDouble *arr=0;
8594   if(field)
8595     arr=field->getArray();
8596   contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
8597 }
8598
8599 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
8600 {
8601   _content=new MEDFileFieldMultiTSWithoutSDA;
8602 }
8603
8604 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
8605 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
8606 {
8607 }
8608 catch(INTERP_KERNEL::Exception& e)
8609   { throw e; }
8610
8611 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
8612 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
8613 {
8614 }
8615 catch(INTERP_KERNEL::Exception& e)
8616   { throw e; }
8617
8618 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
8619 {
8620 }
8621
8622 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTS::getFieldSplitedByType2(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
8623 {
8624   return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
8625 }
8626
8627 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
8628 {
8629   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
8630 }
8631
8632 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
8633 {
8634   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
8635 }
8636
8637 //= MEDFileAnyTypeFieldMultiTSIterator
8638
8639 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
8640 {
8641   if(fmts)
8642     {
8643       fmts->incrRef();
8644       _nb_iter=fmts->getNumberOfTS();
8645     }
8646 }
8647
8648 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
8649 {
8650 }
8651
8652 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt() throw(INTERP_KERNEL::Exception)
8653 {
8654   if(_iter_id<_nb_iter)
8655     {
8656       MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
8657       if(fmts)
8658         return fmts->getTimeStepAtPos(_iter_id++);
8659       else
8660         return 0;
8661     }
8662   else
8663     return 0;
8664 }
8665
8666 //= MEDFileIntFieldMultiTS
8667
8668 /*!
8669  * Returns a new empty instance of MEDFileFieldMultiTS.
8670  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8671  *          is to delete this field using decrRef() as it is no more needed.
8672  */
8673 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
8674 {
8675   return new MEDFileIntFieldMultiTS;
8676 }
8677
8678 /*!
8679  * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
8680  * that has been read from a specified MED file.
8681  *  \param [in] fileName - the name of the MED file to read.
8682  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8683  *          is to delete this field using decrRef() as it is no more needed.
8684  *  \throw If reading the file fails.
8685  */
8686 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
8687 {
8688   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,loadAll);
8689   ret->contentNotNull();//to check that content type matches with \a this type.
8690   return ret.retn();
8691 }
8692
8693 /*!
8694  * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
8695  * that has been read from a specified MED file.
8696  *  \param [in] fileName - the name of the MED file to read.
8697  *  \param [in] fieldName - the name of the field to read.
8698  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8699  *          is to delete this field using decrRef() as it is no more needed.
8700  *  \throw If reading the file fails.
8701  *  \throw If there is no field named \a fieldName in the file.
8702  */
8703 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
8704 {
8705   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,fieldName,loadAll);
8706   ret->contentNotNull();//to check that content type matches with \a this type.
8707   return ret.retn();
8708 }
8709
8710 /*!
8711  * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8712  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8713  *
8714  * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
8715  * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8716  * \warning this is a shallow copy constructor
8717  *  \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
8718  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8719  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8720  *          is to delete this field using decrRef() as it is no more needed.
8721  */
8722 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8723 {
8724   return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
8725 }
8726
8727 /*!
8728  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
8729  * following the given input policy.
8730  *
8731  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8732  *                            By default (true) the globals are deeply copied.
8733  * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
8734  */
8735 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
8736 {
8737   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret;
8738   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8739   if(content)
8740     {
8741       const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
8742       if(!contc)
8743         throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
8744       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
8745       ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc,getFileName()));
8746     }
8747   else
8748     ret=MEDFileFieldMultiTS::New();
8749   if(deepCpyGlobs)
8750     ret->deepCpyGlobs(*this);
8751   else
8752     ret->shallowCpyGlobs(*this);
8753   return ret.retn();
8754 }
8755
8756 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const throw(INTERP_KERNEL::Exception)
8757 {
8758   return new MEDFileIntFieldMultiTS(*this);
8759 }
8760
8761 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const throw(INTERP_KERNEL::Exception)
8762 {
8763   if(!f1ts)
8764     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8765   const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
8766   if(!f1tsC)
8767     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
8768 }
8769
8770 /*!
8771  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8772  * mesh entities of a given dimension of the first mesh in MED file.
8773  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8774  *  \param [in] type - a spatial discretization of interest.
8775  *  \param [in] iteration - the iteration number of a required time step.
8776  *  \param [in] order - the iteration order number of required time step.
8777  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8778  *  \param [out] arrOut - the DataArrayInt containing values of field.
8779  *  \param [in] renumPol - specifies how to permute values of the result field according to
8780  *          the optional numbers of cells and nodes, if any. The valid values are
8781  *          - 0 - do not permute.
8782  *          - 1 - permute cells.
8783  *          - 2 - permute nodes.
8784  *          - 3 - permute cells and nodes.
8785  *
8786  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8787  *          caller is to delete this field using decrRef() as it is no more needed.
8788  *  \throw If the MED file is not readable.
8789  *  \throw If there is no mesh in the MED file.
8790  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8791  *  \throw If no field values of the required parameters are available.
8792  */
8793 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8794 {
8795   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8796   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8797   if(!myF1TSC)
8798     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
8799   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8800   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arr,*contentNotNullBase());
8801   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8802   return ret.retn();
8803 }
8804
8805 /*!
8806  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8807  * the top level cells of the first mesh in MED file.
8808  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8809  *  \param [in] type - a spatial discretization of interest.
8810  *  \param [in] iteration - the iteration number of a required time step.
8811  *  \param [in] order - the iteration order number of required time step.
8812  *  \param [out] arrOut - the DataArrayInt containing values of field.
8813  *  \param [in] renumPol - specifies how to permute values of the result field according to
8814  *          the optional numbers of cells and nodes, if any. The valid values are
8815  *          - 0 - do not permute.
8816  *          - 1 - permute cells.
8817  *          - 2 - permute nodes.
8818  *          - 3 - permute cells and nodes.
8819  *
8820  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8821  *          caller is to delete this field using decrRef() as it is no more needed.
8822  *  \throw If the MED file is not readable.
8823  *  \throw If there is no mesh in the MED file.
8824  *  \throw If no field values of the required parameters are available.
8825  */
8826 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8827 {
8828   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8829   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8830   if(!myF1TSC)
8831     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
8832   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8833   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNullBase());
8834   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8835   return ret.retn();
8836 }
8837
8838 /*!
8839  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8840  * a given support.
8841  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8842  *  \param [in] type - a spatial discretization of interest.
8843  *  \param [in] iteration - the iteration number of a required time step.
8844  *  \param [in] order - the iteration order number of required time step.
8845  *  \param [out] arrOut - the DataArrayInt containing values of field.
8846  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8847  *  \param [in] mesh - the supporting mesh.
8848  *  \param [in] renumPol - specifies how to permute values of the result field according to
8849  *          the optional numbers of cells and nodes, if any. The valid values are
8850  *          - 0 - do not permute.
8851  *          - 1 - permute cells.
8852  *          - 2 - permute nodes.
8853  *          - 3 - permute cells and nodes.
8854  *
8855  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8856  *          caller is to delete this field using decrRef() as it is no more needed.
8857  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8858  *  \throw If no field of \a this is lying on \a mesh.
8859  *  \throw If no field values of the required parameters are available.
8860  */
8861 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8862 {
8863   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8864   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8865   if(!myF1TSC)
8866     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
8867   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8868   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase());
8869   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8870   return ret.retn();
8871 }
8872
8873 /*!
8874  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8875  * given support.
8876  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8877  *  \param [in] type - a spatial discretization of the new field.
8878  *  \param [in] iteration - the iteration number of a required time step.
8879  *  \param [in] order - the iteration order number of required time step.
8880  *  \param [in] mesh - the supporting mesh.
8881  *  \param [out] arrOut - the DataArrayInt containing values of field.
8882  *  \param [in] renumPol - specifies how to permute values of the result field according to
8883  *          the optional numbers of cells and nodes, if any. The valid values are
8884  *          - 0 - do not permute.
8885  *          - 1 - permute cells.
8886  *          - 2 - permute nodes.
8887  *          - 3 - permute cells and nodes.
8888  *
8889  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8890  *          caller is to delete this field using decrRef() as it is no more needed.
8891  *  \throw If no field of \a this is lying on \a mesh.
8892  *  \throw If no field values of the required parameters are available.
8893  */
8894 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8895 {
8896   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8897   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8898   if(!myF1TSC)
8899     throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
8900   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8901   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase());
8902   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8903   return ret.retn();
8904 }
8905
8906 /*!
8907  * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
8908  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8909  * This method is useful for MED2 file format when field on different mesh was autorized.
8910  */
8911 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8912 {
8913   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8914   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8915   if(!myF1TSC)
8916     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
8917   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8918   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase());
8919   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8920   return ret.retn();
8921 }
8922
8923 /*!
8924  * Returns values and a profile of the field of a given type, of a given time step,
8925  * lying on a given support.
8926  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8927  *  \param [in] type - a spatial discretization of the field.
8928  *  \param [in] iteration - the iteration number of a required time step.
8929  *  \param [in] order - the iteration order number of required time step.
8930  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8931  *  \param [in] mesh - the supporting mesh.
8932  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8933  *          field of interest lies on. If the field lies on all entities of the given
8934  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8935  *          using decrRef() as it is no more needed.
8936  *  \param [in] glob - the global data storing profiles and localization.
8937  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
8938  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8939  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8940  *  \throw If no field of \a this is lying on \a mesh.
8941  *  \throw If no field values of the required parameters are available.
8942  */
8943 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
8944 {
8945   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8946   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8947   if(!myF1TSC)
8948     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
8949   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8950   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(ret);
8951 }
8952
8953 /*!
8954  * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
8955  *  \param [in] pos - a time step id.
8956  *  \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
8957  *          delete this field using decrRef() as it is no more needed.
8958  *  \throw If \a pos is not a valid time step id.
8959  */
8960 MEDFileAnyTypeField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const throw(INTERP_KERNEL::Exception)
8961 {
8962   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8963   if(!item)
8964     {
8965       std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8966       throw INTERP_KERNEL::Exception(oss.str().c_str());
8967     }
8968   const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
8969   if(itemC)
8970     {
8971       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
8972       ret->shallowCpyGlobs(*this);
8973       return ret.retn();
8974     }
8975   std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
8976   throw INTERP_KERNEL::Exception(oss.str().c_str());
8977 }
8978
8979 /*!
8980  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8981  * the given field is checked if its elements are sorted suitable for writing to MED file
8982  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8983  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8984  *  \param [in] field - the field to add to \a this.
8985  *  \throw If the name of \a field is empty.
8986  *  \throw If the data array of \a field is not set.
8987  *  \throw If existing time steps have different name or number of components than \a field.
8988  *  \throw If the underlying mesh of \a field has no name.
8989  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8990  */
8991 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals) throw(INTERP_KERNEL::Exception)
8992 {
8993   contentNotNull()->appendFieldNoProfileSBT(field,arrOfVals,*this);
8994 }
8995
8996 /*!
8997  * Adds a MEDCouplingFieldDouble to \a this as another time step. Specified entities of
8998  * a given dimension of a given mesh are used as the support of the given field.
8999  * Elements of the given mesh must be sorted suitable for writing to MED file.
9000  * Order of underlying mesh entities of the given field specified by \a profile parameter
9001  * is not prescribed; this method permutes field values to have them sorted by element
9002  * type as required for writing to MED file.
9003  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9004  *  \param [in] field - the field to add to \a this.
9005  *  \param [in] mesh - the supporting mesh of \a field.
9006  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
9007  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
9008  *  \throw If either \a field or \a mesh or \a profile has an empty name.
9009  *  \throw If existing time steps have different name or number of components than \a field.
9010  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9011  *  \throw If the data array of \a field is not set.
9012  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
9013  */
9014 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
9015 {
9016   contentNotNull()->appendFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this);
9017 }
9018
9019 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const throw(INTERP_KERNEL::Exception)
9020 {
9021   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9022   if(!pt)
9023     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
9024   const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9025   if(!ret)
9026     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is not null but it is not of type int ! Reason is maybe that the read field has not the type INT32 !");
9027   return ret;
9028 }
9029
9030  MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() throw(INTERP_KERNEL::Exception)
9031 {
9032   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9033   if(!pt)
9034     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
9035   MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9036   if(!ret)
9037     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is not null but it is not of type int ! Reason is maybe that the read field has not the type INT32 !");
9038   return ret;
9039 }
9040
9041 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
9042 {
9043   _content=new MEDFileIntFieldMultiTSWithoutSDA;
9044 }
9045
9046 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
9047 {
9048 }
9049
9050 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
9051 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
9052 {
9053 }
9054 catch(INTERP_KERNEL::Exception& e)
9055   { throw e; }
9056
9057 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
9058 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
9059 {
9060 }
9061 catch(INTERP_KERNEL::Exception& e)
9062   { throw e; }
9063
9064 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
9065 {
9066   return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
9067 }
9068
9069 //= MEDFileFields
9070
9071 MEDFileFields *MEDFileFields::New()
9072 {
9073   return new MEDFileFields;
9074 }
9075
9076 MEDFileFields *MEDFileFields::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
9077 {
9078   return new MEDFileFields(fileName,loadAll);
9079 }
9080
9081 std::size_t MEDFileFields::getHeapMemorySize() const
9082 {
9083   std::size_t ret=_fields.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
9084   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9085     if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)*it)
9086       ret+=(*it)->getHeapMemorySize();
9087   return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
9088 }
9089
9090 MEDFileFields *MEDFileFields::deepCpy() const throw(INTERP_KERNEL::Exception)
9091 {
9092   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9093   std::size_t i=0;
9094   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9095     {
9096       if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9097         ret->_fields[i]=(*it)->deepCpy();
9098     }
9099   ret->deepCpyGlobs(*this);
9100   return ret.retn();
9101 }
9102
9103 MEDFileFields *MEDFileFields::shallowCpy() const throw(INTERP_KERNEL::Exception)
9104 {
9105   return new MEDFileFields(*this);
9106 }
9107
9108 /*!
9109  * This method scans for all fields in \a this which time steps ids are common. Time step are discriminated by the pair of integer (iteration,order) whatever
9110  * the double time value. If all returned time steps are \b exactly those for all fields in \a this output parameter \a areThereSomeForgottenTS will be set to false.
9111  * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
9112  *
9113  * \param [out] areThereSomeForgottenTS - indicates to the caller if there is some time steps in \a this that are not present for all fields in \a this.
9114  * \return the sorted list of time steps (specified with a pair of integer iteration first and order second) present for all fields in \a this.
9115  *
9116  * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9117  */
9118 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const throw(INTERP_KERNEL::Exception)
9119 {
9120   std::set< std::pair<int,int> > s;
9121   bool firstShot=true;
9122   areThereSomeForgottenTS=false;
9123   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9124     {
9125       if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9126         continue;
9127       std::vector< std::pair<int,int> > v=(*it)->getIterations();
9128       std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
9129       if(firstShot)
9130         { s=s1; firstShot=false; }
9131       else
9132         {
9133           std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
9134           if(s!=s2)
9135             areThereSomeForgottenTS=true;
9136           s=s2;
9137         }
9138     }
9139   std::vector< std::pair<int,int> > ret;
9140   std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
9141   return ret;
9142 }
9143
9144 int MEDFileFields::getNumberOfFields() const
9145 {
9146   return _fields.size();
9147 }
9148
9149 std::vector<std::string> MEDFileFields::getFieldsNames() const throw(INTERP_KERNEL::Exception)
9150 {
9151   std::vector<std::string> ret(_fields.size());
9152   int i=0;
9153   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9154     {
9155       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
9156       if(f)
9157         {
9158           ret[i]=f->getName();
9159         }
9160       else
9161         {
9162           std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
9163           throw INTERP_KERNEL::Exception(oss.str().c_str());
9164         }
9165     }
9166   return ret;
9167 }
9168
9169 std::vector<std::string> MEDFileFields::getMeshesNames() const throw(INTERP_KERNEL::Exception)
9170 {
9171   std::vector<std::string> ret;
9172   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9173     {
9174       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9175       if(cur)
9176         ret.push_back(cur->getMeshName());
9177     }
9178   return ret;
9179 }
9180
9181 std::string MEDFileFields::simpleRepr() const
9182 {
9183   std::ostringstream oss;
9184   oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
9185   simpleRepr(0,oss);
9186   return oss.str();
9187 }
9188
9189 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
9190 {
9191   int nbOfFields=getNumberOfFields();
9192   std::string startLine(bkOffset,' ');
9193   oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
9194   int i=0;
9195   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9196     {
9197       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9198       if(cur)
9199         {
9200           oss << startLine << "  - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
9201         }
9202       else
9203         {
9204           oss << startLine << "  - not defined !" << std::endl;
9205         }
9206     }
9207   i=0;
9208   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9209     {
9210       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9211       std::string chapter(17,'0'+i);
9212       oss << startLine << chapter << std::endl;
9213       if(cur)
9214         {
9215           cur->simpleRepr(bkOffset+2,oss,i);
9216         }
9217       else
9218         {
9219           oss << startLine << "  - not defined !" << std::endl;
9220         }
9221       oss << startLine << chapter << std::endl;
9222     }
9223   simpleReprGlobs(oss);
9224 }
9225
9226 MEDFileFields::MEDFileFields()
9227 {
9228 }
9229
9230 MEDFileFields::MEDFileFields(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
9231 try:MEDFileFieldGlobsReal(fileName)
9232   {
9233     MEDFileUtilities::CheckFileForRead(fileName);
9234     MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
9235     int nbFields=MEDnField(fid);
9236     _fields.resize(nbFields);
9237     med_field_type typcha;
9238     for(int i=0;i<nbFields;i++)
9239       {
9240         std::vector<std::string> infos;
9241         std::string fieldName,dtunit;
9242         int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,fileName,i,false,fieldName,typcha,infos,dtunit);
9243         switch(typcha)
9244           {
9245           case MED_FLOAT64:
9246             {
9247               _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9248               break;
9249             }
9250           case MED_INT32:
9251             {
9252               _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9253               break;
9254             }
9255           default:
9256             {
9257               std::ostringstream oss; oss << "constructor MEDFileFields(fileName) : file \'" << fileName << "\' at pos #" << i << " field has name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
9258               throw INTERP_KERNEL::Exception(oss.str().c_str());
9259             }
9260           }
9261       }
9262     loadAllGlobals(fid);
9263   }
9264 catch(INTERP_KERNEL::Exception& e)
9265   {
9266     throw e;
9267   }
9268
9269 void MEDFileFields::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
9270 {
9271   int i=0;
9272   writeGlobals(fid,*this);
9273   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9274     {
9275       const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
9276       if(!elt)
9277         {
9278           std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
9279           throw INTERP_KERNEL::Exception(oss.str().c_str());
9280         }
9281       elt->writeLL(fid,*this);
9282     }
9283 }
9284
9285 void MEDFileFields::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
9286 {
9287   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
9288   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
9289   writeLL(fid);
9290 }
9291
9292 /*!
9293  * This method alloc the arrays and load potentially huge arrays contained in this field.
9294  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
9295  * This method can be also called to refresh or reinit values from a file.
9296  *
9297  * \throw If the fileName is not set or points to a non readable MED file.
9298  */
9299 void MEDFileFields::loadArrays() throw(INTERP_KERNEL::Exception)
9300 {
9301   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9302   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9303     {
9304       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9305       if(elt)
9306         elt->loadBigArraysRecursively(fid,*elt);
9307     }
9308 }
9309
9310 /*!
9311  * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
9312  * But once data loaded once, this method does nothing.
9313  *
9314  * \throw If the fileName is not set or points to a non readable MED file.
9315  * \sa MEDFileFields::loadArrays, MEDFileFields::releaseArrays
9316  */
9317 void MEDFileFields::loadArraysIfNecessary() throw(INTERP_KERNEL::Exception)
9318 {
9319   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9320   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9321     {
9322       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9323       if(elt)
9324         elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
9325     }
9326 }
9327
9328 /*!
9329  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
9330  * This method does not release arrays set outside the context of a MED file.
9331  *
9332  * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary
9333  */
9334 void MEDFileFields::releaseArrays() throw(INTERP_KERNEL::Exception)
9335 {
9336   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9337   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9338     {
9339       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9340       if(elt)
9341         elt->releaseArrays();
9342     }
9343 }
9344
9345 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
9346 {
9347   std::vector<std::string> ret;
9348   std::set<std::string> ret2;
9349   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9350     {
9351       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
9352       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9353         if(ret2.find(*it2)==ret2.end())
9354           {
9355             ret.push_back(*it2);
9356             ret2.insert(*it2);
9357           }
9358     }
9359   return ret;
9360 }
9361
9362 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
9363 {
9364   std::vector<std::string> ret;
9365   std::set<std::string> ret2;
9366   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9367     {
9368       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9369       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9370         if(ret2.find(*it2)==ret2.end())
9371           {
9372             ret.push_back(*it2);
9373             ret2.insert(*it2);
9374           }
9375     }
9376   return ret;
9377 }
9378
9379 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
9380 {
9381   std::vector<std::string> ret;
9382   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9383     {
9384       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
9385       ret.insert(ret.end(),tmp.begin(),tmp.end());
9386     }
9387   return ret;
9388 }
9389
9390 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
9391 {
9392   std::vector<std::string> ret;
9393   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9394     {
9395       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9396       ret.insert(ret.end(),tmp.begin(),tmp.end());
9397     }
9398   return ret;
9399 }
9400
9401 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
9402 {
9403   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9404     (*it)->changePflsRefsNamesGen2(mapOfModif);
9405 }
9406
9407 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
9408 {
9409   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9410     (*it)->changeLocsRefsNamesGen2(mapOfModif);
9411 }
9412
9413 void MEDFileFields::resize(int newSize) throw(INTERP_KERNEL::Exception)
9414 {
9415   _fields.resize(newSize);
9416 }
9417
9418 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields) throw(INTERP_KERNEL::Exception)
9419 {
9420   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
9421     pushField(*it);
9422 }
9423
9424 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field) throw(INTERP_KERNEL::Exception)
9425 {
9426   if(!field)
9427     throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
9428   _fields.push_back(field->getContent());
9429   appendGlobs(*field,1e-12);
9430 }
9431
9432 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field) throw(INTERP_KERNEL::Exception)
9433 {
9434   if(!field)
9435     throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
9436   if(i>=(int)_fields.size())
9437     _fields.resize(i+1);
9438   _fields[i]=field->getContent();
9439   appendGlobs(*field,1e-12);
9440 }
9441
9442 void MEDFileFields::destroyFieldAtPos(int i) throw(INTERP_KERNEL::Exception)
9443 {
9444   destroyFieldsAtPos(&i,&i+1);
9445 }
9446
9447 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
9448 {
9449   std::vector<bool> b(_fields.size(),true);
9450   for(const int *i=startIds;i!=endIds;i++)
9451     {
9452       if(*i<0 || *i>=(int)_fields.size())
9453         {
9454           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9455           throw INTERP_KERNEL::Exception(oss.str().c_str());
9456         }
9457       b[*i]=false;
9458     }
9459   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9460   std::size_t j=0;
9461   for(std::size_t i=0;i<_fields.size();i++)
9462     if(b[i])
9463       fields[j++]=_fields[i];
9464   _fields=fields;
9465 }
9466
9467 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step) throw(INTERP_KERNEL::Exception)
9468 {
9469   static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
9470   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
9471   std::vector<bool> b(_fields.size(),true);
9472   int k=bg;
9473   for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
9474     {
9475       if(k<0 || k>=(int)_fields.size())
9476         {
9477           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
9478           throw INTERP_KERNEL::Exception(oss.str().c_str());
9479         }
9480       b[k]=false;
9481     }
9482   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9483   std::size_t j=0;
9484   for(std::size_t i=0;i<_fields.size();i++)
9485     if(b[i])
9486       fields[j++]=_fields[i];
9487   _fields=fields;
9488 }
9489
9490 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
9491 {
9492   bool ret=false;
9493   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9494     {
9495       MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9496       if(cur)
9497         ret=cur->changeMeshNames(modifTab) || ret;
9498     }
9499   return ret;
9500 }
9501
9502 /*!
9503  * \param [in] meshName the name of the mesh that will be renumbered.
9504  * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
9505  *             This code corresponds to the distribution of types in the corresponding mesh.
9506  * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
9507  * \param [in] renumO2N the old to new renumber array.
9508  * \return If true a renumbering has been performed. The structure in \a this has been modified. If false, nothing has been done: it is typically the case if \a meshName is not refered by any
9509  *         field in \a this.
9510  */
9511 bool MEDFileFields::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N) throw(INTERP_KERNEL::Exception)
9512 {
9513   bool ret=false;
9514   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9515     {
9516       MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
9517       if(fmts)
9518         {
9519           ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
9520         }
9521     }
9522   return ret;
9523 }
9524
9525 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const throw(INTERP_KERNEL::Exception)
9526 {
9527   if(i<0 || i>=(int)_fields.size())
9528     {
9529       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
9530       throw INTERP_KERNEL::Exception(oss.str().c_str());
9531     }
9532   const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
9533   if(!fmts)
9534     return 0;
9535   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret;
9536   const MEDFileFieldMultiTSWithoutSDA *fmtsC=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts);
9537   const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts);
9538   if(fmtsC)
9539     ret=MEDFileFieldMultiTS::New(*fmtsC,false);
9540   else if(fmtsC2)
9541     ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
9542   else
9543     {
9544       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
9545       throw INTERP_KERNEL::Exception(oss.str().c_str());
9546     }
9547   ret->shallowCpyGlobs(*this);
9548   return ret.retn();
9549 }
9550
9551 /*!
9552  * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
9553  * This method is accessible in python using __getitem__ with a list in input.
9554  * \return a new object that the caller should deal with.
9555  */
9556 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const throw(INTERP_KERNEL::Exception)
9557 {
9558   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9559   std::size_t sz=std::distance(startIds,endIds);
9560   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
9561   int j=0;
9562   for(const int *i=startIds;i!=endIds;i++,j++)
9563     {
9564       if(*i<0 || *i>=(int)_fields.size())
9565         {
9566           std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9567           throw INTERP_KERNEL::Exception(oss.str().c_str());
9568         }
9569       fields[j]=_fields[*i];
9570     }
9571   ret->_fields=fields;
9572   return ret.retn();
9573 }
9574
9575 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const char *fieldName) const throw(INTERP_KERNEL::Exception)
9576 {
9577   return getFieldAtPos(getPosFromFieldName(fieldName));
9578 }
9579
9580 /*!
9581  * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
9582  * This method can be seen as a filter applied on \a this, that returns an object containing
9583  * reduced the list of fields compared to those in \a this. The returned object is a new object but the object on which it lies are only
9584  * shallow copied from \a this.
9585  *
9586  * \param [in] meshName - the name of the mesh on w
9587  * \return a new object that the caller should deal with.
9588  */
9589 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const char *meshName) const throw(INTERP_KERNEL::Exception)
9590 {
9591   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9592   ret->shallowCpyOnlyUsedGlobs(*this);
9593   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9594     {
9595       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9596       if(!cur)
9597         continue;
9598       if(cur->getMeshName()==meshName)
9599         {
9600           cur->incrRef();
9601           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
9602           ret->_fields.push_back(cur2);
9603         }
9604     }
9605   return ret.retn();
9606 }
9607
9608 /*!
9609  * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
9610  * Input time steps are specified using a pair of integer (iteration, order).
9611  * This method can be seen as a filter applied on \a this, that returns an object containing the same number of fields than those in \a this,
9612  * but for each multitimestep only the time steps in \a timeSteps are kept.
9613  * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
9614  *
9615  * The returned object points to shallow copy of elements in \a this.
9616  *
9617  * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
9618  * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
9619  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9620  */
9621 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
9622 {
9623   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9624   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9625     {
9626       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9627       if(!cur)
9628         continue;
9629       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
9630       ret->_fields.push_back(elt);
9631     }
9632   ret->shallowCpyOnlyUsedGlobs(*this);
9633   return ret.retn();
9634 }
9635
9636 /*!
9637  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
9638  */
9639 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
9640 {
9641   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9642   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9643     {
9644       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9645       if(!cur)
9646         continue;
9647       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
9648       if(elt->getNumberOfTS()!=0)
9649         ret->_fields.push_back(elt);
9650     }
9651   ret->shallowCpyOnlyUsedGlobs(*this);
9652   return ret.retn();
9653 }
9654
9655 MEDFileFieldsIterator *MEDFileFields::iterator() throw(INTERP_KERNEL::Exception)
9656 {
9657   return new MEDFileFieldsIterator(this);
9658 }
9659
9660 int MEDFileFields::getPosFromFieldName(const char *fieldName) const throw(INTERP_KERNEL::Exception)
9661 {
9662   std::string tmp(fieldName);
9663   std::vector<std::string> poss;
9664   for(std::size_t i=0;i<_fields.size();i++)
9665     {
9666       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=_fields[i];
9667       if(f)
9668         {
9669           std::string fname(f->getName());
9670           if(tmp==fname)
9671             return i;
9672           else
9673             poss.push_back(fname);
9674         }
9675     }
9676   std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
9677   std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
9678   oss << " !";
9679   throw INTERP_KERNEL::Exception(oss.str().c_str());
9680 }
9681
9682 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
9683 {
9684   if(fs)
9685     {
9686       fs->incrRef();
9687       _nb_iter=fs->getNumberOfFields();
9688     }
9689 }
9690
9691 MEDFileFieldsIterator::~MEDFileFieldsIterator()
9692 {
9693 }
9694
9695 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
9696 {
9697   if(_iter_id<_nb_iter)
9698     {
9699       MEDFileFields *fs(_fs);
9700       if(fs)
9701         return fs->getFieldAtPos(_iter_id++);
9702       else
9703         return 0;
9704     }
9705   else
9706     return 0;
9707 }