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 #include "MEDFileFieldOverView.hxx"
  26
  27 #include "MEDCouplingFieldDouble.hxx"
  28 #include "MEDCouplingFieldDiscretization.hxx"
  29
  30 #include "InterpKernelAutoPtr.hxx"
  31 #include "CellModel.hxx"
  32
  33 #include <algorithm>
  34 #include <iterator>
  35
  36 extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
  37 extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
  38 extern med_geometry_type typmainoeud[1];
  39 extern med_geometry_type typmai3[34];
  40
  41 using namespace ParaMEDMEM;
  42
  43 const char MEDFileField1TSWithoutSDA::TYPE_STR[]="FLOAT64";
  44 const char MEDFileIntField1TSWithoutSDA::TYPE_STR[]="INT32";
  45
  46 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, const char *locName)
  47 {
  48   return new MEDFileFieldLoc(fid,locName);
  49 }
  50
  51 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, int id)
  52 {
  53   return new MEDFileFieldLoc(fid,id);
  54 }
  55
  56 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)
  57 {
  58   return new MEDFileFieldLoc(locName,geoType,refCoo,gsCoo,w);
  59 }
  60
  61 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, const char *locName):_name(locName)
  62 {
  63   med_geometry_type geotype;
  64   med_geometry_type sectiongeotype;
  65   int nsectionmeshcell;
  66   INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  67   INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  68   MEDlocalizationInfoByName(fid,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
  69   _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype)));
  70   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
  71   _nb_node_per_cell=cm.getNumberOfNodes();
  72   _ref_coo.resize(_dim*_nb_node_per_cell);
  73   _gs_coo.resize(_dim*_nb_gauss_pt);
  74   _w.resize(_nb_gauss_pt);
  75   MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
  76 }
  77
  78 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, int id)
  79 {
  80   med_geometry_type geotype;
  81   med_geometry_type sectiongeotype;
  82   int nsectionmeshcell;
  83   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  84   INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  85   INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  86   MEDlocalizationInfo(fid,id+1,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
  87   _name=locName;
  88   _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype)));
  89   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
  90   _nb_node_per_cell=cm.getNumberOfNodes();
  91   _ref_coo.resize(_dim*_nb_node_per_cell);
  92   _gs_coo.resize(_dim*_nb_gauss_pt);
  93   _w.resize(_nb_gauss_pt);
  94   MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
  95 }
  96
  97 MEDFileFieldLoc::MEDFileFieldLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType,
  98                                  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),
  99                                                                                                                                     _w(w)
 100 {
 101   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
 102   _dim=cm.getDimension();
 103   _nb_node_per_cell=cm.getNumberOfNodes();
 104   _nb_gauss_pt=_w.size();
 105 }
 106
 107 MEDFileFieldLoc *MEDFileFieldLoc::deepCpy() const
 108 {
 109   return new MEDFileFieldLoc(*this);
 110 }
 111
 112 std::size_t MEDFileFieldLoc::getHeapMemorySizeWithoutChildren() const
 113 {
 114   return (_ref_coo.capacity()+_gs_coo.capacity()+_w.capacity())*sizeof(double)+_name.capacity();
 115 }
 116
 117 std::vector<const BigMemoryObject *> MEDFileFieldLoc::getDirectChildren() const
 118 {
 119   return std::vector<const BigMemoryObject *>();
 120 }
 121
 122 void MEDFileFieldLoc::simpleRepr(std::ostream& oss) const
 123 {
 124   static const char OFF7[]="\n    ";
 125   oss << "\"" << _name << "\"" << OFF7;
 126   oss << "GeoType=" << INTERP_KERNEL::CellModel::GetCellModel(_geo_type).getRepr() << OFF7;
 127   oss << "Dimension=" << _dim << OFF7;
 128   oss << "Number of Gauss points=" << _nb_gauss_pt << OFF7;
 129   oss << "Number of nodes per cell=" << _nb_node_per_cell << OFF7;
 130   oss << "RefCoords="; std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 131   oss << "Weights="; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 132   oss << "GaussPtsCoords="; std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," ")); oss << std::endl;
 133 }
 134
 135 void MEDFileFieldLoc::setName(const char *name)
 136 {
 137   _name=name;
 138 }
 139
 140 bool MEDFileFieldLoc::isEqual(const MEDFileFieldLoc& other, double eps) const
 141 {
 142   if(_name!=other._name)
 143     return false;
 144   if(_dim!=other._dim)
 145     return false;
 146   if(_nb_gauss_pt!=other._nb_gauss_pt)
 147     return false;
 148   if(_nb_node_per_cell!=other._nb_node_per_cell)
 149     return false;
 150   if(_geo_type!=other._geo_type)
 151     return false;
 152   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_ref_coo,other._ref_coo,eps))
 153     return false;
 154   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_gs_coo,other._gs_coo,eps))
 155     return false;
 156   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_w,other._w,eps))
 157     return false;
 158
 159   return true;
 160 }
 161
 162 void MEDFileFieldLoc::writeLL(med_idt fid) const
 163 {
 164   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);
 165 }
 166
 167 std::string MEDFileFieldLoc::repr() const
 168 {
 169   std::ostringstream oss; oss.precision(15);
 170   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
 171   oss << "Localization \"" << _name << "\" :\n" << "  - Geometric Type : " << cm.getRepr();
 172   oss << "\n  - Dimension : " << _dim << "\n  - Number of gauss points : ";
 173   oss << _nb_gauss_pt << "\n  - Number of nodes in cell : " << _nb_node_per_cell;
 174   oss << "\n  - Ref coords are : ";
 175   int sz=_ref_coo.size();
 176   if(sz%_dim==0)
 177     {
 178       int nbOfTuples=sz/_dim;
 179       for(int i=0;i<nbOfTuples;i++)
 180         {
 181           oss << "(";
 182           for(int j=0;j<_dim;j++)
 183             { oss << _ref_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 184           oss << ") ";
 185         }
 186     }
 187   else
 188     std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," "));
 189   oss << "\n  - Gauss coords in reference element : ";
 190   sz=_gs_coo.size();
 191   if(sz%_dim==0)
 192     {
 193       int nbOfTuples=sz/_dim;
 194       for(int i=0;i<nbOfTuples;i++)
 195         {
 196           oss << "(";
 197           for(int j=0;j<_dim;j++)
 198             { oss << _gs_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 199           oss << ") ";
 200         }
 201     }
 202   else
 203     std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," "));
 204   oss << "\n  - Weights of Gauss coords are : "; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," "));
 205   return oss.str();
 206 }
 207
 208 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
 209 {
 210   _type=field->getTypeOfField();
 211   _start=start;
 212   switch(_type)
 213     {
 214     case ON_CELLS:
 215       {
 216         getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,offset,offset+nbOfCells,1);
 217         _end=_start+nbOfCells;
 218         _nval=nbOfCells;
 219         break;
 220       }
 221     case ON_GAUSS_NE:
 222       {
 223         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(field->getMesh());
 224         const int *arrPtr=arr->getConstPointer();
 225         getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,arrPtr[offset],arrPtr[offset+nbOfCells],1);
 226         _end=_start+(arrPtr[offset+nbOfCells]-arrPtr[offset]);
 227         _nval=nbOfCells;
 228         break;
 229       }
 230     case ON_GAUSS_PT:
 231       {
 232         const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
 233         const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
 234         const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
 235         if(!disc2)
 236           throw INTERP_KERNEL::Exception("assignFieldNoProfile : invalid call to this method ! Internal Error !");
 237         const DataArrayInt *dai=disc2->getArrayOfDiscIds();
 238         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai2=disc2->getOffsetArr(field->getMesh());
 239         const int *dai2Ptr=dai2->getConstPointer();
 240         int nbi=gsLoc.getWeights().size();
 241         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=dai->selectByTupleId2(offset,offset+nbOfCells,1);
 242         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
 243         const int *da3Ptr=da3->getConstPointer();
 244         if(da3->getNumberOfTuples()!=nbOfCells)
 245           {//profile : for gauss even in NoProfile !!!
 246             std::ostringstream oss; oss << "Pfl_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 247             _profile=oss.str();
 248             da3->setName(_profile.c_str());
 249             glob.appendProfile(da3);
 250           }
 251         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=DataArrayInt::New();
 252         _nval=da3->getNbOfElems();
 253         da4->alloc(_nval*nbi,1);
 254         int *da4Ptr=da4->getPointer();
 255         for(int i=0;i<_nval;i++)
 256           {
 257             int ref=dai2Ptr[offset+da3Ptr[i]];
 258             for(int j=0;j<nbi;j++)
 259               *da4Ptr++=ref+j;
 260           }
 261         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 262         _localization=oss2.str();
 263         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,da4);
 264         _end=_start+_nval*nbi;
 265         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 266         break;
 267       }
 268     default:
 269       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile : not implemented yet for such discretization type of field !");
 270     }
 271   start=_end;
 272 }
 273
 274 /*!
 275  * Leaf method of field with profile assignement. This method is the most general one. No optimization is done here.
 276  * \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).
 277  * \param [in] multiTypePfl is the end user profile specified in high level API
 278  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
 279  * \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.
 280  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
 281  * \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.
 282  */
 283 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)
 284 {
 285   _profile.clear();
 286   _type=field->getTypeOfField();
 287   std::string pflName(multiTypePfl->getName());
 288   std::ostringstream oss; oss << pflName;
 289   if(_type!=ON_NODES) { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType()); oss << "_" <<  cm.getRepr(); } else { oss << "_NODE"; }
 290   if(locIds)
 291     {
 292       if(pflName.empty())
 293         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : existing profile with empty name !");
 294       if(_type!=ON_GAUSS_PT)
 295         {
 296           locIds->setName(oss.str().c_str());
 297           glob.appendProfile(locIds);
 298           _profile=oss.str();
 299         }
 300     }
 301   _start=start;
 302   switch(_type)
 303     {
 304     case ON_NODES:
 305       {
 306          _nval=idsInPfl->getNumberOfTuples();
 307          getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,arrr->getNumberOfTuples(),1);
 308          _end=_start+_nval;
 309          break;
 310       }
 311     case ON_CELLS:
 312       {
 313         _nval=idsInPfl->getNumberOfTuples();
 314         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,idsInPfl);
 315         _end=_start+_nval;
 316         break;
 317       }
 318     case ON_GAUSS_NE:
 319       {
 320         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(mesh);
 321         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr->deltaShiftIndex();
 322         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3=arr2->selectByTupleId(multiTypePfl->begin(),multiTypePfl->end());
 323         arr3->computeOffsets2();
 324         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=idsInPfl->buildExplicitArrByRanges(arr3);
 325         int trueNval=tmp->getNumberOfTuples();
 326         _nval=idsInPfl->getNumberOfTuples();
 327         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 328         _end=_start+trueNval;
 329         break;
 330       }
 331     case ON_GAUSS_PT:
 332       {
 333         const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
 334         if(!disc2)
 335           throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
 336         const DataArrayInt *da1=disc2->getArrayOfDiscIds();
 337         const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
 338         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da1->selectByTupleId(idsInPfl->begin(),idsInPfl->end());
 339         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
 340         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=idsInPfl->selectByTupleId(da3->begin(),da3->end());
 341         //
 342         MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPart(multiTypePfl->begin(),multiTypePfl->end());
 343         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=disc2->getOffsetArr(mesh2);
 344         //
 345         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=DataArrayInt::New();
 346         int trueNval=0;
 347         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 348           trueNval+=arr->getIJ(*pt+1,0)-arr->getIJ(*pt,0);
 349         tmp->alloc(trueNval,1);
 350         int *tmpPtr=tmp->getPointer();
 351         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 352           for(int j=arr->getIJ(*pt,0);j<arr->getIJ(*pt+1,0);j++)
 353             *tmpPtr++=j;
 354         //
 355         _nval=da4->getNumberOfTuples();
 356         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 357         _end=_start+trueNval;
 358         oss << "_loc_" << _loc_id;
 359         if(locIds)
 360           {
 361             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da5=locIds->selectByTupleId(da3->begin(),da3->end());
 362             da5->setName(oss.str().c_str());
 363             glob.appendProfile(da5);
 364             _profile=oss.str();
 365           }
 366         else
 367           {
 368             if(da3->getNumberOfTuples()!=nbOfEltsInWholeMesh || !da3->isIdentity())
 369               {
 370                 da3->setName(oss.str().c_str());
 371                 glob.appendProfile(da3);
 372                 _profile=oss.str();
 373               }
 374           }
 375         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 376         _localization=oss2.str();
 377         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 378         break;
 379       }
 380     default:
 381       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : not implemented yet for such discretization type of field !");
 382     }
 383   start=_end;
 384 }
 385
 386 void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob)
 387 {
 388   _start=start;
 389   _nval=arrr->getNumberOfTuples();
 390   getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,_nval,1);
 391   _end=_start+_nval;
 392   start=_end;
 393 }
 394
 395 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int profileIt)
 396 {
 397   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,profileIt);
 398 }
 399
 400 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId)
 401 {
 402   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,locId,std::string());
 403 }
 404
 405 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(const MEDFileFieldPerMeshPerTypePerDisc& other)
 406 {
 407   return new MEDFileFieldPerMeshPerTypePerDisc(other);
 408 }
 409
 410 std::size_t MEDFileFieldPerMeshPerTypePerDisc::getHeapMemorySizeWithoutChildren() const
 411 {
 412   return _profile.capacity()+_localization.capacity()+5*sizeof(int);
 413 }
 414
 415 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerTypePerDisc::getDirectChildren() const
 416 {
 417   return std::vector<const BigMemoryObject *>();
 418 }
 419
 420 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::deepCpy(MEDFileFieldPerMeshPerType *father) const
 421 {
 422   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> ret=new MEDFileFieldPerMeshPerTypePerDisc(*this);
 423   ret->_father=father;
 424   return ret.retn();
 425 }
 426
 427 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField atype, int profileIt)
 428 try:_type(atype),_father(fath),_profile_it(profileIt)
 429   {
 430   }
 431 catch(INTERP_KERNEL::Exception& e)
 432 {
 433   throw e;
 434 }
 435
 436 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId, const std::string& dummy):_type(type),_father(fath),_loc_id(locId)
 437 {
 438 }
 439
 440 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc& other):RefCountObject(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)
 441 {
 442 }
 443
 444 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(0),_start(-std::numeric_limits<int>::max()),_end(-std::numeric_limits<int>::max()),
 445                                                                        _nval(-std::numeric_limits<int>::max()),_loc_id(-std::numeric_limits<int>::max())
 446 {
 447 }
 448
 449 const MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerTypePerDisc::getFather() const
 450 {
 451   return _father;
 452 }
 453
 454 void MEDFileFieldPerMeshPerTypePerDisc::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
 455 {
 456   INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 457   INTERP_KERNEL::AutoPtr<char> pflname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 458   std::string fieldName=nasc.getName();
 459   std::string meshName=getMeshName();
 460   int iteration=getIteration();
 461   int order=getOrder();
 462   TypeOfField type=getType();
 463   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 464   int profilesize,nbi;
 465   med_geometry_type mgeoti;
 466   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 467   _nval=MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile_it,MED_COMPACT_PFLMODE,
 468                                   pflname,&profilesize,locname,&nbi);
 469   _profile=MEDLoaderBase::buildStringFromFortran(pflname,MED_NAME_SIZE);
 470   _localization=MEDLoaderBase::buildStringFromFortran(locname,MED_NAME_SIZE);
 471   _start=start;
 472   _end=start+_nval*nbi;
 473   start=_end;
 474   if(type==ON_CELLS && !_localization.empty())
 475     {
 476       if(_localization!="MED_GAUSS_ELNO")//For compatibily with MED2.3
 477         setType(ON_GAUSS_PT);
 478       else
 479         {
 480           setType(ON_GAUSS_NE);
 481           _localization.clear();
 482         }
 483     }
 484 }
 485
 486 void MEDFileFieldPerMeshPerTypePerDisc::loadBigArray(med_idt fid, const MEDFileFieldNameScope& nasc)
 487 {
 488   std::string fieldName=nasc.getName();
 489   std::string meshName=getMeshName();
 490   int iteration=getIteration();
 491   int order=getOrder();
 492   TypeOfField type=getType();
 493   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 494   med_geometry_type mgeoti;
 495   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 496   if(_start>_end)
 497     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : internal error in range !");
 498   if(_start==_end)
 499     return ;
 500   DataArray *arr=getOrCreateAndGetArray();//arr is not null due to the spec of getOrCreateAndGetArray
 501   if(_start<0 || _start>=arr->getNumberOfTuples())
 502     {
 503       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << ") !";
 504       throw INTERP_KERNEL::Exception(oss.str().c_str());
 505     }
 506   if(_end<0 || _end>arr->getNumberOfTuples())
 507     {
 508       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << "] !";
 509       throw INTERP_KERNEL::Exception(oss.str().c_str());
 510     }
 511   med_int tmp1,nbi;
 512   INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 513   med_int nbValsInFile=MEDfieldnValueWithProfileByName(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile.c_str(),MED_COMPACT_PFLMODE,&tmp1,locname,&nbi);
 514   int nbOfCompo=arr->getNumberOfComponents();
 515   if(_end-_start!=nbValsInFile*nbi)
 516     {
 517       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 !";
 518       throw INTERP_KERNEL::Exception(oss.str().c_str());
 519     }
 520   DataArrayDouble *arrD=dynamic_cast<DataArrayDouble *>(arr);
 521   if(arrD)
 522     {
 523       double *startFeeding=arrD->getPointer()+_start*nbOfCompo;
 524       MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
 525                                  _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
 526       return ;
 527     }
 528   DataArrayInt *arrI=dynamic_cast<DataArrayInt *>(arr);
 529   if(arrI)
 530     {
 531       int *startFeeding=arrI->getPointer()+_start*nbOfCompo;
 532       MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
 533                                  _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
 534       return ;
 535     }
 536   throw INTERP_KERNEL::Exception("Error on array reading ! Unrecognized type of field ! Should be in FLOAT64 or INT32 !");
 537 }
 538
 539 /*!
 540  * Set a \c this->_start **and** \c this->_end keeping the same delta between the two.
 541  */
 542 void MEDFileFieldPerMeshPerTypePerDisc::setNewStart(int newValueOfStart)
 543 {
 544   int delta=_end-_start;
 545   _start=newValueOfStart;
 546   _end=_start+delta;
 547 }
 548
 549 int MEDFileFieldPerMeshPerTypePerDisc::getIteration() const
 550 {
 551   return _father->getIteration();
 552 }
 553
 554 int MEDFileFieldPerMeshPerTypePerDisc::getOrder() const
 555 {
 556   return _father->getOrder();
 557 }
 558
 559 double MEDFileFieldPerMeshPerTypePerDisc::getTime() const
 560 {
 561   return _father->getTime();
 562 }
 563
 564 std::string MEDFileFieldPerMeshPerTypePerDisc::getMeshName() const
 565 {
 566   return _father->getMeshName();
 567 }
 568
 569 void MEDFileFieldPerMeshPerTypePerDisc::simpleRepr(int bkOffset, std::ostream& oss, int id) const
 570 {
 571   const char startLine[]="    ## ";
 572   std::string startLine2(bkOffset,' ');
 573   startLine2+=startLine;
 574   MEDCouplingFieldDiscretization *tmp=MEDCouplingFieldDiscretization::New(_type);
 575   oss << startLine2 << "Localization #" << id << "." << std::endl;
 576   oss << startLine2 << "  Type=" << tmp->getRepr() << "." << std::endl;
 577   delete tmp;
 578   oss << startLine2 << "  This type discretization lies on profile : \"" << _profile << "\" and on the following localization : \"" << _localization << "\"." << std::endl;
 579   oss << startLine2 << "  This type discretization has " << _end-_start << " tuples (start=" << _start << ", end=" << _end << ")." << std::endl;
 580   oss << startLine2 << "  This type discretization has " << (_end-_start)/_nval << " integration points." << std::endl;
 581 }
 582
 583 TypeOfField MEDFileFieldPerMeshPerTypePerDisc::getType() const
 584 {
 585   return _type;
 586 }
 587
 588 void MEDFileFieldPerMeshPerTypePerDisc::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
 589 {
 590   types.insert(_type);
 591 }
 592
 593 void MEDFileFieldPerMeshPerTypePerDisc::setType(TypeOfField newType)
 594 {
 595   _type=newType;
 596 }
 597
 598 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerTypePerDisc::getGeoType() const
 599 {
 600   return _father->getGeoType();
 601 }
 602
 603 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfComponents() const
 604 {
 605   return _father->getNumberOfComponents();
 606 }
 607
 608 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfTuples() const
 609 {
 610   return _end-_start;
 611 }
 612
 613 DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray()
 614 {
 615   return _father->getOrCreateAndGetArray();
 616 }
 617
 618 const DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray() const
 619 {
 620   const MEDFileFieldPerMeshPerType *fath=_father;
 621   return fath->getOrCreateAndGetArray();
 622 }
 623
 624 const std::vector<std::string>& MEDFileFieldPerMeshPerTypePerDisc::getInfo() const
 625 {
 626   return _father->getInfo();
 627 }
 628
 629 std::string MEDFileFieldPerMeshPerTypePerDisc::getProfile() const
 630 {
 631   return _profile;
 632 }
 633
 634 void MEDFileFieldPerMeshPerTypePerDisc::setProfile(const char *newPflName)
 635 {
 636   _profile=newPflName;
 637 }
 638
 639 std::string MEDFileFieldPerMeshPerTypePerDisc::getLocalization() const
 640 {
 641   return _localization;
 642 }
 643
 644 void MEDFileFieldPerMeshPerTypePerDisc::setLocalization(const char *newLocName)
 645 {
 646   _localization=newLocName;
 647 }
 648
 649 void MEDFileFieldPerMeshPerTypePerDisc::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
 650 {
 651   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 652     {
 653       if(std::find((*it2).first.begin(),(*it2).first.end(),_profile)!=(*it2).first.end())
 654         {
 655           _profile=(*it2).second;
 656           return;
 657         }
 658     }
 659 }
 660
 661 void MEDFileFieldPerMeshPerTypePerDisc::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
 662 {
 663   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 664     {
 665       if(std::find((*it2).first.begin(),(*it2).first.end(),_localization)!=(*it2).first.end())
 666         {
 667           _localization=(*it2).second;
 668           return;
 669         }
 670     }
 671 }
 672
 673 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
 674 {
 675   if(type!=_type)
 676     return ;
 677   dads.push_back(std::pair<int,int>(_start,_end));
 678   geoTypes.push_back(getGeoType());
 679   if(_profile.empty())
 680     pfls.push_back(0);
 681   else
 682     {
 683       pfls.push_back(glob->getProfile(_profile.c_str()));
 684     }
 685   if(_localization.empty())
 686     locs.push_back(-1);
 687   else
 688     {
 689       locs.push_back(glob->getLocalizationId(_localization.c_str()));
 690     }
 691 }
 692
 693 void MEDFileFieldPerMeshPerTypePerDisc::fillValues(int discId, int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
 694 {
 695   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));
 696   startEntryId++;
 697 }
 698
 699 void MEDFileFieldPerMeshPerTypePerDisc::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
 700 {
 701   TypeOfField type=getType();
 702   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 703   med_geometry_type mgeoti;
 704   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 705   const DataArray *arr=getOrCreateAndGetArray();
 706   if(!arr)
 707     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : no array set !");
 708   const DataArrayDouble *arrD=dynamic_cast<const DataArrayDouble *>(arr);
 709   const DataArrayInt *arrI=dynamic_cast<const DataArrayInt *>(arr);
 710   const unsigned char *locToWrite=0;
 711   if(arrD)
 712     locToWrite=reinterpret_cast<const unsigned char *>(arrD->getConstPointer()+_start*arr->getNumberOfComponents());
 713   else if(arrI)
 714     locToWrite=reinterpret_cast<const unsigned char *>(arrI->getConstPointer()+_start*arr->getNumberOfComponents());
 715   else
 716     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : not recognized type of values ! Supported are FLOAT64 and INT32 !");
 717   MEDfieldValueWithProfileWr(fid,nasc.getName().c_str(),getIteration(),getOrder(),getTime(),menti,mgeoti,
 718                              MED_COMPACT_PFLMODE,_profile.c_str(),_localization.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,_nval,
 719                              locToWrite);
 720 }
 721
 722 void MEDFileFieldPerMeshPerTypePerDisc::getCoarseData(TypeOfField& type, std::pair<int,int>& dad, std::string& pfl, std::string& loc) const
 723 {
 724   type=_type;
 725   pfl=_profile;
 726   loc=_localization;
 727   dad.first=_start; dad.second=_end;
 728 }
 729
 730 /*!
 731  * \param [in] codeOfMesh is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
 732  *             This code corresponds to the distribution of types in the corresponding mesh.
 733  * \param [out] ptToFill memory zone where the output will be stored.
 734  * \return the size of data pushed into output param \a ptToFill
 735  */
 736 int MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode(int offset, const std::vector<int>& codeOfMesh, const MEDFileFieldGlobsReal& glob, int *ptToFill) const
 737 {
 738   _loc_id=offset;
 739   std::ostringstream oss;
 740   std::size_t nbOfType=codeOfMesh.size()/3;
 741   int found=-1;
 742   for(std::size_t i=0;i<nbOfType && found==-1;i++)
 743     if(getGeoType()==(INTERP_KERNEL::NormalizedCellType)codeOfMesh[3*i])
 744       found=(int)i;
 745   if(found==-1)
 746     {
 747       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 748       oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : not found geometric type " << cm.getRepr() << " in the referenced mesh of field !";
 749       throw INTERP_KERNEL::Exception(oss.str().c_str());
 750     }
 751   int *work=ptToFill;
 752   if(_profile.empty())
 753     {
 754       if(_nval!=codeOfMesh[3*found+1])
 755         {
 756           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 757           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << " number of elt ids in mesh is equal to " << _nval;
 758           oss << " whereas mesh has " << codeOfMesh[3*found+1] << " for this geometric type !";
 759           throw INTERP_KERNEL::Exception(oss.str().c_str());
 760         }
 761       for(int ii=codeOfMesh[3*found+2];ii<codeOfMesh[3*found+2]+_nval;ii++)
 762         *work++=ii;
 763     }
 764   else
 765     {
 766       const DataArrayInt *pfl=glob.getProfile(_profile.c_str());
 767       if(pfl->getNumberOfTuples()!=_nval)
 768         {
 769           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 770           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << ", field is defined on profile \"" << _profile << "\" and size of profile is ";
 771           oss << _nval;
 772           oss << pfl->getNumberOfTuples() << " whereas the number of ids is set to " << _nval << " for this geometric type !";
 773           throw INTERP_KERNEL::Exception(oss.str().c_str());
 774         }
 775       int offset2=codeOfMesh[3*found+2];
 776       for(const int *pflId=pfl->begin();pflId!=pfl->end();pflId++)
 777         {
 778           if(*pflId<codeOfMesh[3*found+1])
 779             *work++=offset2+*pflId;
 780         }
 781     }
 782   return _nval;
 783 }
 784
 785 int MEDFileFieldPerMeshPerTypePerDisc::fillTupleIds(int *ptToFill) const
 786 {
 787   for(int i=_start;i<_end;i++)
 788     *ptToFill++=i;
 789   return _end-_start;
 790 }
 791
 792 int MEDFileFieldPerMeshPerTypePerDisc::ConvertType(TypeOfField type, int locId)
 793 {
 794   switch(type)
 795     {
 796     case ON_CELLS:
 797       return -2;
 798     case ON_GAUSS_NE:
 799       return -1;
 800     case ON_GAUSS_PT:
 801       return locId;
 802     default:
 803       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::ConvertType : not managed type of field !");
 804     }
 805 }
 806
 807 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entries)
 808 {
 809   int id=0;
 810   std::map<std::pair<std::string,TypeOfField>,int> m;
 811   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > ret;
 812   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 813     if(m.find(std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType()))==m.end())
 814       m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]=id++;
 815   ret.resize(id);
 816   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 817     ret[m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]].push_back(*it);
 818   return ret;
 819 }
 820
 821 /*!
 822  * - \c this->_loc_id mutable attribute is used for elt id in mesh offsets.
 823  *
 824  * \param [in] offset the offset id used to take into account that \a result is not compulsary empty in input
 825  * \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.
 826  * \param [in] explicitIdsInMesh ids in mesh of the considered chunk.
 827  * \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)
 828  * \param [in,out] glob if necessary by the method, new profiles can be added to it
 829  * \param [in,out] arr after the call of this method \a arr is renumbered to be compliant with added entries to \a result.
 830  * \param [out] result All new entries will be appended on it.
 831  * \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 !)
 832  */
 833 bool MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(int offset, const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
 834                                                        const DataArrayInt *explicitIdsInMesh,
 835                                                        const std::vector<int>& newCode,
 836                                                        MEDFileFieldGlobsReal& glob, DataArrayDouble *arr,
 837                                                        std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >& result)
 838 {
 839   if(entriesOnSameDisc.empty())
 840     return false;
 841   TypeOfField type=entriesOnSameDisc[0]->getType();
 842   int szEntities=0,szTuples=0;
 843   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++)
 844     { szEntities+=(*it)->_nval; szTuples+=(*it)->_end-(*it)->_start; }
 845   int nbi=szTuples/szEntities;
 846   if(szTuples%szEntities!=0)
 847     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks : internal error the splitting into same dicretization failed !");
 848   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTuples=DataArrayInt::New(); renumTuples->alloc(szTuples,1);
 849   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ranges=MEDCouplingUMesh::ComputeRangesFromTypeDistribution(newCode);
 850   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk(entriesOnSameDisc.size());
 851   std::vector< const DataArrayInt * > newGeoTypesPerChunk2(entriesOnSameDisc.size());
 852   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk_bis(entriesOnSameDisc.size());
 853   std::vector< const DataArrayInt * > newGeoTypesPerChunk3(entriesOnSameDisc.size());
 854   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesPerChunk4=DataArrayInt::New(); newGeoTypesPerChunk4->alloc(szEntities,nbi);
 855   int id=0;
 856   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
 857     {
 858       int startOfEltIdOfChunk=(*it)->_start;
 859       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newEltIds=explicitIdsInMesh->substr(startOfEltIdOfChunk,startOfEltIdOfChunk+(*it)->_nval);
 860       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> rangeIdsForChunk=newEltIds->findRangeIdForEachTuple(ranges);
 861       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idsInRrangeForChunk=newEltIds->findIdInRangeForEachTuple(ranges);
 862       //
 863       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=rangeIdsForChunk->duplicateEachTupleNTimes(nbi); rangeIdsForChunk->rearrange(nbi);
 864       newGeoTypesPerChunk4->setPartOfValues1(tmp,(*it)->_tmp_work1-offset,(*it)->_tmp_work1+(*it)->_nval*nbi-offset,1,0,nbi,1);
 865       //
 866       newGeoTypesPerChunk[id]=rangeIdsForChunk; newGeoTypesPerChunk2[id]=rangeIdsForChunk;
 867       newGeoTypesPerChunk_bis[id]=idsInRrangeForChunk; newGeoTypesPerChunk3[id]=idsInRrangeForChunk;
 868     }
 869   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather=DataArrayInt::Aggregate(newGeoTypesPerChunk2); newGeoTypesPerChunk.clear(); newGeoTypesPerChunk2.clear();
 870   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather2=DataArrayInt::Aggregate(newGeoTypesPerChunk3); newGeoTypesPerChunk_bis.clear(); newGeoTypesPerChunk3.clear();
 871   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> diffVals=newGeoTypesEltIdsAllGather->getDifferentValues();
 872   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
 873   //
 874   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTupleIds=newGeoTypesPerChunk4->buildPermArrPerLevel();
 875   //
 876   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arrPart=arr->substr(offset,offset+szTuples);
 877   arrPart->renumberInPlace(renumTupleIds->begin());
 878   arr->setPartOfValues1(arrPart,offset,offset+szTuples,1,0,arrPart->getNumberOfComponents(),1);
 879   bool ret=false;
 880   const int *idIt=diffVals->begin();
 881   std::list<const MEDFileFieldPerMeshPerTypePerDisc *> li(entriesOnSameDisc.begin(),entriesOnSameDisc.end());
 882   int offset2=0;
 883   for(int i=0;i<diffVals->getNumberOfTuples();i++,idIt++)
 884     {
 885       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=newGeoTypesEltIdsAllGather->getIdsEqual(*idIt);
 886       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> subIds=newGeoTypesEltIdsAllGather2->selectByTupleId(ids->begin(),ids->end());
 887       int nbEntityElts=subIds->getNumberOfTuples();
 888       bool ret2;
 889       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
 890         NewObjectOnSameDiscThanPool(type,(INTERP_KERNEL::NormalizedCellType)newCode[3*(*idIt)],subIds,!subIds->isIdentity() || nbEntityElts!=newCode[3*(*idIt)+1],nbi,
 891                                     offset+offset2,
 892                                     li,glob,ret2);
 893       ret=ret || ret2;
 894       result.push_back(eltToAdd);
 895       offset2+=nbEntityElts*nbi;
 896     }
 897   ret=ret || li.empty();
 898   return ret;
 899 }
 900
 901 /*!
 902  * \param [in] typeF type of field of new chunk
 903  * \param [in] geoType the geometric type of the chunk
 904  * \param [in] idsOfMeshElt the entity ids of mesh (cells or nodes) of the new chunk.
 905  * \param [in] isPfl specifies if a profile is requested regarding size of \a idsOfMeshElt and the number of such entities regarding underlying mesh.
 906  * \param [in] nbi number of integration points
 907  * \param [in] offset The offset in the **global array of data**.
 908  * \param [in,out] entriesOnSameDisc the pool **on the same discretization** inside which it will be attempted to find an existing entry corresponding exactly
 909  *                 to the new chunk to create.
 910  * \param [in,out] glob the global shared info that will be requested for existing profiles or to append a new profile if needed.
 911  * \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
 912  *              and corresponding entry erased from \a entriesOnSameDisc.
 913  * \return a newly allocated chunk
 914  */
 915 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewObjectOnSameDiscThanPool(TypeOfField typeF, INTERP_KERNEL::NormalizedCellType geoType, DataArrayInt *idsOfMeshElt,
 916                                                                                                   bool isPfl, int nbi, int offset,
 917                                                                                                   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
 918                                                                                                   MEDFileFieldGlobsReal& glob,
 919                                                                                                   bool &notInExisting) throw(INTERP_KERNEL::Exception)
 920 {
 921   int nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
 922   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>::iterator it=entriesOnSameDisc.begin();
 923   for(;it!=entriesOnSameDisc.end();it++)
 924     {
 925       if(((INTERP_KERNEL::NormalizedCellType)(*it)->_loc_id)==geoType && (*it)->_nval==nbMeshEntities)
 926         {
 927           if(!isPfl)
 928             {
 929               if((*it)->_profile.empty())
 930                 break;
 931               else
 932                 if(!(*it)->_profile.empty())
 933                   {
 934                     const DataArrayInt *pfl=glob.getProfile((*it)->_profile.c_str());
 935                     if(pfl->isEqualWithoutConsideringStr(*idsOfMeshElt))
 936                       break;
 937                   }
 938             }
 939         }
 940     }
 941   if(it==entriesOnSameDisc.end())
 942     {
 943       notInExisting=true;
 944       MEDFileFieldPerMeshPerTypePerDisc *ret=new MEDFileFieldPerMeshPerTypePerDisc;
 945       ret->_type=typeF;
 946       ret->_loc_id=(int)geoType;
 947       ret->_nval=nbMeshEntities;
 948       ret->_start=offset;
 949       ret->_end=ret->_start+ret->_nval*nbi;
 950       if(isPfl)
 951         {
 952           idsOfMeshElt->setName(glob.createNewNameOfPfl().c_str());
 953           glob.appendProfile(idsOfMeshElt);
 954           ret->_profile=idsOfMeshElt->getName();
 955         }
 956       //tony treatment of localization
 957       return ret;
 958     }
 959   else
 960     {
 961       notInExisting=false;
 962       MEDFileFieldPerMeshPerTypePerDisc *ret=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
 963       ret->_loc_id=(int)geoType;
 964       ret->setNewStart(offset);
 965       entriesOnSameDisc.erase(it);
 966       return ret;
 967     }
 968
 969 }
 970
 971 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc)
 972 {
 973   return new MEDFileFieldPerMeshPerType(fid,fath,type,geoType,nasc);
 974 }
 975
 976 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::New(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType)
 977 {
 978   return new MEDFileFieldPerMeshPerType(fath,geoType);
 979 }
 980
 981 std::size_t MEDFileFieldPerMeshPerType::getHeapMemorySizeWithoutChildren() const
 982 {
 983   return _field_pm_pt_pd.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc>);
 984 }
 985
 986 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerType::getDirectChildren() const
 987 {
 988   std::vector<const BigMemoryObject *> ret;
 989   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
 990     {
 991       const MEDFileFieldPerMeshPerTypePerDisc *cur(*it);
 992       if(cur)
 993         ret.push_back(cur);
 994     }
 995   return ret;
 996 }
 997
 998 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::deepCpy(MEDFileFieldPerMesh *father) const
 999 {
1000   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> ret=new MEDFileFieldPerMeshPerType(*this);
1001   ret->_father=father;
1002   std::size_t i=0;
1003   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1004     {
1005       if((const MEDFileFieldPerMeshPerTypePerDisc *)*it)
1006         ret->_field_pm_pt_pd[i]=(*it)->deepCpy((MEDFileFieldPerMeshPerType *)ret);
1007     }
1008   return ret.retn();
1009 }
1010
1011 void MEDFileFieldPerMeshPerType::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1012 {
1013   std::vector<int> pos=addNewEntryIfNecessary(field,offset,nbOfCells);
1014   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1015     _field_pm_pt_pd[*it]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1016 }
1017
1018 /*!
1019  * This method is the most general one. No optimization is done here.
1020  * \param [in] multiTypePfl is the end user profile specified in high level API
1021  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
1022  * \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.
1023  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
1024  * \param [in] nbOfEltsInWholeMesh nb of elts of type \a this->_geo_type in \b WHOLE mesh
1025  * \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.
1026  */
1027 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)
1028 {
1029   std::vector<int> pos=addNewEntryIfNecessary(field,idsInPfl);
1030   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1031     _field_pm_pt_pd[*it]->assignFieldProfile(start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,arr,mesh,glob,nasc);
1032 }
1033
1034 void MEDFileFieldPerMeshPerType::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
1035 {
1036   _field_pm_pt_pd.resize(1);
1037   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1038   _field_pm_pt_pd[0]->assignNodeFieldNoProfile(start,field,arr,glob);
1039 }
1040
1041 void MEDFileFieldPerMeshPerType::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1042 {
1043   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2=pfl->deepCpy();
1044   if(!arr || !arr->isAllocated())
1045     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::assignNodeFieldProfile : input array is null, or not allocated !");
1046   _field_pm_pt_pd.resize(1);
1047   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1048   _field_pm_pt_pd[0]->assignFieldProfile(start,pfl,pfl2,pfl2,-1,field,arr,0,glob,nasc);//mesh is not requested so 0 is send.
1049 }
1050
1051 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1052 {
1053   TypeOfField type=field->getTypeOfField();
1054   if(type!=ON_GAUSS_PT)
1055     {
1056       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1057       int sz=_field_pm_pt_pd.size();
1058       bool found=false;
1059       for(int j=0;j<sz && !found;j++)
1060         {
1061           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1062             {
1063               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1064               found=true;
1065             }
1066         }
1067       if(!found)
1068         {
1069           _field_pm_pt_pd.resize(sz+1);
1070           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1071         }
1072       std::vector<int> ret(1,(int)sz);
1073       return ret;
1074     }
1075   else
1076     {
1077       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
1078       int sz2=ret2.size();
1079       std::vector<int> ret3(sz2);
1080       int k=0;
1081       for(int i=0;i<sz2;i++)
1082         {
1083           int sz=_field_pm_pt_pd.size();
1084           int locIdToFind=ret2[i];
1085           bool found=false;
1086           for(int j=0;j<sz && !found;j++)
1087             {
1088               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1089                 {
1090                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1091                   ret3[k++]=j;
1092                   found=true;
1093                 }
1094             }
1095           if(!found)
1096             {
1097               _field_pm_pt_pd.resize(sz+1);
1098               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1099               ret3[k++]=sz;
1100             }
1101         }
1102       return ret3;
1103     }
1104 }
1105
1106 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1107 {
1108   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1109   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1110   if(!disc2)
1111     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1112   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1113   if(!da)
1114     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss (no profile) : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1115   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleId2(offset,offset+nbOfCells,1);
1116   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1117   if(retTmp->presenceOfValue(-1))
1118     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1119   std::vector<int> ret(retTmp->begin(),retTmp->end());
1120   return ret;
1121 }
1122
1123 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1124 {
1125   TypeOfField type=field->getTypeOfField();
1126   if(type!=ON_GAUSS_PT)
1127     {
1128       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1129       int sz=_field_pm_pt_pd.size();
1130       bool found=false;
1131       for(int j=0;j<sz && !found;j++)
1132         {
1133           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1134             {
1135               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1136               found=true;
1137             }
1138         }
1139       if(!found)
1140         {
1141           _field_pm_pt_pd.resize(sz+1);
1142           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1143         }
1144       std::vector<int> ret(1,0);
1145       return ret;
1146     }
1147   else
1148     {
1149       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,subCells);
1150       int sz2=ret2.size();
1151       std::vector<int> ret3(sz2);
1152       int k=0;
1153       for(int i=0;i<sz2;i++)
1154         {
1155           int sz=_field_pm_pt_pd.size();
1156           int locIdToFind=ret2[i];
1157           bool found=false;
1158           for(int j=0;j<sz && !found;j++)
1159             {
1160               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1161                 {
1162                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1163                   ret3[k++]=j;
1164                   found=true;
1165                 }
1166             }
1167           if(!found)
1168             {
1169               _field_pm_pt_pd.resize(sz+1);
1170               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1171               ret3[k++]=sz;
1172             }
1173         }
1174       return ret3;
1175     }
1176 }
1177
1178 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1179 {
1180   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1181   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1182   if(!disc2)
1183     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1184   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1185   if(!da)
1186     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1187   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleIdSafe(subCells->getConstPointer(),subCells->getConstPointer()+subCells->getNumberOfTuples());
1188   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1189   if(retTmp->presenceOfValue(-1))
1190     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1191   std::vector<int> ret(retTmp->begin(),retTmp->end());
1192   return ret;
1193 }
1194
1195 const MEDFileFieldPerMesh *MEDFileFieldPerMeshPerType::getFather() const
1196 {
1197   return _father;
1198 }
1199
1200 void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
1201 {
1202   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1203   int curDim=(int)cm.getDimension();
1204   dim=std::max(dim,curDim);
1205 }
1206
1207 void MEDFileFieldPerMeshPerType::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
1208 {
1209   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1210     {
1211       (*it)->fillTypesOfFieldAvailable(types);
1212     }
1213 }
1214
1215 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
1216 {
1217   int sz=_field_pm_pt_pd.size();
1218   dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
1219   for(int i=0;i<sz;i++)
1220     {
1221       _field_pm_pt_pd[i]->getCoarseData(types[i],dads[i],pfls[i],locs[i]);
1222     }
1223 }
1224
1225 int MEDFileFieldPerMeshPerType::getIteration() const
1226 {
1227   return _father->getIteration();
1228 }
1229
1230 int MEDFileFieldPerMeshPerType::getOrder() const
1231 {
1232   return _father->getOrder();
1233 }
1234
1235 double MEDFileFieldPerMeshPerType::getTime() const
1236 {
1237   return _father->getTime();
1238 }
1239
1240 std::string MEDFileFieldPerMeshPerType::getMeshName() const
1241 {
1242   return _father->getMeshName();
1243 }
1244
1245 void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1246 {
1247   const char startLine[]="  ## ";
1248   std::string startLine2(bkOffset,' ');
1249   std::string startLine3(startLine2);
1250   startLine3+=startLine;
1251   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1252     {
1253       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1254       oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry types " << cm.getRepr() << "." << std::endl;
1255     }
1256   else
1257     oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
1258   oss << startLine3 << "Entry is defined on " <<  _field_pm_pt_pd.size() << " localizations." << std::endl;
1259   int i=0;
1260   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1261     {
1262       const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
1263       if(cur)
1264         cur->simpleRepr(bkOffset,oss,i);
1265       else
1266         {
1267           oss << startLine2 << "    ## " << "Localization #" << i << " is empty !" << std::endl;
1268         }
1269     }
1270 }
1271
1272 void MEDFileFieldPerMeshPerType::getSizes(int& globalSz, int& nbOfEntries) const
1273 {
1274   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1275     {
1276       globalSz+=(*it)->getNumberOfTuples();
1277     }
1278   nbOfEntries+=(int)_field_pm_pt_pd.size();
1279 }
1280
1281 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
1282 {
1283   return _geo_type;
1284 }
1285
1286
1287 int MEDFileFieldPerMeshPerType::getNumberOfComponents() const
1288 {
1289   return _father->getNumberOfComponents();
1290 }
1291
1292 DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray()
1293 {
1294   return _father->getOrCreateAndGetArray();
1295 }
1296
1297 const DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray() const
1298 {
1299   const MEDFileFieldPerMesh *fath=_father;
1300   return fath->getOrCreateAndGetArray();
1301 }
1302
1303 const std::vector<std::string>& MEDFileFieldPerMeshPerType::getInfo() const
1304 {
1305   return _father->getInfo();
1306 }
1307
1308 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsed() const
1309 {
1310   std::vector<std::string> ret;
1311   std::set<std::string> ret2;
1312   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1313     {
1314       std::string tmp=(*it1)->getProfile();
1315       if(!tmp.empty())
1316         if(ret2.find(tmp)==ret2.end())
1317           {
1318             ret.push_back(tmp);
1319             ret2.insert(tmp);
1320           }
1321     }
1322   return ret;
1323 }
1324
1325 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsed() const
1326 {
1327   std::vector<std::string> ret;
1328   std::set<std::string> ret2;
1329   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1330     {
1331       std::string tmp=(*it1)->getLocalization();
1332       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1333         if(ret2.find(tmp)==ret2.end())
1334           {
1335             ret.push_back(tmp);
1336             ret2.insert(tmp);
1337           }
1338     }
1339   return ret;
1340 }
1341
1342 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsedMulti() const
1343 {
1344   std::vector<std::string> ret;
1345   std::set<std::string> ret2;
1346   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1347     {
1348       std::string tmp=(*it1)->getProfile();
1349       if(!tmp.empty())
1350         ret.push_back(tmp);
1351     }
1352   return ret;
1353 }
1354
1355 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsedMulti() const
1356 {
1357   std::vector<std::string> ret;
1358   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1359     {
1360       std::string tmp=(*it1)->getLocalization();
1361       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1362         ret.push_back(tmp);
1363     }
1364   return ret;
1365 }
1366
1367 void MEDFileFieldPerMeshPerType::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1368 {
1369   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1370     (*it1)->changePflsRefsNamesGen(mapOfModif);
1371 }
1372
1373 void MEDFileFieldPerMeshPerType::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1374 {
1375   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1376     (*it1)->changeLocsRefsNamesGen(mapOfModif);
1377 }
1378
1379 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId)
1380 {
1381   if(_field_pm_pt_pd.empty())
1382     {
1383       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1384       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1385       throw INTERP_KERNEL::Exception(oss.str().c_str());
1386     }
1387   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1388     return _field_pm_pt_pd[locId];
1389   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1390   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1391   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1392   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1393   return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
1394 }
1395
1396 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) const
1397 {
1398   if(_field_pm_pt_pd.empty())
1399     {
1400       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1401       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1402       throw INTERP_KERNEL::Exception(oss.str().c_str());
1403     }
1404   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1405     return _field_pm_pt_pd[locId];
1406   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1407   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1408   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1409   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1410   return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
1411 }
1412
1413 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
1414 {
1415   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1416     {
1417       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1418       if(meshDim!=(int)cm.getDimension())
1419         return ;
1420     }
1421   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1422     (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
1423 }
1424
1425 void MEDFileFieldPerMeshPerType::fillValues(int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
1426 {
1427   int i=0;
1428   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1429     {
1430       (*it)->fillValues(i,startEntryId,entries);
1431     }
1432 }
1433
1434 void MEDFileFieldPerMeshPerType::setLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
1435 {
1436   _field_pm_pt_pd=leaves;
1437   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1438     (*it)->setFather(this);
1439 }
1440
1441 /*!
1442  *  \param [in,out] globalNum a global numbering counter for the renumbering.
1443  *  \param [out] its - list of pair (start,stop) kept
1444  *  \return bool - false if the type of field \a tof is not contained in \a this.
1445  */
1446 bool MEDFileFieldPerMeshPerType::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
1447 {
1448   bool ret=false;
1449   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd;
1450   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1451     if((*it)->getType()==tof)
1452       {
1453         newPmPtPd.push_back(*it);
1454         std::pair<int,int> bgEnd; bgEnd.first=(*it)->getStart(); bgEnd.second=(*it)->getEnd();
1455         (*it)->setNewStart(globalNum);
1456         globalNum=(*it)->getEnd();
1457         its.push_back(bgEnd);
1458         ret=true;
1459       }
1460   if(ret)
1461     _field_pm_pt_pd=newPmPtPd;
1462   return ret;
1463 }
1464
1465 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType):_father(fath),_geo_type(geoType)
1466 {
1467 }
1468
1469 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc):_father(fath),_geo_type(geoType)
1470 {
1471   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1472   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1473   med_geometry_type mgeoti;
1474   med_entity_type menti;
1475   menti=ConvertIntoMEDFileType(type,geoType,mgeoti);
1476   int nbProfiles=MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),menti,mgeoti,pflName,locName);
1477   _field_pm_pt_pd.resize(nbProfiles);
1478   for(int i=0;i<nbProfiles;i++)
1479     {
1480       _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,type,i+1);
1481     }
1482   if(type==ON_CELLS)
1483     {
1484       int nbProfiles2=MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,mgeoti,pflName,locName);
1485       for(int i=0;i<nbProfiles2;i++)
1486         _field_pm_pt_pd.push_back(MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,ON_GAUSS_NE,i+1));
1487     }
1488 }
1489
1490 void MEDFileFieldPerMeshPerType::loadOnlyStructureOfDataRecursively(med_idt fid, int &start, const MEDFileFieldNameScope& nasc)
1491 {
1492   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1493     (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1494 }
1495
1496 void MEDFileFieldPerMeshPerType::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
1497 {
1498   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1499     (*it)->loadBigArray(fid,nasc);
1500 }
1501
1502 void MEDFileFieldPerMeshPerType::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
1503 {
1504   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1505     {
1506       (*it)->copyOptionsFrom(*this);
1507       (*it)->writeLL(fid,nasc);
1508     }
1509 }
1510
1511 med_entity_type MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(TypeOfField ikType, INTERP_KERNEL::NormalizedCellType ikGeoType, med_geometry_type& medfGeoType)
1512 {
1513   switch(ikType)
1514     {
1515     case ON_CELLS:
1516       medfGeoType=typmai3[(int)ikGeoType];
1517       return MED_CELL;
1518     case ON_NODES:
1519       medfGeoType=MED_NONE;
1520       return MED_NODE;
1521     case ON_GAUSS_NE:
1522       medfGeoType=typmai3[(int)ikGeoType];
1523       return MED_NODE_ELEMENT;
1524     case ON_GAUSS_PT:
1525       medfGeoType=typmai3[(int)ikGeoType];
1526       return MED_CELL;
1527     default:
1528       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType : unexpected entity type ! internal error");
1529     }
1530   return MED_UNDEF_ENTITY_TYPE;
1531 }
1532
1533 MEDFileFieldPerMesh *MEDFileFieldPerMesh::NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc)
1534 {
1535   return new MEDFileFieldPerMesh(fid,fath,meshCsit,meshIteration,meshOrder,nasc);
1536 }
1537
1538 MEDFileFieldPerMesh *MEDFileFieldPerMesh::New(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh)
1539 {
1540   return new MEDFileFieldPerMesh(fath,mesh);
1541 }
1542
1543 std::size_t MEDFileFieldPerMesh::getHeapMemorySizeWithoutChildren() const
1544 {
1545   return _mesh_name.capacity()+_field_pm_pt.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType >);
1546 }
1547
1548 std::vector<const BigMemoryObject *> MEDFileFieldPerMesh::getDirectChildren() const
1549 {
1550   std::vector<const BigMemoryObject *> ret;
1551   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1552     {
1553       const MEDFileFieldPerMeshPerType *cur(*it);
1554       if(cur)
1555         ret.push_back(cur);
1556     }
1557   return ret;
1558 }
1559
1560 MEDFileFieldPerMesh *MEDFileFieldPerMesh::deepCpy(MEDFileAnyTypeField1TSWithoutSDA *father) const
1561 {
1562   MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
1563   ret->_father=father;
1564   std::size_t i=0;
1565   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1566     {
1567       if((const MEDFileFieldPerMeshPerType *)*it)
1568         ret->_field_pm_pt[i]=(*it)->deepCpy((MEDFileFieldPerMesh *)(ret));
1569     }
1570   return ret.retn();
1571 }
1572
1573 void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1574 {
1575   std::string startLine(bkOffset,' ');
1576   oss << startLine << "## Field part (" << id << ") lying on mesh \"" << _mesh_name << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
1577   oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
1578   int i=0;
1579   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1580     {
1581       const MEDFileFieldPerMeshPerType *cur=*it;
1582       if(cur)
1583         cur->simpleRepr(bkOffset,oss,i);
1584       else
1585         {
1586           oss << startLine << "  ## Entry geometry type #" << i << " is empty !" << std::endl;
1587         }
1588     }
1589 }
1590
1591 void MEDFileFieldPerMesh::copyTinyInfoFrom(const MEDCouplingMesh *mesh)
1592 {
1593   _mesh_name=mesh->getName();
1594   mesh->getTime(_mesh_iteration,_mesh_order);
1595 }
1596
1597 void MEDFileFieldPerMesh::assignFieldNoProfileNoRenum(int& start, const std::vector<int>& code, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1598 {
1599   int nbOfTypes=code.size()/3;
1600   int offset=0;
1601   for(int i=0;i<nbOfTypes;i++)
1602     {
1603       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1604       int nbOfCells=code[3*i+1];
1605       int pos=addNewEntryIfNecessary(type);
1606       _field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1607       offset+=nbOfCells;
1608     }
1609 }
1610
1611 /*!
1612  * This method is the most general one. No optimization is done here.
1613  * \param [in] multiTypePfl is the end user profile specified in high level API
1614  * \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].
1615  * \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.
1616  * \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.
1617  * \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.
1618  * \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.
1619  */
1620 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)
1621 {
1622   int nbOfTypes=code.size()/3;
1623   for(int i=0;i<nbOfTypes;i++)
1624     {
1625       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1626       int pos=addNewEntryIfNecessary(type);
1627       DataArrayInt *pfl=0;
1628       if(code[3*i+2]!=-1)
1629         pfl=idsPerType[code[3*i+2]];
1630       int nbOfTupes2=code2.size()/3;
1631       int found=0;
1632       for(;found<nbOfTupes2;found++)
1633         if(code[3*i]==code2[3*found])
1634           break;
1635       if(found==nbOfTupes2)
1636         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::assignFieldProfile : internal problem ! Should never happen ! Please report bug to anthony.geay@cea.fr !");
1637       _field_pm_pt[pos]->assignFieldProfile(start,multiTypePfl,idsInPflPerType[i],pfl,code2[3*found+1],field,arr,mesh,glob,nasc);
1638     }
1639 }
1640
1641 void MEDFileFieldPerMesh::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
1642 {
1643   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1644   _field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
1645 }
1646
1647 void MEDFileFieldPerMesh::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1648 {
1649   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1650   _field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,arr,glob,nasc);
1651 }
1652
1653 void MEDFileFieldPerMesh::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
1654 {
1655   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1656     (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1657 }
1658
1659 void MEDFileFieldPerMesh::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
1660 {
1661   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1662     (*it)->loadBigArraysRecursively(fid,nasc);
1663 }
1664
1665 void MEDFileFieldPerMesh::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
1666 {
1667   int nbOfTypes=_field_pm_pt.size();
1668   for(int i=0;i<nbOfTypes;i++)
1669     {
1670       _field_pm_pt[i]->copyOptionsFrom(*this);
1671       _field_pm_pt[i]->writeLL(fid,nasc);
1672     }
1673 }
1674
1675 void MEDFileFieldPerMesh::getDimension(int& dim) const
1676 {
1677   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1678     (*it)->getDimension(dim);
1679 }
1680
1681 void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
1682 {
1683   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1684     (*it)->fillTypesOfFieldAvailable(types);
1685 }
1686
1687 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
1688 {
1689   int sz=_field_pm_pt.size();
1690   std::vector< std::vector<std::pair<int,int> > > ret(sz);
1691   types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
1692   for(int i=0;i<sz;i++)
1693     {
1694       types[i]=_field_pm_pt[i]->getGeoType();
1695       _field_pm_pt[i]->fillFieldSplitedByType(ret[i],typesF[i],pfls[i],locs[i]);
1696     }
1697   return ret;
1698 }
1699
1700 double MEDFileFieldPerMesh::getTime() const
1701 {
1702   int tmp1,tmp2;
1703   return _father->getTime(tmp1,tmp2);
1704 }
1705
1706 int MEDFileFieldPerMesh::getIteration() const
1707 {
1708   return _father->getIteration();
1709 }
1710
1711 int MEDFileFieldPerMesh::getOrder() const
1712 {
1713   return _father->getOrder();
1714 }
1715
1716 int MEDFileFieldPerMesh::getNumberOfComponents() const
1717 {
1718   return _father->getNumberOfComponents();
1719 }
1720
1721 DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray()
1722 {
1723   if(!_father)
1724     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1725   return _father->getOrCreateAndGetArray();
1726 }
1727
1728 const DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray() const
1729 {
1730   if(!_father)
1731     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1732   return _father->getOrCreateAndGetArray();
1733 }
1734
1735 const std::vector<std::string>& MEDFileFieldPerMesh::getInfo() const
1736 {
1737   return _father->getInfo();
1738 }
1739
1740 /*!
1741  * type,geoTypes,dads,pfls,locs are input parameters. They should have the same size.
1742  * 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.
1743  * It returns 2 output vectors :
1744  * - 'code' of size 3*sz where sz is the number of different values into 'geoTypes'
1745  * - 'notNullPfls' contains sz2 values that are extracted from 'pfls' in which null profiles have been removed.
1746  * 'code' and 'notNullPfls' are in MEDCouplingUMesh::checkTypeConsistencyAndContig format.
1747  */
1748 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)
1749 {
1750   int notNullPflsSz=0;
1751   int nbOfArrs=geoTypes.size();
1752   for(int i=0;i<nbOfArrs;i++)
1753     if(pfls[i])
1754       notNullPflsSz++;
1755   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
1756   int nbOfDiffGeoTypes=geoTypes3.size();
1757   code.resize(3*nbOfDiffGeoTypes);
1758   notNullPfls.resize(notNullPflsSz);
1759   notNullPflsSz=0;
1760   int j=0;
1761   for(int i=0;i<nbOfDiffGeoTypes;i++)
1762     {
1763       int startZone=j;
1764       INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
1765       std::vector<const DataArrayInt *> notNullTmp;
1766       if(pfls[j])
1767         notNullTmp.push_back(pfls[j]);
1768       j++;
1769       for(;j<nbOfArrs;j++)
1770         if(geoTypes[j]==refType)
1771           {
1772             if(pfls[j])
1773               notNullTmp.push_back(pfls[j]);
1774           }
1775         else
1776           break;
1777       std::vector< std::pair<int,int> > tmpDads(dads.begin()+startZone,dads.begin()+j);
1778       std::vector<const DataArrayInt *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
1779       std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
1780       code[3*i]=(int)refType;
1781       std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
1782       code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
1783       if(notNullTmp.empty())
1784         code[3*i+2]=-1;
1785       else
1786         {
1787           notNullPfls[notNullPflsSz]=DataArrayInt::Aggregate(notNullTmp);
1788           code[3*i+2]=notNullPflsSz++;
1789         }
1790     }
1791 }
1792
1793 /*!
1794  * 'dads' 'geoTypes' and 'locs' are input parameters that should have same size sz. sz should be >=1.
1795  */
1796 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)
1797 {
1798   int sz=dads.size();
1799   int ret=0;
1800   for(int i=0;i<sz;i++)
1801     {
1802       if(locs[i]==-1)
1803         {
1804           if(type!=ON_GAUSS_NE)
1805             ret+=dads[i].second-dads[i].first;
1806           else
1807             {
1808               const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(geoTypes[i]);
1809               ret+=(dads[i].second-dads[i].first)/cm.getNumberOfNodes();
1810             }
1811         }
1812       else
1813         {
1814           int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
1815           ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
1816         }
1817     }
1818   return ret;
1819 }
1820
1821 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsed() const
1822 {
1823   std::vector<std::string> ret;
1824   std::set<std::string> ret2;
1825   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1826     {
1827       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
1828       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1829         if(ret2.find(*it2)==ret2.end())
1830           {
1831             ret.push_back(*it2);
1832             ret2.insert(*it2);
1833           }
1834     }
1835   return ret;
1836 }
1837
1838 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
1839 {
1840   std::vector<std::string> ret;
1841   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1842     {
1843       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
1844       ret.insert(ret.end(),tmp.begin(),tmp.end());
1845     }
1846   return ret;
1847 }
1848
1849 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsed() const
1850 {
1851   std::vector<std::string> ret;
1852   std::set<std::string> ret2;
1853   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1854     {
1855       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
1856       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1857         if(ret2.find(*it2)==ret2.end())
1858           {
1859             ret.push_back(*it2);
1860             ret2.insert(*it2);
1861           }
1862     }
1863   return ret;
1864 }
1865
1866 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
1867 {
1868   std::vector<std::string> ret;
1869   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1870     {
1871       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
1872       ret.insert(ret.end(),tmp.begin(),tmp.end());
1873     }
1874   return ret;
1875 }
1876
1877 bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
1878 {
1879   for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
1880     {
1881       if((*it).first==_mesh_name)
1882         {
1883           _mesh_name=(*it).second;
1884           return true;
1885         }
1886     }
1887   return false;
1888 }
1889
1890 bool MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
1891                                                       MEDFileFieldGlobsReal& glob)
1892 {
1893   if(_mesh_name!=meshName)
1894     return false;
1895   std::set<INTERP_KERNEL::NormalizedCellType> typesToKeep;
1896   for(std::size_t i=0;i<oldCode.size()/3;i++) typesToKeep.insert((INTERP_KERNEL::NormalizedCellType)oldCode[3*i]);
1897   std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > > entries;
1898   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKept;
1899   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> otherEntries;
1900   getUndergroundDataArrayExt(entries);
1901   DataArray *arr0=getOrCreateAndGetArray();//tony
1902   if(!arr0)
1903     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values of field is null !");
1904   DataArrayDouble *arr=dynamic_cast<DataArrayDouble *>(arr0);//tony
1905   if(!arr0)
1906     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values is double ! Not managed for the moment !");
1907   int sz=0;
1908   if(!arr)
1909     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
1910   for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >::const_iterator it=entries.begin();it!=entries.end();it++)
1911     {
1912       if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
1913         {
1914           entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1915           sz+=(*it).second.second-(*it).second.first;
1916         }
1917       else
1918         otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1919     }
1920   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumDefrag=DataArrayInt::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
1921   ////////////////////
1922   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInMesh=DataArrayInt::New(); explicitIdsOldInMesh->alloc(sz,1);//sz is a majorant of the real size. A realloc will be done after
1923   int *workI2=explicitIdsOldInMesh->getPointer();
1924   int sz1=0,sz2=0,sid=1;
1925   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptML=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKept);
1926   // std::vector<int> tupleIdOfStartOfNewChuncksV(entriesKeptML.size());
1927   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator itL1=entriesKeptML.begin();itL1!=entriesKeptML.end();itL1++,sid++)
1928     {
1929       //  tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
1930       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInArr=DataArrayInt::New(); explicitIdsOldInArr->alloc(sz,1);
1931       int *workI=explicitIdsOldInArr->getPointer();
1932       for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
1933         {
1934           int delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
1935           (*itL2)->setLocId(sz2);
1936           (*itL2)->_tmp_work1=(*itL2)->getStart();
1937           int delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
1938         }
1939       renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
1940     }
1941   explicitIdsOldInMesh->reAlloc(sz2);
1942   int tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
1943   ////////////////////
1944   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
1945   // perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
1946   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
1947   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
1948     {
1949       otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
1950       otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
1951       otherEntriesNew.back()->setLocId((*it)->getGeoType());
1952     }
1953   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
1954   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
1955   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
1956     {
1957       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
1958       int newStart=elt->getLocId();
1959       elt->setLocId((*it)->getGeoType());
1960       elt->setNewStart(newStart);
1961       elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
1962       entriesKeptNew.push_back(elt);
1963       entriesKeptNew2.push_back(elt);
1964     }
1965   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
1966   // perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
1967   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
1968   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
1969   bool ret=false;
1970   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
1971     {
1972       sid=0;
1973       /*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
1974         {
1975           MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
1976           curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
1977           }*/
1978       ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
1979                                                             glob,arr2,otherEntriesNew) || ret;
1980     }
1981   if(!ret)
1982     return false;
1983   // Assign new dispatching
1984   assignNewLeaves(otherEntriesNew);
1985   arr->cpyFrom(*arr2);
1986   return true;
1987 }
1988
1989 /*!
1990  * \param [in,out] globalNum a global numbering counter for the renumbering.
1991  * \param [out] its - list of pair (start,stop) kept
1992  */
1993 void MEDFileFieldPerMesh::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
1994 {
1995   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > ret;
1996   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1997     {
1998       std::vector< std::pair<int,int> > its2;
1999       if((*it)->keepOnlySpatialDiscretization(tof,globalNum,its2))
2000         {
2001           ret.push_back(*it);
2002           its.insert(its.end(),its2.begin(),its2.end());
2003         }
2004     }
2005   _field_pm_pt=ret;
2006 }
2007
2008 void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
2009 {
2010   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > > types;
2011   for( std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
2012     types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
2013   //
2014   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > fieldPmPt(types.size());
2015   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
2016   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=fieldPmPt.begin();
2017   for(;it1!=types.end();it1++,it2++)
2018     {
2019       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
2020       elt->setLeaves((*it1).second);
2021       *it2=elt;
2022     }
2023   _field_pm_pt=fieldPmPt;
2024 }
2025
2026 void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2027 {
2028   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2029     (*it)->changePflsRefsNamesGen(mapOfModif);
2030 }
2031
2032 void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2033 {
2034   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2035     (*it)->changeLocsRefsNamesGen(mapOfModif);
2036 }
2037
2038 /*!
2039  * \param [in] mesh is the whole mesh
2040  */
2041 MEDCouplingFieldDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2042 {
2043   if(_field_pm_pt.empty())
2044     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2045   //
2046   std::vector< std::pair<int,int> > dads;
2047   std::vector<const DataArrayInt *> pfls;
2048   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2049   std::vector<int> locs,code;
2050   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2051   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2052     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2053   // Sort by types
2054   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2055   if(code.empty())
2056     {
2057       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2058       throw INTERP_KERNEL::Exception(oss.str().c_str());
2059     }
2060   //
2061   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2062   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2063   if(type!=ON_NODES)
2064     {
2065       DataArrayInt *arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2066       if(!arr)
2067         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2068       else
2069         {
2070           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr);
2071           return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl,arrOut,nasc);
2072         }
2073     }
2074   else
2075     {
2076       if(code.size()!=3)
2077         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2078       int nb=code[1];
2079       if(code[2]==-1)
2080         {
2081           if(nb!=mesh->getNumberOfNodes())
2082             {
2083               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2084               oss << " nodes in mesh !";
2085               throw INTERP_KERNEL::Exception(oss.str().c_str());
2086             }
2087           return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2088         }
2089       else
2090         return finishFieldNode2(glob,dads,locs,mesh,notNullPflsPerGeoType3[0],isPfl,arrOut,nasc);
2091     }
2092 }
2093
2094 DataArray *MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
2095 {
2096   if(_field_pm_pt.empty())
2097     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2098   //
2099   std::vector<std::pair<int,int> > dads;
2100   std::vector<const DataArrayInt *> pfls;
2101   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2102   std::vector<int> locs,code;
2103   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2104   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2105     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2106   // Sort by types
2107   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2108   if(code.empty())
2109     {
2110       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2111       throw INTERP_KERNEL::Exception(oss.str().c_str());
2112     }
2113   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2114   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2115   if(type!=ON_NODES)
2116     {
2117       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2118       return finishField4(dads,arr,mesh->getNumberOfCells(),pfl);
2119     }
2120   else
2121     {
2122       if(code.size()!=3)
2123         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2124       int nb=code[1];
2125       if(code[2]==-1)
2126         {
2127           if(nb!=mesh->getNumberOfNodes())
2128             {
2129               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2130               oss << " nodes in mesh !";
2131               throw INTERP_KERNEL::Exception(oss.str().c_str());
2132             }
2133         }
2134       return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
2135     }
2136   //
2137   return 0;
2138 }
2139
2140 void MEDFileFieldPerMesh::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
2141 {
2142   int globalSz=0;
2143   int nbOfEntries=0;
2144   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2145     {
2146       (*it)->getSizes(globalSz,nbOfEntries);
2147     }
2148   entries.resize(nbOfEntries);
2149   nbOfEntries=0;
2150   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2151     {
2152       (*it)->fillValues(nbOfEntries,entries);
2153     }
2154 }
2155
2156 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId)
2157 {
2158   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2159     {
2160       if((*it)->getGeoType()==typ)
2161         return (*it)->getLeafGivenLocId(locId);
2162     }
2163   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2164   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2165   oss << "Possiblities are : ";
2166   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2167     {
2168       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2169       oss << "\"" << cm2.getRepr() << "\", ";
2170     }
2171   throw INTERP_KERNEL::Exception(oss.str().c_str());
2172 }
2173
2174 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) const
2175 {
2176   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2177     {
2178       if((*it)->getGeoType()==typ)
2179         return (*it)->getLeafGivenLocId(locId);
2180     }
2181   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2182   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2183   oss << "Possiblities are : ";
2184   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2185     {
2186       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2187       oss << "\"" << cm2.getRepr() << "\", ";
2188     }
2189   throw INTERP_KERNEL::Exception(oss.str().c_str());
2190 }
2191
2192 int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
2193 {
2194   int i=0;
2195   int pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
2196   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=_field_pm_pt.begin();
2197   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
2198     {
2199       INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
2200       if(type==curType)
2201         return i;
2202       else
2203         {
2204           int pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
2205           if(pos>pos2)
2206             it2=it+1;
2207         }
2208     }
2209   int ret=std::distance(_field_pm_pt.begin(),it2);
2210   _field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
2211   return ret;
2212 }
2213
2214 /*!
2215  * 'dads' and 'locs' input parameters have the same number of elements
2216  * \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
2217  */
2218 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2219                                                          const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs,
2220                                                          const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2221 {
2222   isPfl=false;
2223   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(type,ONE_TIME);
2224   ret->setMesh(mesh); ret->setName(nasc.getName().c_str()); ret->setTime(getTime(),getIteration(),getOrder()); ret->setTimeUnit(nasc.getDtUnit().c_str());
2225   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2226   const std::vector<std::string>& infos=getInfo();
2227   da->setInfoOnComponents(infos);
2228   da->setName("");
2229   if(type==ON_GAUSS_PT)
2230     {
2231       int offset=0;
2232       int nbOfArrs=dads.size();
2233       for(int i=0;i<nbOfArrs;i++)
2234         {
2235           std::vector<std::pair<int,int> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
2236           const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
2237           int nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
2238           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> di=DataArrayInt::New();
2239           di->alloc(nbOfElems,1);
2240           di->iota(offset);
2241           const MEDFileFieldLoc& fl=glob->getLocalizationFromId(locs[i]);
2242           ret->setGaussLocalizationOnCells(di->getConstPointer(),di->getConstPointer()+nbOfElems,fl.getRefCoords(),fl.getGaussCoords(),fl.getGaussWeights());
2243           offset+=nbOfElems;
2244         }
2245     }
2246   arrOut=da;
2247   return ret.retn();
2248 }
2249
2250 /*!
2251  * 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.
2252  * 'dads', 'locs' and 'geoTypes' input parameters have the same number of elements.
2253  * No check of this is performed. 'da' array contains an array in old2New style to be applyied to mesh to obtain the right support.
2254  * The order of cells in the returned field is those imposed by the profile.
2255  * \param [in] mesh is the global mesh.
2256  */
2257 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2258                                                           const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2259                                                           const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
2260                                                           const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2261 {
2262   if(da->isIdentity())
2263     {
2264       int nbOfTuples=da->getNumberOfTuples();
2265       if(nbOfTuples==mesh->getNumberOfCells())
2266         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2267     }
2268   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m2=mesh->buildPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2269   m2->setName(mesh->getName().c_str());
2270   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(type,glob,dads,locs,m2,isPfl,arrOut,nasc);
2271   isPfl=true;
2272   return ret.retn();
2273 }
2274
2275 /*!
2276  * This method is the complement of MEDFileFieldPerMesh::finishField2 method except that this method works for node profiles.
2277  */
2278 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishFieldNode2(const MEDFileFieldGlobsReal *glob,
2279                                                               const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2280                                                               const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2281 {
2282   if(da->isIdentity())
2283     {
2284       int nbOfTuples=da->getNumberOfTuples();
2285       if(nbOfTuples==mesh->getNumberOfNodes())//No problem for NORM_ERROR because it is in context of node
2286         return finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2287     }
2288   // Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
2289   const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
2290   if(meshu)
2291     {
2292       if(meshu->getNodalConnectivity()==0)
2293         {
2294           MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2295           int nb=da->getNbOfElems();
2296           const int *ptr=da->getConstPointer();
2297           MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
2298           meshuc->allocateCells(nb);
2299           for(int i=0;i<nb;i++)
2300             meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
2301           meshuc->finishInsertingCells();
2302           ret->setMesh(meshuc);
2303           const MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
2304           if(!disc) throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::finishFieldNode2 : internal error, no discretization on field !");
2305           disc->checkCoherencyBetween(meshuc,arrOut);
2306           return ret.retn();
2307         }
2308     }
2309   //
2310   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2311   isPfl=true;
2312   DataArrayInt *arr2=0;
2313   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2314   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
2315   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3(arr2);
2316   int nnodes=mesh2->getNumberOfNodes();
2317   if(nnodes==(int)da->getNbOfElems())
2318     {
2319       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
2320       arrOut->renumberInPlace(da3->getConstPointer());
2321       mesh2->setName(mesh->getName().c_str());
2322       ret->setMesh(mesh2);
2323       return ret.retn();
2324     }
2325   else
2326     {
2327       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 !!!";
2328       oss << "So it is impossible to return a well definied MEDCouplingFieldDouble instance on specified mesh on a specified meshDim !" << std::endl;
2329       oss << "To retrieve correctly such a field you have 3 possibilities :" << std::endl;
2330       oss << " - use an another meshDim compatible with the field on nodes (MED file does not have such information)" << std::endl;
2331       oss << " - use an another a meshDimRelToMax equal to 1 -> it will return a mesh with artificial cell POINT1 containing the profile !" << std::endl;
2332       oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
2333       throw INTERP_KERNEL::Exception(oss.str().c_str());
2334     }
2335   return 0;
2336 }
2337
2338 /*!
2339  * This method is the most light method of field retrieving.
2340  */
2341 DataArray *MEDFileFieldPerMesh::finishField4(const std::vector<std::pair<int,int> >& dads, const DataArrayInt *pflIn, int nbOfElems, DataArrayInt *&pflOut) const
2342 {
2343   if(!pflIn)
2344     {
2345       pflOut=DataArrayInt::New();
2346       pflOut->alloc(nbOfElems,1);
2347       pflOut->iota(0);
2348     }
2349   else
2350     {
2351       pflOut=const_cast<DataArrayInt*>(pflIn);
2352       pflOut->incrRef();
2353     }
2354   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> safePfl(pflOut);
2355   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2356   const std::vector<std::string>& infos=getInfo();
2357   int nbOfComp=infos.size();
2358   for(int i=0;i<nbOfComp;i++)
2359     da->setInfoOnComponent(i,infos[i].c_str());
2360   safePfl->incrRef();
2361   return da.retn();
2362 }
2363
2364 MEDFileFieldPerMesh::MEDFileFieldPerMesh(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc):_mesh_iteration(meshIteration),_mesh_order(meshOrder),
2365                                                                                                                                                                                                                  _mesh_csit(meshCsit),_father(fath)
2366 {
2367   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2368   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2369   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2370   for(int i=0;i<MED_N_CELL_FIXED_GEO;i++)
2371     {
2372       int nbProfile =MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL        ,typmai[i],_mesh_csit,meshName,pflName,locName);
2373       std::string name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
2374       int nbProfile2=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[i],_mesh_csit,meshName,pflName,locName);
2375       std::string name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
2376       if(nbProfile>0 || nbProfile2>0)
2377         {
2378           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[i],nasc));
2379           if(nbProfile>0)
2380             _mesh_name=name0;
2381           else
2382             _mesh_name=name1;
2383         }
2384     }
2385   int nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,_mesh_csit,meshName,pflName,locName);
2386   if(nbProfile>0)
2387     {
2388       _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc));
2389       _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2390     }
2391 }
2392
2393 MEDFileFieldPerMesh::MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh):_father(fath)
2394 {
2395   copyTinyInfoFrom(mesh);
2396 }
2397
2398 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int id, const char *pflName)
2399 {
2400   if(id>=(int)_pfls.size())
2401     _pfls.resize(id+1);
2402   _pfls[id]=DataArrayInt::New();
2403   int lgth=MEDprofileSizeByName(fid,pflName);
2404   _pfls[id]->setName(pflName);
2405   _pfls[id]->alloc(lgth,1);
2406   MEDprofileRd(fid,pflName,_pfls[id]->getPointer());
2407   _pfls[id]->applyLin(1,-1,0);//Converting into C format
2408 }
2409
2410 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int i)
2411 {
2412   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2413   int sz;
2414   MEDprofileInfo(fid,i+1,pflName,&sz);
2415   std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
2416   if(i>=(int)_pfls.size())
2417     _pfls.resize(i+1);
2418   _pfls[i]=DataArrayInt::New();
2419   _pfls[i]->alloc(sz,1);
2420   _pfls[i]->setName(pflCpp.c_str());
2421   MEDprofileRd(fid,pflName,_pfls[i]->getPointer());
2422   _pfls[i]->applyLin(1,-1,0);//Converting into C format
2423 }
2424
2425 void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
2426 {
2427   int nbOfPfls=_pfls.size();
2428   for(int i=0;i<nbOfPfls;i++)
2429     {
2430       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cpy=_pfls[i]->deepCpy();
2431       cpy->applyLin(1,1,0);
2432       INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2433       MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
2434       MEDprofileWr(fid,pflName,_pfls[i]->getNumberOfTuples(),cpy->getConstPointer());
2435     }
2436   //
2437   int nbOfLocs=_locs.size();
2438   for(int i=0;i<nbOfLocs;i++)
2439     _locs[i]->writeLL(fid);
2440 }
2441
2442 void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps)
2443 {
2444   std::vector<std::string> pfls=getPfls();
2445   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
2446     {
2447       std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
2448       if(it2==pfls.end())
2449         {
2450           _pfls.push_back(*it);
2451         }
2452       else
2453         {
2454           int id=std::distance(pfls.begin(),it2);
2455           if(!(*it)->isEqual(*_pfls[id]))
2456             {
2457               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2458               throw INTERP_KERNEL::Exception(oss.str().c_str());
2459             }
2460         }
2461     }
2462   std::vector<std::string> locs=getLocs();
2463   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=other._locs.begin();it!=other._locs.end();it++)
2464     {
2465       std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
2466       if(it2==locs.end())
2467         {
2468           _locs.push_back(*it);
2469         }
2470       else
2471         {
2472           int id=std::distance(locs.begin(),it2);
2473           if(!(*it)->isEqual(*_locs[id],eps))
2474             {
2475               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2476               throw INTERP_KERNEL::Exception(oss.str().c_str());
2477             }
2478         }
2479     }
2480 }
2481
2482 void MEDFileFieldGlobs::checkGlobsPflsPartCoherency(const std::vector<std::string>& pflsUsed) const
2483 {
2484   for(std::vector<std::string>::const_iterator it=pflsUsed.begin();it!=pflsUsed.end();it++)
2485     getProfile((*it).c_str());
2486 }
2487
2488 void MEDFileFieldGlobs::checkGlobsLocsPartCoherency(const std::vector<std::string>& locsUsed) const
2489 {
2490   for(std::vector<std::string>::const_iterator it=locsUsed.begin();it!=locsUsed.end();it++)
2491     getLocalization((*it).c_str());
2492 }
2493
2494 void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real)
2495 {
2496   std::vector<std::string> profiles=real.getPflsReallyUsed();
2497   int sz=profiles.size();
2498   _pfls.resize(sz);
2499   for(int i=0;i<sz;i++)
2500     loadProfileInFile(fid,i,profiles[i].c_str());
2501   //
2502   std::vector<std::string> locs=real.getLocsReallyUsed();
2503   sz=locs.size();
2504   _locs.resize(sz);
2505   for(int i=0;i<sz;i++)
2506     _locs[i]=MEDFileFieldLoc::New(fid,locs[i].c_str());
2507 }
2508
2509 void MEDFileFieldGlobs::loadAllGlobals(med_idt fid)
2510 {
2511   int nProfil=MEDnProfile(fid);
2512   for(int i=0;i<nProfil;i++)
2513     loadProfileInFile(fid,i);
2514   int sz=MEDnLocalization(fid);
2515   _locs.resize(sz);
2516   for(int i=0;i<sz;i++)
2517     {
2518       _locs[i]=MEDFileFieldLoc::New(fid,i);
2519     }
2520 }
2521
2522 MEDFileFieldGlobs *MEDFileFieldGlobs::New(const char *fname)
2523 {
2524   return new MEDFileFieldGlobs(fname);
2525 }
2526
2527 MEDFileFieldGlobs *MEDFileFieldGlobs::New()
2528 {
2529   return new MEDFileFieldGlobs;
2530 }
2531
2532 std::size_t MEDFileFieldGlobs::getHeapMemorySizeWithoutChildren() const
2533 {
2534   return _file_name.capacity()+_pfls.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<DataArrayInt>)+_locs.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>);
2535 }
2536
2537 std::vector<const BigMemoryObject *> MEDFileFieldGlobs::getDirectChildren() const
2538 {
2539   std::vector<const BigMemoryObject *> ret;
2540   for(std::vector< MEDCouplingAutoRefCountObjectPtr< DataArrayInt > >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2541     {
2542       const DataArrayInt *cur(*it);
2543       if(cur)
2544         ret.push_back(cur);
2545     }
2546   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2547     {
2548       const MEDFileFieldLoc *cur(*it);
2549       if(cur)
2550         ret.push_back(cur);
2551     }
2552   return ret;
2553 }
2554
2555 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpy() const
2556 {
2557   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
2558   std::size_t i=0;
2559   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2560     {
2561       if((const DataArrayInt *)*it)
2562         ret->_pfls[i]=(*it)->deepCpy();
2563     }
2564   i=0;
2565   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2566     {
2567       if((const MEDFileFieldLoc*)*it)
2568         ret->_locs[i]=(*it)->deepCpy();
2569     }
2570   return ret.retn();
2571 }
2572
2573 /*!
2574  * \throw if a profile in \a pfls in not in \a this.
2575  * \throw if a localization in \a locs in not in \a this.
2576  * \sa MEDFileFieldGlobs::deepCpyPart
2577  */
2578 MEDFileFieldGlobs *MEDFileFieldGlobs::shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
2579 {
2580   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2581   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2582     {
2583       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2584       if(!pfl)
2585         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! pfl null !");
2586       pfl->incrRef();
2587       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2(pfl);
2588       ret->_pfls.push_back(pfl2);
2589     }
2590   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2591     {
2592       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2593       if(!loc)
2594         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! loc null !");
2595       loc->incrRef();
2596       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> loc2(loc);
2597       ret->_locs.push_back(loc2);
2598     }
2599   ret->setFileName(getFileName());
2600   return ret.retn();
2601 }
2602
2603 /*!
2604  * \throw if a profile in \a pfls in not in \a this.
2605  * \throw if a localization in \a locs in not in \a this.
2606  * \sa MEDFileFieldGlobs::shallowCpyPart
2607  */
2608 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
2609 {
2610   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2611   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2612     {
2613       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2614       if(!pfl)
2615         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! pfl null !");
2616       ret->_pfls.push_back(pfl->deepCpy());
2617     }
2618   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2619     {
2620       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2621       if(!loc)
2622         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! loc null !");
2623       ret->_locs.push_back(loc->deepCpy());
2624     }
2625   ret->setFileName(getFileName());
2626   return ret.retn();
2627 }
2628
2629 MEDFileFieldGlobs::MEDFileFieldGlobs(const char *fname):_file_name(fname)
2630 {
2631 }
2632
2633 MEDFileFieldGlobs::MEDFileFieldGlobs()
2634 {
2635 }
2636
2637 MEDFileFieldGlobs::~MEDFileFieldGlobs()
2638 {
2639 }
2640
2641 void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
2642 {
2643   oss << "Profiles :\n";
2644   std::size_t n=_pfls.size();
2645   for(std::size_t i=0;i<n;i++)
2646     {
2647       oss << "  - #" << i << " ";
2648       const DataArrayInt *pfl=_pfls[i];
2649       if(pfl)
2650         oss << "\"" << pfl->getName() << "\"\n";
2651       else
2652         oss << "EMPTY !\n";
2653     }
2654   n=_locs.size();
2655   oss << "Localizations :\n";
2656   for(std::size_t i=0;i<n;i++)
2657     {
2658       oss << "  - #" << i << " ";
2659       const MEDFileFieldLoc *loc=_locs[i];
2660       if(loc)
2661         loc->simpleRepr(oss);
2662       else
2663         oss<< "EMPTY !\n";
2664     }
2665 }
2666
2667 void MEDFileFieldGlobs::setFileName(const char *fileName)
2668 {
2669   _file_name=fileName;
2670 }
2671
2672 void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2673 {
2674   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
2675     {
2676       DataArrayInt *elt(*it);
2677       if(elt)
2678         {
2679           std::string name(elt->getName());
2680           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2681             {
2682               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2683                 {
2684                   elt->setName((*it2).second.c_str());
2685                   return;
2686                 }
2687             }
2688         }
2689     }
2690 }
2691
2692 void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2693 {
2694   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
2695     {
2696       MEDFileFieldLoc *elt(*it);
2697       if(elt)
2698         {
2699           std::string name(elt->getName());
2700           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2701             {
2702               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2703                 {
2704                   elt->setName((*it2).second.c_str());
2705                   return;
2706                 }
2707             }
2708         }
2709     }
2710 }
2711
2712 int MEDFileFieldGlobs::getNbOfGaussPtPerCell(int locId) const
2713 {
2714   if(locId<0 || locId>=(int)_locs.size())
2715     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getNbOfGaussPtPerCell : Invalid localization id !");
2716   return _locs[locId]->getNbOfGaussPtPerCell();
2717 }
2718
2719 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName) const
2720 {
2721   return getLocalizationFromId(getLocalizationId(locName));
2722 }
2723
2724 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) const
2725 {
2726   if(locId<0 || locId>=(int)_locs.size())
2727     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2728   return *_locs[locId];
2729 }
2730
2731 namespace ParaMEDMEMImpl
2732 {
2733   class LocFinder
2734   {
2735   public:
2736     LocFinder(const char *loc):_loc(loc) { }
2737     bool operator() (const MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>& loc) { return loc->isName(_loc); }
2738   private:
2739     const char *_loc;
2740   };
2741
2742   class PflFinder
2743   {
2744   public:
2745     PflFinder(const std::string& pfl):_pfl(pfl) { }
2746     bool operator() (const MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& pfl) { return _pfl==pfl->getName(); }
2747   private:
2748     const std::string& _pfl;
2749   };
2750 }
2751
2752 int MEDFileFieldGlobs::getLocalizationId(const char *loc) const
2753 {
2754   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),ParaMEDMEMImpl::LocFinder(loc));
2755   if(it==_locs.end())
2756     {
2757       std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
2758       for(it=_locs.begin();it!=_locs.end();it++)
2759         oss << "\"" << (*it)->getName() << "\", ";
2760       throw INTERP_KERNEL::Exception(oss.str().c_str());
2761     }
2762   return std::distance(_locs.begin(),it);
2763 }
2764
2765 /*!
2766  * The returned value is never null.
2767  */
2768 const DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName) const
2769 {
2770   std::string pflNameCpp(pflName);
2771   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2772   if(it==_pfls.end())
2773     {
2774       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2775       for(it=_pfls.begin();it!=_pfls.end();it++)
2776         oss << "\"" << (*it)->getName() << "\", ";
2777       throw INTERP_KERNEL::Exception(oss.str().c_str());
2778     }
2779   return *it;
2780 }
2781
2782 const DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) const
2783 {
2784   if(pflId<0 || pflId>=(int)_pfls.size())
2785     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2786   return _pfls[pflId];
2787 }
2788
2789 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId)
2790 {
2791   if(locId<0 || locId>=(int)_locs.size())
2792     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2793   return *_locs[locId];
2794 }
2795
2796 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName)
2797 {
2798   return getLocalizationFromId(getLocalizationId(locName));
2799 }
2800
2801 /*!
2802  * The returned value is never null.
2803  */
2804 DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName)
2805 {
2806   std::string pflNameCpp(pflName);
2807   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2808   if(it==_pfls.end())
2809     {
2810       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2811       for(it=_pfls.begin();it!=_pfls.end();it++)
2812         oss << "\"" << (*it)->getName() << "\", ";
2813       throw INTERP_KERNEL::Exception(oss.str().c_str());
2814     }
2815   return *it;
2816 }
2817
2818 DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId)
2819 {
2820   if(pflId<0 || pflId>=(int)_pfls.size())
2821     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2822   return _pfls[pflId];
2823 }
2824
2825 void MEDFileFieldGlobs::killProfileIds(const std::vector<int>& pflIds)
2826 {
2827   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newPfls;
2828   int i=0;
2829   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2830     {
2831       if(std::find(pflIds.begin(),pflIds.end(),i)==pflIds.end())
2832         newPfls.push_back(*it);
2833     }
2834   _pfls=newPfls;
2835 }
2836
2837 void MEDFileFieldGlobs::killLocalizationIds(const std::vector<int>& locIds)
2838 {
2839   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> > newLocs;
2840   int i=0;
2841   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2842     {
2843       if(std::find(locIds.begin(),locIds.end(),i)==locIds.end())
2844         newLocs.push_back(*it);
2845     }
2846   _locs=newLocs;
2847 }
2848
2849 std::vector<std::string> MEDFileFieldGlobs::getPfls() const
2850 {
2851   int sz=_pfls.size();
2852   std::vector<std::string> ret(sz);
2853   for(int i=0;i<sz;i++)
2854     ret[i]=_pfls[i]->getName();
2855   return ret;
2856 }
2857
2858 std::vector<std::string> MEDFileFieldGlobs::getLocs() const
2859 {
2860   int sz=_locs.size();
2861   std::vector<std::string> ret(sz);
2862   for(int i=0;i<sz;i++)
2863     ret[i]=_locs[i]->getName();
2864   return ret;
2865 }
2866
2867 bool MEDFileFieldGlobs::existsPfl(const char *pflName) const
2868 {
2869   std::vector<std::string> v=getPfls();
2870   std::string s(pflName);
2871   return std::find(v.begin(),v.end(),s)!=v.end();
2872 }
2873
2874 bool MEDFileFieldGlobs::existsLoc(const char *locName) const
2875 {
2876   std::vector<std::string> v=getLocs();
2877   std::string s(locName);
2878   return std::find(v.begin(),v.end(),s)!=v.end();
2879 }
2880
2881 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualProfiles() const
2882 {
2883   std::map<int,std::vector<int> > m;
2884   int i=0;
2885   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2886     {
2887       const DataArrayInt *tmp=(*it);
2888       if(tmp)
2889         {
2890           m[tmp->getHashCode()].push_back(i);
2891         }
2892     }
2893   std::vector< std::vector<int> > ret;
2894   for(std::map<int,std::vector<int> >::const_iterator it2=m.begin();it2!=m.end();it2++)
2895     {
2896       if((*it2).second.size()>1)
2897         {
2898           std::vector<int> ret0;
2899           bool equalityOrNot=false;
2900           for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
2901             {
2902               std::vector<int>::const_iterator it4=it3; it4++;
2903               for(;it4!=(*it2).second.end();it4++)
2904                 {
2905                   if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
2906                     {
2907                       if(!equalityOrNot)
2908                         ret0.push_back(*it3);
2909                       ret0.push_back(*it4);
2910                       equalityOrNot=true;
2911                     }
2912                 }
2913             }
2914           if(!ret0.empty())
2915             ret.push_back(ret0);
2916         }
2917     }
2918   return ret;
2919 }
2920
2921 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
2922 {
2923   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
2924 }
2925
2926 void MEDFileFieldGlobs::appendProfile(DataArrayInt *pfl)
2927 {
2928   std::string name(pfl->getName());
2929   if(name.empty())
2930     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
2931   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2932     if(name==(*it)->getName())
2933       {
2934         if(!pfl->isEqual(*(*it)))
2935           {
2936             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
2937             throw INTERP_KERNEL::Exception(oss.str().c_str());
2938           }
2939       }
2940   pfl->incrRef();
2941   _pfls.push_back(pfl);
2942 }
2943
2944 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)
2945 {
2946   std::string name(locName);
2947   if(name.empty())
2948     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
2949   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
2950   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2951     if((*it)->isName(locName))
2952       {
2953         if(!(*it)->isEqual(*obj,1e-12))
2954           {
2955             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
2956             throw INTERP_KERNEL::Exception(oss.str().c_str());
2957           }
2958       }
2959   _locs.push_back(obj);
2960 }
2961
2962 std::string MEDFileFieldGlobs::createNewNameOfPfl() const
2963 {
2964   std::vector<std::string> names=getPfls();
2965   return CreateNewNameNotIn("NewPfl_",names);
2966 }
2967
2968 std::string MEDFileFieldGlobs::createNewNameOfLoc() const
2969 {
2970   std::vector<std::string> names=getLocs();
2971   return CreateNewNameNotIn("NewLoc_",names);
2972 }
2973
2974 std::string MEDFileFieldGlobs::CreateNewNameNotIn(const char *prefix, const std::vector<std::string>& namesToAvoid)
2975 {
2976   for(std::size_t sz=0;sz<100000;sz++)
2977     {
2978       std::ostringstream tryName;
2979       tryName << prefix << sz;
2980       if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tryName.str())==namesToAvoid.end())
2981         return tryName.str();
2982     }
2983   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::CreateNewNameNotIn : impossible to create an additional profile limit of 100000 profiles reached !");
2984 }
2985
2986 /*!
2987  * Creates a MEDFileFieldGlobsReal on a given file name. Nothing is read here.
2988  *  \param [in] fname - the file name.
2989  */
2990 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal(const char *fname):_globals(MEDFileFieldGlobs::New(fname))
2991 {
2992 }
2993
2994 /*!
2995  * Creates an empty MEDFileFieldGlobsReal.
2996  */
2997 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal():_globals(MEDFileFieldGlobs::New())
2998 {
2999 }
3000
3001 std::size_t MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren() const
3002 {
3003   return 0;
3004 }
3005
3006 std::vector<const BigMemoryObject *> MEDFileFieldGlobsReal::getDirectChildren() const
3007 {
3008   std::vector<const BigMemoryObject *> ret;
3009   if((const MEDFileFieldGlobs *)_globals)
3010     ret.push_back((const MEDFileFieldGlobs *)_globals);
3011   return ret;
3012 }
3013
3014 /*!
3015  * Returns a string describing profiles and Gauss points held in \a this.
3016  *  \return std::string - the description string.
3017  */
3018 void MEDFileFieldGlobsReal::simpleReprGlobs(std::ostream& oss) const
3019 {
3020   const MEDFileFieldGlobs *glob=_globals;
3021   std::ostringstream oss2; oss2 << glob;
3022   std::string stars(oss2.str().length(),'*');
3023   oss << "Globals information on fields (at " << oss2.str() << "):" << "\n************************************" << stars  << "\n\n";
3024   if(glob)
3025     glob->simpleRepr(oss);
3026   else
3027     oss << "NO GLOBAL INFORMATION !\n";
3028 }
3029
3030 void MEDFileFieldGlobsReal::resetContent()
3031 {
3032   _globals=MEDFileFieldGlobs::New();
3033 }
3034
3035 MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
3036 {
3037 }
3038
3039 /*!
3040  * Copies references to profiles and Gauss points from another MEDFileFieldGlobsReal.
3041  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3042  */
3043 void MEDFileFieldGlobsReal::shallowCpyGlobs(const MEDFileFieldGlobsReal& other)
3044 {
3045   _globals=other._globals;
3046 }
3047
3048 /*!
3049  * Copies references to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3050  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3051  */
3052 void MEDFileFieldGlobsReal::shallowCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3053 {
3054   const MEDFileFieldGlobs *otherg(other._globals);
3055   if(!otherg)
3056     return ;
3057   _globals=otherg->shallowCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3058 }
3059
3060 /*!
3061  * Copies deeply to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3062  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3063  */
3064 void MEDFileFieldGlobsReal::deepCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3065 {
3066   const MEDFileFieldGlobs *otherg(other._globals);
3067   if(!otherg)
3068     return ;
3069   _globals=otherg->deepCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3070 }
3071
3072 void MEDFileFieldGlobsReal::deepCpyGlobs(const MEDFileFieldGlobsReal& other)
3073 {
3074   _globals=other._globals;
3075   if((const MEDFileFieldGlobs *)_globals)
3076     _globals=other._globals->deepCpy();
3077 }
3078
3079 /*!
3080  * Adds profiles and Gauss points held by another MEDFileFieldGlobsReal to \a this one.
3081  *  \param [in] other - the MEDFileFieldGlobsReal to copy data from.
3082  *  \param [in] eps - a precision used to compare Gauss points with same name held by
3083  *         \a this and \a other MEDFileFieldGlobsReal.
3084  *  \throw If \a this and \a other hold profiles with equal names but different ids.
3085  *  \throw If  \a this and \a other hold different Gauss points with equal names.
3086  */
3087 void MEDFileFieldGlobsReal::appendGlobs(const MEDFileFieldGlobsReal& other, double eps)
3088 {
3089   const MEDFileFieldGlobs *thisGlobals(_globals),*otherGlobals(other._globals);
3090   if(thisGlobals==otherGlobals)
3091     return ;
3092   if(!thisGlobals)
3093     {
3094       _globals=other._globals;
3095       return ;
3096     }
3097   _globals->appendGlobs(*other._globals,eps);
3098 }
3099
3100 void MEDFileFieldGlobsReal::checkGlobsCoherency() const
3101 {
3102   checkGlobsPflsPartCoherency();
3103   checkGlobsLocsPartCoherency();
3104 }
3105
3106 void MEDFileFieldGlobsReal::checkGlobsPflsPartCoherency() const
3107 {
3108   contentNotNull()->checkGlobsPflsPartCoherency(getPflsReallyUsed());
3109 }
3110
3111 void MEDFileFieldGlobsReal::checkGlobsLocsPartCoherency() const
3112 {
3113   contentNotNull()->checkGlobsLocsPartCoherency(getLocsReallyUsed());
3114 }
3115
3116 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id, const char *pflName)
3117 {
3118   contentNotNull()->loadProfileInFile(fid,id,pflName);
3119 }
3120
3121 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id)
3122 {
3123   contentNotNull()->loadProfileInFile(fid,id);
3124 }
3125
3126 void MEDFileFieldGlobsReal::loadGlobals(med_idt fid)
3127 {
3128   contentNotNull()->loadGlobals(fid,*this);
3129 }
3130
3131 void MEDFileFieldGlobsReal::loadAllGlobals(med_idt fid)
3132 {
3133   contentNotNull()->loadAllGlobals(fid);
3134 }
3135
3136 void MEDFileFieldGlobsReal::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
3137 {
3138   contentNotNull()->writeGlobals(fid,opt);
3139 }
3140
3141 /*!
3142  * Returns names of all profiles. To get only used profiles call getPflsReallyUsed()
3143  * or getPflsReallyUsedMulti().
3144  *  \return std::vector<std::string> - a sequence of names of all profiles.
3145  */
3146 std::vector<std::string> MEDFileFieldGlobsReal::getPfls() const
3147 {
3148   return contentNotNull()->getPfls();
3149 }
3150
3151 /*!
3152  * Returns names of all localizations. To get only used localizations call getLocsReallyUsed()
3153  * or getLocsReallyUsedMulti().
3154  *  \return std::vector<std::string> - a sequence of names of all localizations.
3155  */
3156 std::vector<std::string> MEDFileFieldGlobsReal::getLocs() const
3157 {
3158   return contentNotNull()->getLocs();
3159 }
3160
3161 /*!
3162  * Checks if the profile with a given name exists.
3163  *  \param [in] pflName - the profile name of interest.
3164  *  \return bool - \c true if the profile named \a pflName exists.
3165  */
3166 bool MEDFileFieldGlobsReal::existsPfl(const char *pflName) const
3167 {
3168   return contentNotNull()->existsPfl(pflName);
3169 }
3170
3171 /*!
3172  * Checks if the localization with a given name exists.
3173  *  \param [in] locName - the localization name of interest.
3174  *  \return bool - \c true if the localization named \a locName exists.
3175  */
3176 bool MEDFileFieldGlobsReal::existsLoc(const char *locName) const
3177 {
3178   return contentNotNull()->existsLoc(locName);
3179 }
3180
3181 std::string MEDFileFieldGlobsReal::createNewNameOfPfl() const
3182 {
3183   return contentNotNull()->createNewNameOfPfl();
3184 }
3185
3186 std::string MEDFileFieldGlobsReal::createNewNameOfLoc() const
3187 {
3188   return contentNotNull()->createNewNameOfLoc();
3189 }
3190
3191 /*!
3192  * Sets the name of a MED file.
3193  *  \param [inout] fileName - the file name.
3194  */
3195 void MEDFileFieldGlobsReal::setFileName(const char *fileName)
3196 {
3197   contentNotNull()->setFileName(fileName);
3198 }
3199
3200 /*!
3201  * Finds equal profiles. Two profiles are considered equal if they contain the same ids
3202  * in the same order.
3203  *  \return std::vector< std::vector<int> > - a sequence of groups of equal profiles.
3204  *          Each item of this sequence is a vector containing ids of equal profiles.
3205  */
3206 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualProfiles() const
3207 {
3208   return contentNotNull()->whichAreEqualProfiles();
3209 }
3210
3211 /*!
3212  * Finds equal localizations.
3213  *  \param [in] eps - a precision used to compare real values of the localizations.
3214  *  \return std::vector< std::vector<int> > - a sequence of groups of equal localizations.
3215  *          Each item of this sequence is a vector containing ids of equal localizations.
3216  */
3217 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualLocs(double eps) const
3218 {
3219   return contentNotNull()->whichAreEqualLocs(eps);
3220 }
3221
3222 /*!
3223  * Renames the profiles. References to profiles (a reference is a profile name) are not changed.
3224  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3225  *        this sequence is a pair whose
3226  *        - the first item is a vector of profile names to replace by the second item,
3227  *        - the second item is a profile name to replace every profile name of the first item.
3228  */
3229 void MEDFileFieldGlobsReal::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3230 {
3231   contentNotNull()->changePflsNamesInStruct(mapOfModif);
3232 }
3233
3234 /*!
3235  * Renames the localizations. References to localizations (a reference is a localization name) are not changed.
3236  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3237  *        this sequence is a pair whose
3238  *        - the first item is a vector of localization names to replace by the second item,
3239  *        - the second item is a localization name to replace every localization name of the first item.
3240  */
3241 void MEDFileFieldGlobsReal::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3242 {
3243   contentNotNull()->changeLocsNamesInStruct(mapOfModif);
3244 }
3245
3246 /*!
3247  * Replaces references to some profiles (a reference is a profile name) by references
3248  * to other profiles and, contrary to changePflsRefsNamesGen(), renames the profiles
3249  * them-selves accordingly. <br>
3250  * This method is a generalization of changePflName().
3251  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3252  *        this sequence is a pair whose
3253  *        - the first item is a vector of profile names to replace by the second item,
3254  *        - the second item is a profile name to replace every profile of the first item.
3255  * \sa changePflsRefsNamesGen()
3256  * \sa changePflName()
3257  */
3258 void MEDFileFieldGlobsReal::changePflsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3259 {
3260   changePflsRefsNamesGen(mapOfModif);
3261   changePflsNamesInStruct(mapOfModif);
3262 }
3263
3264 /*!
3265  * Replaces references to some localizations (a reference is a localization name) by references
3266  * to other localizations and, contrary to changeLocsRefsNamesGen(), renames the localizations
3267  * them-selves accordingly. <br>
3268  * This method is a generalization of changeLocName().
3269  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3270  *        this sequence is a pair whose
3271  *        - the first item is a vector of localization names to replace by the second item,
3272  *        - the second item is a localization name to replace every localization of the first item.
3273  * \sa changeLocsRefsNamesGen()
3274  * \sa changeLocName()
3275  */
3276 void MEDFileFieldGlobsReal::changeLocsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3277 {
3278   changeLocsRefsNamesGen(mapOfModif);
3279   changeLocsNamesInStruct(mapOfModif);
3280 }
3281
3282 /*!
3283  * Renames the profile having a given name and updates references to this profile.
3284  *  \param [in] oldName - the name of the profile to rename.
3285  *  \param [in] newName - a new name of the profile.
3286  * \sa changePflsNames().
3287  */
3288 void MEDFileFieldGlobsReal::changePflName(const char *oldName, const char *newName)
3289 {
3290   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3291   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3292   mapOfModif[0]=p;
3293   changePflsNames(mapOfModif);
3294 }
3295
3296 /*!
3297  * Renames the localization having a given name and updates references to this localization.
3298  *  \param [in] oldName - the name of the localization to rename.
3299  *  \param [in] newName - a new name of the localization.
3300  * \sa changeLocsNames().
3301  */
3302 void MEDFileFieldGlobsReal::changeLocName(const char *oldName, const char *newName)
3303 {
3304   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3305   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3306   mapOfModif[0]=p;
3307   changeLocsNames(mapOfModif);
3308 }
3309
3310 /*!
3311  * Removes duplicated profiles. Returns a map used to update references to removed
3312  * profiles via changePflsRefsNamesGen().
3313  * Equal profiles are found using whichAreEqualProfiles().
3314  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3315  *          a sequence describing the performed replacements of profiles. Each element of
3316  *          this sequence is a pair whose
3317  *          - the first item is a vector of profile names replaced by the second item,
3318  *          - the second item is a profile name replacing every profile of the first item.
3319  */
3320 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipPflsNames()
3321 {
3322   std::vector< std::vector<int> > pseudoRet=whichAreEqualProfiles();
3323   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3324   int i=0;
3325   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3326     {
3327       std::vector< std::string > tmp((*it).size());
3328       int j=0;
3329       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3330         tmp[j]=std::string(getProfileFromId(*it2)->getName());
3331       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3332       ret[i]=p;
3333       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3334       killProfileIds(tmp2);
3335     }
3336   changePflsRefsNamesGen(ret);
3337   return ret;
3338 }
3339
3340 /*!
3341  * Removes duplicated localizations. Returns a map used to update references to removed
3342  * localizations via changeLocsRefsNamesGen().
3343  * Equal localizations are found using whichAreEqualLocs().
3344  *  \param [in] eps - a precision used to compare real values of the localizations.
3345  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3346  *          a sequence describing the performed replacements of localizations. Each element of
3347  *          this sequence is a pair whose
3348  *          - the first item is a vector of localization names replaced by the second item,
3349  *          - the second item is a localization name replacing every localization of the first item.
3350  */
3351 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipLocsNames(double eps)
3352 {
3353   std::vector< std::vector<int> > pseudoRet=whichAreEqualLocs(eps);
3354   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3355   int i=0;
3356   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3357     {
3358       std::vector< std::string > tmp((*it).size());
3359       int j=0;
3360       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3361         tmp[j]=std::string(getLocalizationFromId(*it2).getName());
3362       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3363       ret[i]=p;
3364       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3365       killLocalizationIds(tmp2);
3366     }
3367   changeLocsRefsNamesGen(ret);
3368   return ret;
3369 }
3370
3371 /*!
3372  * Returns number of Gauss points per cell in a given localization.
3373  *  \param [in] locId - an id of the localization of interest.
3374  *  \return int - the number of the Gauss points per cell.
3375  */
3376 int MEDFileFieldGlobsReal::getNbOfGaussPtPerCell(int locId) const
3377 {
3378   return contentNotNull()->getNbOfGaussPtPerCell(locId);
3379 }
3380
3381 /*!
3382  * Returns an id of a localization by its name.
3383  *  \param [in] loc - the localization name of interest.
3384  *  \return int - the id of the localization.
3385  *  \throw If there is no a localization named \a loc.
3386  */
3387 int MEDFileFieldGlobsReal::getLocalizationId(const char *loc) const
3388 {
3389   return contentNotNull()->getLocalizationId(loc);
3390 }
3391
3392 /*!
3393  * Returns the name of the MED file.
3394  *  \return const char * - the MED file name.
3395  */
3396 const char *MEDFileFieldGlobsReal::getFileName() const
3397 {
3398   return contentNotNull()->getFileName();
3399 }
3400
3401 std::string MEDFileFieldGlobsReal::getFileName2() const
3402 {
3403   return contentNotNull()->getFileName2();
3404 }
3405
3406 /*!
3407  * Returns a localization object by its name.
3408  *  \param [in] locName - the name of the localization of interest.
3409  *  \return const MEDFileFieldLoc& - the localization object having the name \a locName.
3410  *  \throw If there is no a localization named \a locName.
3411  */
3412 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName) const
3413 {
3414   return contentNotNull()->getLocalization(locName);
3415 }
3416
3417 /*!
3418  * Returns a localization object by its id.
3419  *  \param [in] locId - the id of the localization of interest.
3420  *  \return const MEDFileFieldLoc& - the localization object having the id \a locId.
3421  *  \throw If there is no a localization with id \a locId.
3422  */
3423 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) const
3424 {
3425   return contentNotNull()->getLocalizationFromId(locId);
3426 }
3427
3428 /*!
3429  * Returns a profile array by its name.
3430  *  \param [in] pflName - the name of the profile of interest.
3431  *  \return const DataArrayInt * - the profile array having the name \a pflName.
3432  *  \throw If there is no a profile named \a pflName.
3433  */
3434 const DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName) const
3435 {
3436   return contentNotNull()->getProfile(pflName);
3437 }
3438
3439 /*!
3440  * Returns a profile array by its id.
3441  *  \param [in] pflId - the id of the profile of interest.
3442  *  \return const DataArrayInt * - the profile array having the id \a pflId.
3443  *  \throw If there is no a profile with id \a pflId.
3444  */
3445 const DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) const
3446 {
3447   return contentNotNull()->getProfileFromId(pflId);
3448 }
3449
3450 /*!
3451  * Returns a localization object, apt for modification, by its id.
3452  *  \param [in] locId - the id of the localization of interest.
3453  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3454  *          having the id \a locId.
3455  *  \throw If there is no a localization with id \a locId.
3456  */
3457 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId)
3458 {
3459   return contentNotNull()->getLocalizationFromId(locId);
3460 }
3461
3462 /*!
3463  * Returns a localization object, apt for modification, by its name.
3464  *  \param [in] locName - the name of the localization of interest.
3465  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3466  *          having the name \a locName.
3467  *  \throw If there is no a localization named \a locName.
3468  */
3469 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName)
3470 {
3471   return contentNotNull()->getLocalization(locName);
3472 }
3473
3474 /*!
3475  * Returns a profile array, apt for modification, by its name.
3476  *  \param [in] pflName - the name of the profile of interest.
3477  *  \return DataArrayInt * - a non-const pointer to the profile array having the name \a pflName.
3478  *  \throw If there is no a profile named \a pflName.
3479  */
3480 DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName)
3481 {
3482   return contentNotNull()->getProfile(pflName);
3483 }
3484
3485 /*!
3486  * Returns a profile array, apt for modification, by its id.
3487  *  \param [in] pflId - the id of the profile of interest.
3488  *  \return DataArrayInt * - a non-const pointer to the profile array having the id \a pflId.
3489  *  \throw If there is no a profile with id \a pflId.
3490  */
3491 DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId)
3492 {
3493   return contentNotNull()->getProfileFromId(pflId);
3494 }
3495
3496 /*!
3497  * Removes profiles given by their ids. No data is updated to track this removal.
3498  *  \param [in] pflIds - a sequence of ids of the profiles to remove.
3499  */
3500 void MEDFileFieldGlobsReal::killProfileIds(const std::vector<int>& pflIds)
3501 {
3502   contentNotNull()->killProfileIds(pflIds);
3503 }
3504
3505 /*!
3506  * Removes localizations given by their ids. No data is updated to track this removal.
3507  *  \param [in] locIds - a sequence of ids of the localizations to remove.
3508  */
3509 void MEDFileFieldGlobsReal::killLocalizationIds(const std::vector<int>& locIds)
3510 {
3511   contentNotNull()->killLocalizationIds(locIds);
3512 }
3513
3514 /*!
3515  * Stores a profile array.
3516  *  \param [in] pfl - the profile array to store.
3517  *  \throw If the name of \a pfl is empty.
3518  *  \throw If a profile with the same name as that of \a pfl already exists but contains
3519  *         different ids.
3520  */
3521 void MEDFileFieldGlobsReal::appendProfile(DataArrayInt *pfl)
3522 {
3523   contentNotNull()->appendProfile(pfl);
3524 }
3525
3526 /*!
3527  * Adds a new localization of Gauss points.
3528  *  \param [in] locName - the name of the new localization.
3529  *  \param [in] geoType - a geometrical type of the reference cell.
3530  *  \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
3531  *         must be \c nbOfNodesPerCell * \c dimOfType.
3532  *  \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
3533  *         must be  _wg_.size() * \c dimOfType.
3534  *  \param [in] w - the weights of Gauss points.
3535  *  \throw If \a locName is empty.
3536  *  \throw If a localization with the name \a locName already exists but is
3537  *         different form the new one.
3538  */
3539 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)
3540 {
3541   contentNotNull()->appendLoc(locName,geoType,refCoo,gsCoo,w);
3542 }
3543
3544 MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull()
3545 {
3546   MEDFileFieldGlobs *g(_globals);
3547   if(!g)
3548     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in not const !");
3549   return g;
3550 }
3551
3552 const MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() const
3553 {
3554   const MEDFileFieldGlobs *g(_globals);
3555   if(!g)
3556     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in const !");
3557   return g;
3558 }
3559
3560 //= MEDFileFieldNameScope
3561
3562 MEDFileFieldNameScope::MEDFileFieldNameScope()
3563 {
3564 }
3565
3566 MEDFileFieldNameScope::MEDFileFieldNameScope(const char *fieldName):_name(fieldName)
3567 {
3568 }
3569
3570 /*!
3571  * Returns the name of \a this field.
3572  *  \return std::string - a string containing the field name.
3573  */
3574 std::string MEDFileFieldNameScope::getName() const
3575 {
3576   return _name;
3577 }
3578
3579 /*!
3580  * Sets name of \a this field
3581  *  \param [in] name - the new field name.
3582  */
3583 void MEDFileFieldNameScope::setName(const char *fieldName)
3584 {
3585   _name=fieldName;
3586 }
3587
3588 std::string MEDFileFieldNameScope::getDtUnit() const
3589 {
3590   return _dt_unit;
3591 }
3592
3593 void MEDFileFieldNameScope::setDtUnit(const char *dtUnit)
3594 {
3595   _dt_unit=dtUnit;
3596 }
3597
3598 void MEDFileFieldNameScope::copyNameScope(const MEDFileFieldNameScope& other)
3599 {
3600   _name=other._name;
3601   _dt_unit=other._dt_unit;
3602 }
3603
3604 //= MEDFileAnyTypeField1TSWithoutSDA
3605
3606 void MEDFileAnyTypeField1TSWithoutSDA::deepCpyLeavesFrom(const MEDFileAnyTypeField1TSWithoutSDA& other)
3607 {
3608   _field_per_mesh.resize(other._field_per_mesh.size());
3609   std::size_t i=0;
3610   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
3611     {
3612       if((const MEDFileFieldPerMesh *)*it)
3613         _field_per_mesh[i]=(*it)->deepCpy(this);
3614     }
3615 }
3616
3617 /*!
3618  * Prints a string describing \a this field into a stream. This string is outputted
3619  * by \c print Python command.
3620  *  \param [in] bkOffset - number of white spaces printed at the beginning of each line.
3621  *  \param [in,out] oss - the out stream.
3622  *  \param [in] f1tsId - the field index within a MED file. If \a f1tsId < 0, the tiny
3623  *          info id printed, else, not.
3624  */
3625 void MEDFileAnyTypeField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
3626 {
3627   std::string startOfLine(bkOffset,' ');
3628   oss << startOfLine << "Field ";
3629   if(bkOffset==0)
3630     oss << "[Type=" << getTypeStr() << "] with name \"" << getName() << "\" ";
3631   oss << "on one time Step ";
3632   if(f1tsId>=0)
3633     oss << "(" << f1tsId << ") ";
3634   oss << "on iteration=" << _iteration << " order=" << _order << "." << std::endl;
3635   oss << startOfLine << "Time attached is : " << _dt << " [" << _dt_unit << "]." << std::endl;
3636   const DataArray *arr=getUndergroundDataArray();
3637   if(arr)
3638     {
3639       const std::vector<std::string> &comps=arr->getInfoOnComponents();
3640       if(f1tsId<0)
3641         {
3642           oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
3643           for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
3644             oss << startOfLine << "  -  \"" << (*it) << "\"" << std::endl;
3645         }
3646       if(arr->isAllocated())
3647         {
3648           oss << startOfLine << "Whole field contains " << arr->getNumberOfTuples() << " tuples." << std::endl;
3649         }
3650       else
3651         oss << startOfLine << "The array of the current field has not allocated yet !" << std::endl;
3652     }
3653   else
3654     {
3655       oss << startOfLine << "Field infos are empty ! Not defined yet !" << std::endl;
3656     }
3657   oss << startOfLine << "----------------------" << std::endl;
3658   if(!_field_per_mesh.empty())
3659     {
3660       int i=0;
3661       for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
3662         {
3663           const MEDFileFieldPerMesh *cur=(*it2);
3664           if(cur)
3665             cur->simpleRepr(bkOffset,oss,i);
3666           else
3667             oss << startOfLine << "Field per mesh #" << i << " is not defined !" << std::endl;
3668         }
3669     }
3670   else
3671     {
3672       oss << startOfLine << "Field is not defined on any meshes !" << std::endl;
3673     }
3674   oss << startOfLine << "----------------------" << std::endl;
3675 }
3676
3677 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitComponents() const
3678 {
3679   const DataArray *arr(getUndergroundDataArray());
3680   if(!arr)
3681     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitComponents : no array defined !");
3682   int nbOfCompo=arr->getNumberOfComponents();
3683   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfCompo);
3684   for(int i=0;i<nbOfCompo;i++)
3685     {
3686       ret[i]=deepCpy();
3687       std::vector<int> v(1,i);
3688       MEDCouplingAutoRefCountObjectPtr<DataArray> arr2=arr->keepSelectedComponents(v);
3689       ret[i]->setArray(arr2);
3690     }
3691   return ret;
3692 }
3693
3694 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)
3695 {
3696 }
3697
3698 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA():_iteration(-1),_order(-1),_dt(0.),_csit(-1),_nb_of_tuples_to_be_allocated(-1)
3699 {
3700 }
3701
3702 /*!
3703  * Returns the maximal dimension of supporting elements. Returns -2 if \a this is
3704  * empty. Returns -1 if this in on nodes.
3705  *  \return int - the dimension of \a this.
3706  */
3707 int MEDFileAnyTypeField1TSWithoutSDA::getDimension() const
3708 {
3709   int ret=-2;
3710   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3711     (*it)->getDimension(ret);
3712   return ret;
3713 }
3714
3715 /*!
3716  * Returns the mesh name.
3717  *  \return std::string - a string holding the mesh name.
3718  *  \throw If \c _field_per_mesh.empty()
3719  */
3720 std::string MEDFileAnyTypeField1TSWithoutSDA::getMeshName() const
3721 {
3722   if(_field_per_mesh.empty())
3723     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshName : No field set !");
3724   return _field_per_mesh[0]->getMeshName();
3725 }
3726
3727 void MEDFileAnyTypeField1TSWithoutSDA::setMeshName(const char *newMeshName)
3728 {
3729   std::string oldName(getMeshName());
3730   std::vector< std::pair<std::string,std::string> > v(1);
3731   v[0].first=oldName; v[0].second=newMeshName;
3732   changeMeshNames(v);
3733 }
3734
3735 bool MEDFileAnyTypeField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
3736 {
3737   bool ret=false;
3738   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3739     {
3740       MEDFileFieldPerMesh *cur(*it);
3741       if(cur)
3742         ret=cur->changeMeshNames(modifTab) || ret;
3743     }
3744   return ret;
3745 }
3746
3747 /*!
3748  * Returns the number of iteration of the state of underlying mesh.
3749  *  \return int - the iteration number.
3750  *  \throw If \c _field_per_mesh.empty()
3751  */
3752 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIteration() const
3753 {
3754   if(_field_per_mesh.empty())
3755     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshIteration : No field set !");
3756   return _field_per_mesh[0]->getMeshIteration();
3757 }
3758
3759 /*!
3760  * Returns the order number of iteration of the state of underlying mesh.
3761  *  \return int - the order number.
3762  *  \throw If \c _field_per_mesh.empty()
3763  */
3764 int MEDFileAnyTypeField1TSWithoutSDA::getMeshOrder() const
3765 {
3766   if(_field_per_mesh.empty())
3767     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshOrder : No field set !");
3768   return _field_per_mesh[0]->getMeshOrder();
3769 }
3770
3771 /*!
3772  * Checks if \a this field is tagged by a given iteration number and a given
3773  * iteration order number.
3774  *  \param [in] iteration - the iteration number of interest.
3775  *  \param [in] order - the iteration order number of interest.
3776  *  \return bool - \c true if \a this->getIteration() == \a iteration &&
3777  *          \a this->getOrder() == \a order.
3778  */
3779 bool MEDFileAnyTypeField1TSWithoutSDA::isDealingTS(int iteration, int order) const
3780 {
3781   return iteration==_iteration && order==_order;
3782 }
3783
3784 /*!
3785  * Returns number of iteration and order number of iteration when
3786  * \a this field has been calculated.
3787  *  \return std::pair<int,int> - a pair of the iteration number and the iteration
3788  *          order number.
3789  */
3790 std::pair<int,int> MEDFileAnyTypeField1TSWithoutSDA::getDtIt() const
3791 {
3792   std::pair<int,int> p;
3793   fillIteration(p);
3794   return p;
3795 }
3796
3797 /*!
3798  * Returns number of iteration and order number of iteration when
3799  * \a this field has been calculated.
3800  *  \param [in,out] p - a pair returning the iteration number and the iteration
3801  *          order number.
3802  */
3803 void MEDFileAnyTypeField1TSWithoutSDA::fillIteration(std::pair<int,int>& p) const
3804 {
3805   p.first=_iteration;
3806   p.second=_order;
3807 }
3808
3809 /*!
3810  * Returns all types of spatial discretization of \a this field.
3811  *  \param [in,out] types - a sequence of types of \a this field.
3812  */
3813 void MEDFileAnyTypeField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
3814 {
3815   std::set<TypeOfField> types2;
3816   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3817     {
3818       (*it)->fillTypesOfFieldAvailable(types2);
3819     }
3820   std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
3821   std::copy(types2.begin(),types2.end(),bi);
3822 }
3823
3824 /*!
3825  * Returns all types of spatial discretization of \a this field.
3826  *  \return std::vector<TypeOfField> - a sequence of types of spatial discretization
3827  *          of \a this field.
3828  */
3829 std::vector<TypeOfField> MEDFileAnyTypeField1TSWithoutSDA::getTypesOfFieldAvailable() const
3830 {
3831   std::vector<TypeOfField> ret;
3832   fillTypesOfFieldAvailable(ret);
3833   return ret;
3834 }
3835
3836 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsed2() const
3837 {
3838   std::vector<std::string> ret;
3839   std::set<std::string> ret2;
3840   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3841     {
3842       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
3843       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3844         if(ret2.find(*it2)==ret2.end())
3845           {
3846             ret.push_back(*it2);
3847             ret2.insert(*it2);
3848           }
3849     }
3850   return ret;
3851 }
3852
3853 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsed2() const
3854 {
3855   std::vector<std::string> ret;
3856   std::set<std::string> ret2;
3857   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3858     {
3859       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
3860       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3861         if(ret2.find(*it2)==ret2.end())
3862           {
3863             ret.push_back(*it2);
3864             ret2.insert(*it2);
3865           }
3866     }
3867   return ret;
3868 }
3869
3870 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsedMulti2() const
3871 {
3872   std::vector<std::string> ret;
3873   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3874     {
3875       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
3876       ret.insert(ret.end(),tmp.begin(),tmp.end());
3877     }
3878   return ret;
3879 }
3880
3881 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsedMulti2() const
3882 {
3883   std::vector<std::string> ret;
3884   std::set<std::string> ret2;
3885   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3886     {
3887       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
3888       ret.insert(ret.end(),tmp.begin(),tmp.end());
3889     }
3890   return ret;
3891 }
3892
3893 void MEDFileAnyTypeField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3894 {
3895   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3896     (*it)->changePflsRefsNamesGen(mapOfModif);
3897 }
3898
3899 void MEDFileAnyTypeField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3900 {
3901   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3902     (*it)->changeLocsRefsNamesGen(mapOfModif);
3903 }
3904
3905 /*!
3906  * Returns all attributes of parts of \a this field lying on a given mesh.
3907  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
3908  * item of every of returned sequences refers to the _i_-th part of \a this field.
3909  * Thus all sequences returned by this method are of the same length equal to number
3910  * of different types of supporting entities.<br>
3911  * A field part can include sub-parts with several different spatial discretizations,
3912  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
3913  * for example. Hence, some of the returned sequences contains nested sequences, and an item
3914  * of a nested sequence corresponds to a type of spatial discretization.<br>
3915  * This method allows for iteration over MEDFile DataStructure without any overhead.
3916  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3917  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3918  *          not checked if \a mname == \c NULL).
3919  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
3920  *          a field part is returned.
3921  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
3922  *          This sequence is of the same length as \a types.
3923  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
3924  *          discretization. A profile name can be empty.
3925  *          Length of this and of nested sequences is the same as that of \a typesF.
3926  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
3927  *          discretization. A localization name can be empty.
3928  *          Length of this and of nested sequences is the same as that of \a typesF.
3929  *  \return std::vector< std::vector< std::pair<int,int> > > - a sequence holding a range
3930  *          of ids of tuples within the data array, per each type of spatial
3931  *          discretization within one mesh entity type.
3932  *          Length of this and of nested sequences is the same as that of \a typesF.
3933  *  \throw If no field is lying on \a mname.
3934  */
3935 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
3936 {
3937   int meshId=0;
3938   if(mname)
3939     meshId=getMeshIdFromMeshName(mname);
3940   else
3941     if(_field_per_mesh.empty())
3942       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
3943   return _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3944 }
3945
3946 /*!
3947  * Returns dimensions of mesh elements \a this field lies on. The returned value is a
3948  * maximal absolute dimension and values returned via the out parameter \a levs are
3949  * dimensions relative to the maximal absolute dimension. <br>
3950  * This method is designed for MEDFileField1TS instances that have a discretization
3951  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS",
3952  * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT",
3953  * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE".
3954  * Only these 3 discretizations will be taken into account here. If \a this is
3955  * \ref ParaMEDMEM::ON_NODES "ON_NODES", -1 is returned and \a levs are empty.<br>
3956  * This method is useful to make the link between the dimension of the underlying mesh
3957  * and the levels of \a this, because it is possible that the highest dimension of \a this
3958  * field is not equal to the dimension of the underlying mesh.
3959  *
3960  * Let's consider the following case:
3961  * - mesh \a m1 has a meshDimension 3 and has non empty levels [0,-1,-2] with elements
3962  * TETRA4, HEXA8, TRI3 and SEG2.
3963  * - field \a f1 lies on \a m1 and is defined on 3D and 1D elements TETRA4 and SEG2.
3964  * - field \a f2 lies on \a m1 and is defined on 2D and 1D elements TRI3 and SEG2.
3965  *
3966  * In this case \a f1->getNonEmptyLevels() returns (3,[0,-2]) and \a
3967  * f2->getNonEmptyLevels() returns (2,[0,-1]). <br>
3968  * The returned values can be used for example to retrieve a MEDCouplingFieldDouble lying
3969  * on elements of a certain relative level by calling getFieldAtLevel(). \a meshDimRelToMax
3970  * parameter of getFieldAtLevel() is computed basing on the returned values as this:
3971  * <em> meshDimRelToMax = absDim - meshDim + relativeLev </em>.
3972  * For example<br>
3973  * to retrieve the highest level of
3974  * \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+0 ); // absDim - meshDim + relativeLev</em><br>
3975  * to retrieve the lowest level of \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+(-2) );</em><br>
3976  * to retrieve the highest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+0 );</em><br>
3977  * to retrieve the lowest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+(-1) )</em>.
3978  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3979  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3980  *          not checked if \a mname == \c NULL).
3981  *  \param [in,out] levs - a sequence returning the dimensions relative to the maximal
3982  *          absolute one. They are in decreasing order. This sequence is cleared before
3983  *          filling it in.
3984  *  \return int - the maximal absolute dimension of elements \a this fields lies on.
3985  *  \throw If no field is lying on \a mname.
3986  */
3987 int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const
3988 {
3989   levs.clear();
3990   int meshId=getMeshIdFromMeshName(mname);
3991   std::vector<INTERP_KERNEL::NormalizedCellType> types;
3992   std::vector< std::vector<TypeOfField> > typesF;
3993   std::vector< std::vector<std::string> > pfls, locs;
3994   _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3995   if(types.empty())
3996     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getNonEmptyLevels : 'this' is empty !");
3997   std::set<INTERP_KERNEL::NormalizedCellType> st(types.begin(),types.end());
3998   if(st.size()==1 && (*st.begin())==INTERP_KERNEL::NORM_ERROR)
3999     return -1;
4000   st.erase(INTERP_KERNEL::NORM_ERROR);
4001   std::set<int> ret1;
4002   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
4003     {
4004       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
4005       ret1.insert((int)cm.getDimension());
4006     }
4007   int ret=*std::max_element(ret1.begin(),ret1.end());
4008   std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
4009   std::transform(levs.begin(),levs.end(),levs.begin(),std::bind2nd(std::plus<int>(),-ret));
4010   return ret;
4011 }
4012
4013 /*!
4014  * \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.
4015  * \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.
4016  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4017  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4018  */
4019 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
4020 {
4021   int mid=getMeshIdFromMeshName(mName);
4022   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
4023 }
4024
4025 /*!
4026  * \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.
4027  * \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.
4028  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4029  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4030  */
4031 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
4032 {
4033   int mid=getMeshIdFromMeshName(mName);
4034   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
4035 }
4036
4037 /*!
4038  * \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.
4039  */
4040 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIdFromMeshName(const char *mName) const
4041 {
4042   if(_field_per_mesh.empty())
4043     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
4044   if(mName==0)
4045     return 0;
4046   std::string mName2(mName);
4047   int ret=0;
4048   std::vector<std::string> msg;
4049   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
4050     if(mName2==(*it)->getMeshName())
4051       return ret;
4052     else
4053       msg.push_back((*it)->getMeshName());
4054   std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
4055   oss << "Possible meshes are : ";
4056   for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
4057     oss << "\"" << (*it2) << "\" ";
4058   throw INTERP_KERNEL::Exception(oss.str().c_str());
4059 }
4060
4061 int MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary(const MEDCouplingMesh *mesh)
4062 {
4063   if(!mesh)
4064     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary : input mesh is NULL !");
4065   std::string tmp(mesh->getName());
4066   if(tmp.empty())
4067     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
4068   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();
4069   int i=0;
4070   for(;it!=_field_per_mesh.end();it++,i++)
4071     {
4072       if((*it)->getMeshName()==tmp)
4073         return i;
4074     }
4075   int sz=_field_per_mesh.size();
4076   _field_per_mesh.resize(sz+1);
4077   _field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
4078   return sz;
4079 }
4080
4081 bool MEDFileAnyTypeField1TSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
4082                                                             MEDFileFieldGlobsReal& glob)
4083 {
4084   bool ret=false;
4085   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4086     {
4087       MEDFileFieldPerMesh *fpm(*it);
4088       if(fpm)
4089         ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
4090     }
4091   return ret;
4092 }
4093
4094 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations() const
4095 {
4096   std::vector<INTERP_KERNEL::NormalizedCellType> types;
4097   std::vector< std::vector<TypeOfField> > typesF;
4098   std::vector< std::vector<std::string> > pfls,locs;
4099   std::vector< std::vector<std::pair<int,int> > > bgEnd=getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs);
4100   std::set<TypeOfField> allEnt;
4101   for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++)
4102     for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4103       allEnt.insert(*it2);
4104   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(allEnt.size());
4105   std::set<TypeOfField>::const_iterator it3(allEnt.begin());
4106   for(std::size_t i=0;i<allEnt.size();i++,it3++)
4107     {
4108       std::vector< std::pair<int,int> > its;
4109       ret[i]=shallowCpy();
4110       int newLgth=ret[i]->keepOnlySpatialDiscretization(*it3,its);
4111       ret[i]->updateData(newLgth,its);
4112     }
4113   return ret;
4114 }
4115
4116 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlySpatialDiscretization(TypeOfField tof, std::vector< std::pair<int,int> >& its)
4117 {
4118   int globalCounter=0;
4119   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4120     (*it)->keepOnlySpatialDiscretization(tof,globalCounter,its);
4121   return globalCounter;
4122 }
4123
4124 void MEDFileAnyTypeField1TSWithoutSDA::updateData(int newLgth, const std::vector< std::pair<int,int> >& oldStartStops)
4125 {
4126   if(_nb_of_tuples_to_be_allocated>=0)
4127     {
4128       _nb_of_tuples_to_be_allocated=newLgth;
4129       return ;
4130     }
4131   if(_nb_of_tuples_to_be_allocated==-1)
4132     return ;
4133   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4134     {
4135       const DataArray *oldArr=getUndergroundDataArray();
4136       if(!oldArr || !oldArr->isAllocated())
4137         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 1 !");
4138       MEDCouplingAutoRefCountObjectPtr<DataArray> newArr=createNewEmptyDataArrayInstance();
4139       newArr->alloc(newLgth,getNumberOfComponents());
4140       int pos=0;
4141       for(std::vector< std::pair<int,int> >::const_iterator it=oldStartStops.begin();it!=oldStartStops.end();it++)
4142         {
4143           if((*it).second<(*it).first)
4144             throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : the range in the leaves was invalid !");
4145           newArr->setContigPartOfSelectedValues2(pos,oldArr,(*it).first,(*it).second,1);
4146           pos+=(*it).second-(*it).first;
4147         }
4148       setArray(newArr);
4149       return ;
4150     }
4151   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 2 !");
4152 }
4153
4154 void MEDFileAnyTypeField1TSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts, const MEDFileFieldNameScope& nasc) const
4155 {
4156   if(_field_per_mesh.empty())
4157     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : empty field !");
4158   if(_field_per_mesh.size()>1)
4159     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : In MED3.0 mode in writting mode only ONE underlying mesh supported !");
4160   _field_per_mesh[0]->copyOptionsFrom(opts);
4161   _field_per_mesh[0]->writeLL(fid,nasc);
4162 }
4163
4164 /*!
4165  * 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.
4166  * If false is returned the memory allocation is not required.
4167  */
4168 bool MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile()
4169 {
4170   if(_nb_of_tuples_to_be_allocated>=0)
4171     {
4172       getOrCreateAndGetArray()->alloc(_nb_of_tuples_to_be_allocated,getNumberOfComponents());
4173       _nb_of_tuples_to_be_allocated=-2;
4174       return true;
4175     }
4176   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4177     return false;
4178   if(_nb_of_tuples_to_be_allocated==-1)
4179     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : trying to read from a file an empty instance ! Need to prepare the structure before !");
4180   if(_nb_of_tuples_to_be_allocated<-3)
4181     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4182   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4183 }
4184
4185 void MEDFileAnyTypeField1TSWithoutSDA::loadOnlyStructureOfDataRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4186 {
4187   med_int numdt,numit;
4188   med_float dt;
4189   med_int nmesh;
4190   med_bool localMesh;
4191   med_int meshnumdt,meshnumit;
4192   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
4193   MEDfieldComputingStepInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&_dt);
4194   MEDfield23ComputingStepMeshInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&dt,&nmesh,meshName,&localMesh,&meshnumdt,&meshnumit);
4195   if(_iteration!=numdt || _order!=numit)
4196     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively : unexpected exception internal error !");
4197   _field_per_mesh.resize(nmesh);
4198   for(int i=0;i<nmesh;i++)
4199     _field_per_mesh[i]=MEDFileFieldPerMesh::NewOnRead(fid,this,i+1,meshnumdt,meshnumit,nasc);//tony
4200   _nb_of_tuples_to_be_allocated=0;
4201   for(int i=0;i<nmesh;i++)
4202     _field_per_mesh[i]->loadOnlyStructureOfDataRecursively(fid,_nb_of_tuples_to_be_allocated,nasc);
4203 }
4204
4205 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4206 {
4207   allocIfNecessaryTheArrayToReceiveDataFromFile();
4208   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4209     (*it)->loadBigArraysRecursively(fid,nasc);
4210 }
4211
4212 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
4213 {
4214   if(allocIfNecessaryTheArrayToReceiveDataFromFile())
4215     for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4216       (*it)->loadBigArraysRecursively(fid,nasc);
4217 }
4218
4219 void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4220 {
4221   loadOnlyStructureOfDataRecursively(fid,nasc);
4222   loadBigArraysRecursively(fid,nasc);
4223 }
4224
4225 void MEDFileAnyTypeField1TSWithoutSDA::unloadArrays()
4226 {
4227   DataArray *thisArr(getUndergroundDataArray());
4228   if(thisArr && thisArr->isAllocated())
4229     {
4230       _nb_of_tuples_to_be_allocated=thisArr->getNumberOfTuples();
4231       thisArr->desallocate();
4232     }
4233 }
4234
4235 std::size_t MEDFileAnyTypeField1TSWithoutSDA::getHeapMemorySizeWithoutChildren() const
4236 {
4237   return _dt_unit.capacity()+_field_per_mesh.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh >);
4238 }
4239
4240 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TSWithoutSDA::getDirectChildren() const
4241 {
4242   std::vector<const BigMemoryObject *> ret;
4243   if(getUndergroundDataArray())
4244     ret.push_back(getUndergroundDataArray());
4245   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4246     {
4247       const MEDFileFieldPerMesh *cur(*it);
4248       if(cur)
4249         ret.push_back(cur);
4250     }
4251   return ret;
4252 }
4253
4254 /*!
4255  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
4256  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
4257  * "Sort By Type"), if not, an exception is thrown.
4258  *  \param [in] field - the field to add to \a this. The array of field \a field is ignored
4259  *  \param [in] arr - the array of values.
4260  *  \param [in,out] glob - the global data where profiles and localization present in
4261  *          \a field, if any, are added.
4262  *  \throw If the name of \a field is empty.
4263  *  \throw If the data array of \a field is not set.
4264  *  \throw If \a this->_arr is already allocated but has different number of components
4265  *         than \a field.
4266  *  \throw If the underlying mesh of \a field has no name.
4267  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
4268  */
4269 void MEDFileAnyTypeField1TSWithoutSDA::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
4270 {
4271   const MEDCouplingMesh *mesh=field->getMesh();
4272   //
4273   TypeOfField type=field->getTypeOfField();
4274   std::vector<DataArrayInt *> dummy;
4275   int start=copyTinyInfoFrom(field,arr);
4276   int pos=addNewEntryIfNecessary(mesh);
4277   if(type!=ON_NODES)
4278     {
4279       std::vector<int> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
4280       _field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,arr,glob,nasc);
4281     }
4282   else
4283     _field_per_mesh[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
4284 }
4285
4286 /*!
4287  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
4288  * of a given mesh are used as the support of the given field (a real support is not used).
4289  * Elements of the given mesh must be sorted suitable for writing to MED file.
4290  * Order of underlying mesh entities of the given field specified by \a profile parameter
4291  * is not prescribed; this method permutes field values to have them sorted by element
4292  * type as required for writing to MED file. A new profile is added only if no equal
4293  * profile is missing.
4294  *  \param [in] field - the field to add to \a this. The field double values are ignored.
4295  *  \param [in] arrOfVals - the values of the field \a field used.
4296  *  \param [in] mesh - the supporting mesh of \a field.
4297  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
4298  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
4299  *  \param [in,out] glob - the global data where profiles and localization present in
4300  *          \a field, if any, are added.
4301  *  \throw If either \a field or \a mesh or \a profile has an empty name.
4302  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4303  *  \throw If the data array of \a field is not set.
4304  *  \throw If \a this->_arr is already allocated but has different number of components
4305  *         than \a field.
4306  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4307  *  \sa setFieldNoProfileSBT()
4308  */
4309 void MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
4310 {
4311   if(!field)
4312     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input field is null !");
4313   if(!arrOfVals || !arrOfVals->isAllocated())
4314     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input array is null or not allocated !");
4315   TypeOfField type=field->getTypeOfField();
4316   std::vector<DataArrayInt *> idsInPflPerType;
4317   std::vector<DataArrayInt *> idsPerType;
4318   std::vector<int> code,code2;
4319   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4320   if(type!=ON_NODES)
4321     {
4322       m->splitProfilePerType(profile,code,idsInPflPerType,idsPerType);
4323       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsInPflPerType2(idsInPflPerType.size()); std::copy(idsInPflPerType.begin(),idsInPflPerType.end(),idsInPflPerType2.begin());
4324       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsPerType2(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType2.begin());
4325       std::vector<const DataArrayInt *> idsPerType3(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType3.begin());
4326       // start of check
4327       MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field2=field->clone(false);
4328       int nbOfTuplesExp=field2->getNumberOfTuplesExpectedRegardingCode(code,idsPerType3);
4329       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4330         {
4331           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : The array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4332           throw INTERP_KERNEL::Exception(oss.str().c_str());
4333         }
4334       // end of check
4335       int start=copyTinyInfoFrom(field,arrOfVals);
4336       code2=m->getDistributionOfTypes();
4337       //
4338       int pos=addNewEntryIfNecessary(m);
4339       _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
4340     }
4341   else
4342     {
4343       if(!profile || !profile->isAllocated() || profile->getNumberOfComponents()!=1)
4344         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input profile is null, not allocated or with number of components != 1 !");
4345       std::vector<int> v(3); v[0]=-1; v[1]=profile->getNumberOfTuples(); v[2]=0;
4346       std::vector<const DataArrayInt *> idsPerType3(1); idsPerType3[0]=profile;
4347       int nbOfTuplesExp=field->getNumberOfTuplesExpectedRegardingCode(v,idsPerType3);
4348       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4349         {
4350           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : For node field, the array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4351           throw INTERP_KERNEL::Exception(oss.str().c_str());
4352         }
4353       int start=copyTinyInfoFrom(field,arrOfVals);
4354       int pos=addNewEntryIfNecessary(m);
4355       _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
4356     }
4357 }
4358
4359 /*!
4360  * \param [in] newNbOfTuples - The new nb of tuples to be allocated.
4361  */
4362 void MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile(int newNbOfTuples)
4363 {
4364   if(_nb_of_tuples_to_be_allocated>=0)
4365     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 !");
4366   DataArray *arr(getOrCreateAndGetArray());
4367   arr->alloc(newNbOfTuples,arr->getNumberOfComponents());
4368   _nb_of_tuples_to_be_allocated=-3;
4369 }
4370
4371 /*!
4372  * Copies tiny info and allocates \a this->_arr instance of DataArrayDouble to
4373  * append data of a given MEDCouplingFieldDouble. So that the size of \a this->_arr becomes
4374  * larger by the size of \a field. Returns an id of the first not filled
4375  * tuple of \a this->_arr.
4376  *  \param [in] field - the field to copy the info on components and the name from.
4377  *  \return int - the id of first not initialized tuple of \a this->_arr.
4378  *  \throw If the name of \a field is empty.
4379  *  \throw If the data array of \a field is not set.
4380  *  \throw If \a this->_arr is already allocated but has different number of components
4381  *         than \a field.
4382  */
4383 int MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
4384 {
4385   if(!field)
4386     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
4387   std::string name(field->getName());
4388   setName(name.c_str());
4389   setDtUnit(field->getTimeUnit());
4390   if(name.empty())
4391     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
4392   if(!arr)
4393     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
4394   if(!arr->isAllocated())
4395     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : array is not allocated !");
4396   _dt=field->getTime(_iteration,_order);
4397   getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
4398   if(!getOrCreateAndGetArray()->isAllocated())
4399     {
4400       allocNotFromFile(arr->getNumberOfTuples());
4401       return 0;
4402     }
4403   else
4404     {
4405       int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
4406       int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
4407       getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
4408       _nb_of_tuples_to_be_allocated=-3;
4409       return oldNbOfTuples;
4410     }
4411 }
4412
4413 /*!
4414  * Returns number of components in \a this field
4415  *  \return int - the number of components.
4416  */
4417 int MEDFileAnyTypeField1TSWithoutSDA::getNumberOfComponents() const
4418 {
4419   return getOrCreateAndGetArray()->getNumberOfComponents();
4420 }
4421
4422 /*!
4423  * Change info on components in \a this.
4424  * \throw If size of \a infos is not equal to the number of components already in \a this.
4425  */
4426 void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos)
4427 {
4428   DataArray *arr=getOrCreateAndGetArray();
4429   arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
4430 }
4431
4432 /*!
4433  * Returns info on components of \a this field.
4434  *  \return const std::vector<std::string>& - a sequence of strings each being an
4435  *          information on _i_-th component.
4436  */
4437 const std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo() const
4438 {
4439   const DataArray *arr=getOrCreateAndGetArray();
4440   return arr->getInfoOnComponents();
4441 }
4442
4443 /*!
4444  * Returns a mutable info on components of \a this field.
4445  *  \return std::vector<std::string>& - a sequence of strings each being an
4446  *          information on _i_-th component.
4447  */
4448 std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo()
4449 {
4450   DataArray *arr=getOrCreateAndGetArray();
4451   return arr->getInfoOnComponents();
4452 }
4453
4454 /*!
4455  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4456  *  \param [in] type - a spatial discretization of the new field.
4457  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4458  *  \param [in] mName - a name of the supporting mesh.
4459  *  \param [in] renumPol - specifies how to permute values of the result field according to
4460  *          the optional numbers of cells and nodes, if any. The valid values are
4461  *          - 0 - do not permute.
4462  *          - 1 - permute cells.
4463  *          - 2 - permute nodes.
4464  *          - 3 - permute cells and nodes.
4465  *
4466  *  \param [in] glob - the global data storing profiles and localization.
4467  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4468  *          caller is to delete this field using decrRef() as it is no more needed.
4469  *  \throw If the MED file is not readable.
4470  *  \throw If there is no mesh named \a mName in the MED file.
4471  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4472  *  \throw If no field of \a this is lying on the mesh \a mName.
4473  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4474  */
4475 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4476 {
4477   MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4478   if(mName==0)
4479     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4480   else
4481     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4482   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4483 }
4484
4485 /*!
4486  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4487  *  \param [in] type - a spatial discretization of the new field.
4488  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4489  *  \param [in] renumPol - specifies how to permute values of the result field according to
4490  *          the optional numbers of cells and nodes, if any. The valid values are
4491  *          - 0 - do not permute.
4492  *          - 1 - permute cells.
4493  *          - 2 - permute nodes.
4494  *          - 3 - permute cells and nodes.
4495  *
4496  *  \param [in] glob - the global data storing profiles and localization.
4497  *  \param [in] mesh - the supporting mesh.
4498  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4499  *          caller is to delete this field using decrRef() as it is no more needed.
4500  *  \throw If the MED file is not readable.
4501  *  \throw If no field of \a this is lying on \a mesh.
4502  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4503  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4504  */
4505 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4506 {
4507   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax,false);
4508   const DataArrayInt *d=mesh->getNumberFieldAtLevel(meshDimRelToMax);
4509   const DataArrayInt *e=mesh->getNumberFieldAtLevel(1);
4510   if(meshDimRelToMax==1)
4511     (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
4512   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e,arrOut,nasc);
4513 }
4514
4515 /*!
4516  * Returns a new MEDCouplingFieldDouble of a given type lying on the top level cells of a
4517  * given mesh.
4518  *  \param [in] type - a spatial discretization of the new field.
4519  *  \param [in] mName - a name of the supporting mesh.
4520  *  \param [in] renumPol - specifies how to permute values of the result field according to
4521  *          the optional numbers of cells and nodes, if any. The valid values are
4522  *          - 0 - do not permute.
4523  *          - 1 - permute cells.
4524  *          - 2 - permute nodes.
4525  *          - 3 - permute cells and nodes.
4526  *
4527  *  \param [in] glob - the global data storing profiles and localization.
4528  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4529  *          caller is to delete this field using decrRef() as it is no more needed.
4530  *  \throw If the MED file is not readable.
4531  *  \throw If there is no mesh named \a mName in the MED file.
4532  *  \throw If there are no mesh entities in the mesh.
4533  *  \throw If no field values of the given \a type are available.
4534  */
4535 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4536 {
4537    MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4538   if(mName==0)
4539     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4540   else
4541     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4542   int absDim=getDimension();
4543   int meshDimRelToMax=absDim-mm->getMeshDimension();
4544   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4545 }
4546
4547 /*!
4548  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4549  *  \param [in] type - a spatial discretization of the new field.
4550  *  \param [in] renumPol - specifies how to permute values of the result field according to
4551  *          the optional numbers of cells and nodes, if any. The valid values are
4552  *          - 0 - do not permute.
4553  *          - 1 - permute cells.
4554  *          - 2 - permute nodes.
4555  *          - 3 - permute cells and nodes.
4556  *
4557  *  \param [in] glob - the global data storing profiles and localization.
4558  *  \param [in] mesh - the supporting mesh.
4559  *  \param [in] cellRenum - the cell numbers array used for permutation of the result
4560  *         field according to \a renumPol.
4561  *  \param [in] nodeRenum - the node numbers array used for permutation of the result
4562  *         field according to \a renumPol.
4563  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4564  *          caller is to delete this field using decrRef() as it is no more needed.
4565  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4566  *  \throw If no field of \a this is lying on \a mesh.
4567  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4568  */
4569 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
4570 {
4571   static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
4572   int meshId=getMeshIdFromMeshName(mesh->getName().c_str());
4573   bool isPfl=false;
4574   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl,arrOut,nasc);
4575   switch(renumPol)
4576     {
4577     case 0:
4578       {
4579         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4580         return ret.retn();
4581       }
4582     case 3:
4583     case 1:
4584       {
4585         if(isPfl)
4586           throw INTERP_KERNEL::Exception(msg1);
4587         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4588         if(cellRenum)
4589           {
4590             if((int)cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
4591               {
4592                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4593                 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
4594                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4595               }
4596             MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
4597             if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
4598             std::vector<DataArray *> arrOut2(1,arrOut);
4599             // 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
4600             disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
4601             (const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
4602           }
4603         if(renumPol==1)
4604           return ret.retn();
4605       }
4606     case 2:
4607       {
4608         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4609         if(isPfl)
4610           throw INTERP_KERNEL::Exception(msg1);
4611         if(nodeRenum)
4612           {
4613             if((int)nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
4614               {
4615                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4616                 oss << "\"" << nasc.getName() << "\" not defined on all nodes !";
4617                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4618               }
4619             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
4620             if(!dynamic_cast<DataArrayDouble *>((DataArray *)arrOut))
4621               throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : node renumbering not implemented for not double DataArrays !");
4622             ret->renumberNodes(nodeRenumSafe->getConstPointer());
4623           }
4624         return ret.retn();
4625       }
4626     default:
4627       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
4628     }
4629 }
4630
4631 /*!
4632  * Returns values and a profile of the field of a given type lying on a given support.
4633  *  \param [in] type - a spatial discretization of the field.
4634  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4635  *  \param [in] mesh - the supporting mesh.
4636  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
4637  *          field of interest lies on. If the field lies on all entities of the given
4638  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
4639  *          using decrRef() as it is no more needed.
4640  *  \param [in] glob - the global data storing profiles and localization.
4641  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
4642  *          field. The caller is to delete this array using decrRef() as it is no more needed.
4643  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4644  *  \throw If no field of \a this is lying on \a mesh.
4645  *  \throw If no field values of the given \a type are available.
4646  */
4647 DataArray *MEDFileAnyTypeField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
4648 {
4649   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4650   int meshId=getMeshIdFromMeshName(mesh->getName().c_str());
4651   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob,nasc);
4652   ret->setName(nasc.getName().c_str());
4653   return ret.retn();
4654 }
4655
4656 //= MEDFileField1TSWithoutSDA
4657
4658 /*!
4659  * Throws if a given value is not a valid (non-extended) relative dimension.
4660  *  \param [in] meshDimRelToMax - the relative dimension value.
4661  *  \throw If \a meshDimRelToMax > 0.
4662  */
4663 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax)
4664 {
4665   if(meshDimRelToMax>0)
4666     throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
4667 }
4668
4669 /*!
4670  * Checks if elements of a given mesh are in the order suitable for writing
4671  * to the MED file. If this is not so, an exception is thrown. In a case of success, returns a
4672  * vector describing types of elements and their number.
4673  *  \param [in] mesh - the mesh to check.
4674  *  \return std::vector<int> - a vector holding for each element type (1) item of
4675  *          INTERP_KERNEL::NormalizedCellType, (2) number of elements, (3) -1.
4676  *          These values are in full-interlace mode.
4677  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4678  */
4679 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh)
4680 {
4681   if(!mesh)
4682     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
4683   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
4684   int nbOfTypes=geoTypes.size();
4685   std::vector<int> code(3*nbOfTypes);
4686   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr1=DataArrayInt::New();
4687   arr1->alloc(nbOfTypes,1);
4688   int *arrPtr=arr1->getPointer();
4689   std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
4690   for(int i=0;i<nbOfTypes;i++,it++)
4691     arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
4692   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
4693   const int *arrPtr2=arr2->getConstPointer();
4694   int i=0;
4695   for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
4696     {
4697       int pos=arrPtr2[i];
4698       int nbCells=mesh->getNumberOfCellsWithType(*it);
4699       code[3*pos]=(int)(*it);
4700       code[3*pos+1]=nbCells;
4701       code[3*pos+2]=-1;//no profiles
4702     }
4703   std::vector<const DataArrayInt *> idsPerType;//no profiles
4704   DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
4705   if(da)
4706     {
4707       da->decrRef();
4708       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
4709     }
4710   return code;
4711 }
4712
4713 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos)
4714 {
4715   return new MEDFileField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4716 }
4717
4718 /*!
4719  * Returns all attributes and values of parts of \a this field lying on a given mesh.
4720  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
4721  * item of every of returned sequences refers to the _i_-th part of \a this field.
4722  * Thus all sequences returned by this method are of the same length equal to number
4723  * of different types of supporting entities.<br>
4724  * A field part can include sub-parts with several different spatial discretizations,
4725  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
4726  * for example. Hence, some of the returned sequences contains nested sequences, and an item
4727  * of a nested sequence corresponds to a type of spatial discretization.<br>
4728  * This method allows for iteration over MEDFile DataStructure with a reduced overhead.
4729  * The overhead is due to selecting values into new instances of DataArrayDouble.
4730  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4731  *          for the case with only one underlying mesh. (Actually, the number of meshes is
4732  *          not checked if \a mname == \c NULL).
4733  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
4734  *          a field part is returned.
4735  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
4736  *          A field part can include sub-parts with several different spatial discretizations,
4737  *          \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and
4738  *          \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT" for example.
4739  *          This sequence is of the same length as \a types.
4740  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
4741  *          discretization. A profile name can be empty.
4742  *          Length of this and of nested sequences is the same as that of \a typesF.
4743  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
4744  *          discretization. A localization name can be empty.
4745  *          Length of this and of nested sequences is the same as that of \a typesF.
4746  *  \return std::vector< std::vector<DataArrayDouble *> > - a sequence holding arrays of values
4747  *          per each type of spatial discretization within one mesh entity type.
4748  *          The caller is to delete each DataArrayDouble using decrRef() as it is no more needed.
4749  *          Length of this and of nested sequences is the same as that of \a typesF.
4750  *  \throw If no field is lying on \a mname.
4751  */
4752 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
4753 {
4754   int meshId=0;
4755   if(mname)
4756     meshId=getMeshIdFromMeshName(mname);
4757   else
4758     if(_field_per_mesh.empty())
4759       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
4760   std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
4761   int nbOfRet=ret0.size();
4762   std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
4763   for(int i=0;i<nbOfRet;i++)
4764     {
4765       const std::vector< std::pair<int,int> >& p=ret0[i];
4766       int nbOfRet1=p.size();
4767       ret[i].resize(nbOfRet1);
4768       for(int j=0;j<nbOfRet1;j++)
4769         {
4770           DataArrayDouble *tmp=_arr->selectByTupleId2(p[j].first,p[j].second,1);
4771           ret[i][j]=tmp;
4772         }
4773     }
4774   return ret;
4775 }
4776
4777 /*!
4778  * Returns a pointer to the underground DataArrayDouble instance. So the
4779  * caller should not decrRef() it. This method allows for a direct access to the field
4780  * values. This method is quite unusable if there is more than a nodal field or a cell
4781  * field on single geometric cell type.
4782  *  \return DataArrayDouble * - the pointer to the field values array.
4783  */
4784 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDouble() const
4785 {
4786   const DataArrayDouble *ret=_arr;
4787   if(ret)
4788     return const_cast<DataArrayDouble *>(ret);
4789   else
4790     return 0;
4791 }
4792
4793 const char *MEDFileField1TSWithoutSDA::getTypeStr() const
4794 {
4795   return TYPE_STR;
4796 }
4797
4798 MEDFileIntField1TSWithoutSDA *MEDFileField1TSWithoutSDA::convertToInt() const
4799 {
4800   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA);
4801   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4802   ret->deepCpyLeavesFrom(*this);
4803   const DataArrayDouble *arr(_arr);
4804   if(arr)
4805     {
4806       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr->convertToIntArr());
4807       ret->setArray(arr2);
4808     }
4809   return ret.retn();
4810 }
4811
4812 /*!
4813  * Returns a pointer to the underground DataArrayDouble instance. So the
4814  * caller should not decrRef() it. This method allows for a direct access to the field
4815  * values. This method is quite unusable if there is more than a nodal field or a cell
4816  * field on single geometric cell type.
4817  *  \return DataArrayDouble * - the pointer to the field values array.
4818  */
4819 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArray() const
4820 {
4821   return getUndergroundDataArrayDouble();
4822 }
4823
4824 /*!
4825  * Returns a pointer to the underground DataArrayDouble instance and a
4826  * sequence describing parameters of a support of each part of \a this field. The
4827  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4828  * direct access to the field values. This method is intended for the field lying on one
4829  * mesh only.
4830  *  \param [in,out] entries - the sequence describing parameters of a support of each
4831  *         part of \a this field. Each item of this sequence consists of two parts. The
4832  *         first part describes a type of mesh entity and an id of discretization of a
4833  *         current field part. The second part describes a range of values [begin,end)
4834  *         within the returned array relating to the current field part.
4835  *  \return DataArrayDouble * - the pointer to the field values array.
4836  *  \throw If the number of underlying meshes is not equal to 1.
4837  *  \throw If no field values are available.
4838  *  \sa getUndergroundDataArray()
4839  */
4840 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDoubleExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
4841 {
4842   if(_field_per_mesh.size()!=1)
4843     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
4844   if(_field_per_mesh[0]==0)
4845     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
4846   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
4847   return getUndergroundDataArrayDouble();
4848 }
4849
4850 /*!
4851  * Returns a pointer to the underground DataArrayDouble instance and a
4852  * sequence describing parameters of a support of each part of \a this field. The
4853  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4854  * direct access to the field values. This method is intended for the field lying on one
4855  * mesh only.
4856  *  \param [in,out] entries - the sequence describing parameters of a support of each
4857  *         part of \a this field. Each item of this sequence consists of two parts. The
4858  *         first part describes a type of mesh entity and an id of discretization of a
4859  *         current field part. The second part describes a range of values [begin,end)
4860  *         within the returned array relating to the current field part.
4861  *  \return DataArrayDouble * - the pointer to the field values array.
4862  *  \throw If the number of underlying meshes is not equal to 1.
4863  *  \throw If no field values are available.
4864  *  \sa getUndergroundDataArray()
4865  */
4866 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
4867 {
4868   return getUndergroundDataArrayDoubleExt(entries);
4869 }
4870
4871 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4872                                                      const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4873 {
4874   DataArrayDouble *arr=getOrCreateAndGetArrayDouble();
4875   arr->setInfoAndChangeNbOfCompo(infos);
4876 }
4877
4878 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4879 {
4880 }
4881
4882 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::shallowCpy() const
4883 {
4884   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA(*this));
4885   ret->deepCpyLeavesFrom(*this);
4886   return ret.retn();
4887 }
4888
4889 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCpy() const
4890 {
4891   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret=static_cast<MEDFileField1TSWithoutSDA *>(shallowCpy());
4892   if((const DataArrayDouble *)_arr)
4893     ret->_arr=_arr->deepCpy();
4894   return ret.retn();
4895 }
4896
4897 void MEDFileField1TSWithoutSDA::setArray(DataArray *arr)
4898 {
4899   if(!arr)
4900     {
4901       _nb_of_tuples_to_be_allocated=-1;
4902       _arr=0;
4903       return ;
4904     }
4905   DataArrayDouble *arrC=dynamic_cast<DataArrayDouble *>(arr);
4906   if(!arrC)
4907     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayDouble !");
4908   else
4909     _nb_of_tuples_to_be_allocated=-3;
4910   arrC->incrRef();
4911   _arr=arrC;
4912 }
4913
4914 DataArray *MEDFileField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
4915 {
4916   return DataArrayDouble::New();
4917 }
4918
4919 DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble()
4920 {
4921   DataArrayDouble *ret=_arr;
4922   if(ret)
4923     return ret;
4924   _arr=DataArrayDouble::New();
4925   return _arr;
4926 }
4927
4928 DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray()
4929 {
4930   return getOrCreateAndGetArrayDouble();
4931 }
4932
4933 const DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble() const
4934 {
4935   const DataArrayDouble *ret=_arr;
4936   if(ret)
4937     return ret;
4938   DataArrayDouble *ret2=DataArrayDouble::New();
4939   const_cast<MEDFileField1TSWithoutSDA *>(this)->_arr=DataArrayDouble::New();
4940   return ret2;
4941 }
4942
4943 const DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray() const
4944 {
4945   return getOrCreateAndGetArrayDouble();
4946 }
4947
4948 //= MEDFileIntField1TSWithoutSDA
4949
4950 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order,
4951                                                                 const std::vector<std::string>& infos)
4952 {
4953   return new MEDFileIntField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4954 }
4955
4956 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4957 {
4958 }
4959
4960 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4961                                                            const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4962 {
4963   DataArrayInt *arr=getOrCreateAndGetArrayInt();
4964   arr->setInfoAndChangeNbOfCompo(infos);
4965 }
4966
4967 const char *MEDFileIntField1TSWithoutSDA::getTypeStr() const
4968 {
4969   return TYPE_STR;
4970 }
4971
4972 MEDFileField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::convertToDouble() const
4973 {
4974   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
4975   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4976   ret->deepCpyLeavesFrom(*this);
4977   const DataArrayInt *arr(_arr);
4978   if(arr)
4979     {
4980       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2(arr->convertToDblArr());
4981       ret->setArray(arr2);
4982     }
4983   return ret.retn();
4984 }
4985
4986 /*!
4987  * Returns a pointer to the underground DataArrayInt instance. So the
4988  * caller should not decrRef() it. This method allows for a direct access to the field
4989  * values. This method is quite unusable if there is more than a nodal field or a cell
4990  * field on single geometric cell type.
4991  *  \return DataArrayInt * - the pointer to the field values array.
4992  */
4993 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArray() const
4994 {
4995   return getUndergroundDataArrayInt();
4996 }
4997
4998 /*!
4999  * Returns a pointer to the underground DataArrayInt instance. So the
5000  * caller should not decrRef() it. This method allows for a direct access to the field
5001  * values. This method is quite unusable if there is more than a nodal field or a cell
5002  * field on single geometric cell type.
5003  *  \return DataArrayInt * - the pointer to the field values array.
5004  */
5005 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayInt() const
5006 {
5007   const DataArrayInt *ret=_arr;
5008   if(ret)
5009     return const_cast<DataArrayInt *>(ret);
5010   else
5011     return 0;
5012 }
5013
5014 /*!
5015  * Returns a pointer to the underground DataArrayInt instance and a
5016  * sequence describing parameters of a support of each part of \a this field. The
5017  * caller should not decrRef() the returned DataArrayInt. This method allows for a
5018  * direct access to the field values. This method is intended for the field lying on one
5019  * mesh only.
5020  *  \param [in,out] entries - the sequence describing parameters of a support of each
5021  *         part of \a this field. Each item of this sequence consists of two parts. The
5022  *         first part describes a type of mesh entity and an id of discretization of a
5023  *         current field part. The second part describes a range of values [begin,end)
5024  *         within the returned array relating to the current field part.
5025  *  \return DataArrayInt * - the pointer to the field values array.
5026  *  \throw If the number of underlying meshes is not equal to 1.
5027  *  \throw If no field values are available.
5028  *  \sa getUndergroundDataArray()
5029  */
5030 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5031 {
5032   return getUndergroundDataArrayIntExt(entries);
5033 }
5034
5035 /*!
5036  * Returns a pointer to the underground DataArrayInt instance and a
5037  * sequence describing parameters of a support of each part of \a this field. The
5038  * caller should not decrRef() the returned DataArrayInt. This method allows for a
5039  * direct access to the field values. This method is intended for the field lying on one
5040  * mesh only.
5041  *  \param [in,out] entries - the sequence describing parameters of a support of each
5042  *         part of \a this field. Each item of this sequence consists of two parts. The
5043  *         first part describes a type of mesh entity and an id of discretization of a
5044  *         current field part. The second part describes a range of values [begin,end)
5045  *         within the returned array relating to the current field part.
5046  *  \return DataArrayInt * - the pointer to the field values array.
5047  *  \throw If the number of underlying meshes is not equal to 1.
5048  *  \throw If no field values are available.
5049  *  \sa getUndergroundDataArray()
5050  */
5051 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5052 {
5053   if(_field_per_mesh.size()!=1)
5054     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
5055   if(_field_per_mesh[0]==0)
5056     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
5057   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
5058   return getUndergroundDataArrayInt();
5059 }
5060
5061 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::shallowCpy() const
5062 {
5063   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA(*this));
5064   ret->deepCpyLeavesFrom(*this);
5065   return ret.retn();
5066 }
5067
5068 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::deepCpy() const
5069 {
5070   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret=static_cast<MEDFileIntField1TSWithoutSDA *>(shallowCpy());
5071   if((const DataArrayInt *)_arr)
5072     ret->_arr=_arr->deepCpy();
5073   return ret.retn();
5074 }
5075
5076 void MEDFileIntField1TSWithoutSDA::setArray(DataArray *arr)
5077 {
5078   if(!arr)
5079     {
5080       _nb_of_tuples_to_be_allocated=-1;
5081       _arr=0;
5082       return ;
5083     }
5084   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>(arr);
5085   if(!arrC)
5086     throw INTERP_KERNEL::Exception("MEDFileIntField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayInt !");
5087   else
5088     _nb_of_tuples_to_be_allocated=-3;
5089   arrC->incrRef();
5090   _arr=arrC;
5091 }
5092
5093 DataArray *MEDFileIntField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
5094 {
5095   return DataArrayInt::New();
5096 }
5097
5098 DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt()
5099 {
5100   DataArrayInt *ret=_arr;
5101   if(ret)
5102     return ret;
5103   _arr=DataArrayInt::New();
5104   return _arr;
5105 }
5106
5107 DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray()
5108 {
5109   return getOrCreateAndGetArrayInt();
5110 }
5111
5112 const DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt() const
5113 {
5114   const DataArrayInt *ret=_arr;
5115   if(ret)
5116     return ret;
5117   DataArrayInt *ret2=DataArrayInt::New();
5118   const_cast<MEDFileIntField1TSWithoutSDA *>(this)->_arr=DataArrayInt::New();
5119   return ret2;
5120 }
5121
5122 const DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray() const
5123 {
5124   return getOrCreateAndGetArrayInt();
5125 }
5126
5127 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
5128 {
5129 }
5130
5131 //= MEDFileAnyTypeField1TS
5132
5133 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll)
5134 {
5135   med_field_type typcha;
5136   //
5137   std::vector<std::string> infos;
5138   std::string dtunit,fieldName;
5139   LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
5140   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5141   switch(typcha)
5142     {
5143     case MED_FLOAT64:
5144       {
5145         ret=MEDFileField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5146         break;
5147       }
5148     case MED_INT32:
5149       {
5150         ret=MEDFileIntField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5151         break;
5152       }
5153     default:
5154       {
5155         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] !";
5156         throw INTERP_KERNEL::Exception(oss.str().c_str());
5157       }
5158     }
5159   ret->setDtUnit(dtunit.c_str());
5160   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5161   //
5162   med_int numdt,numit;
5163   med_float dt;
5164   MEDfieldComputingStepInfo(fid,fieldName.c_str(),1,&numdt,&numit,&dt);
5165   ret->setTime(numdt,numit,dt);
5166   ret->_csit=1;
5167   if(loadAll)
5168     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5169   else
5170     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5171   return ret.retn();
5172 }
5173
5174 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, bool loadAll)
5175 try:MEDFileFieldGlobsReal(fileName)
5176 {
5177   MEDFileUtilities::CheckFileForRead(fileName);
5178   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5179   _content=BuildContentFrom(fid,fileName,loadAll);
5180   loadGlobals(fid);
5181 }
5182 catch(INTERP_KERNEL::Exception& e)
5183   {
5184     throw e;
5185   }
5186
5187 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll)
5188 {
5189   med_field_type typcha;
5190   std::vector<std::string> infos;
5191   std::string dtunit;
5192   int iii=-1;
5193   int nbSteps=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5194   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5195   switch(typcha)
5196     {
5197     case MED_FLOAT64:
5198       {
5199         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5200         break;
5201       }
5202     case MED_INT32:
5203       {
5204         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5205         break;
5206       }
5207     default:
5208       {
5209         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] !";
5210         throw INTERP_KERNEL::Exception(oss.str().c_str());
5211       }
5212     }
5213   ret->setDtUnit(dtunit.c_str());
5214   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5215   //
5216   if(nbSteps<1)
5217     {
5218       std::ostringstream oss; oss << "MEDFileField1TS(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but there is no time steps on it !";
5219       throw INTERP_KERNEL::Exception(oss.str().c_str());
5220     }
5221   //
5222   med_int numdt,numit;
5223   med_float dt;
5224   MEDfieldComputingStepInfo(fid,fieldName,1,&numdt,&numit,&dt);
5225   ret->setTime(numdt,numit,dt);
5226   ret->_csit=1;
5227   if(loadAll)
5228     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5229   else
5230     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5231   return ret.retn();
5232 }
5233
5234 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, bool loadAll)
5235 try:MEDFileFieldGlobsReal(fileName)
5236 {
5237   MEDFileUtilities::CheckFileForRead(fileName);
5238   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5239   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
5240   loadGlobals(fid);
5241 }
5242 catch(INTERP_KERNEL::Exception& e)
5243   {
5244     throw e;
5245   }
5246
5247 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c, const char *fileName)
5248 {
5249   if(!c)
5250     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
5251   if(dynamic_cast<const MEDFileField1TSWithoutSDA *>(c))
5252     {
5253       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New();
5254       ret->setFileName(fileName);
5255       ret->_content=c; c->incrRef();
5256       return ret.retn();
5257     }
5258   if(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(c))
5259     {
5260       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New();
5261       ret->setFileName(fileName);
5262       ret->_content=c; c->incrRef();
5263       return ret.retn();
5264     }
5265   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
5266 }
5267
5268 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, bool loadAll)
5269 {
5270   MEDFileUtilities::CheckFileForRead(fileName);
5271   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5272   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
5273   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5274   ret->loadGlobals(fid);
5275   return ret.retn();
5276 }
5277
5278 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, bool loadAll)
5279 {
5280   MEDFileUtilities::CheckFileForRead(fileName);
5281   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5282   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
5283   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5284   ret->loadGlobals(fid);
5285   return ret.retn();
5286 }
5287
5288 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
5289 {
5290   MEDFileUtilities::CheckFileForRead(fileName);
5291   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5292   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5293   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5294   ret->loadGlobals(fid);
5295   return ret.retn();
5296 }
5297
5298 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
5299 {
5300   med_field_type typcha;
5301   std::vector<std::string> infos;
5302   std::string dtunit;
5303   int iii=-1;
5304   int nbOfStep2=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5305   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5306   switch(typcha)
5307     {
5308     case MED_FLOAT64:
5309       {
5310         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5311         break;
5312       }
5313     case MED_INT32:
5314       {
5315         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5316         break;
5317       }
5318     default:
5319       {
5320         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] !";
5321         throw INTERP_KERNEL::Exception(oss.str().c_str());
5322       }
5323     }
5324   ret->setDtUnit(dtunit.c_str());
5325   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5326   //
5327   bool found=false;
5328   std::vector< std::pair<int,int> > dtits(nbOfStep2);
5329   for(int i=0;i<nbOfStep2 && !found;i++)
5330     {
5331       med_int numdt,numit;
5332       med_float dt;
5333       MEDfieldComputingStepInfo(fid,fieldName,i+1,&numdt,&numit,&dt);
5334       if(numdt==iteration && numit==order)
5335         {
5336           found=true;
5337           ret->_csit=i+1;
5338         }
5339       else
5340         dtits[i]=std::pair<int,int>(numdt,numit);
5341     }
5342   if(!found)
5343     {
5344       std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << fileName << "' ! Available iterations are : ";
5345       for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
5346         oss << "(" << (*iter).first << "," << (*iter).second << "), ";
5347       throw INTERP_KERNEL::Exception(oss.str().c_str());
5348     }
5349   if(loadAll)
5350     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5351   else
5352     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5353   return ret.retn();
5354 }
5355
5356 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
5357 try:MEDFileFieldGlobsReal(fileName)
5358 {
5359   MEDFileUtilities::CheckFileForRead(fileName);
5360   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5361   _content=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5362   loadGlobals(fid);
5363 }
5364 catch(INTERP_KERNEL::Exception& e)
5365   {
5366     throw e;
5367   }
5368
5369 /*!
5370  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5371  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5372  *
5373  * \warning this is a shallow copy constructor
5374  */
5375 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent)
5376 {
5377   if(!shallowCopyOfContent)
5378     {
5379       const MEDFileAnyTypeField1TSWithoutSDA *otherPtr(&other);
5380       otherPtr->incrRef();
5381       _content=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(otherPtr);
5382     }
5383   else
5384     {
5385       _content=other.shallowCpy();
5386     }
5387 }
5388
5389 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)
5390 {
5391   if(checkFieldId)
5392     {
5393       int nbFields=MEDnField(fid);
5394       if(fieldIdCFormat>=nbFields)
5395         {
5396           std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << fileName << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
5397           throw INTERP_KERNEL::Exception(oss.str().c_str());
5398         }
5399     }
5400   int ncomp=MEDfieldnComponent(fid,fieldIdCFormat+1);
5401   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5402   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5403   INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5404   INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5405   INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5406   med_bool localMesh;
5407   int nbOfStep;
5408   MEDfieldInfo(fid,fieldIdCFormat+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
5409   fieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
5410   dtunitOut=MEDLoaderBase::buildStringFromFortran(dtunit,MED_LNAME_SIZE);
5411   infos.clear(); infos.resize(ncomp);
5412   for(int j=0;j<ncomp;j++)
5413     infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
5414   return nbOfStep;
5415 }
5416
5417 /*!
5418  * This method throws an INTERP_KERNEL::Exception if \a fieldName field is not in file pointed by \a fid and with name \a fileName.
5419  *
5420  * \param [out]
5421  * \return in case of success the number of time steps available for the field with name \a fieldName.
5422  */
5423 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)
5424 {
5425   int nbFields=MEDnField(fid);
5426   bool found=false;
5427   std::vector<std::string> fns(nbFields);
5428   int nbOfStep2=-1;
5429   for(int i=0;i<nbFields && !found;i++)
5430     {
5431       std::string tmp;
5432       nbOfStep2=LocateField2(fid,fileName,i,false,tmp,typcha,infos,dtunitOut);
5433       fns[i]=tmp;
5434       found=(tmp==fieldName);
5435       if(found)
5436         posCFormat=i;
5437     }
5438   if(!found)
5439     {
5440       std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << fileName << "' ! Available fields are : ";
5441       for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
5442         oss << "\"" << *it << "\" ";
5443       throw INTERP_KERNEL::Exception(oss.str().c_str());
5444     }
5445   return nbOfStep2;
5446 }
5447
5448 /*!
5449  * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5450  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5451  * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5452  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5453  * to keep a valid instance.
5454  * 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.
5455  * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
5456  * 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.
5457  *
5458  * \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.
5459  * \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.
5460  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5461  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5462  * \param [in] newLocName is the new localization name.
5463  * \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.
5464  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
5465  */
5466 void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newPflName, bool forceRenameOnGlob)
5467 {
5468   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5469   std::string oldPflName=disc->getProfile();
5470   std::vector<std::string> vv=getPflsReallyUsedMulti();
5471   int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
5472   if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
5473     {
5474       disc->setProfile(newPflName);
5475       DataArrayInt *pfl=getProfile(oldPflName.c_str());
5476       pfl->setName(newPflName);
5477     }
5478   else
5479     {
5480       std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
5481       throw INTERP_KERNEL::Exception(oss.str().c_str());
5482     }
5483 }
5484
5485 /*!
5486  * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5487  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5488  * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5489  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5490  * to keep a valid instance.
5491  * 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.
5492  * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
5493  * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
5494  * 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.
5495  *
5496  * \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.
5497  * \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.
5498  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5499  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5500  * \param [in] newLocName is the new localization name.
5501  * \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.
5502  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
5503  */
5504 void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newLocName, bool forceRenameOnGlob)
5505 {
5506   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5507   std::string oldLocName=disc->getLocalization();
5508   std::vector<std::string> vv=getLocsReallyUsedMulti();
5509   int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
5510   if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
5511     {
5512       disc->setLocalization(newLocName);
5513       MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
5514       loc.setName(newLocName);
5515     }
5516   else
5517     {
5518       std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
5519       throw INTERP_KERNEL::Exception(oss.str().c_str());
5520     }
5521 }
5522
5523 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase()
5524 {
5525   MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5526   if(!ret)
5527     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : content is expected to be not null !");
5528   return ret;
5529 }
5530
5531 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() const
5532 {
5533   const MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5534   if(!ret)
5535     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : const content is expected to be not null !");
5536   return ret;
5537 }
5538
5539 /*!
5540  * Writes \a this field into a MED file specified by its name.
5541  *  \param [in] fileName - the MED file name.
5542  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
5543  * - 2 - erase; an existing file is removed.
5544  * - 1 - append; same data should not be present in an existing file.
5545  * - 0 - overwrite; same data present in an existing file is overwritten.
5546  *  \throw If the field name is not set.
5547  *  \throw If no field data is set.
5548  *  \throw If \a mode == 1 and the same data is present in an existing file.
5549  */
5550 void MEDFileAnyTypeField1TS::write(const char *fileName, int mode) const
5551 {
5552   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
5553   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
5554   writeLL(fid);
5555 }
5556
5557 /*!
5558  * This method alloc the arrays and load potentially huge arrays contained in this field.
5559  * This method should be called when a MEDFileAnyTypeField1TS::New constructor has been with false as the last parameter.
5560  * This method can be also called to refresh or reinit values from a file.
5561  *
5562  * \throw If the fileName is not set or points to a non readable MED file.
5563  * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5564  */
5565 void MEDFileAnyTypeField1TS::loadArrays()
5566 {
5567   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5568   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
5569 }
5570
5571 /*!
5572  * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
5573  * But once data loaded once, this method does nothing.
5574  *
5575  * \throw If the fileName is not set or points to a non readable MED file.
5576  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::unloadArrays
5577  */
5578 void MEDFileAnyTypeField1TS::loadArraysIfNecessary()
5579 {
5580   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5581   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
5582 }
5583
5584 /*!
5585  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
5586  * This method does not release arrays set outside the context of a MED file.
5587  *
5588  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary
5589  */
5590 void MEDFileAnyTypeField1TS::unloadArrays()
5591 {
5592   contentNotNullBase()->unloadArrays();
5593 }
5594
5595 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const
5596 {
5597   int nbComp=getNumberOfComponents();
5598   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5599   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5600   for(int i=0;i<nbComp;i++)
5601     {
5602       std::string info=getInfo()[i];
5603       std::string c,u;
5604       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
5605       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
5606       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
5607     }
5608   if(getName().empty())
5609     throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
5610   MEDfieldCr(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
5611   writeGlobals(fid,*this);
5612   contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
5613 }
5614
5615 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySizeWithoutChildren() const
5616 {
5617   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
5618 }
5619
5620 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TS::getDirectChildren() const
5621 {
5622   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
5623   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5624     ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)_content);
5625   return ret;
5626 }
5627
5628 /*!
5629  * Returns a string describing \a this field. This string is outputted
5630  * by \c print Python command.
5631  */
5632 std::string MEDFileAnyTypeField1TS::simpleRepr() const
5633 {
5634   std::ostringstream oss;
5635   contentNotNullBase()->simpleRepr(0,oss,-1);
5636   simpleReprGlobs(oss);
5637   return oss.str();
5638 }
5639
5640 /*!
5641  * This method returns all profiles whose name is non empty used.
5642  * \b WARNING If profile is used several times it will be reported \b only \b once.
5643  * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
5644  */
5645 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
5646 {
5647   return contentNotNullBase()->getPflsReallyUsed2();
5648 }
5649
5650 /*!
5651  * This method returns all localizations whose name is non empty used.
5652  * \b WARNING If localization is used several times it will be reported \b only \b once.
5653  */
5654 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
5655 {
5656   return contentNotNullBase()->getLocsReallyUsed2();
5657 }
5658
5659 /*!
5660  * This method returns all profiles whose name is non empty used.
5661  * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
5662  */
5663 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
5664 {
5665   return contentNotNullBase()->getPflsReallyUsedMulti2();
5666 }
5667
5668 /*!
5669  * This method returns all localizations whose name is non empty used.
5670  * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
5671  */
5672 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
5673 {
5674   return contentNotNullBase()->getLocsReallyUsedMulti2();
5675 }
5676
5677 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5678 {
5679   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
5680 }
5681
5682 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5683 {
5684   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
5685 }
5686
5687 int MEDFileAnyTypeField1TS::getDimension() const
5688 {
5689   return contentNotNullBase()->getDimension();
5690 }
5691
5692 int MEDFileAnyTypeField1TS::getIteration() const
5693 {
5694   return contentNotNullBase()->getIteration();
5695 }
5696
5697 int MEDFileAnyTypeField1TS::getOrder() const
5698 {
5699   return contentNotNullBase()->getOrder();
5700 }
5701
5702 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
5703 {
5704   return contentNotNullBase()->getTime(iteration,order);
5705 }
5706
5707 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
5708 {
5709   contentNotNullBase()->setTime(iteration,order,val);
5710 }
5711
5712 std::string MEDFileAnyTypeField1TS::getName() const
5713 {
5714   return contentNotNullBase()->getName();
5715 }
5716
5717 void MEDFileAnyTypeField1TS::setName(const char *name)
5718 {
5719   contentNotNullBase()->setName(name);
5720 }
5721
5722 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
5723 {
5724   contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
5725 }
5726
5727 std::string MEDFileAnyTypeField1TS::getDtUnit() const
5728 {
5729   return contentNotNullBase()->getDtUnit();
5730 }
5731
5732 void MEDFileAnyTypeField1TS::setDtUnit(const char *dtUnit)
5733 {
5734   contentNotNullBase()->setDtUnit(dtUnit);
5735 }
5736
5737 std::string MEDFileAnyTypeField1TS::getMeshName() const
5738 {
5739   return contentNotNullBase()->getMeshName();
5740 }
5741
5742 void MEDFileAnyTypeField1TS::setMeshName(const char *newMeshName)
5743 {
5744   contentNotNullBase()->setMeshName(newMeshName);
5745 }
5746
5747 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
5748 {
5749   return contentNotNullBase()->changeMeshNames(modifTab);
5750 }
5751
5752 int MEDFileAnyTypeField1TS::getMeshIteration() const
5753 {
5754   return contentNotNullBase()->getMeshIteration();
5755 }
5756
5757 int MEDFileAnyTypeField1TS::getMeshOrder() const
5758 {
5759   return contentNotNullBase()->getMeshOrder();
5760 }
5761
5762 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
5763 {
5764   return contentNotNullBase()->getNumberOfComponents();
5765 }
5766
5767 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
5768 {
5769   return contentNotNullBase()->isDealingTS(iteration,order);
5770 }
5771
5772 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
5773 {
5774   return contentNotNullBase()->getDtIt();
5775 }
5776
5777 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
5778 {
5779   contentNotNullBase()->fillIteration(p);
5780 }
5781
5782 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
5783 {
5784   contentNotNullBase()->fillTypesOfFieldAvailable(types);
5785 }
5786
5787 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos)
5788 {
5789   contentNotNullBase()->setInfo(infos);
5790 }
5791
5792 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
5793 {
5794   return contentNotNullBase()->getInfo();
5795 }
5796 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
5797 {
5798   return contentNotNullBase()->getInfo();
5799 }
5800
5801 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
5802 {
5803   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5804 }
5805
5806 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
5807 {
5808   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5809 }
5810
5811 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const
5812 {
5813   return contentNotNullBase()->getNonEmptyLevels(mname,levs);
5814 }
5815
5816 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const
5817 {
5818   return contentNotNullBase()->getTypesOfFieldAvailable();
5819 }
5820
5821 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,
5822                                                                                        std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5823 {
5824   return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
5825 }
5826
5827 /*!
5828  * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
5829  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5830  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
5831  */
5832 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const
5833 {
5834   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5835   if(!content)
5836     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
5837   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
5838   std::size_t sz(contentsSplit.size());
5839   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5840   for(std::size_t i=0;i<sz;i++)
5841     {
5842       ret[i]=shallowCpy();
5843       ret[i]->_content=contentsSplit[i];
5844     }
5845   return ret;
5846 }
5847
5848 /*!
5849  * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
5850  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5851  */
5852 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const
5853 {
5854   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5855   if(!content)
5856     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
5857   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitDiscretizations();
5858   std::size_t sz(contentsSplit.size());
5859   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5860   for(std::size_t i=0;i<sz;i++)
5861     {
5862       ret[i]=shallowCpy();
5863       ret[i]->_content=contentsSplit[i];
5864     }
5865   return ret;
5866 }
5867
5868 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCpy() const
5869 {
5870   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=shallowCpy();
5871   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5872     ret->_content=_content->deepCpy();
5873   ret->deepCpyGlobs(*this);
5874   return ret.retn();
5875 }
5876
5877 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
5878 {
5879   return contentNotNullBase()->copyTinyInfoFrom(field,arr);
5880 }
5881
5882 //= MEDFileField1TS
5883
5884 /*!
5885  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5886  * the first field that has been read from a specified MED file.
5887  *  \param [in] fileName - the name of the MED file to read.
5888  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5889  *          is to delete this field using decrRef() as it is no more needed.
5890  *  \throw If reading the file fails.
5891  */
5892 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, bool loadAll)
5893 {
5894   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,loadAll);
5895   ret->contentNotNull();
5896   return ret.retn();
5897 }
5898
5899 /*!
5900  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5901  * a given field that has been read from a specified MED file.
5902  *  \param [in] fileName - the name of the MED file to read.
5903  *  \param [in] fieldName - the name of the field to read.
5904  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5905  *          is to delete this field using decrRef() as it is no more needed.
5906  *  \throw If reading the file fails.
5907  *  \throw If there is no field named \a fieldName in the file.
5908  */
5909 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, bool loadAll)
5910 {
5911   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,loadAll);
5912   ret->contentNotNull();
5913   return ret.retn();
5914 }
5915
5916 /*!
5917  * Returns a new instance of MEDFileField1TS holding data of a given time step of
5918  * a given field that has been read from a specified MED file.
5919  *  \param [in] fileName - the name of the MED file to read.
5920  *  \param [in] fieldName - the name of the field to read.
5921  *  \param [in] iteration - the iteration number of a required time step.
5922  *  \param [in] order - the iteration order number of required time step.
5923  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5924  *          is to delete this field using decrRef() as it is no more needed.
5925  *  \throw If reading the file fails.
5926  *  \throw If there is no field named \a fieldName in the file.
5927  *  \throw If the required time step is missing from the file.
5928  */
5929 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
5930 {
5931   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,iteration,order,loadAll);
5932   ret->contentNotNull();
5933   return ret.retn();
5934 }
5935
5936 /*!
5937  * Returns a new instance of MEDFileField1TS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5938  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5939  *
5940  * Returns a new instance of MEDFileField1TS holding either a shallow copy
5941  * of a given MEDFileField1TSWithoutSDA ( \a other ) or \a other itself.
5942  * \warning this is a shallow copy constructor
5943  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
5944  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
5945  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5946  *          is to delete this field using decrRef() as it is no more needed.
5947  */
5948 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5949 {
5950   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(other,shallowCopyOfContent);
5951   ret->contentNotNull();
5952   return ret.retn();
5953 }
5954
5955 /*!
5956  * Returns a new empty instance of MEDFileField1TS.
5957  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5958  *          is to delete this field using decrRef() as it is no more needed.
5959  */
5960 MEDFileField1TS *MEDFileField1TS::New()
5961 {
5962   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS;
5963   ret->contentNotNull();
5964   return ret.retn();
5965 }
5966
5967 /*!
5968  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
5969  * following the given input policy.
5970  *
5971  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
5972  *                            By default (true) the globals are deeply copied.
5973  * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
5974  */
5975 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool isDeepCpyGlobs) const
5976 {
5977   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret;
5978   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5979   if(content)
5980     {
5981       const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
5982       if(!contc)
5983         throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
5984       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
5985       ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc,getFileName()));
5986     }
5987   else
5988     ret=MEDFileIntField1TS::New();
5989   if(isDeepCpyGlobs)
5990     ret->deepCpyGlobs(*this);
5991   else
5992     ret->shallowCpyGlobs(*this);
5993   return ret.retn();
5994 }
5995
5996 const MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() const
5997 {
5998   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
5999   if(!pt)
6000     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is null !");
6001   const MEDFileField1TSWithoutSDA *ret=dynamic_cast<const MEDFileField1TSWithoutSDA *>(pt);
6002   if(!ret)
6003     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 !");
6004   return ret;
6005 }
6006
6007 MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull()
6008 {
6009   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6010   if(!pt)
6011     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is null !");
6012   MEDFileField1TSWithoutSDA *ret=dynamic_cast<MEDFileField1TSWithoutSDA *>(pt);
6013   if(!ret)
6014     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 !");
6015   return ret;
6016 }
6017
6018 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6019 {
6020   if(!f)
6021     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
6022   if(!((DataArray*)arr))
6023     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
6024   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6025   if(!arrOutC)
6026     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6027   f->setArray(arrOutC);
6028 }
6029
6030 DataArrayDouble *MEDFileField1TS::ReturnSafelyDataArrayDouble(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6031 {
6032   if(!((DataArray*)arr))
6033     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : no array !");
6034   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6035   if(!arrOutC)
6036     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6037   arrOutC->incrRef();
6038   return arrOutC;
6039 }
6040
6041 MEDFileField1TS::MEDFileField1TS(const char *fileName, bool loadAll)
6042 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6043 {
6044 }
6045 catch(INTERP_KERNEL::Exception& e)
6046   { throw e; }
6047
6048 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, bool loadAll)
6049 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6050 {
6051 }
6052 catch(INTERP_KERNEL::Exception& e)
6053   { throw e; }
6054
6055 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
6056 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6057 {
6058 }
6059 catch(INTERP_KERNEL::Exception& e)
6060   { throw e; }
6061
6062 /*!
6063  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6064  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6065  *
6066  * \warning this is a shallow copy constructor
6067  */
6068 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
6069 try:MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6070 {
6071 }
6072 catch(INTERP_KERNEL::Exception& e)
6073   { throw e; }
6074
6075 MEDFileField1TS::MEDFileField1TS()
6076 {
6077   _content=new MEDFileField1TSWithoutSDA;
6078 }
6079
6080 /*!
6081  * Returns a new MEDCouplingFieldDouble of a given type lying on
6082  * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6083  * has not been constructed via file reading, an exception is thrown.
6084  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6085  *  \param [in] type - a spatial discretization of interest.
6086  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6087  *  \param [in] renumPol - specifies how to permute values of the result field according to
6088  *          the optional numbers of cells and nodes, if any. The valid values are
6089  *          - 0 - do not permute.
6090  *          - 1 - permute cells.
6091  *          - 2 - permute nodes.
6092  *          - 3 - permute cells and nodes.
6093  *
6094  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6095  *          caller is to delete this field using decrRef() as it is no more needed.
6096  *  \throw If \a this field has not been constructed via file reading.
6097  *  \throw If the MED file is not readable.
6098  *  \throw If there is no mesh in the MED file.
6099  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6100  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6101  *  \sa getFieldOnMeshAtLevel()
6102  */
6103 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const
6104 {
6105   if(getFileName2().empty())
6106     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6107   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6108   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNull());
6109   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6110   return ret.retn();
6111 }
6112
6113 /*!
6114  * Returns a new MEDCouplingFieldDouble of a given type lying on
6115  * the top level cells of the first mesh in MED file. If \a this field
6116  * has not been constructed via file reading, an exception is thrown.
6117  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6118  *  \param [in] type - a spatial discretization of interest.
6119  *  \param [in] renumPol - specifies how to permute values of the result field according to
6120  *          the optional numbers of cells and nodes, if any. The valid values are
6121  *          - 0 - do not permute.
6122  *          - 1 - permute cells.
6123  *          - 2 - permute nodes.
6124  *          - 3 - permute cells and nodes.
6125  *
6126  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6127  *          caller is to delete this field using decrRef() as it is no more needed.
6128  *  \throw If \a this field has not been constructed via file reading.
6129  *  \throw If the MED file is not readable.
6130  *  \throw If there is no mesh in the MED file.
6131  *  \throw If no field values of the given \a type.
6132  *  \throw If no field values lying on the top level support.
6133  *  \sa getFieldAtLevel()
6134  */
6135 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const
6136 {
6137   if(getFileName2().empty())
6138     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6139   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6140   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNull());
6141   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6142   return ret.retn();
6143 }
6144
6145 /*!
6146  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6147  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6148  *  \param [in] type - a spatial discretization of the new field.
6149  *  \param [in] mesh - the supporting mesh.
6150  *  \param [in] renumPol - specifies how to permute values of the result field according to
6151  *          the optional numbers of cells and nodes, if any. The valid values are
6152  *          - 0 - do not permute.
6153  *          - 1 - permute cells.
6154  *          - 2 - permute nodes.
6155  *          - 3 - permute cells and nodes.
6156  *
6157  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6158  *          caller is to delete this field using decrRef() as it is no more needed.
6159  *  \throw If no field of \a this is lying on \a mesh.
6160  *  \throw If the mesh is empty.
6161  *  \throw If no field values of the given \a type are available.
6162  *  \sa getFieldAtLevel()
6163  *  \sa getFieldOnMeshAtLevel()
6164  */
6165 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const
6166 {
6167   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6168   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull());
6169   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6170   return ret.retn();
6171 }
6172
6173 /*!
6174  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6175  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6176  *  \param [in] type - a spatial discretization of interest.
6177  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6178  *  \param [in] mesh - the supporting mesh.
6179  *  \param [in] renumPol - specifies how to permute values of the result field according to
6180  *          the optional numbers of cells and nodes, if any. The valid values are
6181  *          - 0 - do not permute.
6182  *          - 1 - permute cells.
6183  *          - 2 - permute nodes.
6184  *          - 3 - permute cells and nodes.
6185  *
6186  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6187  *          caller is to delete this field using decrRef() as it is no more needed.
6188  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6189  *  \throw If no field of \a this is lying on \a mesh.
6190  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6191  *  \sa getFieldAtLevel()
6192  *  \sa getFieldOnMeshAtLevel()
6193  */
6194 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
6195 {
6196   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6197   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull());
6198   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6199   return ret.retn();
6200 }
6201
6202 /*!
6203  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6204  * This method is called "Old" because in MED3 norm a field has only one meshName
6205  * attached, so this method is for readers of MED2 files. If \a this field
6206  * has not been constructed via file reading, an exception is thrown.
6207  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6208  *  \param [in] type - a spatial discretization of interest.
6209  *  \param [in] mName - a name of the supporting mesh.
6210  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6211  *  \param [in] renumPol - specifies how to permute values of the result field according to
6212  *          the optional numbers of cells and nodes, if any. The valid values are
6213  *          - 0 - do not permute.
6214  *          - 1 - permute cells.
6215  *          - 2 - permute nodes.
6216  *          - 3 - permute cells and nodes.
6217  *
6218  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6219  *          caller is to delete this field using decrRef() as it is no more needed.
6220  *  \throw If the MED file is not readable.
6221  *  \throw If there is no mesh named \a mName in the MED file.
6222  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6223  *  \throw If \a this field has not been constructed via file reading.
6224  *  \throw If no field of \a this is lying on the mesh named \a mName.
6225  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6226  *  \sa getFieldAtLevel()
6227  */
6228 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, int renumPol) const
6229 {
6230   if(getFileName2().empty())
6231     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6232   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6233   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
6234   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6235   return ret.retn();
6236 }
6237
6238 /*!
6239  * Returns values and a profile of the field of a given type lying on a given support.
6240  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6241  *  \param [in] type - a spatial discretization of the field.
6242  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6243  *  \param [in] mesh - the supporting mesh.
6244  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6245  *          field of interest lies on. If the field lies on all entities of the given
6246  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6247  *          using decrRef() as it is no more needed.
6248  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
6249  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6250  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6251  *  \throw If no field of \a this is lying on \a mesh.
6252  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6253  */
6254 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6255 {
6256   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6257   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
6258 }
6259
6260 /*!
6261  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6262  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6263  * "Sort By Type"), if not, an exception is thrown.
6264  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6265  *  \param [in] field - the field to add to \a this.
6266  *  \throw If the name of \a field is empty.
6267  *  \throw If the data array of \a field is not set.
6268  *  \throw If the data array is already allocated but has different number of components
6269  *         than \a field.
6270  *  \throw If the underlying mesh of \a field has no name.
6271  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6272  */
6273 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
6274 {
6275   setFileName("");
6276   contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
6277 }
6278
6279 /*!
6280  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6281  * can be an aggregation of several MEDCouplingFieldDouble instances.
6282  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6283  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6284  * and \a profile.
6285  *
6286  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6287  * A new profile is added only if no equal profile is missing.
6288  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6289  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
6290  *  \param [in] mesh - the supporting mesh of \a field.
6291  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6292  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6293  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6294  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6295  *  \throw If the data array of \a field is not set.
6296  *  \throw If the data array of \a this is already allocated but has different number of
6297  *         components than \a field.
6298  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6299  *  \sa setFieldNoProfileSBT()
6300  */
6301 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6302 {
6303   setFileName("");
6304   contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6305 }
6306
6307 MEDFileAnyTypeField1TS *MEDFileField1TS::shallowCpy() const
6308 {
6309   return new MEDFileField1TS(*this);
6310 }
6311
6312 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const
6313 {
6314   return contentNotNull()->getUndergroundDataArrayDouble();
6315 }
6316
6317 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6318 {
6319   return contentNotNull()->getUndergroundDataArrayDoubleExt(entries);
6320 }
6321
6322 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6323                                                                                       std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
6324 {
6325   return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
6326 }
6327
6328 //= MEDFileIntField1TS
6329
6330 MEDFileIntField1TS *MEDFileIntField1TS::New()
6331 {
6332   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS;
6333   ret->contentNotNull();
6334   return ret.retn();
6335 }
6336
6337 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, bool loadAll)
6338 {
6339   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,loadAll);
6340   ret->contentNotNull();
6341   return ret.retn();
6342 }
6343
6344 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, bool loadAll)
6345 {
6346   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,loadAll);
6347   ret->contentNotNull();
6348   return ret.retn();
6349 }
6350
6351 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
6352 {
6353   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,iteration,order,loadAll);
6354   ret->contentNotNull();
6355   return ret.retn();
6356 }
6357
6358 MEDFileIntField1TS *MEDFileIntField1TS::New(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent)
6359 {
6360   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(other,shallowCopyOfContent);
6361   ret->contentNotNull();
6362   return ret.retn();
6363 }
6364
6365 MEDFileIntField1TS::MEDFileIntField1TS()
6366 {
6367   _content=new MEDFileIntField1TSWithoutSDA;
6368 }
6369
6370 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, bool loadAll)
6371 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6372 {
6373 }
6374 catch(INTERP_KERNEL::Exception& e)
6375   { throw e; }
6376
6377 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, bool loadAll)
6378 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6379 {
6380 }
6381 catch(INTERP_KERNEL::Exception& e)
6382   { throw e; }
6383
6384 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
6385 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6386 {
6387 }
6388 catch(INTERP_KERNEL::Exception& e)
6389   { throw e; }
6390
6391 /*!
6392  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6393  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6394  *
6395  * \warning this is a shallow copy constructor
6396  */
6397 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6398 {
6399 }
6400
6401 MEDFileAnyTypeField1TS *MEDFileIntField1TS::shallowCpy() const
6402 {
6403   return new MEDFileIntField1TS(*this);
6404 }
6405
6406 /*!
6407  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
6408  * following the given input policy.
6409  *
6410  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6411  *                            By default (true) the globals are deeply copied.
6412  * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
6413  */
6414 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool isDeepCpyGlobs) const
6415 {
6416   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret;
6417   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6418   if(content)
6419     {
6420       const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
6421       if(!contc)
6422         throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
6423       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
6424       ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc,getFileName()));
6425     }
6426   else
6427     ret=MEDFileField1TS::New();
6428   if(isDeepCpyGlobs)
6429     ret->deepCpyGlobs(*this);
6430   else
6431     ret->shallowCpyGlobs(*this);
6432   return ret.retn();
6433 }
6434
6435 /*!
6436  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6437  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6438  * "Sort By Type"), if not, an exception is thrown.
6439  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6440  *  \param [in] field - the field to add to \a this. The field double values are ignored.
6441  *  \param [in] arrOfVals - the values of the field \a field used.
6442  *  \throw If the name of \a field is empty.
6443  *  \throw If the data array of \a field is not set.
6444  *  \throw If the data array is already allocated but has different number of components
6445  *         than \a field.
6446  *  \throw If the underlying mesh of \a field has no name.
6447  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6448  */
6449 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
6450 {
6451   setFileName("");
6452   contentNotNull()->setFieldNoProfileSBT(field,arrOfVals,*this,*contentNotNull());
6453 }
6454
6455 /*!
6456  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6457  * can be an aggregation of several MEDCouplingFieldDouble instances.
6458  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6459  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6460  * and \a profile.
6461  *
6462  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6463  * A new profile is added only if no equal profile is missing.
6464  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6465  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
6466  *  \param [in] arrOfVals - the values of the field \a field used.
6467  *  \param [in] mesh - the supporting mesh of \a field.
6468  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6469  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6470  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6471  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6472  *  \throw If the data array of \a field is not set.
6473  *  \throw If the data array of \a this is already allocated but has different number of
6474  *         components than \a field.
6475  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6476  *  \sa setFieldNoProfileSBT()
6477  */
6478 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6479 {
6480   setFileName("");
6481   contentNotNull()->setFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6482 }
6483
6484 const MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() const
6485 {
6486   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6487   if(!pt)
6488     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is null !");
6489   const MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(pt);
6490   if(!ret)
6491     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 !");
6492   return ret;
6493 }
6494
6495 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6496 {
6497   if(getFileName2().empty())
6498     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6499   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut2;
6500   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut2,*contentNotNull());
6501   DataArrayInt *arrOutC=dynamic_cast<DataArrayInt *>((DataArray *)arrOut2);
6502   if(!arrOutC)
6503     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : mismatch between dataArrays type and MEDFileIntField1TS ! Expected int32 !");
6504   arrOut=arrOutC;
6505   return ret.retn();
6506 }
6507
6508 DataArrayInt *MEDFileIntField1TS::ReturnSafelyDataArrayInt(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6509 {
6510   if(!((DataArray *)arr))
6511     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is NULL !");
6512   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>((DataArray *)arr);
6513   if(!arrC)
6514     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is not of type INT32 !");
6515   arrC->incrRef();
6516   return arrC;
6517 }
6518
6519 /*!
6520  * Returns a new MEDCouplingFieldDouble of a given type lying on
6521  * the top level cells of the first mesh in MED file. If \a this field
6522  * has not been constructed via file reading, an exception is thrown.
6523  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6524  *  \param [in] type - a spatial discretization of interest.
6525  *  \param [out] arrOut - the DataArrayInt containing values of field.
6526  *  \param [in] renumPol - specifies how to permute values of the result field according to
6527  *          the optional numbers of cells and nodes, if any. The valid values are
6528  *          - 0 - do not permute.
6529  *          - 1 - permute cells.
6530  *          - 2 - permute nodes.
6531  *          - 3 - permute cells and nodes.
6532  *
6533  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6534  *          caller is to delete this field using decrRef() as it is no more needed.
6535  *  \throw If \a this field has not been constructed via file reading.
6536  *  \throw If the MED file is not readable.
6537  *  \throw If there is no mesh in the MED file.
6538  *  \throw If no field values of the given \a type.
6539  *  \throw If no field values lying on the top level support.
6540  *  \sa getFieldAtLevel()
6541  */
6542 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, DataArrayInt* &arrOut, int renumPol) const
6543 {
6544   if(getFileName2().empty())
6545     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6546   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6547   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNull());
6548   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6549   return ret.retn();
6550 }
6551
6552 /*!
6553  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6554  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6555  *  \param [in] type - a spatial discretization of the new field.
6556  *  \param [in] mesh - the supporting mesh.
6557  *  \param [out] arrOut - the DataArrayInt containing values of field.
6558  *  \param [in] renumPol - specifies how to permute values of the result field according to
6559  *          the optional numbers of cells and nodes, if any. The valid values are
6560  *          - 0 - do not permute.
6561  *          - 1 - permute cells.
6562  *          - 2 - permute nodes.
6563  *          - 3 - permute cells and nodes.
6564  *
6565  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6566  *          caller is to delete this field using decrRef() as it is no more needed.
6567  *  \throw If no field of \a this is lying on \a mesh.
6568  *  \throw If the mesh is empty.
6569  *  \throw If no field values of the given \a type are available.
6570  *  \sa getFieldAtLevel()
6571  *  \sa getFieldOnMeshAtLevel()
6572  */
6573 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6574 {
6575   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6576   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNull());
6577   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6578   return ret.retn();
6579 }
6580
6581 /*!
6582  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6583  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6584  *  \param [in] type - a spatial discretization of interest.
6585  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6586  *  \param [out] arrOut - the DataArrayInt containing values of field.
6587  *  \param [in] mesh - the supporting mesh.
6588  *  \param [in] renumPol - specifies how to permute values of the result field according to
6589  *          the optional numbers of cells and nodes, if any. The valid values are
6590  *          - 0 - do not permute.
6591  *          - 1 - permute cells.
6592  *          - 2 - permute nodes.
6593  *          - 3 - permute cells and nodes.
6594  *
6595  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6596  *          caller is to delete this field using decrRef() as it is no more needed.
6597  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6598  *  \throw If no field of \a this is lying on \a mesh.
6599  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6600  *  \sa getFieldAtLevel()
6601  *  \sa getFieldOnMeshAtLevel()
6602  */
6603 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6604 {
6605   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6606   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNull());
6607   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6608   return ret.retn();
6609 }
6610
6611 /*!
6612  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6613  * This method is called "Old" because in MED3 norm a field has only one meshName
6614  * attached, so this method is for readers of MED2 files. If \a this field
6615  * has not been constructed via file reading, an exception is thrown.
6616  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6617  *  \param [in] type - a spatial discretization of interest.
6618  *  \param [in] mName - a name of the supporting mesh.
6619  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6620  *  \param [out] arrOut - the DataArrayInt containing values of field.
6621  *  \param [in] renumPol - specifies how to permute values of the result field according to
6622  *          the optional numbers of cells and nodes, if any. The valid values are
6623  *          - 0 - do not permute.
6624  *          - 1 - permute cells.
6625  *          - 2 - permute nodes.
6626  *          - 3 - permute cells and nodes.
6627  *
6628  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6629  *          caller is to delete this field using decrRef() as it is no more needed.
6630  *  \throw If the MED file is not readable.
6631  *  \throw If there is no mesh named \a mName in the MED file.
6632  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6633  *  \throw If \a this field has not been constructed via file reading.
6634  *  \throw If no field of \a this is lying on the mesh named \a mName.
6635  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6636  *  \sa getFieldAtLevel()
6637  */
6638 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6639 {
6640   if(getFileName2().empty())
6641     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6642   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6643   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNull());
6644   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6645   return ret.retn();
6646 }
6647
6648 /*!
6649  * Returns values and a profile of the field of a given type lying on a given support.
6650  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6651  *  \param [in] type - a spatial discretization of the field.
6652  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6653  *  \param [in] mesh - the supporting mesh.
6654  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6655  *          field of interest lies on. If the field lies on all entities of the given
6656  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6657  *          using decrRef() as it is no more needed.
6658  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
6659  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6660  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6661  *  \throw If no field of \a this is lying on \a mesh.
6662  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6663  */
6664 DataArrayInt *MEDFileIntField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6665 {
6666   MEDCouplingAutoRefCountObjectPtr<DataArray> arr=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6667   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6668 }
6669
6670 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull()
6671 {
6672   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6673   if(!pt)
6674     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is null !");
6675   MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<MEDFileIntField1TSWithoutSDA *>(pt);
6676   if(!ret)
6677     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 !");
6678   return ret;
6679 }
6680
6681 DataArrayInt *MEDFileIntField1TS::getUndergroundDataArray() const
6682 {
6683   return contentNotNull()->getUndergroundDataArrayInt();
6684 }
6685
6686 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
6687
6688 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
6689 {
6690 }
6691
6692 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const char *fieldName):MEDFileFieldNameScope(fieldName)
6693 {
6694 }
6695
6696 /*!
6697  * \param [in] fieldId field id in C mode
6698  */
6699 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
6700 {
6701   med_field_type typcha;
6702   std::string dtunitOut;
6703   int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,"",fieldId,false,_name,typcha,_infos,dtunitOut);
6704   setDtUnit(dtunitOut.c_str());
6705   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll);
6706 }
6707
6708 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)
6709 try:MEDFileFieldNameScope(fieldName),_infos(infos)
6710 {
6711   setDtUnit(dtunit.c_str());
6712   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll);
6713 }
6714 catch(INTERP_KERNEL::Exception& e)
6715 {
6716   throw e;
6717 }
6718
6719 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySizeWithoutChildren() const
6720 {
6721   std::size_t ret(_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA>));
6722   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6723     ret+=(*it).capacity();
6724   return ret;
6725 }
6726
6727 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTSWithoutSDA::getDirectChildren() const
6728 {
6729   std::vector<const BigMemoryObject *> ret;
6730   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6731     {
6732       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6733       if(cur)
6734         ret.push_back(cur);
6735     }
6736   return ret;
6737 }
6738
6739 /*!
6740  * 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
6741  * NULL.
6742  */
6743 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const
6744 {
6745   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6746   ret->setInfo(_infos);
6747   int sz=(int)_time_steps.size();
6748   for(const int *id=startIds;id!=endIds;id++)
6749     {
6750       if(*id>=0 && *id<sz)
6751         {
6752           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
6753           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6754           if(tse)
6755             {
6756               tse->incrRef();
6757               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6758             }
6759           ret->pushBackTimeStep(tse2);
6760         }
6761       else
6762         {
6763           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
6764           oss << " ! Should be in [0," << sz << ") !";
6765           throw INTERP_KERNEL::Exception(oss.str().c_str());
6766         }
6767     }
6768   if(ret->getNumberOfTS()>0)
6769     ret->synchronizeNameScope();
6770   ret->copyNameScope(*this);
6771   return ret.retn();
6772 }
6773
6774 /*!
6775  * 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
6776  * NULL.
6777  */
6778 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const
6779 {
6780   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
6781   int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
6782   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6783   ret->setInfo(_infos);
6784   int sz=(int)_time_steps.size();
6785   int j=bg;
6786   for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
6787     {
6788       if(j>=0 && j<sz)
6789         {
6790           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
6791           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6792           if(tse)
6793             {
6794               tse->incrRef();
6795               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6796             }
6797           ret->pushBackTimeStep(tse2);
6798         }
6799       else
6800         {
6801           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
6802           oss << " ! Should be in [0," << sz << ") !";
6803           throw INTERP_KERNEL::Exception(oss.str().c_str());
6804         }
6805     }
6806   if(ret->getNumberOfTS()>0)
6807     ret->synchronizeNameScope();
6808   ret->copyNameScope(*this);
6809   return ret.retn();
6810 }
6811
6812 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6813 {
6814   int id=0;
6815   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6816   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6817     {
6818       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6819       if(!cur)
6820         continue;
6821       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6822       if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
6823         ids->pushBackSilent(id);
6824     }
6825   return buildFromTimeStepIds(ids->begin(),ids->end());
6826 }
6827
6828 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6829 {
6830   int id=0;
6831   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6832   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6833     {
6834       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6835       if(!cur)
6836         continue;
6837       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6838       if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
6839         ids->pushBackSilent(id);
6840     }
6841   return buildFromTimeStepIds(ids->begin(),ids->end());
6842 }
6843
6844 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const
6845 {
6846   return _infos;
6847 }
6848
6849 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info)
6850 {
6851   _infos=info;
6852 }
6853
6854 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const
6855 {
6856   int ret=0;
6857   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
6858     {
6859       const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
6860       if(pt->isDealingTS(iteration,order))
6861         return ret;
6862     }
6863   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
6864   std::vector< std::pair<int,int> > vp=getIterations();
6865   for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
6866     oss << "(" << (*it2).first << "," << (*it2).second << ") ";
6867   throw INTERP_KERNEL::Exception(oss.str().c_str());
6868 }
6869
6870 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const
6871 {
6872   return *_time_steps[getTimeStepPos(iteration,order)];
6873 }
6874
6875 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order)
6876 {
6877   return *_time_steps[getTimeStepPos(iteration,order)];
6878 }
6879
6880 std::string MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshName() const
6881 {
6882   if(_time_steps.empty())
6883     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
6884   return _time_steps[0]->getMeshName();
6885 }
6886
6887 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setMeshName(const char *newMeshName)
6888 {
6889   std::string oldName(getMeshName());
6890   std::vector< std::pair<std::string,std::string> > v(1);
6891   v[0].first=oldName; v[0].second=newMeshName;
6892   changeMeshNames(v);
6893 }
6894
6895 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
6896 {
6897   bool ret=false;
6898   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6899     {
6900       MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6901       if(cur)
6902         ret=cur->changeMeshNames(modifTab) || ret;
6903     }
6904   return ret;
6905 }
6906
6907 /*!
6908  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
6909  */
6910 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const
6911 {
6912   return getTimeStepEntry(iteration,order).getUndergroundDataArray();
6913 }
6914
6915 /*!
6916  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
6917  */
6918 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6919 {
6920   return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
6921 }
6922
6923 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
6924                                                                 MEDFileFieldGlobsReal& glob)
6925 {
6926   bool ret=false;
6927   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6928     {
6929       MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
6930       if(f1ts)
6931         ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
6932     }
6933   return ret;
6934 }
6935
6936 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
6937 {
6938   std::string startLine(bkOffset,' ');
6939   oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
6940   if(fmtsId>=0)
6941     oss << " (" << fmtsId << ")";
6942   oss << " has the following name: \"" << _name << "\"." << std::endl;
6943   oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
6944   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6945     {
6946       oss << startLine << "  -  \"" << *it << "\"" << std::endl;
6947     }
6948   int i=0;
6949   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
6950     {
6951       std::string chapter(17,'0'+i);
6952       oss << startLine << chapter << std::endl;
6953       const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6954       if(cur)
6955         cur->simpleRepr(bkOffset+2,oss,i);
6956       else
6957         oss << startLine << "  Field on one time step #" << i << " is not defined !" << std::endl;
6958       oss << startLine << chapter << std::endl;
6959     }
6960 }
6961
6962 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const
6963 {
6964   std::size_t sz=_time_steps.size();
6965   std::vector< std::pair<int,int> > ret(sz);
6966   ret1.resize(sz);
6967   for(std::size_t i=0;i<sz;i++)
6968     {
6969       const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
6970       if(f1ts)
6971         {
6972           ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
6973         }
6974       else
6975         {
6976           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
6977           throw INTERP_KERNEL::Exception(oss.str().c_str());
6978         }
6979     }
6980   return ret;
6981 }
6982
6983 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>& tse)
6984 {
6985   MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
6986   if(!tse2)
6987     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
6988   checkCoherencyOfType(tse2);
6989   if(_time_steps.empty())
6990     {
6991       setName(tse2->getName().c_str());
6992       setInfo(tse2->getInfo());
6993     }
6994   checkThatComponentsMatch(tse2->getInfo());
6995   _time_steps.push_back(tse);
6996 }
6997
6998 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope()
6999 {
7000   std::size_t nbOfCompo=_infos.size();
7001   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7002     {
7003       MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
7004       if(cur)
7005         {
7006           if((cur->getInfo()).size()!=nbOfCompo)
7007             {
7008               std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
7009               oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
7010               throw INTERP_KERNEL::Exception(oss.str().c_str());
7011             }
7012           cur->copyNameScope(*this);
7013         }
7014     }
7015 }
7016
7017 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll)
7018 {
7019   _time_steps.resize(nbPdt);
7020   for(int i=0;i<nbPdt;i++)
7021     {
7022       std::vector< std::pair<int,int> > ts;
7023       med_int numdt=0,numo=0;
7024       med_int meshIt=0,meshOrder=0;
7025       med_float dt=0.0;
7026       MEDfieldComputingStepMeshInfo(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder);
7027       switch(fieldTyp)
7028         {
7029         case MED_FLOAT64:
7030           {
7031             _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7032             break;
7033           }
7034         case MED_INT32:
7035           {
7036             _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7037             break;
7038           }
7039         default:
7040           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
7041         }
7042       if(loadAll)
7043         _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this);
7044       else
7045         _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this);
7046     }
7047 }
7048
7049 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const
7050 {
7051   if(_time_steps.empty())
7052     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
7053   checkThatNbOfCompoOfTSMatchThis();
7054   std::vector<std::string> infos(getInfo());
7055   int nbComp=infos.size();
7056   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7057   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7058   for(int i=0;i<nbComp;i++)
7059     {
7060       std::string info=infos[i];
7061       std::string c,u;
7062       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
7063       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7064       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7065     }
7066   if(_name.empty())
7067     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
7068   MEDfieldCr(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
7069   int nbOfTS=_time_steps.size();
7070   for(int i=0;i<nbOfTS;i++)
7071     _time_steps[i]->writeLL(fid,opts,*this);
7072 }
7073
7074 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
7075 {
7076   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7077     {
7078       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7079       if(elt)
7080         elt->loadBigArraysRecursively(fid,nasc);
7081     }
7082 }
7083
7084 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
7085 {
7086   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7087     {
7088       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7089       if(elt)
7090         elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
7091     }
7092 }
7093
7094 void MEDFileAnyTypeFieldMultiTSWithoutSDA::unloadArrays()
7095 {
7096   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7097     {
7098       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7099       if(elt)
7100         elt->unloadArrays();
7101     }
7102 }
7103
7104 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
7105 {
7106   return _time_steps.size();
7107 }
7108
7109 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS()
7110 {
7111   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  > newTS;
7112   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7113     {
7114       const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
7115       if(tmp)
7116         newTS.push_back(*it);
7117     }
7118   _time_steps=newTS;
7119 }
7120
7121 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds)
7122 {
7123   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7124   int maxId=(int)_time_steps.size();
7125   int ii=0;
7126   std::set<int> idsToDel;
7127   for(const int *id=startIds;id!=endIds;id++,ii++)
7128     {
7129       if(*id>=0 && *id<maxId)
7130         {
7131           idsToDel.insert(*id);
7132         }
7133       else
7134         {
7135           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
7136           throw INTERP_KERNEL::Exception(oss.str().c_str());
7137         }
7138     }
7139   for(int iii=0;iii<maxId;iii++)
7140     if(idsToDel.find(iii)==idsToDel.end())
7141       newTS.push_back(_time_steps[iii]);
7142   _time_steps=newTS;
7143 }
7144
7145 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step)
7146 {
7147   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
7148   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7149   if(nbOfEntriesToKill==0)
7150     return ;
7151   std::size_t sz=_time_steps.size();
7152   std::vector<bool> b(sz,true);
7153   int j=bg;
7154   for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
7155     b[j]=false;
7156   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7157   for(std::size_t i=0;i<sz;i++)
7158     if(b[i])
7159       newTS.push_back(_time_steps[i]);
7160   _time_steps=newTS;
7161 }
7162
7163 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const
7164 {
7165   int ret=0;
7166   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
7167   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7168     {
7169       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7170       if(tmp)
7171         {
7172           int it2,ord;
7173           tmp->getTime(it2,ord);
7174           if(it2==iteration && order==ord)
7175             return ret;
7176           else
7177             oss << "(" << it2 << ","  << ord << "), ";
7178         }
7179     }
7180   throw INTERP_KERNEL::Exception(oss.str().c_str());
7181 }
7182
7183 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const
7184 {
7185   int ret=0;
7186   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
7187   oss.precision(15);
7188   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7189     {
7190       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7191       if(tmp)
7192         {
7193           int it2,ord;
7194           double ti=tmp->getTime(it2,ord);
7195           if(fabs(time-ti)<eps)
7196             return ret;
7197           else
7198             oss << ti << ", ";
7199         }
7200     }
7201   throw INTERP_KERNEL::Exception(oss.str().c_str());
7202 }
7203
7204 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
7205 {
7206   int lgth=_time_steps.size();
7207   std::vector< std::pair<int,int> > ret(lgth);
7208   for(int i=0;i<lgth;i++)
7209     _time_steps[i]->fillIteration(ret[i]);
7210   return ret;
7211 }
7212
7213 /*!
7214  * 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'
7215  * This method returns two things.
7216  * - The absolute dimension of 'this' in first parameter.
7217  * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
7218  *   to the first output parameter. The values in 'levs' will be returned in decreasing order.
7219  *
7220  * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
7221  * Only these 3 discretizations will be taken into account here.
7222  *
7223  * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
7224  * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
7225  * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
7226  *
7227  * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
7228  * 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'.
7229  *
7230  * Let's consider the typical following case :
7231  * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
7232  * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
7233  * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
7234  *   TETRA4 and SEG2
7235  * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
7236  *
7237  * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
7238  *
7239  * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
7240  * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
7241  * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
7242  * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
7243  */
7244 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const
7245 {
7246   return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
7247 }
7248
7249 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const
7250 {
7251   if(pos<0 || pos>=(int)_time_steps.size())
7252     {
7253       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7254       throw INTERP_KERNEL::Exception(oss.str().c_str());
7255     }
7256   const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7257   if(item==0)
7258     {
7259       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7260       oss << "\nTry to use following method eraseEmptyTS !";
7261       throw INTERP_KERNEL::Exception(oss.str().c_str());
7262     }
7263   return item;
7264 }
7265
7266 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos)
7267 {
7268   if(pos<0 || pos>=(int)_time_steps.size())
7269     {
7270       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7271       throw INTERP_KERNEL::Exception(oss.str().c_str());
7272     }
7273   MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7274   if(item==0)
7275     {
7276       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7277       oss << "\nTry to use following method eraseEmptyTS !";
7278       throw INTERP_KERNEL::Exception(oss.str().c_str());
7279     }
7280   return item;
7281 }
7282
7283 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
7284 {
7285   std::vector<std::string> ret;
7286   std::set<std::string> ret2;
7287   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7288     {
7289       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
7290       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7291         if(ret2.find(*it2)==ret2.end())
7292           {
7293             ret.push_back(*it2);
7294             ret2.insert(*it2);
7295           }
7296     }
7297   return ret;
7298 }
7299
7300 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
7301 {
7302   std::vector<std::string> ret;
7303   std::set<std::string> ret2;
7304   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7305     {
7306       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
7307       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7308         if(ret2.find(*it2)==ret2.end())
7309           {
7310             ret.push_back(*it2);
7311             ret2.insert(*it2);
7312           }
7313     }
7314   return ret;
7315 }
7316
7317 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
7318 {
7319   std::vector<std::string> ret;
7320   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7321     {
7322       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
7323       ret.insert(ret.end(),tmp.begin(),tmp.end());
7324     }
7325   return ret;
7326 }
7327
7328 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
7329 {
7330   std::vector<std::string> ret;
7331   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7332     {
7333       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
7334       ret.insert(ret.end(),tmp.begin(),tmp.end());
7335     }
7336   return ret;
7337 }
7338
7339 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7340 {
7341   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7342     (*it)->changePflsRefsNamesGen2(mapOfModif);
7343 }
7344
7345 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7346 {
7347   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7348     (*it)->changeLocsRefsNamesGen2(mapOfModif);
7349 }
7350
7351 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const
7352 {
7353   int lgth=_time_steps.size();
7354   std::vector< std::vector<TypeOfField> > ret(lgth);
7355   for(int i=0;i<lgth;i++)
7356     _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
7357   return ret;
7358 }
7359
7360 /*!
7361  * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
7362  */
7363 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
7364 {
7365   return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
7366 }
7367
7368 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCpy() const
7369 {
7370   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
7371   std::size_t i=0;
7372   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7373     {
7374       if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
7375         ret->_time_steps[i]=(*it)->deepCpy();
7376     }
7377   return ret.retn();
7378 }
7379
7380 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const
7381 {
7382   std::size_t sz(_infos.size()),sz2(_time_steps.size());
7383   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
7384   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
7385   for(std::size_t i=0;i<sz;i++)
7386     {
7387       ret[i]=shallowCpy();
7388       ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
7389     }
7390   for(std::size_t i=0;i<sz2;i++)
7391     {
7392       std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
7393       if(ret1.size()!=sz)
7394         {
7395           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
7396           throw INTERP_KERNEL::Exception(oss.str().c_str());
7397         }
7398       ts[i]=ret1;
7399     }
7400   for(std::size_t i=0;i<sz;i++)
7401     for(std::size_t j=0;j<sz2;j++)
7402       ret[i]->_time_steps[j]=ts[j][i];
7403   return ret;
7404 }
7405
7406 /*!
7407  * This method splits into discretization each time steps in \a this.
7408  * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
7409  */
7410 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const
7411 {
7412   std::size_t sz(_time_steps.size());
7413   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7414   for(std::size_t i=0;i<sz;i++)
7415     {
7416       const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7417       if(!timeStep)
7418         {
7419           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
7420           throw INTERP_KERNEL::Exception(oss.str().c_str());
7421         }
7422       items[i]=timeStep->splitDiscretizations();
7423     }
7424   //
7425   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
7426   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
7427   std::vector< TypeOfField > types;
7428   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7429     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7430       {
7431         std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
7432         if(ts.size()!=1)
7433           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
7434         std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
7435         if(it2==types.end())
7436           types.push_back(ts[0]);
7437       }
7438   ret.resize(types.size()); ret2.resize(types.size());
7439   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7440     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7441       {
7442         TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
7443         std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
7444         ret2[pos].push_back(*it1);
7445       }
7446   for(std::size_t i=0;i<types.size();i++)
7447     {
7448       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=createNew();
7449       for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
7450         elt->pushBackTimeStep(*it1);//also updates infos in elt
7451       ret[i]=elt;
7452       elt->MEDFileFieldNameScope::operator=(*this);
7453     }
7454   return ret;
7455 }
7456
7457 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
7458 {
7459   _name=field->getName();
7460   if(_name.empty())
7461     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
7462   if(!arr)
7463     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
7464   _infos=arr->getInfoOnComponents();
7465 }
7466
7467 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const
7468 {
7469   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
7470   if(_name!=field->getName())
7471     {
7472       std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
7473       oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
7474       throw INTERP_KERNEL::Exception(oss.str().c_str());
7475     }
7476   if(!arr)
7477     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
7478   checkThatComponentsMatch(arr->getInfoOnComponents());
7479 }
7480
7481 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const
7482 {
7483   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
7484   if(getInfo().size()!=compos.size())
7485     {
7486       std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
7487       oss << " number of components of element to append (" << compos.size() << ") !";
7488       throw INTERP_KERNEL::Exception(oss.str().c_str());
7489     }
7490   if(_infos!=compos)
7491     {
7492       std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
7493       std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
7494       oss << " But compo in input fields are : ";
7495       std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
7496       oss << " !";
7497       throw INTERP_KERNEL::Exception(oss.str().c_str());
7498     }
7499 }
7500
7501 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const
7502 {
7503   std::size_t sz=_infos.size();
7504   int j=0;
7505   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
7506     {
7507       const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7508       if(elt)
7509         if(elt->getInfo().size()!=sz)
7510           {
7511             std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
7512             oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
7513             throw INTERP_KERNEL::Exception(oss.str().c_str());
7514           }
7515     }
7516 }
7517
7518 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
7519 {
7520   if(!field)
7521     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7522   if(!_time_steps.empty())
7523     checkCoherencyOfTinyInfo(field,arr);
7524   MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
7525   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7526   objC->setFieldNoProfileSBT(field,arr,glob,*this);
7527   copyTinyInfoFrom(field,arr);
7528   _time_steps.push_back(obj);
7529 }
7530
7531 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob)
7532 {
7533   if(!field)
7534     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7535   if(!_time_steps.empty())
7536     checkCoherencyOfTinyInfo(field,arr);
7537   MEDFileField1TSWithoutSDA *objC=new MEDFileField1TSWithoutSDA;
7538   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7539   objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
7540   copyTinyInfoFrom(field,arr);
7541   _time_steps.push_back(obj);
7542 }
7543
7544 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ts)
7545 {
7546   int sz=(int)_time_steps.size();
7547   if(i<0 || i>=sz)
7548     {
7549       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
7550       throw INTERP_KERNEL::Exception(oss.str().c_str());
7551     }
7552   const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
7553   if(tsPtr)
7554     {
7555       if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
7556         {
7557           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() <<  " !";
7558           throw INTERP_KERNEL::Exception(oss.str().c_str());
7559         }
7560     }
7561   _time_steps[i]=ts;
7562 }
7563
7564 //= MEDFileFieldMultiTSWithoutSDA
7565
7566 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)
7567 {
7568   return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7569 }
7570
7571 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
7572 {
7573 }
7574
7575 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7576 {
7577 }
7578
7579 /*!
7580  * \param [in] fieldId field id in C mode
7581  */
7582 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7583 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7584 {
7585 }
7586 catch(INTERP_KERNEL::Exception& e)
7587   { throw e; }
7588
7589 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)
7590 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7591 {
7592 }
7593 catch(INTERP_KERNEL::Exception& e)
7594 { throw e; }
7595
7596 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7597 {
7598   return new MEDFileField1TSWithoutSDA;
7599 }
7600
7601 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7602 {
7603   if(!f1ts)
7604     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7605   const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
7606   if(!f1tsC)
7607     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
7608 }
7609
7610 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const
7611 {
7612   return MEDFileField1TSWithoutSDA::TYPE_STR;
7613 }
7614
7615 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const
7616 {
7617   return new MEDFileFieldMultiTSWithoutSDA(*this);
7618 }
7619
7620 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const
7621 {
7622   return new MEDFileFieldMultiTSWithoutSDA;
7623 }
7624
7625 /*!
7626  * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
7627  * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
7628  */
7629 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
7630 {
7631   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
7632   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
7633   if(!myF1TSC)
7634     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
7635   return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
7636 }
7637
7638 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const
7639 {
7640   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
7641   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7642   int i=0;
7643   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7644     {
7645       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7646       if(eltToConv)
7647         {
7648           const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
7649           if(!eltToConvC)
7650             throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
7651           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
7652           ret->setIteration(i,elt);
7653         }
7654     }
7655   return ret.retn();
7656 }
7657
7658 //= MEDFileAnyTypeFieldMultiTS
7659
7660 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
7661 {
7662 }
7663
7664 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, bool loadAll)
7665 try:MEDFileFieldGlobsReal(fileName)
7666 {
7667   MEDFileUtilities::CheckFileForRead(fileName);
7668   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7669   _content=BuildContentFrom(fid,fileName,loadAll);
7670   loadGlobals(fid);
7671 }
7672 catch(INTERP_KERNEL::Exception& e)
7673   {
7674     throw e;
7675   }
7676
7677 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll)
7678 {
7679   med_field_type typcha;
7680   std::vector<std::string> infos;
7681   std::string dtunit;
7682   int i=-1;
7683   MEDFileAnyTypeField1TS::LocateField(fid,fileName,fieldName,i,typcha,infos,dtunit);
7684   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7685   switch(typcha)
7686     {
7687     case MED_FLOAT64:
7688       {
7689         ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll);
7690         break;
7691       }
7692     case MED_INT32:
7693       {
7694         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll);
7695         break;
7696       }
7697     default:
7698       {
7699         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] !";
7700         throw INTERP_KERNEL::Exception(oss.str().c_str());
7701       }
7702     }
7703   ret->setDtUnit(dtunit.c_str());
7704   return ret.retn();
7705 }
7706
7707 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll)
7708 {
7709   med_field_type typcha;
7710   //
7711   std::vector<std::string> infos;
7712   std::string dtunit,fieldName;
7713   MEDFileAnyTypeField1TS::LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
7714   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7715   switch(typcha)
7716     {
7717     case MED_FLOAT64:
7718       {
7719         ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll);
7720         break;
7721       }
7722     case MED_INT32:
7723       {
7724         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll);
7725         break;
7726       }
7727     default:
7728       {
7729         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] !";
7730         throw INTERP_KERNEL::Exception(oss.str().c_str());
7731       }
7732     }
7733   ret->setDtUnit(dtunit.c_str());
7734   return ret.retn();
7735 }
7736
7737 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, const char *fileName)
7738 {
7739   if(!c)
7740     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
7741   if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
7742     {
7743       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=MEDFileFieldMultiTS::New();
7744       ret->setFileName(fileName);
7745       ret->_content=c;  c->incrRef();
7746       return ret.retn();
7747     }
7748   if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
7749     {
7750       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=MEDFileIntFieldMultiTS::New();
7751       ret->setFileName(fileName);
7752       ret->_content=c;  c->incrRef();
7753       return ret.retn();
7754     }
7755   throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
7756 }
7757
7758 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll)
7759 try:MEDFileFieldGlobsReal(fileName)
7760 {
7761   MEDFileUtilities::CheckFileForRead(fileName);
7762   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7763   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
7764   loadGlobals(fid);
7765 }
7766 catch(INTERP_KERNEL::Exception& e)
7767   {
7768     throw e;
7769   }
7770
7771 //= MEDFileIntFieldMultiTSWithoutSDA
7772
7773 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)
7774 {
7775   return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7776 }
7777
7778 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
7779 {
7780 }
7781
7782 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7783 {
7784 }
7785
7786 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)
7787 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7788 {
7789 }
7790 catch(INTERP_KERNEL::Exception& e)
7791 { throw e; }
7792
7793 /*!
7794  * \param [in] fieldId field id in C mode
7795  */
7796 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7797 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7798 {
7799 }
7800 catch(INTERP_KERNEL::Exception& e)
7801   { throw e; }
7802
7803 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7804 {
7805   return new MEDFileIntField1TSWithoutSDA;
7806 }
7807
7808 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7809 {
7810   if(!f1ts)
7811     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7812   const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
7813   if(!f1tsC)
7814     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
7815 }
7816
7817 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const
7818 {
7819   return MEDFileIntField1TSWithoutSDA::TYPE_STR;
7820 }
7821
7822 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const
7823 {
7824   return new MEDFileIntFieldMultiTSWithoutSDA(*this);
7825 }
7826
7827 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const
7828 {
7829   return new MEDFileIntFieldMultiTSWithoutSDA;
7830 }
7831
7832 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const
7833 {
7834   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
7835   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7836   int i=0;
7837   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7838     {
7839       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7840       if(eltToConv)
7841         {
7842           const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
7843           if(!eltToConvC)
7844             throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
7845           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
7846           ret->setIteration(i,elt);
7847         }
7848     }
7849   return ret.retn();
7850 }
7851
7852 //= MEDFileAnyTypeFieldMultiTS
7853
7854 /*!
7855  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
7856  * that has been read from a specified MED file.
7857  *  \param [in] fileName - the name of the MED file to read.
7858  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7859  *          is to delete this field using decrRef() as it is no more needed.
7860  *  \throw If reading the file fails.
7861  */
7862 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, bool loadAll)
7863 {
7864   MEDFileUtilities::CheckFileForRead(fileName);
7865   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7866   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
7867   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7868   ret->loadGlobals(fid);
7869   return ret.retn();
7870 }
7871
7872 /*!
7873  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
7874  * that has been read from a specified MED file.
7875  *  \param [in] fileName - the name of the MED file to read.
7876  *  \param [in] fieldName - the name of the field to read.
7877  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7878  *          is to delete this field using decrRef() as it is no more needed.
7879  *  \throw If reading the file fails.
7880  *  \throw If there is no field named \a fieldName in the file.
7881  */
7882 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll)
7883 {
7884   MEDFileUtilities::CheckFileForRead(fileName);
7885   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7886   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
7887   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7888   ret->loadGlobals(fid);
7889   return ret.retn();
7890 }
7891
7892 /*!
7893  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
7894  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
7895  *
7896  * \warning this is a shallow copy constructor
7897  */
7898 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
7899 {
7900   if(!shallowCopyOfContent)
7901     {
7902       const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
7903       otherPtr->incrRef();
7904       _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
7905     }
7906   else
7907     {
7908       _content=other.shallowCpy();
7909     }
7910 }
7911
7912 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase()
7913 {
7914   MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7915   if(!ret)
7916     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
7917   return ret;
7918 }
7919
7920 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const
7921 {
7922   const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7923   if(!ret)
7924     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
7925   return ret;
7926 }
7927
7928 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
7929 {
7930   return contentNotNullBase()->getPflsReallyUsed2();
7931 }
7932
7933 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
7934 {
7935   return contentNotNullBase()->getLocsReallyUsed2();
7936 }
7937
7938 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
7939 {
7940   return contentNotNullBase()->getPflsReallyUsedMulti2();
7941 }
7942
7943 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
7944 {
7945   return contentNotNullBase()->getLocsReallyUsedMulti2();
7946 }
7947
7948 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7949 {
7950   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
7951 }
7952
7953 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7954 {
7955   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
7956 }
7957
7958 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
7959 {
7960   return contentNotNullBase()->getNumberOfTS();
7961 }
7962
7963 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS()
7964 {
7965   contentNotNullBase()->eraseEmptyTS();
7966 }
7967
7968 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
7969 {
7970   contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
7971 }
7972
7973 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step)
7974 {
7975   contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
7976 }
7977
7978 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const
7979 {
7980   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
7981   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7982   ret->_content=c;
7983   return ret.retn();
7984 }
7985
7986 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const
7987 {
7988   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
7989   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7990   ret->_content=c;
7991   return ret.retn();
7992 }
7993
7994 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
7995 {
7996   return contentNotNullBase()->getIterations();
7997 }
7998
7999 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts)
8000 {
8001   for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
8002     pushBackTimeStep(*it);
8003 }
8004
8005 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts)
8006 {
8007   if(!f1ts)
8008     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
8009   checkCoherencyOfType(f1ts);
8010   f1ts->incrRef();
8011   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
8012   MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
8013   c->incrRef();
8014   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
8015   if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
8016     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
8017   _content->pushBackTimeStep(cSafe);
8018   appendGlobs(*f1ts,1e-12);
8019 }
8020
8021 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope()
8022 {
8023   contentNotNullBase()->synchronizeNameScope();
8024 }
8025
8026 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const
8027 {
8028   return contentNotNullBase()->getPosOfTimeStep(iteration,order);
8029 }
8030
8031 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const
8032 {
8033   return contentNotNullBase()->getPosGivenTime(time,eps);
8034 }
8035
8036 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const
8037 {
8038   return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
8039 }
8040
8041 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const
8042 {
8043   return contentNotNullBase()->getTypesOfFieldAvailable();
8044 }
8045
8046 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
8047 {
8048   return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
8049 }
8050
8051 std::string MEDFileAnyTypeFieldMultiTS::getName() const
8052 {
8053   return contentNotNullBase()->getName();
8054 }
8055
8056 void MEDFileAnyTypeFieldMultiTS::setName(const char *name)
8057 {
8058   contentNotNullBase()->setName(name);
8059 }
8060
8061 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const
8062 {
8063   return contentNotNullBase()->getDtUnit();
8064 }
8065
8066 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const char *dtUnit)
8067 {
8068   contentNotNullBase()->setDtUnit(dtUnit);
8069 }
8070
8071 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
8072 {
8073   contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
8074 }
8075
8076 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const
8077 {
8078   return contentNotNullBase()->getTimeSteps(ret1);
8079 }
8080
8081 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const
8082 {
8083   return contentNotNullBase()->getMeshName();
8084 }
8085
8086 void MEDFileAnyTypeFieldMultiTS::setMeshName(const char *newMeshName)
8087 {
8088   contentNotNullBase()->setMeshName(newMeshName);
8089 }
8090
8091 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
8092 {
8093   return contentNotNullBase()->changeMeshNames(modifTab);
8094 }
8095
8096 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const
8097 {
8098   return contentNotNullBase()->getInfo();
8099 }
8100
8101 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info)
8102 {
8103   return contentNotNullBase()->setInfo(info);
8104 }
8105
8106 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const
8107 {
8108   const std::vector<std::string> ret=getInfo();
8109   return (int)ret.size();
8110 }
8111
8112 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const
8113 {
8114   writeGlobals(fid,*this);
8115   contentNotNullBase()->writeLL(fid,*this);
8116 }
8117
8118 /*!
8119  * Writes \a this field into a MED file specified by its name.
8120  *  \param [in] fileName - the MED file name.
8121  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
8122  * - 2 - erase; an existing file is removed.
8123  * - 1 - append; same data should not be present in an existing file.
8124  * - 0 - overwrite; same data present in an existing file is overwritten.
8125  *  \throw If the field name is not set.
8126  *  \throw If no field data is set.
8127  *  \throw If \a mode == 1 and the same data is present in an existing file.
8128  */
8129 void MEDFileAnyTypeFieldMultiTS::write(const char *fileName, int mode) const
8130 {
8131   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
8132   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
8133   writeLL(fid);
8134 }
8135
8136 /*!
8137  * This method alloc the arrays and load potentially huge arrays contained in this field.
8138  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
8139  * This method can be also called to refresh or reinit values from a file.
8140  *
8141  * \throw If the fileName is not set or points to a non readable MED file.
8142  */
8143 void MEDFileAnyTypeFieldMultiTS::loadArrays()
8144 {
8145   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8146   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
8147 }
8148
8149 /*!
8150  * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
8151  * But once data loaded once, this method does nothing.
8152  *
8153  * \throw If the fileName is not set or points to a non readable MED file.
8154  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::unloadArrays
8155  */
8156 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary()
8157 {
8158   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8159   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
8160 }
8161
8162 /*!
8163  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
8164  * This method does not release arrays set outside the context of a MED file.
8165  *
8166  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
8167  */
8168 void MEDFileAnyTypeFieldMultiTS::unloadArrays()
8169 {
8170   contentNotNullBase()->unloadArrays();
8171 }
8172
8173 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
8174 {
8175   std::ostringstream oss;
8176   contentNotNullBase()->simpleRepr(0,oss,-1);
8177   simpleReprGlobs(oss);
8178   return oss.str();
8179 }
8180
8181 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySizeWithoutChildren() const
8182 {
8183   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
8184 }
8185
8186 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTS::getDirectChildren() const
8187 {
8188   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
8189   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8190     ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content);
8191   return ret;
8192 }
8193
8194 /*!
8195  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
8196  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8197  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
8198  */
8199 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const
8200 {
8201   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8202   if(!content)
8203     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
8204   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
8205   std::size_t sz(contentsSplit.size());
8206   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8207   for(std::size_t i=0;i<sz;i++)
8208     {
8209       ret[i]=shallowCpy();
8210       ret[i]->_content=contentsSplit[i];
8211     }
8212   return ret;
8213 }
8214
8215 /*!
8216  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
8217  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8218  */
8219 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const
8220 {
8221   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8222   if(!content)
8223     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
8224   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitDiscretizations();
8225   std::size_t sz(contentsSplit.size());
8226   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8227   for(std::size_t i=0;i<sz;i++)
8228     {
8229       ret[i]=shallowCpy();
8230       ret[i]->_content=contentsSplit[i];
8231     }
8232   return ret;
8233 }
8234
8235 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCpy() const
8236 {
8237   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8238   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8239     ret->_content=_content->deepCpy();
8240   ret->deepCpyGlobs(*this);
8241   return ret.retn();
8242 }
8243
8244 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
8245 {
8246   return _content;
8247 }
8248
8249 /*!
8250  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8251  *  \param [in] iteration - the iteration number of a required time step.
8252  *  \param [in] order - the iteration order number of required time step.
8253  *  \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
8254  *          delete this field using decrRef() as it is no more needed.
8255  *  \throw If there is no required time step in \a this field.
8256  */
8257 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const
8258 {
8259   int pos=getPosOfTimeStep(iteration,order);
8260   return getTimeStepAtPos(pos);
8261 }
8262
8263 /*!
8264  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8265  *  \param [in] time - the time of the time step of interest.
8266  *  \param [in] eps - a precision used to compare time values.
8267  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8268  *          delete this field using decrRef() as it is no more needed.
8269  *  \throw If there is no required time step in \a this field.
8270  */
8271 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const
8272 {
8273   int pos=getPosGivenTime(time,eps);
8274   return getTimeStepAtPos(pos);
8275 }
8276
8277 /*!
8278  * 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.
8279  * The float64 value of time attached to the pair of integers are not considered here.
8280  * WARNING the returned pointers are not incremented. The caller is \b not responsible to deallocate them ! This method only reorganizes entries in \a vectFMTS.
8281  *
8282  * \param [in] vectFMTS - vector of not null fields defined on a same global data pointer.
8283  * \throw If there is a null pointer in \a vectFMTS.
8284  */
8285 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS)
8286 {
8287   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries : presence of null instance in input vector !";
8288   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8289   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8290   while(!lstFMTS.empty())
8291     {
8292       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8293       MEDFileAnyTypeFieldMultiTS *curIt(*it);
8294       if(!curIt)
8295         throw INTERP_KERNEL::Exception(msg);
8296       std::vector< std::pair<int,int> > refIts=curIt->getIterations();
8297       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8298       elt.push_back(curIt); it=lstFMTS.erase(it);
8299       while(it!=lstFMTS.end())
8300         {
8301           curIt=*it;
8302           if(!curIt)
8303             throw INTERP_KERNEL::Exception(msg);
8304           std::vector< std::pair<int,int> > curIts=curIt->getIterations();
8305           if(refIts==curIts)
8306             { elt.push_back(curIt); it=lstFMTS.erase(it); }
8307           else
8308             it++;
8309         }
8310       ret.push_back(elt);
8311     }
8312   return ret;
8313 }
8314
8315 /*!
8316  * This method splits the input list \a vectFMTS considering the aspect of the geometrical support over time.
8317  * All returned instances in a subvector can be safely loaded, rendered along time
8318  * All items must be defined on the same time step ids ( see MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries method ).
8319  * Each item in \a vectFMTS is expected to have one and exactly one spatial discretization along time.
8320  * All items in \a vectFMTS must lie on the mesh (located by meshname and time step) and compatible with the input mesh \a mesh (having the same name than those in items).
8321  * All items in \a vectFMTS whose spatial discretization is not ON_NODES will appear once.
8322  * For items in \a vectFMTS that are ON_NODES it is possible to appear several times (more than once or once) in the returned vector.
8323  *
8324  * \param [in] vectFMTS - list of multi times step part all defined each on a same spatial discretization along time and pointing to a mesh whose name is equal to \c mesh->getName().
8325  * \param [in] mesh - the mesh shared by all items in \a vectFMTS across time.
8326  * \param [out] fsc - A vector having same size than returned vector. It specifies the support comporator of the corresponding vector of MEDFileAnyTypeFieldMultiTS in returned vector of vector.
8327  * \return - A vector of vector of objects that contains the same pointers (objects) than thoose in \a vectFMTS except that there are organized differently. So pointers included in returned vector of vector should \b not been dealt by the caller.
8328  *
8329  * \throw If an element in \a vectFMTS has not only one spatial discretization set.
8330  * \throw If an element in \a vectFMTS change of spatial discretization along time.
8331  * \throw If an element in \a vectFMTS lies on a mesh with meshname different from those in \a mesh.
8332  * \thorw If some elements in \a vectFMTS do not have the same times steps.
8333  * \throw If mesh is null.
8334  * \throw If an element in \a vectFMTS is null.
8335  * \sa MEDFileAnyTypeFieldMultiTS::AreOnSameSupportAcrossTime
8336  */
8337 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& fsc)
8338 {
8339   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : presence of a null instance in the input vector !";
8340   if(!mesh)
8341     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : input mesh is null !");
8342   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8343   if(vectFMTS.empty())
8344     return ret;
8345   std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it(vectFMTS.begin());
8346   MEDFileAnyTypeFieldMultiTS *frstElt(*it);
8347   if(!frstElt)
8348     throw INTERP_KERNEL::Exception(msg);
8349   std::size_t i=0;
8350   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNotNodes;
8351   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNodes;
8352   for(;it!=vectFMTS.end();it++,i++)
8353     {
8354       if(!(*it))
8355         throw INTERP_KERNEL::Exception(msg);
8356       TypeOfField tof0,tof1;
8357       if(CheckSupportAcrossTime(frstElt,*it,mesh,tof0,tof1)>0)
8358         {
8359           if(tof1!=ON_NODES)
8360             vectFMTSNotNodes.push_back(*it);
8361           else
8362             vectFMTSNodes.push_back(*it);
8363         }
8364       else
8365         vectFMTSNotNodes.push_back(*it);
8366     }
8367   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> > cmps;
8368   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > retCell=SplitPerCommonSupportNotNodesAlg(vectFMTSNotNodes,mesh,cmps);
8369   ret=retCell;
8370   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it2=vectFMTSNodes.begin();it2!=vectFMTSNodes.end();it2++)
8371     {
8372       i=0;
8373       bool isFetched(false);
8374       for(std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> >::const_iterator it0=retCell.begin();it0!=retCell.end();it0++,i++)
8375         {
8376           if((*it0).empty())
8377             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : internal error !");
8378           if(cmps[i]->isCompatibleWithNodesDiscr(*it2))
8379             { ret[i].push_back(*it2); isFetched=true; }
8380         }
8381       if(!isFetched)
8382         {
8383           std::vector<MEDFileAnyTypeFieldMultiTS *> tmp(1,*it2);
8384           MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> tmp2(MEDFileMeshStruct::New(mesh));
8385           ret.push_back(tmp); retCell.push_back(tmp); cmps.push_back(MEDFileFastCellSupportComparator::New(tmp2,*it2));
8386         }
8387     }
8388   fsc=cmps;
8389   return ret;
8390 }
8391
8392 /*!
8393  * WARNING no check here. The caller must be sure that all items in vectFMTS are coherent each other in time steps, only one same spatial discretization and not ON_NODES.
8394  * \param [out] cmps - same size than the returned vector.
8395  */
8396 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupportNotNodesAlg(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& cmps)
8397 {
8398   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8399   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8400   while(!lstFMTS.empty())
8401     {
8402       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8403       MEDFileAnyTypeFieldMultiTS *ref(*it);
8404       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8405       elt.push_back(ref); it=lstFMTS.erase(it);
8406       MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(mesh));
8407       MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> cmp(MEDFileFastCellSupportComparator::New(mst,ref));
8408       while(it!=lstFMTS.end())
8409         {
8410           MEDFileAnyTypeFieldMultiTS *curIt(*it);
8411           if(cmp->isEqual(curIt))
8412             { elt.push_back(curIt); it=lstFMTS.erase(it); }
8413           else
8414             it++;
8415         }
8416       ret.push_back(elt); cmps.push_back(cmp);
8417     }
8418   return ret;
8419 }
8420
8421 /*!
8422  * This method scan the two main structs along time of \a f0 and \a f1 to see if there are all lying on the same mesh along time than those in \a mesh.
8423  * \a f0 and \a f1 must be defined each only on a same spatial discretization even if this can be different each other.
8424  *
8425  * \throw If \a f0 or \a f1 has not only one spatial discretization set.
8426  * \throw If \a f0 or \a f1 change of spatial discretization along time.
8427  * \throw If \a f0 or \a f1 on a mesh with meshname different from those in \a mesh.
8428  * \thorw If \a f0 and \a f1 do not have the same times steps.
8429  * \throw If mesh is null.
8430  * \throw If \a f0 or \a f1 is null.
8431  * \sa MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport
8432  */
8433 int MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime(MEDFileAnyTypeFieldMultiTS *f0, MEDFileAnyTypeFieldMultiTS *f1, const MEDFileMesh *mesh, TypeOfField& tof0, TypeOfField& tof1)
8434 {
8435   if(!mesh)
8436     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : input mesh is null !");
8437   if(!f0 || !f1)
8438     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : presence of null instance in fields over time !");
8439   if(f0->getMeshName()!=mesh->getName())
8440     {
8441       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh \""<< f0->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8442       throw INTERP_KERNEL::Exception(oss.str().c_str());
8443     }
8444   if(f1->getMeshName()!=mesh->getName())
8445     {
8446       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh \""<< f1->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8447       throw INTERP_KERNEL::Exception(oss.str().c_str());
8448     }
8449   int nts=f0->getNumberOfTS();
8450   if(nts!=f1->getNumberOfTS())
8451     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : number of time steps are not the same !");
8452   if(nts==0)
8453     return nts;
8454   for(int i=0;i<nts;i++)
8455     {
8456       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f0cur=f0->getTimeStepAtPos(i);
8457       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1cur=f1->getTimeStepAtPos(i);
8458       std::vector<TypeOfField> tofs0(f0cur->getTypesOfFieldAvailable()),tofs1(f1cur->getTypesOfFieldAvailable());
8459       if(tofs0.size()!=1 || tofs1.size()!=1)
8460         throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : All time steps must be defined on only one spatial discretization !");
8461       if(i!=0)
8462         {
8463           if(tof0!=tofs0[0] || tof1!=tofs1[0])
8464             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : Across times steps MEDFileAnyTypeFieldMultiTS instances have to keep the same unique spatial discretization !");
8465         }
8466       else
8467         { tof0=tofs0[0]; tof1=tofs1[0]; }
8468       if(f0cur->getMeshIteration()!=mesh->getIteration() || f0cur->getMeshOrder()!=mesh->getOrder())
8469         {
8470           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh time step (" << f0cur->getMeshIteration() << ","<< f0cur->getMeshOrder() << ") whereas input mesh points to time step (" << mesh->getIteration() << "," << mesh->getOrder() << ") !";
8471           throw INTERP_KERNEL::Exception(oss.str().c_str());
8472         }
8473       if(f1cur->getMeshIteration()!=mesh->getIteration() || f1cur->getMeshOrder()!=mesh->getOrder())
8474         {
8475           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh time step (" << f1cur->getMeshIteration() << ","<< f1cur->getMeshOrder() << ") whereas input mesh points to time step (" << mesh->getIteration() << "," << mesh->getOrder() << ") !";
8476           throw INTERP_KERNEL::Exception(oss.str().c_str());
8477         }
8478       if(f0cur->getIteration()!=f1cur->getIteration() || f0cur->getOrder()!=f1cur->getOrder())
8479         {
8480           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : all the time steps must be the same ! it is not the case (" << f0cur->getIteration() << "," << f0cur->getOrder() << ")!=(" << f1cur->getIteration() << "," << f1cur->getOrder() << ") !";
8481           throw INTERP_KERNEL::Exception(oss.str().c_str());
8482         }
8483     }
8484   return nts;
8485 }
8486
8487 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator()
8488 {
8489   return new MEDFileAnyTypeFieldMultiTSIterator(this);
8490 }
8491
8492 //= MEDFileFieldMultiTS
8493
8494 /*!
8495  * Returns a new empty instance of MEDFileFieldMultiTS.
8496  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8497  *          is to delete this field using decrRef() as it is no more needed.
8498  */
8499 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
8500 {
8501   return new MEDFileFieldMultiTS;
8502 }
8503
8504 /*!
8505  * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
8506  * that has been read from a specified MED file.
8507  *  \param [in] fileName - the name of the MED file to read.
8508  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8509  *          is to delete this field using decrRef() as it is no more needed.
8510  *  \throw If reading the file fails.
8511  */
8512 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, bool loadAll)
8513 {
8514   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,loadAll);
8515   ret->contentNotNull();//to check that content type matches with \a this type.
8516   return ret.retn();
8517 }
8518
8519 /*!
8520  * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
8521  * that has been read from a specified MED file.
8522  *  \param [in] fileName - the name of the MED file to read.
8523  *  \param [in] fieldName - the name of the field to read.
8524  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8525  *          is to delete this field using decrRef() as it is no more needed.
8526  *  \throw If reading the file fails.
8527  *  \throw If there is no field named \a fieldName in the file.
8528  */
8529 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll)
8530 {
8531   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,fieldName,loadAll);
8532   ret->contentNotNull();//to check that content type matches with \a this type.
8533   return ret.retn();
8534 }
8535
8536 /*!
8537  * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8538  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8539  *
8540  * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
8541  * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8542  * \warning this is a shallow copy constructor
8543  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
8544  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8545  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8546  *          is to delete this field using decrRef() as it is no more needed.
8547  */
8548 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8549 {
8550   return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
8551 }
8552
8553 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const
8554 {
8555   return new MEDFileFieldMultiTS(*this);
8556 }
8557
8558 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
8559 {
8560   if(!f1ts)
8561     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8562   const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
8563   if(!f1tsC)
8564     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8565 }
8566
8567 /*!
8568  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
8569  * following the given input policy.
8570  *
8571  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8572  *                            By default (true) the globals are deeply copied.
8573  * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
8574  */
8575 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool isDeepCpyGlobs) const
8576 {
8577   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret;
8578   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8579   if(content)
8580     {
8581       const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
8582       if(!contc)
8583         throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
8584       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
8585       ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc,getFileName()));
8586     }
8587   else
8588     ret=MEDFileIntFieldMultiTS::New();
8589   if(isDeepCpyGlobs)
8590     ret->deepCpyGlobs(*this);
8591   else
8592     ret->shallowCpyGlobs(*this);
8593   return ret.retn();
8594 }
8595
8596 /*!
8597  * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
8598  *  \param [in] pos - a time step id.
8599  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8600  *          delete this field using decrRef() as it is no more needed.
8601  *  \throw If \a pos is not a valid time step id.
8602  */
8603 MEDFileAnyTypeField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const
8604 {
8605   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8606   if(!item)
8607     {
8608       std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8609       throw INTERP_KERNEL::Exception(oss.str().c_str());
8610     }
8611   const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
8612   if(itemC)
8613     {
8614       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
8615       ret->shallowCpyGlobs(*this);
8616       return ret.retn();
8617     }
8618   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
8619   throw INTERP_KERNEL::Exception(oss.str().c_str());
8620 }
8621
8622 /*!
8623  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8624  * mesh entities of a given dimension of the first mesh in MED file.
8625  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8626  *  \param [in] type - a spatial discretization of interest.
8627  *  \param [in] iteration - the iteration number of a required time step.
8628  *  \param [in] order - the iteration order number of required time step.
8629  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8630  *  \param [in] renumPol - specifies how to permute values of the result field according to
8631  *          the optional numbers of cells and nodes, if any. The valid values are
8632  *          - 0 - do not permute.
8633  *          - 1 - permute cells.
8634  *          - 2 - permute nodes.
8635  *          - 3 - permute cells and nodes.
8636  *
8637  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8638  *          caller is to delete this field using decrRef() as it is no more needed.
8639  *  \throw If the MED file is not readable.
8640  *  \throw If there is no mesh in the MED file.
8641  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8642  *  \throw If no field values of the required parameters are available.
8643  */
8644 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const
8645 {
8646   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8647   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8648   if(!myF1TSC)
8649     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
8650   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8651   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNullBase());
8652   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8653   return ret.retn();
8654 }
8655
8656 /*!
8657  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8658  * the top level cells of the first mesh in MED file.
8659  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8660  *  \param [in] type - a spatial discretization of interest.
8661  *  \param [in] iteration - the iteration number of a required time step.
8662  *  \param [in] order - the iteration order number of required time step.
8663  *  \param [in] renumPol - specifies how to permute values of the result field according to
8664  *          the optional numbers of cells and nodes, if any. The valid values are
8665  *          - 0 - do not permute.
8666  *          - 1 - permute cells.
8667  *          - 2 - permute nodes.
8668  *          - 3 - permute cells and nodes.
8669  *
8670  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8671  *          caller is to delete this field using decrRef() as it is no more needed.
8672  *  \throw If the MED file is not readable.
8673  *  \throw If there is no mesh in the MED file.
8674  *  \throw If no field values of the required parameters are available.
8675  */
8676 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const
8677 {
8678   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8679   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8680   if(!myF1TSC)
8681     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
8682   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8683   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNullBase());
8684   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8685   return ret.retn();
8686 }
8687
8688 /*!
8689  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8690  * a given support.
8691  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8692  *  \param [in] type - a spatial discretization of interest.
8693  *  \param [in] iteration - the iteration number of a required time step.
8694  *  \param [in] order - the iteration order number of required time step.
8695  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8696  *  \param [in] mesh - the supporting mesh.
8697  *  \param [in] renumPol - specifies how to permute values of the result field according to
8698  *          the optional numbers of cells and nodes, if any. The valid values are
8699  *          - 0 - do not permute.
8700  *          - 1 - permute cells.
8701  *          - 2 - permute nodes.
8702  *          - 3 - permute cells and nodes.
8703  *
8704  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8705  *          caller is to delete this field using decrRef() as it is no more needed.
8706  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8707  *  \throw If no field of \a this is lying on \a mesh.
8708  *  \throw If no field values of the required parameters are available.
8709  */
8710 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
8711 {
8712   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8713   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8714   if(!myF1TSC)
8715     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8716   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8717   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
8718   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8719   return ret.retn();
8720 }
8721
8722 /*!
8723  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8724  * given support.
8725  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8726  *  \param [in] type - a spatial discretization of the new field.
8727  *  \param [in] iteration - the iteration number of a required time step.
8728  *  \param [in] order - the iteration order number of required time step.
8729  *  \param [in] mesh - the supporting mesh.
8730  *  \param [in] renumPol - specifies how to permute values of the result field according to
8731  *          the optional numbers of cells and nodes, if any. The valid values are
8732  *          - 0 - do not permute.
8733  *          - 1 - permute cells.
8734  *          - 2 - permute nodes.
8735  *          - 3 - permute cells and nodes.
8736  *
8737  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8738  *          caller is to delete this field using decrRef() as it is no more needed.
8739  *  \throw If no field of \a this is lying on \a mesh.
8740  *  \throw If no field values of the required parameters are available.
8741  */
8742 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const
8743 {
8744   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8745   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8746   if(!myF1TSC)
8747     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8748   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8749   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
8750   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8751   return ret.retn();
8752 }
8753
8754 /*!
8755  * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
8756  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8757  * This method is useful for MED2 file format when field on different mesh was autorized.
8758  */
8759 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const char *mname, int iteration, int order, int meshDimRelToMax, int renumPol) const
8760 {
8761   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8762   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8763   if(!myF1TSC)
8764     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
8765   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8766   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
8767   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8768   return ret.retn();
8769 }
8770
8771 /*!
8772  * Returns values and a profile of the field of a given type, of a given time step,
8773  * lying on a given support.
8774  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8775  *  \param [in] type - a spatial discretization of the field.
8776  *  \param [in] iteration - the iteration number of a required time step.
8777  *  \param [in] order - the iteration order number of required time step.
8778  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8779  *  \param [in] mesh - the supporting mesh.
8780  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8781  *          field of interest lies on. If the field lies on all entities of the given
8782  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8783  *          using decrRef() as it is no more needed.
8784  *  \param [in] glob - the global data storing profiles and localization.
8785  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
8786  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8787  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8788  *  \throw If no field of \a this is lying on \a mesh.
8789  *  \throw If no field values of the required parameters are available.
8790  */
8791 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
8792 {
8793   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8794   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8795   if(!myF1TSC)
8796     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
8797   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8798   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
8799 }
8800
8801 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const
8802 {
8803   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8804   if(!pt)
8805     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
8806   const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
8807   if(!ret)
8808     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 !");
8809   return ret;
8810 }
8811
8812  MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull()
8813 {
8814   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8815   if(!pt)
8816     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
8817   MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
8818   if(!ret)
8819     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 !");
8820   return ret;
8821 }
8822
8823 /*!
8824  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8825  * the given field is checked if its elements are sorted suitable for writing to MED file
8826  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8827  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8828  *  \param [in] field - the field to add to \a this.
8829  *  \throw If the name of \a field is empty.
8830  *  \throw If the data array of \a field is not set.
8831  *  \throw If existing time steps have different name or number of components than \a field.
8832  *  \throw If the underlying mesh of \a field has no name.
8833  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8834  */
8835 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
8836 {
8837   const DataArrayDouble *arr=0;
8838   if(field)
8839     arr=field->getArray();
8840   contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
8841 }
8842
8843 /*!
8844  * Adds a MEDCouplingFieldDouble to \a this as another time step.
8845  * The mesh support of input parameter \a field is ignored here, it can be NULL.
8846  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
8847  * and \a profile.
8848  *
8849  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
8850  * A new profile is added only if no equal profile is missing.
8851  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8852  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
8853  *  \param [in] mesh - the supporting mesh of \a field.
8854  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
8855  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
8856  *  \throw If either \a field or \a mesh or \a profile has an empty name.
8857  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8858  *  \throw If the data array of \a field is not set.
8859  *  \throw If the data array of \a this is already allocated but has different number of
8860  *         components than \a field.
8861  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
8862  *  \sa setFieldNoProfileSBT()
8863  */
8864 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
8865 {
8866   const DataArrayDouble *arr=0;
8867   if(field)
8868     arr=field->getArray();
8869   contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
8870 }
8871
8872 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
8873 {
8874   _content=new MEDFileFieldMultiTSWithoutSDA;
8875 }
8876
8877 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, bool loadAll)
8878 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
8879 {
8880 }
8881 catch(INTERP_KERNEL::Exception& e)
8882   { throw e; }
8883
8884 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll)
8885 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
8886 {
8887 }
8888 catch(INTERP_KERNEL::Exception& e)
8889   { throw e; }
8890
8891 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
8892 {
8893 }
8894
8895 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
8896 {
8897   return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
8898 }
8899
8900 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
8901 {
8902   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
8903 }
8904
8905 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
8906 {
8907   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
8908 }
8909
8910 //= MEDFileAnyTypeFieldMultiTSIterator
8911
8912 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
8913 {
8914   if(fmts)
8915     {
8916       fmts->incrRef();
8917       _nb_iter=fmts->getNumberOfTS();
8918     }
8919 }
8920
8921 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
8922 {
8923 }
8924
8925 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt()
8926 {
8927   if(_iter_id<_nb_iter)
8928     {
8929       MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
8930       if(fmts)
8931         return fmts->getTimeStepAtPos(_iter_id++);
8932       else
8933         return 0;
8934     }
8935   else
8936     return 0;
8937 }
8938
8939 //= MEDFileIntFieldMultiTS
8940
8941 /*!
8942  * Returns a new empty instance of MEDFileFieldMultiTS.
8943  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8944  *          is to delete this field using decrRef() as it is no more needed.
8945  */
8946 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
8947 {
8948   return new MEDFileIntFieldMultiTS;
8949 }
8950
8951 /*!
8952  * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
8953  * that has been read from a specified MED file.
8954  *  \param [in] fileName - the name of the MED file to read.
8955  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8956  *          is to delete this field using decrRef() as it is no more needed.
8957  *  \throw If reading the file fails.
8958  */
8959 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, bool loadAll)
8960 {
8961   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,loadAll);
8962   ret->contentNotNull();//to check that content type matches with \a this type.
8963   return ret.retn();
8964 }
8965
8966 /*!
8967  * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
8968  * that has been read from a specified MED file.
8969  *  \param [in] fileName - the name of the MED file to read.
8970  *  \param [in] fieldName - the name of the field to read.
8971  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8972  *          is to delete this field using decrRef() as it is no more needed.
8973  *  \throw If reading the file fails.
8974  *  \throw If there is no field named \a fieldName in the file.
8975  */
8976 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll)
8977 {
8978   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,fieldName,loadAll);
8979   ret->contentNotNull();//to check that content type matches with \a this type.
8980   return ret.retn();
8981 }
8982
8983 /*!
8984  * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8985  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8986  *
8987  * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
8988  * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8989  * \warning this is a shallow copy constructor
8990  *  \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
8991  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8992  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8993  *          is to delete this field using decrRef() as it is no more needed.
8994  */
8995 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8996 {
8997   return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
8998 }
8999
9000 /*!
9001  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
9002  * following the given input policy.
9003  *
9004  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
9005  *                            By default (true) the globals are deeply copied.
9006  * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
9007  */
9008 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool isDeepCpyGlobs) const
9009 {
9010   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret;
9011   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9012   if(content)
9013     {
9014       const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
9015       if(!contc)
9016         throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
9017       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
9018       ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc,getFileName()));
9019     }
9020   else
9021     ret=MEDFileFieldMultiTS::New();
9022   if(isDeepCpyGlobs)
9023     ret->deepCpyGlobs(*this);
9024   else
9025     ret->shallowCpyGlobs(*this);
9026   return ret.retn();
9027 }
9028
9029 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const
9030 {
9031   return new MEDFileIntFieldMultiTS(*this);
9032 }
9033
9034 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
9035 {
9036   if(!f1ts)
9037     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
9038   const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
9039   if(!f1tsC)
9040     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
9041 }
9042
9043 /*!
9044  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9045  * mesh entities of a given dimension of the first mesh in MED file.
9046  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9047  *  \param [in] type - a spatial discretization of interest.
9048  *  \param [in] iteration - the iteration number of a required time step.
9049  *  \param [in] order - the iteration order number of required time step.
9050  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9051  *  \param [out] arrOut - the DataArrayInt containing values of field.
9052  *  \param [in] renumPol - specifies how to permute values of the result field according to
9053  *          the optional numbers of cells and nodes, if any. The valid values are
9054  *          - 0 - do not permute.
9055  *          - 1 - permute cells.
9056  *          - 2 - permute nodes.
9057  *          - 3 - permute cells and nodes.
9058  *
9059  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9060  *          caller is to delete this field using decrRef() as it is no more needed.
9061  *  \throw If the MED file is not readable.
9062  *  \throw If there is no mesh in the MED file.
9063  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9064  *  \throw If no field values of the required parameters are available.
9065  */
9066 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9067 {
9068   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9069   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9070   if(!myF1TSC)
9071     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
9072   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9073   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arr,*contentNotNullBase());
9074   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9075   return ret.retn();
9076 }
9077
9078 /*!
9079  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9080  * the top level cells of the first mesh in MED file.
9081  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9082  *  \param [in] type - a spatial discretization of interest.
9083  *  \param [in] iteration - the iteration number of a required time step.
9084  *  \param [in] order - the iteration order number of required time step.
9085  *  \param [out] arrOut - the DataArrayInt containing values of field.
9086  *  \param [in] renumPol - specifies how to permute values of the result field according to
9087  *          the optional numbers of cells and nodes, if any. The valid values are
9088  *          - 0 - do not permute.
9089  *          - 1 - permute cells.
9090  *          - 2 - permute nodes.
9091  *          - 3 - permute cells and nodes.
9092  *
9093  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9094  *          caller is to delete this field using decrRef() as it is no more needed.
9095  *  \throw If the MED file is not readable.
9096  *  \throw If there is no mesh in the MED file.
9097  *  \throw If no field values of the required parameters are available.
9098  */
9099 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, DataArrayInt* &arrOut, int renumPol) const
9100 {
9101   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9102   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9103   if(!myF1TSC)
9104     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
9105   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9106   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNullBase());
9107   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9108   return ret.retn();
9109 }
9110
9111 /*!
9112  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9113  * a given support.
9114  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9115  *  \param [in] type - a spatial discretization of interest.
9116  *  \param [in] iteration - the iteration number of a required time step.
9117  *  \param [in] order - the iteration order number of required time step.
9118  *  \param [out] arrOut - the DataArrayInt containing values of field.
9119  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9120  *  \param [in] mesh - the supporting mesh.
9121  *  \param [in] renumPol - specifies how to permute values of the result field according to
9122  *          the optional numbers of cells and nodes, if any. The valid values are
9123  *          - 0 - do not permute.
9124  *          - 1 - permute cells.
9125  *          - 2 - permute nodes.
9126  *          - 3 - permute cells and nodes.
9127  *
9128  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9129  *          caller is to delete this field using decrRef() as it is no more needed.
9130  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9131  *  \throw If no field of \a this is lying on \a mesh.
9132  *  \throw If no field values of the required parameters are available.
9133  */
9134 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9135 {
9136   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9137   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9138   if(!myF1TSC)
9139     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9140   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9141   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase());
9142   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9143   return ret.retn();
9144 }
9145
9146 /*!
9147  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
9148  * given support.
9149  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9150  *  \param [in] type - a spatial discretization of the new field.
9151  *  \param [in] iteration - the iteration number of a required time step.
9152  *  \param [in] order - the iteration order number of required time step.
9153  *  \param [in] mesh - the supporting mesh.
9154  *  \param [out] arrOut - the DataArrayInt containing values of field.
9155  *  \param [in] renumPol - specifies how to permute values of the result field according to
9156  *          the optional numbers of cells and nodes, if any. The valid values are
9157  *          - 0 - do not permute.
9158  *          - 1 - permute cells.
9159  *          - 2 - permute nodes.
9160  *          - 3 - permute cells and nodes.
9161  *
9162  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9163  *          caller is to delete this field using decrRef() as it is no more needed.
9164  *  \throw If no field of \a this is lying on \a mesh.
9165  *  \throw If no field values of the required parameters are available.
9166  */
9167 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9168 {
9169   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9170   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9171   if(!myF1TSC)
9172     throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9173   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9174   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase());
9175   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9176   return ret.retn();
9177 }
9178
9179 /*!
9180  * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
9181  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
9182  * This method is useful for MED2 file format when field on different mesh was autorized.
9183  */
9184 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9185 {
9186   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9187   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9188   if(!myF1TSC)
9189     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9190   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9191   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase());
9192   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9193   return ret.retn();
9194 }
9195
9196 /*!
9197  * Returns values and a profile of the field of a given type, of a given time step,
9198  * lying on a given support.
9199  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9200  *  \param [in] type - a spatial discretization of the field.
9201  *  \param [in] iteration - the iteration number of a required time step.
9202  *  \param [in] order - the iteration order number of required time step.
9203  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9204  *  \param [in] mesh - the supporting mesh.
9205  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
9206  *          field of interest lies on. If the field lies on all entities of the given
9207  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
9208  *          using decrRef() as it is no more needed.
9209  *  \param [in] glob - the global data storing profiles and localization.
9210  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
9211  *          field. The caller is to delete this array using decrRef() as it is no more needed.
9212  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9213  *  \throw If no field of \a this is lying on \a mesh.
9214  *  \throw If no field values of the required parameters are available.
9215  */
9216 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
9217 {
9218   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9219   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9220   if(!myF1TSC)
9221     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
9222   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
9223   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(ret);
9224 }
9225
9226 /*!
9227  * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
9228  *  \param [in] pos - a time step id.
9229  *  \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
9230  *          delete this field using decrRef() as it is no more needed.
9231  *  \throw If \a pos is not a valid time step id.
9232  */
9233 MEDFileAnyTypeField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const
9234 {
9235   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
9236   if(!item)
9237     {
9238       std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
9239       throw INTERP_KERNEL::Exception(oss.str().c_str());
9240     }
9241   const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
9242   if(itemC)
9243     {
9244       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
9245       ret->shallowCpyGlobs(*this);
9246       return ret.retn();
9247     }
9248   std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
9249   throw INTERP_KERNEL::Exception(oss.str().c_str());
9250 }
9251
9252 /*!
9253  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
9254  * the given field is checked if its elements are sorted suitable for writing to MED file
9255  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
9256  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9257  *  \param [in] field - the field to add to \a this.
9258  *  \throw If the name of \a field is empty.
9259  *  \throw If the data array of \a field is not set.
9260  *  \throw If existing time steps have different name or number of components than \a field.
9261  *  \throw If the underlying mesh of \a field has no name.
9262  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
9263  */
9264 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
9265 {
9266   contentNotNull()->appendFieldNoProfileSBT(field,arrOfVals,*this);
9267 }
9268
9269 /*!
9270  * Adds a MEDCouplingFieldDouble to \a this as another time step.
9271  * The mesh support of input parameter \a field is ignored here, it can be NULL.
9272  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
9273  * and \a profile.
9274  *
9275  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
9276  * A new profile is added only if no equal profile is missing.
9277  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9278  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
9279  *  \param [in] arrOfVals - the values of the field \a field used.
9280  *  \param [in] mesh - the supporting mesh of \a field.
9281  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
9282  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
9283  *  \throw If either \a field or \a mesh or \a profile has an empty name.
9284  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9285  *  \throw If the data array of \a field is not set.
9286  *  \throw If the data array of \a this is already allocated but has different number of
9287  *         components than \a field.
9288  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
9289  *  \sa setFieldNoProfileSBT()
9290  */
9291 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
9292 {
9293   contentNotNull()->appendFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this);
9294 }
9295
9296 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const
9297 {
9298   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9299   if(!pt)
9300     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
9301   const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9302   if(!ret)
9303     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 !");
9304   return ret;
9305 }
9306
9307  MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull()
9308 {
9309   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9310   if(!pt)
9311     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
9312   MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9313   if(!ret)
9314     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 !");
9315   return ret;
9316 }
9317
9318 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
9319 {
9320   _content=new MEDFileIntFieldMultiTSWithoutSDA;
9321 }
9322
9323 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
9324 {
9325 }
9326
9327 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, bool loadAll)
9328 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
9329 {
9330 }
9331 catch(INTERP_KERNEL::Exception& e)
9332   { throw e; }
9333
9334 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll)
9335 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
9336 {
9337 }
9338 catch(INTERP_KERNEL::Exception& e)
9339   { throw e; }
9340
9341 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
9342 {
9343   return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
9344 }
9345
9346 //= MEDFileFields
9347
9348 MEDFileFields *MEDFileFields::New()
9349 {
9350   return new MEDFileFields;
9351 }
9352
9353 MEDFileFields *MEDFileFields::New(const char *fileName, bool loadAll)
9354 {
9355   return new MEDFileFields(fileName,loadAll);
9356 }
9357
9358 std::size_t MEDFileFields::getHeapMemorySizeWithoutChildren() const
9359 {
9360   std::size_t ret(MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren());
9361   ret+=_fields.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
9362   return ret;
9363 }
9364
9365 std::vector<const BigMemoryObject *> MEDFileFields::getDirectChildren() const
9366 {
9367   std::vector<const BigMemoryObject *> ret;
9368   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9369     {
9370       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9371       if(cur)
9372         ret.push_back(cur);
9373     }
9374   return ret;
9375 }
9376
9377 MEDFileFields *MEDFileFields::deepCpy() const
9378 {
9379   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9380   std::size_t i=0;
9381   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9382     {
9383       if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9384         ret->_fields[i]=(*it)->deepCpy();
9385     }
9386   ret->deepCpyGlobs(*this);
9387   return ret.retn();
9388 }
9389
9390 MEDFileFields *MEDFileFields::shallowCpy() const
9391 {
9392   return new MEDFileFields(*this);
9393 }
9394
9395 /*!
9396  * 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
9397  * 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.
9398  * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
9399  *
9400  * \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.
9401  * \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.
9402  *
9403  * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9404  */
9405 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const
9406 {
9407   std::set< std::pair<int,int> > s;
9408   bool firstShot=true;
9409   areThereSomeForgottenTS=false;
9410   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9411     {
9412       if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9413         continue;
9414       std::vector< std::pair<int,int> > v=(*it)->getIterations();
9415       std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
9416       if(firstShot)
9417         { s=s1; firstShot=false; }
9418       else
9419         {
9420           std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
9421           if(s!=s2)
9422             areThereSomeForgottenTS=true;
9423           s=s2;
9424         }
9425     }
9426   std::vector< std::pair<int,int> > ret;
9427   std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
9428   return ret;
9429 }
9430
9431 int MEDFileFields::getNumberOfFields() const
9432 {
9433   return _fields.size();
9434 }
9435
9436 std::vector<std::string> MEDFileFields::getFieldsNames() const
9437 {
9438   std::vector<std::string> ret(_fields.size());
9439   int i=0;
9440   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9441     {
9442       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
9443       if(f)
9444         {
9445           ret[i]=f->getName();
9446         }
9447       else
9448         {
9449           std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
9450           throw INTERP_KERNEL::Exception(oss.str().c_str());
9451         }
9452     }
9453   return ret;
9454 }
9455
9456 std::vector<std::string> MEDFileFields::getMeshesNames() const
9457 {
9458   std::vector<std::string> ret;
9459   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9460     {
9461       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9462       if(cur)
9463         ret.push_back(cur->getMeshName());
9464     }
9465   return ret;
9466 }
9467
9468 std::string MEDFileFields::simpleRepr() const
9469 {
9470   std::ostringstream oss;
9471   oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
9472   simpleRepr(0,oss);
9473   return oss.str();
9474 }
9475
9476 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
9477 {
9478   int nbOfFields=getNumberOfFields();
9479   std::string startLine(bkOffset,' ');
9480   oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
9481   int i=0;
9482   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9483     {
9484       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9485       if(cur)
9486         {
9487           oss << startLine << "  - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
9488         }
9489       else
9490         {
9491           oss << startLine << "  - not defined !" << std::endl;
9492         }
9493     }
9494   i=0;
9495   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9496     {
9497       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9498       std::string chapter(17,'0'+i);
9499       oss << startLine << chapter << std::endl;
9500       if(cur)
9501         {
9502           cur->simpleRepr(bkOffset+2,oss,i);
9503         }
9504       else
9505         {
9506           oss << startLine << "  - not defined !" << std::endl;
9507         }
9508       oss << startLine << chapter << std::endl;
9509     }
9510   simpleReprGlobs(oss);
9511 }
9512
9513 MEDFileFields::MEDFileFields()
9514 {
9515 }
9516
9517 MEDFileFields::MEDFileFields(const char *fileName, bool loadAll)
9518 try:MEDFileFieldGlobsReal(fileName)
9519   {
9520     MEDFileUtilities::CheckFileForRead(fileName);
9521     MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
9522     int nbFields=MEDnField(fid);
9523     _fields.resize(nbFields);
9524     med_field_type typcha;
9525     for(int i=0;i<nbFields;i++)
9526       {
9527         std::vector<std::string> infos;
9528         std::string fieldName,dtunit;
9529         int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,fileName,i,false,fieldName,typcha,infos,dtunit);
9530         switch(typcha)
9531           {
9532           case MED_FLOAT64:
9533             {
9534               _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9535               break;
9536             }
9537           case MED_INT32:
9538             {
9539               _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9540               break;
9541             }
9542           default:
9543             {
9544               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] !";
9545               throw INTERP_KERNEL::Exception(oss.str().c_str());
9546             }
9547           }
9548       }
9549     loadAllGlobals(fid);
9550   }
9551 catch(INTERP_KERNEL::Exception& e)
9552   {
9553     throw e;
9554   }
9555
9556 void MEDFileFields::writeLL(med_idt fid) const
9557 {
9558   int i=0;
9559   writeGlobals(fid,*this);
9560   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9561     {
9562       const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
9563       if(!elt)
9564         {
9565           std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
9566           throw INTERP_KERNEL::Exception(oss.str().c_str());
9567         }
9568       elt->writeLL(fid,*this);
9569     }
9570 }
9571
9572 void MEDFileFields::write(const char *fileName, int mode) const
9573 {
9574   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
9575   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
9576   writeLL(fid);
9577 }
9578
9579 /*!
9580  * This method alloc the arrays and load potentially huge arrays contained in this field.
9581  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
9582  * This method can be also called to refresh or reinit values from a file.
9583  *
9584  * \throw If the fileName is not set or points to a non readable MED file.
9585  */
9586 void MEDFileFields::loadArrays()
9587 {
9588   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9589   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9590     {
9591       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9592       if(elt)
9593         elt->loadBigArraysRecursively(fid,*elt);
9594     }
9595 }
9596
9597 /*!
9598  * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
9599  * But once data loaded once, this method does nothing.
9600  *
9601  * \throw If the fileName is not set or points to a non readable MED file.
9602  * \sa MEDFileFields::loadArrays, MEDFileFields::unloadArrays
9603  */
9604 void MEDFileFields::loadArraysIfNecessary()
9605 {
9606   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9607   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9608     {
9609       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9610       if(elt)
9611         elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
9612     }
9613 }
9614
9615 /*!
9616  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
9617  * This method does not release arrays set outside the context of a MED file.
9618  *
9619  * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary
9620  */
9621 void MEDFileFields::unloadArrays()
9622 {
9623   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9624   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9625     {
9626       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9627       if(elt)
9628         elt->unloadArrays();
9629     }
9630 }
9631
9632 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
9633 {
9634   std::vector<std::string> ret;
9635   std::set<std::string> ret2;
9636   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9637     {
9638       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
9639       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9640         if(ret2.find(*it2)==ret2.end())
9641           {
9642             ret.push_back(*it2);
9643             ret2.insert(*it2);
9644           }
9645     }
9646   return ret;
9647 }
9648
9649 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
9650 {
9651   std::vector<std::string> ret;
9652   std::set<std::string> ret2;
9653   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9654     {
9655       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9656       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9657         if(ret2.find(*it2)==ret2.end())
9658           {
9659             ret.push_back(*it2);
9660             ret2.insert(*it2);
9661           }
9662     }
9663   return ret;
9664 }
9665
9666 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
9667 {
9668   std::vector<std::string> ret;
9669   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9670     {
9671       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
9672       ret.insert(ret.end(),tmp.begin(),tmp.end());
9673     }
9674   return ret;
9675 }
9676
9677 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
9678 {
9679   std::vector<std::string> ret;
9680   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9681     {
9682       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9683       ret.insert(ret.end(),tmp.begin(),tmp.end());
9684     }
9685   return ret;
9686 }
9687
9688 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9689 {
9690   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9691     (*it)->changePflsRefsNamesGen2(mapOfModif);
9692 }
9693
9694 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9695 {
9696   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9697     (*it)->changeLocsRefsNamesGen2(mapOfModif);
9698 }
9699
9700 void MEDFileFields::resize(int newSize)
9701 {
9702   _fields.resize(newSize);
9703 }
9704
9705 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields)
9706 {
9707   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
9708     pushField(*it);
9709 }
9710
9711 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field)
9712 {
9713   if(!field)
9714     throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
9715   _fields.push_back(field->getContent());
9716   appendGlobs(*field,1e-12);
9717 }
9718
9719 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field)
9720 {
9721   if(!field)
9722     throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
9723   if(i>=(int)_fields.size())
9724     _fields.resize(i+1);
9725   _fields[i]=field->getContent();
9726   appendGlobs(*field,1e-12);
9727 }
9728
9729 void MEDFileFields::destroyFieldAtPos(int i)
9730 {
9731   destroyFieldsAtPos(&i,&i+1);
9732 }
9733
9734 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds)
9735 {
9736   std::vector<bool> b(_fields.size(),true);
9737   for(const int *i=startIds;i!=endIds;i++)
9738     {
9739       if(*i<0 || *i>=(int)_fields.size())
9740         {
9741           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9742           throw INTERP_KERNEL::Exception(oss.str().c_str());
9743         }
9744       b[*i]=false;
9745     }
9746   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9747   std::size_t j=0;
9748   for(std::size_t i=0;i<_fields.size();i++)
9749     if(b[i])
9750       fields[j++]=_fields[i];
9751   _fields=fields;
9752 }
9753
9754 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step)
9755 {
9756   static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
9757   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
9758   std::vector<bool> b(_fields.size(),true);
9759   int k=bg;
9760   for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
9761     {
9762       if(k<0 || k>=(int)_fields.size())
9763         {
9764           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
9765           throw INTERP_KERNEL::Exception(oss.str().c_str());
9766         }
9767       b[k]=false;
9768     }
9769   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9770   std::size_t j=0;
9771   for(std::size_t i=0;i<_fields.size();i++)
9772     if(b[i])
9773       fields[j++]=_fields[i];
9774   _fields=fields;
9775 }
9776
9777 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
9778 {
9779   bool ret=false;
9780   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9781     {
9782       MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9783       if(cur)
9784         ret=cur->changeMeshNames(modifTab) || ret;
9785     }
9786   return ret;
9787 }
9788
9789 /*!
9790  * \param [in] meshName the name of the mesh that will be renumbered.
9791  * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
9792  *             This code corresponds to the distribution of types in the corresponding mesh.
9793  * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
9794  * \param [in] renumO2N the old to new renumber array.
9795  * \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
9796  *         field in \a this.
9797  */
9798 bool MEDFileFields::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N)
9799 {
9800   bool ret=false;
9801   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9802     {
9803       MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
9804       if(fmts)
9805         {
9806           ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
9807         }
9808     }
9809   return ret;
9810 }
9811
9812 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const
9813 {
9814   if(i<0 || i>=(int)_fields.size())
9815     {
9816       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
9817       throw INTERP_KERNEL::Exception(oss.str().c_str());
9818     }
9819   const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
9820   if(!fmts)
9821     return 0;
9822   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret;
9823   const MEDFileFieldMultiTSWithoutSDA *fmtsC=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts);
9824   const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts);
9825   if(fmtsC)
9826     ret=MEDFileFieldMultiTS::New(*fmtsC,false);
9827   else if(fmtsC2)
9828     ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
9829   else
9830     {
9831       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
9832       throw INTERP_KERNEL::Exception(oss.str().c_str());
9833     }
9834   ret->shallowCpyGlobs(*this);
9835   return ret.retn();
9836 }
9837
9838 /*!
9839  * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
9840  * This method is accessible in python using __getitem__ with a list in input.
9841  * \return a new object that the caller should deal with.
9842  */
9843 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const
9844 {
9845   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9846   std::size_t sz=std::distance(startIds,endIds);
9847   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
9848   int j=0;
9849   for(const int *i=startIds;i!=endIds;i++,j++)
9850     {
9851       if(*i<0 || *i>=(int)_fields.size())
9852         {
9853           std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9854           throw INTERP_KERNEL::Exception(oss.str().c_str());
9855         }
9856       fields[j]=_fields[*i];
9857     }
9858   ret->_fields=fields;
9859   return ret.retn();
9860 }
9861
9862 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const char *fieldName) const
9863 {
9864   return getFieldAtPos(getPosFromFieldName(fieldName));
9865 }
9866
9867 /*!
9868  * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
9869  * This method can be seen as a filter applied on \a this, that returns an object containing
9870  * 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
9871  * shallow copied from \a this.
9872  *
9873  * \param [in] meshName - the name of the mesh on w
9874  * \return a new object that the caller should deal with.
9875  */
9876 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const char *meshName) const
9877 {
9878   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9879   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9880     {
9881       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9882       if(!cur)
9883         continue;
9884       if(cur->getMeshName()==meshName)
9885         {
9886           cur->incrRef();
9887           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
9888           ret->_fields.push_back(cur2);
9889         }
9890     }
9891   ret->shallowCpyOnlyUsedGlobs(*this);
9892   return ret.retn();
9893 }
9894
9895 /*!
9896  * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
9897  * Input time steps are specified using a pair of integer (iteration, order).
9898  * 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,
9899  * but for each multitimestep only the time steps in \a timeSteps are kept.
9900  * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
9901  *
9902  * The returned object points to shallow copy of elements in \a this.
9903  *
9904  * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
9905  * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
9906  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9907  */
9908 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
9909 {
9910   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9911   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9912     {
9913       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9914       if(!cur)
9915         continue;
9916       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
9917       ret->_fields.push_back(elt);
9918     }
9919   ret->shallowCpyOnlyUsedGlobs(*this);
9920   return ret.retn();
9921 }
9922
9923 /*!
9924  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
9925  */
9926 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
9927 {
9928   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9929   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9930     {
9931       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9932       if(!cur)
9933         continue;
9934       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
9935       if(elt->getNumberOfTS()!=0)
9936         ret->_fields.push_back(elt);
9937     }
9938   ret->shallowCpyOnlyUsedGlobs(*this);
9939   return ret.retn();
9940 }
9941
9942 MEDFileFieldsIterator *MEDFileFields::iterator()
9943 {
9944   return new MEDFileFieldsIterator(this);
9945 }
9946
9947 int MEDFileFields::getPosFromFieldName(const char *fieldName) const
9948 {
9949   std::string tmp(fieldName);
9950   std::vector<std::string> poss;
9951   for(std::size_t i=0;i<_fields.size();i++)
9952     {
9953       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=_fields[i];
9954       if(f)
9955         {
9956           std::string fname(f->getName());
9957           if(tmp==fname)
9958             return i;
9959           else
9960             poss.push_back(fname);
9961         }
9962     }
9963   std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
9964   std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
9965   oss << " !";
9966   throw INTERP_KERNEL::Exception(oss.str().c_str());
9967 }
9968
9969 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
9970 {
9971   if(fs)
9972     {
9973       fs->incrRef();
9974       _nb_iter=fs->getNumberOfFields();
9975     }
9976 }
9977
9978 MEDFileFieldsIterator::~MEDFileFieldsIterator()
9979 {
9980 }
9981
9982 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
9983 {
9984   if(_iter_id<_nb_iter)
9985     {
9986       MEDFileFields *fs(_fs);
9987       if(fs)
9988         return fs->getFieldAtPos(_iter_id++);
9989       else
9990         return 0;
9991     }
9992   else
9993     return 0;
9994 }