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[32];
  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+32,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+32,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):_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       if(type==ON_GAUSS_NE)
4329         {
4330           MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mPart=m->buildPart(profile->begin(),profile->end());
4331           field2->setMesh(mPart);
4332         }
4333       int nbOfTuplesExp=field2->getNumberOfTuplesExpectedRegardingCode(code,idsPerType3);
4334       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4335         {
4336           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : The array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4337           throw INTERP_KERNEL::Exception(oss.str().c_str());
4338         }
4339       // end of check
4340       int start=copyTinyInfoFrom(field,arrOfVals);
4341       code2=m->getDistributionOfTypes();
4342       //
4343       int pos=addNewEntryIfNecessary(m);
4344       _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
4345     }
4346   else
4347     {
4348       if(!profile || !profile->isAllocated() || profile->getNumberOfComponents()!=1)
4349         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input profile is null, not allocated or with number of components != 1 !");
4350       std::vector<int> v(3); v[0]=-1; v[1]=profile->getNumberOfTuples(); v[2]=0;
4351       std::vector<const DataArrayInt *> idsPerType3(1); idsPerType3[0]=profile;
4352       int nbOfTuplesExp=field->getNumberOfTuplesExpectedRegardingCode(v,idsPerType3);
4353       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4354         {
4355           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : For node field, the array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4356           throw INTERP_KERNEL::Exception(oss.str().c_str());
4357         }
4358       int start=copyTinyInfoFrom(field,arrOfVals);
4359       int pos=addNewEntryIfNecessary(m);
4360       _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
4361     }
4362 }
4363
4364 /*!
4365  * \param [in] newNbOfTuples - The new nb of tuples to be allocated.
4366  */
4367 void MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile(int newNbOfTuples)
4368 {
4369   if(_nb_of_tuples_to_be_allocated>=0)
4370     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 !");
4371   DataArray *arr(getOrCreateAndGetArray());
4372   arr->alloc(newNbOfTuples,arr->getNumberOfComponents());
4373   _nb_of_tuples_to_be_allocated=-3;
4374 }
4375
4376 /*!
4377  * Copies tiny info and allocates \a this->_arr instance of DataArrayDouble to
4378  * append data of a given MEDCouplingFieldDouble. So that the size of \a this->_arr becomes
4379  * larger by the size of \a field. Returns an id of the first not filled
4380  * tuple of \a this->_arr.
4381  *  \param [in] field - the field to copy the info on components and the name from.
4382  *  \return int - the id of first not initialized tuple of \a this->_arr.
4383  *  \throw If the name of \a field is empty.
4384  *  \throw If the data array of \a field is not set.
4385  *  \throw If \a this->_arr is already allocated but has different number of components
4386  *         than \a field.
4387  */
4388 int MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
4389 {
4390   if(!field)
4391     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
4392   std::string name(field->getName());
4393   setName(name.c_str());
4394   setDtUnit(field->getTimeUnit());
4395   if(name.empty())
4396     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
4397   if(!arr)
4398     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
4399   if(!arr->isAllocated())
4400     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : array is not allocated !");
4401   _dt=field->getTime(_iteration,_order);
4402   int nbOfComponents=arr->getNumberOfComponents();
4403   getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
4404   if(!getOrCreateAndGetArray()->isAllocated())
4405     {
4406       allocNotFromFile(arr->getNumberOfTuples());
4407       return 0;
4408     }
4409   else
4410     {
4411       int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
4412       int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
4413       getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
4414       _nb_of_tuples_to_be_allocated=-3;
4415       return oldNbOfTuples;
4416     }
4417 }
4418
4419 /*!
4420  * Returns number of components in \a this field
4421  *  \return int - the number of components.
4422  */
4423 int MEDFileAnyTypeField1TSWithoutSDA::getNumberOfComponents() const
4424 {
4425   return getOrCreateAndGetArray()->getNumberOfComponents();
4426 }
4427
4428 /*!
4429  * Change info on components in \a this.
4430  * \throw If size of \a infos is not equal to the number of components already in \a this.
4431  */
4432 void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos)
4433 {
4434   DataArray *arr=getOrCreateAndGetArray();
4435   arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
4436 }
4437
4438 /*!
4439  * Returns info on components of \a this field.
4440  *  \return const std::vector<std::string>& - a sequence of strings each being an
4441  *          information on _i_-th component.
4442  */
4443 const std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo() const
4444 {
4445   const DataArray *arr=getOrCreateAndGetArray();
4446   return arr->getInfoOnComponents();
4447 }
4448
4449 /*!
4450  * Returns a mutable info on components of \a this field.
4451  *  \return std::vector<std::string>& - a sequence of strings each being an
4452  *          information on _i_-th component.
4453  */
4454 std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo()
4455 {
4456   DataArray *arr=getOrCreateAndGetArray();
4457   return arr->getInfoOnComponents();
4458 }
4459
4460 /*!
4461  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4462  *  \param [in] type - a spatial discretization of the new field.
4463  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4464  *  \param [in] mName - a name of the supporting mesh.
4465  *  \param [in] renumPol - specifies how to permute values of the result field according to
4466  *          the optional numbers of cells and nodes, if any. The valid values are
4467  *          - 0 - do not permute.
4468  *          - 1 - permute cells.
4469  *          - 2 - permute nodes.
4470  *          - 3 - permute cells and nodes.
4471  *
4472  *  \param [in] glob - the global data storing profiles and localization.
4473  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4474  *          caller is to delete this field using decrRef() as it is no more needed.
4475  *  \throw If the MED file is not readable.
4476  *  \throw If there is no mesh named \a mName in the MED file.
4477  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4478  *  \throw If no field of \a this is lying on the mesh \a mName.
4479  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4480  */
4481 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4482 {
4483   MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4484   if(mName==0)
4485     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4486   else
4487     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4488   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4489 }
4490
4491 /*!
4492  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4493  *  \param [in] type - a spatial discretization of the new field.
4494  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4495  *  \param [in] renumPol - specifies how to permute values of the result field according to
4496  *          the optional numbers of cells and nodes, if any. The valid values are
4497  *          - 0 - do not permute.
4498  *          - 1 - permute cells.
4499  *          - 2 - permute nodes.
4500  *          - 3 - permute cells and nodes.
4501  *
4502  *  \param [in] glob - the global data storing profiles and localization.
4503  *  \param [in] mesh - the supporting mesh.
4504  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4505  *          caller is to delete this field using decrRef() as it is no more needed.
4506  *  \throw If the MED file is not readable.
4507  *  \throw If no field of \a this is lying on \a mesh.
4508  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4509  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4510  */
4511 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4512 {
4513   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax,false);
4514   const DataArrayInt *d=mesh->getNumberFieldAtLevel(meshDimRelToMax);
4515   const DataArrayInt *e=mesh->getNumberFieldAtLevel(1);
4516   if(meshDimRelToMax==1)
4517     (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
4518   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e,arrOut,nasc);
4519 }
4520
4521 /*!
4522  * Returns a new MEDCouplingFieldDouble of a given type lying on the top level cells of a
4523  * given mesh.
4524  *  \param [in] type - a spatial discretization of the new field.
4525  *  \param [in] mName - a name of the supporting mesh.
4526  *  \param [in] renumPol - specifies how to permute values of the result field according to
4527  *          the optional numbers of cells and nodes, if any. The valid values are
4528  *          - 0 - do not permute.
4529  *          - 1 - permute cells.
4530  *          - 2 - permute nodes.
4531  *          - 3 - permute cells and nodes.
4532  *
4533  *  \param [in] glob - the global data storing profiles and localization.
4534  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4535  *          caller is to delete this field using decrRef() as it is no more needed.
4536  *  \throw If the MED file is not readable.
4537  *  \throw If there is no mesh named \a mName in the MED file.
4538  *  \throw If there are no mesh entities in the mesh.
4539  *  \throw If no field values of the given \a type are available.
4540  */
4541 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4542 {
4543    MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4544   if(mName==0)
4545     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4546   else
4547     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4548   int absDim=getDimension();
4549   int meshDimRelToMax=absDim-mm->getMeshDimension();
4550   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4551 }
4552
4553 /*!
4554  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4555  *  \param [in] type - a spatial discretization of the new field.
4556  *  \param [in] renumPol - specifies how to permute values of the result field according to
4557  *          the optional numbers of cells and nodes, if any. The valid values are
4558  *          - 0 - do not permute.
4559  *          - 1 - permute cells.
4560  *          - 2 - permute nodes.
4561  *          - 3 - permute cells and nodes.
4562  *
4563  *  \param [in] glob - the global data storing profiles and localization.
4564  *  \param [in] mesh - the supporting mesh.
4565  *  \param [in] cellRenum - the cell numbers array used for permutation of the result
4566  *         field according to \a renumPol.
4567  *  \param [in] nodeRenum - the node numbers array used for permutation of the result
4568  *         field according to \a renumPol.
4569  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4570  *          caller is to delete this field using decrRef() as it is no more needed.
4571  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4572  *  \throw If no field of \a this is lying on \a mesh.
4573  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4574  */
4575 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
4576 {
4577   static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
4578   int meshId=getMeshIdFromMeshName(mesh->getName().c_str());
4579   bool isPfl=false;
4580   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl,arrOut,nasc);
4581   switch(renumPol)
4582     {
4583     case 0:
4584       {
4585         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4586         return ret.retn();
4587       }
4588     case 3:
4589     case 1:
4590       {
4591         if(isPfl)
4592           throw INTERP_KERNEL::Exception(msg1);
4593         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4594         if(cellRenum)
4595           {
4596             if((int)cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
4597               {
4598                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4599                 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
4600                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4601               }
4602             MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
4603             if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
4604             std::vector<DataArray *> arrOut2(1,arrOut);
4605             // 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
4606             disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
4607             (const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
4608           }
4609         if(renumPol==1)
4610           return ret.retn();
4611       }
4612     case 2:
4613       {
4614         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4615         if(isPfl)
4616           throw INTERP_KERNEL::Exception(msg1);
4617         if(nodeRenum)
4618           {
4619             if((int)nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
4620               {
4621                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4622                 oss << "\"" << nasc.getName() << "\" not defined on all nodes !";
4623                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4624               }
4625             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
4626             if(!dynamic_cast<DataArrayDouble *>((DataArray *)arrOut))
4627               throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : node renumbering not implemented for not double DataArrays !");
4628             ret->renumberNodes(nodeRenumSafe->getConstPointer());
4629           }
4630         return ret.retn();
4631       }
4632     default:
4633       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
4634     }
4635 }
4636
4637 /*!
4638  * Returns values and a profile of the field of a given type lying on a given support.
4639  *  \param [in] type - a spatial discretization of the field.
4640  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4641  *  \param [in] mesh - the supporting mesh.
4642  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
4643  *          field of interest lies on. If the field lies on all entities of the given
4644  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
4645  *          using decrRef() as it is no more needed.
4646  *  \param [in] glob - the global data storing profiles and localization.
4647  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
4648  *          field. The caller is to delete this array using decrRef() as it is no more needed.
4649  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4650  *  \throw If no field of \a this is lying on \a mesh.
4651  *  \throw If no field values of the given \a type are available.
4652  */
4653 DataArray *MEDFileAnyTypeField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
4654 {
4655   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4656   int meshId=getMeshIdFromMeshName(mesh->getName().c_str());
4657   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob,nasc);
4658   ret->setName(nasc.getName().c_str());
4659   return ret.retn();
4660 }
4661
4662 //= MEDFileField1TSWithoutSDA
4663
4664 /*!
4665  * Throws if a given value is not a valid (non-extended) relative dimension.
4666  *  \param [in] meshDimRelToMax - the relative dimension value.
4667  *  \throw If \a meshDimRelToMax > 0.
4668  */
4669 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax)
4670 {
4671   if(meshDimRelToMax>0)
4672     throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
4673 }
4674
4675 /*!
4676  * Checks if elements of a given mesh are in the order suitable for writing
4677  * to the MED file. If this is not so, an exception is thrown. In a case of success, returns a
4678  * vector describing types of elements and their number.
4679  *  \param [in] mesh - the mesh to check.
4680  *  \return std::vector<int> - a vector holding for each element type (1) item of
4681  *          INTERP_KERNEL::NormalizedCellType, (2) number of elements, (3) -1.
4682  *          These values are in full-interlace mode.
4683  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4684  */
4685 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh)
4686 {
4687   if(!mesh)
4688     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
4689   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
4690   int nbOfTypes=geoTypes.size();
4691   std::vector<int> code(3*nbOfTypes);
4692   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr1=DataArrayInt::New();
4693   arr1->alloc(nbOfTypes,1);
4694   int *arrPtr=arr1->getPointer();
4695   std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
4696   for(int i=0;i<nbOfTypes;i++,it++)
4697     arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
4698   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
4699   const int *arrPtr2=arr2->getConstPointer();
4700   int i=0;
4701   for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
4702     {
4703       int pos=arrPtr2[i];
4704       int nbCells=mesh->getNumberOfCellsWithType(*it);
4705       code[3*pos]=(int)(*it);
4706       code[3*pos+1]=nbCells;
4707       code[3*pos+2]=-1;//no profiles
4708     }
4709   std::vector<const DataArrayInt *> idsPerType;//no profiles
4710   DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
4711   if(da)
4712     {
4713       da->decrRef();
4714       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
4715     }
4716   return code;
4717 }
4718
4719 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos)
4720 {
4721   return new MEDFileField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4722 }
4723
4724 /*!
4725  * Returns all attributes and values of parts of \a this field lying on a given mesh.
4726  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
4727  * item of every of returned sequences refers to the _i_-th part of \a this field.
4728  * Thus all sequences returned by this method are of the same length equal to number
4729  * of different types of supporting entities.<br>
4730  * A field part can include sub-parts with several different spatial discretizations,
4731  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
4732  * for example. Hence, some of the returned sequences contains nested sequences, and an item
4733  * of a nested sequence corresponds to a type of spatial discretization.<br>
4734  * This method allows for iteration over MEDFile DataStructure with a reduced overhead.
4735  * The overhead is due to selecting values into new instances of DataArrayDouble.
4736  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4737  *          for the case with only one underlying mesh. (Actually, the number of meshes is
4738  *          not checked if \a mname == \c NULL).
4739  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
4740  *          a field part is returned.
4741  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
4742  *          A field part can include sub-parts with several different spatial discretizations,
4743  *          \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and
4744  *          \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT" for example.
4745  *          This sequence is of the same length as \a types.
4746  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
4747  *          discretization. A profile name can be empty.
4748  *          Length of this and of nested sequences is the same as that of \a typesF.
4749  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
4750  *          discretization. A localization name can be empty.
4751  *          Length of this and of nested sequences is the same as that of \a typesF.
4752  *  \return std::vector< std::vector<DataArrayDouble *> > - a sequence holding arrays of values
4753  *          per each type of spatial discretization within one mesh entity type.
4754  *          The caller is to delete each DataArrayDouble using decrRef() as it is no more needed.
4755  *          Length of this and of nested sequences is the same as that of \a typesF.
4756  *  \throw If no field is lying on \a mname.
4757  */
4758 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
4759 {
4760   int meshId=0;
4761   if(mname)
4762     meshId=getMeshIdFromMeshName(mname);
4763   else
4764     if(_field_per_mesh.empty())
4765       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
4766   std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
4767   int nbOfRet=ret0.size();
4768   std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
4769   for(int i=0;i<nbOfRet;i++)
4770     {
4771       const std::vector< std::pair<int,int> >& p=ret0[i];
4772       int nbOfRet1=p.size();
4773       ret[i].resize(nbOfRet1);
4774       for(int j=0;j<nbOfRet1;j++)
4775         {
4776           DataArrayDouble *tmp=_arr->selectByTupleId2(p[j].first,p[j].second,1);
4777           ret[i][j]=tmp;
4778         }
4779     }
4780   return ret;
4781 }
4782
4783 /*!
4784  * Returns a pointer to the underground DataArrayDouble instance. So the
4785  * caller should not decrRef() it. This method allows for a direct access to the field
4786  * values. This method is quite unusable if there is more than a nodal field or a cell
4787  * field on single geometric cell type.
4788  *  \return DataArrayDouble * - the pointer to the field values array.
4789  */
4790 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDouble() const
4791 {
4792   const DataArrayDouble *ret=_arr;
4793   if(ret)
4794     return const_cast<DataArrayDouble *>(ret);
4795   else
4796     return 0;
4797 }
4798
4799 const char *MEDFileField1TSWithoutSDA::getTypeStr() const
4800 {
4801   return TYPE_STR;
4802 }
4803
4804 MEDFileIntField1TSWithoutSDA *MEDFileField1TSWithoutSDA::convertToInt() const
4805 {
4806   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA);
4807   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4808   ret->deepCpyLeavesFrom(*this);
4809   const DataArrayDouble *arr(_arr);
4810   if(arr)
4811     {
4812       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr->convertToIntArr());
4813       ret->setArray(arr2);
4814     }
4815   return ret.retn();
4816 }
4817
4818 /*!
4819  * Returns a pointer to the underground DataArrayDouble instance. So the
4820  * caller should not decrRef() it. This method allows for a direct access to the field
4821  * values. This method is quite unusable if there is more than a nodal field or a cell
4822  * field on single geometric cell type.
4823  *  \return DataArrayDouble * - the pointer to the field values array.
4824  */
4825 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArray() const
4826 {
4827   return getUndergroundDataArrayDouble();
4828 }
4829
4830 /*!
4831  * Returns a pointer to the underground DataArrayDouble instance and a
4832  * sequence describing parameters of a support of each part of \a this field. The
4833  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4834  * direct access to the field values. This method is intended for the field lying on one
4835  * mesh only.
4836  *  \param [in,out] entries - the sequence describing parameters of a support of each
4837  *         part of \a this field. Each item of this sequence consists of two parts. The
4838  *         first part describes a type of mesh entity and an id of discretization of a
4839  *         current field part. The second part describes a range of values [begin,end)
4840  *         within the returned array relating to the current field part.
4841  *  \return DataArrayDouble * - the pointer to the field values array.
4842  *  \throw If the number of underlying meshes is not equal to 1.
4843  *  \throw If no field values are available.
4844  *  \sa getUndergroundDataArray()
4845  */
4846 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDoubleExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
4847 {
4848   if(_field_per_mesh.size()!=1)
4849     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
4850   if(_field_per_mesh[0]==0)
4851     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
4852   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
4853   return getUndergroundDataArrayDouble();
4854 }
4855
4856 /*!
4857  * Returns a pointer to the underground DataArrayDouble instance and a
4858  * sequence describing parameters of a support of each part of \a this field. The
4859  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4860  * direct access to the field values. This method is intended for the field lying on one
4861  * mesh only.
4862  *  \param [in,out] entries - the sequence describing parameters of a support of each
4863  *         part of \a this field. Each item of this sequence consists of two parts. The
4864  *         first part describes a type of mesh entity and an id of discretization of a
4865  *         current field part. The second part describes a range of values [begin,end)
4866  *         within the returned array relating to the current field part.
4867  *  \return DataArrayDouble * - the pointer to the field values array.
4868  *  \throw If the number of underlying meshes is not equal to 1.
4869  *  \throw If no field values are available.
4870  *  \sa getUndergroundDataArray()
4871  */
4872 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
4873 {
4874   return getUndergroundDataArrayDoubleExt(entries);
4875 }
4876
4877 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4878                                                      const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4879 {
4880   DataArrayDouble *arr=getOrCreateAndGetArrayDouble();
4881   arr->setInfoAndChangeNbOfCompo(infos);
4882 }
4883
4884 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4885 {
4886 }
4887
4888 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::shallowCpy() const
4889 {
4890   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA(*this));
4891   ret->deepCpyLeavesFrom(*this);
4892   return ret.retn();
4893 }
4894
4895 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCpy() const
4896 {
4897   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret=static_cast<MEDFileField1TSWithoutSDA *>(shallowCpy());
4898   if((const DataArrayDouble *)_arr)
4899     ret->_arr=_arr->deepCpy();
4900   return ret.retn();
4901 }
4902
4903 void MEDFileField1TSWithoutSDA::setArray(DataArray *arr)
4904 {
4905   if(!arr)
4906     {
4907       _nb_of_tuples_to_be_allocated=-1;
4908       _arr=0;
4909       return ;
4910     }
4911   DataArrayDouble *arrC=dynamic_cast<DataArrayDouble *>(arr);
4912   if(!arrC)
4913     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayDouble !");
4914   else
4915     _nb_of_tuples_to_be_allocated=-3;
4916   arrC->incrRef();
4917   _arr=arrC;
4918 }
4919
4920 DataArray *MEDFileField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
4921 {
4922   return DataArrayDouble::New();
4923 }
4924
4925 DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble()
4926 {
4927   DataArrayDouble *ret=_arr;
4928   if(ret)
4929     return ret;
4930   _arr=DataArrayDouble::New();
4931   return _arr;
4932 }
4933
4934 DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray()
4935 {
4936   return getOrCreateAndGetArrayDouble();
4937 }
4938
4939 const DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble() const
4940 {
4941   const DataArrayDouble *ret=_arr;
4942   if(ret)
4943     return ret;
4944   DataArrayDouble *ret2=DataArrayDouble::New();
4945   const_cast<MEDFileField1TSWithoutSDA *>(this)->_arr=DataArrayDouble::New();
4946   return ret2;
4947 }
4948
4949 const DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray() const
4950 {
4951   return getOrCreateAndGetArrayDouble();
4952 }
4953
4954 //= MEDFileIntField1TSWithoutSDA
4955
4956 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order,
4957                                                                 const std::vector<std::string>& infos)
4958 {
4959   return new MEDFileIntField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4960 }
4961
4962 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4963 {
4964 }
4965
4966 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4967                                                            const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4968 {
4969   DataArrayInt *arr=getOrCreateAndGetArrayInt();
4970   arr->setInfoAndChangeNbOfCompo(infos);
4971 }
4972
4973 const char *MEDFileIntField1TSWithoutSDA::getTypeStr() const
4974 {
4975   return TYPE_STR;
4976 }
4977
4978 MEDFileField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::convertToDouble() const
4979 {
4980   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
4981   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4982   ret->deepCpyLeavesFrom(*this);
4983   const DataArrayInt *arr(_arr);
4984   if(arr)
4985     {
4986       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2(arr->convertToDblArr());
4987       ret->setArray(arr2);
4988     }
4989   return ret.retn();
4990 }
4991
4992 /*!
4993  * Returns a pointer to the underground DataArrayInt instance. So the
4994  * caller should not decrRef() it. This method allows for a direct access to the field
4995  * values. This method is quite unusable if there is more than a nodal field or a cell
4996  * field on single geometric cell type.
4997  *  \return DataArrayInt * - the pointer to the field values array.
4998  */
4999 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArray() const
5000 {
5001   return getUndergroundDataArrayInt();
5002 }
5003
5004 /*!
5005  * Returns a pointer to the underground DataArrayInt instance. So the
5006  * caller should not decrRef() it. This method allows for a direct access to the field
5007  * values. This method is quite unusable if there is more than a nodal field or a cell
5008  * field on single geometric cell type.
5009  *  \return DataArrayInt * - the pointer to the field values array.
5010  */
5011 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayInt() const
5012 {
5013   const DataArrayInt *ret=_arr;
5014   if(ret)
5015     return const_cast<DataArrayInt *>(ret);
5016   else
5017     return 0;
5018 }
5019
5020 /*!
5021  * Returns a pointer to the underground DataArrayInt instance and a
5022  * sequence describing parameters of a support of each part of \a this field. The
5023  * caller should not decrRef() the returned DataArrayInt. This method allows for a
5024  * direct access to the field values. This method is intended for the field lying on one
5025  * mesh only.
5026  *  \param [in,out] entries - the sequence describing parameters of a support of each
5027  *         part of \a this field. Each item of this sequence consists of two parts. The
5028  *         first part describes a type of mesh entity and an id of discretization of a
5029  *         current field part. The second part describes a range of values [begin,end)
5030  *         within the returned array relating to the current field part.
5031  *  \return DataArrayInt * - the pointer to the field values array.
5032  *  \throw If the number of underlying meshes is not equal to 1.
5033  *  \throw If no field values are available.
5034  *  \sa getUndergroundDataArray()
5035  */
5036 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5037 {
5038   return getUndergroundDataArrayIntExt(entries);
5039 }
5040
5041 /*!
5042  * Returns a pointer to the underground DataArrayInt instance and a
5043  * sequence describing parameters of a support of each part of \a this field. The
5044  * caller should not decrRef() the returned DataArrayInt. This method allows for a
5045  * direct access to the field values. This method is intended for the field lying on one
5046  * mesh only.
5047  *  \param [in,out] entries - the sequence describing parameters of a support of each
5048  *         part of \a this field. Each item of this sequence consists of two parts. The
5049  *         first part describes a type of mesh entity and an id of discretization of a
5050  *         current field part. The second part describes a range of values [begin,end)
5051  *         within the returned array relating to the current field part.
5052  *  \return DataArrayInt * - the pointer to the field values array.
5053  *  \throw If the number of underlying meshes is not equal to 1.
5054  *  \throw If no field values are available.
5055  *  \sa getUndergroundDataArray()
5056  */
5057 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5058 {
5059   if(_field_per_mesh.size()!=1)
5060     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
5061   if(_field_per_mesh[0]==0)
5062     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
5063   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
5064   return getUndergroundDataArrayInt();
5065 }
5066
5067 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::shallowCpy() const
5068 {
5069   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA(*this));
5070   ret->deepCpyLeavesFrom(*this);
5071   return ret.retn();
5072 }
5073
5074 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::deepCpy() const
5075 {
5076   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret=static_cast<MEDFileIntField1TSWithoutSDA *>(shallowCpy());
5077   if((const DataArrayInt *)_arr)
5078     ret->_arr=_arr->deepCpy();
5079   return ret.retn();
5080 }
5081
5082 void MEDFileIntField1TSWithoutSDA::setArray(DataArray *arr)
5083 {
5084   if(!arr)
5085     {
5086       _nb_of_tuples_to_be_allocated=-1;
5087       _arr=0;
5088       return ;
5089     }
5090   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>(arr);
5091   if(!arrC)
5092     throw INTERP_KERNEL::Exception("MEDFileIntField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayInt !");
5093   else
5094     _nb_of_tuples_to_be_allocated=-3;
5095   arrC->incrRef();
5096   _arr=arrC;
5097 }
5098
5099 DataArray *MEDFileIntField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
5100 {
5101   return DataArrayInt::New();
5102 }
5103
5104 DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt()
5105 {
5106   DataArrayInt *ret=_arr;
5107   if(ret)
5108     return ret;
5109   _arr=DataArrayInt::New();
5110   return _arr;
5111 }
5112
5113 DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray()
5114 {
5115   return getOrCreateAndGetArrayInt();
5116 }
5117
5118 const DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt() const
5119 {
5120   const DataArrayInt *ret=_arr;
5121   if(ret)
5122     return ret;
5123   DataArrayInt *ret2=DataArrayInt::New();
5124   const_cast<MEDFileIntField1TSWithoutSDA *>(this)->_arr=DataArrayInt::New();
5125   return ret2;
5126 }
5127
5128 const DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray() const
5129 {
5130   return getOrCreateAndGetArrayInt();
5131 }
5132
5133 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
5134 {
5135 }
5136
5137 //= MEDFileAnyTypeField1TS
5138
5139 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll)
5140 {
5141   med_field_type typcha;
5142   //
5143   std::vector<std::string> infos;
5144   std::string dtunit,fieldName;
5145   LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
5146   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5147   switch(typcha)
5148     {
5149     case MED_FLOAT64:
5150       {
5151         ret=MEDFileField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5152         break;
5153       }
5154     case MED_INT32:
5155       {
5156         ret=MEDFileIntField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5157         break;
5158       }
5159     default:
5160       {
5161         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] !";
5162         throw INTERP_KERNEL::Exception(oss.str().c_str());
5163       }
5164     }
5165   ret->setDtUnit(dtunit.c_str());
5166   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5167   //
5168   med_int numdt,numit;
5169   med_float dt;
5170   MEDfieldComputingStepInfo(fid,fieldName.c_str(),1,&numdt,&numit,&dt);
5171   ret->setTime(numdt,numit,dt);
5172   ret->_csit=1;
5173   if(loadAll)
5174     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5175   else
5176     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5177   return ret.retn();
5178 }
5179
5180 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, bool loadAll)
5181 try:MEDFileFieldGlobsReal(fileName)
5182 {
5183   MEDFileUtilities::CheckFileForRead(fileName);
5184   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5185   _content=BuildContentFrom(fid,fileName,loadAll);
5186   loadGlobals(fid);
5187 }
5188 catch(INTERP_KERNEL::Exception& e)
5189   {
5190     throw e;
5191   }
5192
5193 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll)
5194 {
5195   med_field_type typcha;
5196   std::vector<std::string> infos;
5197   std::string dtunit;
5198   int iii=-1;
5199   int nbSteps=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5200   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5201   switch(typcha)
5202     {
5203     case MED_FLOAT64:
5204       {
5205         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5206         break;
5207       }
5208     case MED_INT32:
5209       {
5210         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5211         break;
5212       }
5213     default:
5214       {
5215         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] !";
5216         throw INTERP_KERNEL::Exception(oss.str().c_str());
5217       }
5218     }
5219   ret->setDtUnit(dtunit.c_str());
5220   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5221   //
5222   if(nbSteps<1)
5223     {
5224       std::ostringstream oss; oss << "MEDFileField1TS(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but there is no time steps on it !";
5225       throw INTERP_KERNEL::Exception(oss.str().c_str());
5226     }
5227   //
5228   med_int numdt,numit;
5229   med_float dt;
5230   MEDfieldComputingStepInfo(fid,fieldName,1,&numdt,&numit,&dt);
5231   ret->setTime(numdt,numit,dt);
5232   ret->_csit=1;
5233   if(loadAll)
5234     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5235   else
5236     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5237   return ret.retn();
5238 }
5239
5240 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, bool loadAll)
5241 try:MEDFileFieldGlobsReal(fileName)
5242 {
5243   MEDFileUtilities::CheckFileForRead(fileName);
5244   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5245   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
5246   loadGlobals(fid);
5247 }
5248 catch(INTERP_KERNEL::Exception& e)
5249   {
5250     throw e;
5251   }
5252
5253 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c, const char *fileName)
5254 {
5255   if(!c)
5256     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
5257   if(dynamic_cast<const MEDFileField1TSWithoutSDA *>(c))
5258     {
5259       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New();
5260       ret->setFileName(fileName);
5261       ret->_content=c; c->incrRef();
5262       return ret.retn();
5263     }
5264   if(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(c))
5265     {
5266       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New();
5267       ret->setFileName(fileName);
5268       ret->_content=c; c->incrRef();
5269       return ret.retn();
5270     }
5271   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
5272 }
5273
5274 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, bool loadAll)
5275 {
5276   MEDFileUtilities::CheckFileForRead(fileName);
5277   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5278   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
5279   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5280   ret->loadGlobals(fid);
5281   return ret.retn();
5282 }
5283
5284 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, bool loadAll)
5285 {
5286   MEDFileUtilities::CheckFileForRead(fileName);
5287   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5288   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
5289   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5290   ret->loadGlobals(fid);
5291   return ret.retn();
5292 }
5293
5294 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
5295 {
5296   MEDFileUtilities::CheckFileForRead(fileName);
5297   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5298   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5299   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5300   ret->loadGlobals(fid);
5301   return ret.retn();
5302 }
5303
5304 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
5305 {
5306   med_field_type typcha;
5307   std::vector<std::string> infos;
5308   std::string dtunit;
5309   int iii=-1;
5310   int nbOfStep2=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5311   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5312   switch(typcha)
5313     {
5314     case MED_FLOAT64:
5315       {
5316         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5317         break;
5318       }
5319     case MED_INT32:
5320       {
5321         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5322         break;
5323       }
5324     default:
5325       {
5326         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] !";
5327         throw INTERP_KERNEL::Exception(oss.str().c_str());
5328       }
5329     }
5330   ret->setDtUnit(dtunit.c_str());
5331   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5332   //
5333   bool found=false;
5334   std::vector< std::pair<int,int> > dtits(nbOfStep2);
5335   for(int i=0;i<nbOfStep2 && !found;i++)
5336     {
5337       med_int numdt,numit;
5338       med_float dt;
5339       MEDfieldComputingStepInfo(fid,fieldName,i+1,&numdt,&numit,&dt);
5340       if(numdt==iteration && numit==order)
5341         {
5342           found=true;
5343           ret->_csit=i+1;
5344         }
5345       else
5346         dtits[i]=std::pair<int,int>(numdt,numit);
5347     }
5348   if(!found)
5349     {
5350       std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << fileName << "' ! Available iterations are : ";
5351       for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
5352         oss << "(" << (*iter).first << "," << (*iter).second << "), ";
5353       throw INTERP_KERNEL::Exception(oss.str().c_str());
5354     }
5355   if(loadAll)
5356     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5357   else
5358     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5359   return ret.retn();
5360 }
5361
5362 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
5363 try:MEDFileFieldGlobsReal(fileName)
5364 {
5365   MEDFileUtilities::CheckFileForRead(fileName);
5366   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5367   _content=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5368   loadGlobals(fid);
5369 }
5370 catch(INTERP_KERNEL::Exception& e)
5371   {
5372     throw e;
5373   }
5374
5375 /*!
5376  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5377  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5378  *
5379  * \warning this is a shallow copy constructor
5380  */
5381 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent)
5382 {
5383   if(!shallowCopyOfContent)
5384     {
5385       const MEDFileAnyTypeField1TSWithoutSDA *otherPtr(&other);
5386       otherPtr->incrRef();
5387       _content=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(otherPtr);
5388     }
5389   else
5390     {
5391       _content=other.shallowCpy();
5392     }
5393 }
5394
5395 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)
5396 {
5397   if(checkFieldId)
5398     {
5399       int nbFields=MEDnField(fid);
5400       if(fieldIdCFormat>=nbFields)
5401         {
5402           std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << fileName << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
5403           throw INTERP_KERNEL::Exception(oss.str().c_str());
5404         }
5405     }
5406   int ncomp=MEDfieldnComponent(fid,fieldIdCFormat+1);
5407   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5408   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5409   INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5410   INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5411   INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5412   med_bool localMesh;
5413   int nbOfStep;
5414   MEDfieldInfo(fid,fieldIdCFormat+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
5415   fieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
5416   dtunitOut=MEDLoaderBase::buildStringFromFortran(dtunit,MED_LNAME_SIZE);
5417   infos.clear(); infos.resize(ncomp);
5418   for(int j=0;j<ncomp;j++)
5419     infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
5420   return nbOfStep;
5421 }
5422
5423 /*!
5424  * This method throws an INTERP_KERNEL::Exception if \a fieldName field is not in file pointed by \a fid and with name \a fileName.
5425  *
5426  * \param [out]
5427  * \return in case of success the number of time steps available for the field with name \a fieldName.
5428  */
5429 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)
5430 {
5431   int nbFields=MEDnField(fid);
5432   bool found=false;
5433   std::vector<std::string> fns(nbFields);
5434   int nbOfStep2=-1;
5435   for(int i=0;i<nbFields && !found;i++)
5436     {
5437       std::string tmp;
5438       nbOfStep2=LocateField2(fid,fileName,i,false,tmp,typcha,infos,dtunitOut);
5439       fns[i]=tmp;
5440       found=(tmp==fieldName);
5441       if(found)
5442         posCFormat=i;
5443     }
5444   if(!found)
5445     {
5446       std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << fileName << "' ! Available fields are : ";
5447       for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
5448         oss << "\"" << *it << "\" ";
5449       throw INTERP_KERNEL::Exception(oss.str().c_str());
5450     }
5451   return nbOfStep2;
5452 }
5453
5454 /*!
5455  * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5456  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5457  * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5458  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5459  * to keep a valid instance.
5460  * 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.
5461  * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
5462  * 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.
5463  *
5464  * \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.
5465  * \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.
5466  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5467  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5468  * \param [in] newLocName is the new localization name.
5469  * \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.
5470  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
5471  */
5472 void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newPflName, bool forceRenameOnGlob)
5473 {
5474   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5475   std::string oldPflName=disc->getProfile();
5476   std::vector<std::string> vv=getPflsReallyUsedMulti();
5477   int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
5478   if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
5479     {
5480       disc->setProfile(newPflName);
5481       DataArrayInt *pfl=getProfile(oldPflName.c_str());
5482       pfl->setName(newPflName);
5483     }
5484   else
5485     {
5486       std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
5487       throw INTERP_KERNEL::Exception(oss.str().c_str());
5488     }
5489 }
5490
5491 /*!
5492  * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5493  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5494  * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5495  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5496  * to keep a valid instance.
5497  * 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.
5498  * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
5499  * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
5500  * 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.
5501  *
5502  * \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.
5503  * \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.
5504  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5505  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5506  * \param [in] newLocName is the new localization name.
5507  * \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.
5508  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
5509  */
5510 void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newLocName, bool forceRenameOnGlob)
5511 {
5512   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5513   std::string oldLocName=disc->getLocalization();
5514   std::vector<std::string> vv=getLocsReallyUsedMulti();
5515   int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
5516   if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
5517     {
5518       disc->setLocalization(newLocName);
5519       MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
5520       loc.setName(newLocName);
5521     }
5522   else
5523     {
5524       std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
5525       throw INTERP_KERNEL::Exception(oss.str().c_str());
5526     }
5527 }
5528
5529 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase()
5530 {
5531   MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5532   if(!ret)
5533     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : content is expected to be not null !");
5534   return ret;
5535 }
5536
5537 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() const
5538 {
5539   const MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5540   if(!ret)
5541     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : const content is expected to be not null !");
5542   return ret;
5543 }
5544
5545 /*!
5546  * Writes \a this field into a MED file specified by its name.
5547  *  \param [in] fileName - the MED file name.
5548  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
5549  * - 2 - erase; an existing file is removed.
5550  * - 1 - append; same data should not be present in an existing file.
5551  * - 0 - overwrite; same data present in an existing file is overwritten.
5552  *  \throw If the field name is not set.
5553  *  \throw If no field data is set.
5554  *  \throw If \a mode == 1 and the same data is present in an existing file.
5555  */
5556 void MEDFileAnyTypeField1TS::write(const char *fileName, int mode) const
5557 {
5558   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
5559   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
5560   writeLL(fid);
5561 }
5562
5563 /*!
5564  * This method alloc the arrays and load potentially huge arrays contained in this field.
5565  * This method should be called when a MEDFileAnyTypeField1TS::New constructor has been with false as the last parameter.
5566  * This method can be also called to refresh or reinit values from a file.
5567  *
5568  * \throw If the fileName is not set or points to a non readable MED file.
5569  * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5570  */
5571 void MEDFileAnyTypeField1TS::loadArrays()
5572 {
5573   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5574   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
5575 }
5576
5577 /*!
5578  * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
5579  * But once data loaded once, this method does nothing.
5580  *
5581  * \throw If the fileName is not set or points to a non readable MED file.
5582  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::unloadArrays
5583  */
5584 void MEDFileAnyTypeField1TS::loadArraysIfNecessary()
5585 {
5586   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5587   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
5588 }
5589
5590 /*!
5591  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
5592  * This method does not release arrays set outside the context of a MED file.
5593  *
5594  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary
5595  */
5596 void MEDFileAnyTypeField1TS::unloadArrays()
5597 {
5598   contentNotNullBase()->unloadArrays();
5599 }
5600
5601 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const
5602 {
5603   int nbComp=getNumberOfComponents();
5604   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5605   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5606   for(int i=0;i<nbComp;i++)
5607     {
5608       std::string info=getInfo()[i];
5609       std::string c,u;
5610       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
5611       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
5612       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
5613     }
5614   if(getName().empty())
5615     throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
5616   MEDfieldCr(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
5617   writeGlobals(fid,*this);
5618   contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
5619 }
5620
5621 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySizeWithoutChildren() const
5622 {
5623   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
5624 }
5625
5626 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TS::getDirectChildren() const
5627 {
5628   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
5629   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5630     ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)_content);
5631   return ret;
5632 }
5633
5634 /*!
5635  * Returns a string describing \a this field. This string is outputted
5636  * by \c print Python command.
5637  */
5638 std::string MEDFileAnyTypeField1TS::simpleRepr() const
5639 {
5640   std::ostringstream oss;
5641   contentNotNullBase()->simpleRepr(0,oss,-1);
5642   simpleReprGlobs(oss);
5643   return oss.str();
5644 }
5645
5646 /*!
5647  * This method returns all profiles whose name is non empty used.
5648  * \b WARNING If profile is used several times it will be reported \b only \b once.
5649  * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
5650  */
5651 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
5652 {
5653   return contentNotNullBase()->getPflsReallyUsed2();
5654 }
5655
5656 /*!
5657  * This method returns all localizations whose name is non empty used.
5658  * \b WARNING If localization is used several times it will be reported \b only \b once.
5659  */
5660 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
5661 {
5662   return contentNotNullBase()->getLocsReallyUsed2();
5663 }
5664
5665 /*!
5666  * This method returns all profiles whose name is non empty used.
5667  * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
5668  */
5669 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
5670 {
5671   return contentNotNullBase()->getPflsReallyUsedMulti2();
5672 }
5673
5674 /*!
5675  * This method returns all localizations whose name is non empty used.
5676  * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
5677  */
5678 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
5679 {
5680   return contentNotNullBase()->getLocsReallyUsedMulti2();
5681 }
5682
5683 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5684 {
5685   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
5686 }
5687
5688 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5689 {
5690   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
5691 }
5692
5693 int MEDFileAnyTypeField1TS::getDimension() const
5694 {
5695   return contentNotNullBase()->getDimension();
5696 }
5697
5698 int MEDFileAnyTypeField1TS::getIteration() const
5699 {
5700   return contentNotNullBase()->getIteration();
5701 }
5702
5703 int MEDFileAnyTypeField1TS::getOrder() const
5704 {
5705   return contentNotNullBase()->getOrder();
5706 }
5707
5708 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
5709 {
5710   return contentNotNullBase()->getTime(iteration,order);
5711 }
5712
5713 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
5714 {
5715   contentNotNullBase()->setTime(iteration,order,val);
5716 }
5717
5718 std::string MEDFileAnyTypeField1TS::getName() const
5719 {
5720   return contentNotNullBase()->getName();
5721 }
5722
5723 void MEDFileAnyTypeField1TS::setName(const char *name)
5724 {
5725   contentNotNullBase()->setName(name);
5726 }
5727
5728 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
5729 {
5730   contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
5731 }
5732
5733 std::string MEDFileAnyTypeField1TS::getDtUnit() const
5734 {
5735   return contentNotNullBase()->getDtUnit();
5736 }
5737
5738 void MEDFileAnyTypeField1TS::setDtUnit(const char *dtUnit)
5739 {
5740   contentNotNullBase()->setDtUnit(dtUnit);
5741 }
5742
5743 std::string MEDFileAnyTypeField1TS::getMeshName() const
5744 {
5745   return contentNotNullBase()->getMeshName();
5746 }
5747
5748 void MEDFileAnyTypeField1TS::setMeshName(const char *newMeshName)
5749 {
5750   contentNotNullBase()->setMeshName(newMeshName);
5751 }
5752
5753 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
5754 {
5755   return contentNotNullBase()->changeMeshNames(modifTab);
5756 }
5757
5758 int MEDFileAnyTypeField1TS::getMeshIteration() const
5759 {
5760   return contentNotNullBase()->getMeshIteration();
5761 }
5762
5763 int MEDFileAnyTypeField1TS::getMeshOrder() const
5764 {
5765   return contentNotNullBase()->getMeshOrder();
5766 }
5767
5768 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
5769 {
5770   return contentNotNullBase()->getNumberOfComponents();
5771 }
5772
5773 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
5774 {
5775   return contentNotNullBase()->isDealingTS(iteration,order);
5776 }
5777
5778 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
5779 {
5780   return contentNotNullBase()->getDtIt();
5781 }
5782
5783 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
5784 {
5785   contentNotNullBase()->fillIteration(p);
5786 }
5787
5788 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
5789 {
5790   contentNotNullBase()->fillTypesOfFieldAvailable(types);
5791 }
5792
5793 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos)
5794 {
5795   contentNotNullBase()->setInfo(infos);
5796 }
5797
5798 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
5799 {
5800   return contentNotNullBase()->getInfo();
5801 }
5802 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
5803 {
5804   return contentNotNullBase()->getInfo();
5805 }
5806
5807 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
5808 {
5809   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5810 }
5811
5812 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
5813 {
5814   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5815 }
5816
5817 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const
5818 {
5819   return contentNotNullBase()->getNonEmptyLevels(mname,levs);
5820 }
5821
5822 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const
5823 {
5824   return contentNotNullBase()->getTypesOfFieldAvailable();
5825 }
5826
5827 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,
5828                                                                                        std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5829 {
5830   return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
5831 }
5832
5833 /*!
5834  * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
5835  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5836  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
5837  */
5838 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const
5839 {
5840   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5841   if(!content)
5842     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
5843   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
5844   std::size_t sz(contentsSplit.size());
5845   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5846   for(std::size_t i=0;i<sz;i++)
5847     {
5848       ret[i]=shallowCpy();
5849       ret[i]->_content=contentsSplit[i];
5850     }
5851   return ret;
5852 }
5853
5854 /*!
5855  * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
5856  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5857  */
5858 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const
5859 {
5860   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5861   if(!content)
5862     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
5863   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitDiscretizations();
5864   std::size_t sz(contentsSplit.size());
5865   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5866   for(std::size_t i=0;i<sz;i++)
5867     {
5868       ret[i]=shallowCpy();
5869       ret[i]->_content=contentsSplit[i];
5870     }
5871   return ret;
5872 }
5873
5874 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCpy() const
5875 {
5876   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=shallowCpy();
5877   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5878     ret->_content=_content->deepCpy();
5879   ret->deepCpyGlobs(*this);
5880   return ret.retn();
5881 }
5882
5883 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
5884 {
5885   return contentNotNullBase()->copyTinyInfoFrom(field,arr);
5886 }
5887
5888 //= MEDFileField1TS
5889
5890 /*!
5891  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5892  * the first field that has been read from a specified MED file.
5893  *  \param [in] fileName - the name of the MED file to read.
5894  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5895  *          is to delete this field using decrRef() as it is no more needed.
5896  *  \throw If reading the file fails.
5897  */
5898 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, bool loadAll)
5899 {
5900   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,loadAll);
5901   ret->contentNotNull();
5902   return ret.retn();
5903 }
5904
5905 /*!
5906  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5907  * a given field that has been read from a specified MED file.
5908  *  \param [in] fileName - the name of the MED file to read.
5909  *  \param [in] fieldName - the name of the field to read.
5910  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5911  *          is to delete this field using decrRef() as it is no more needed.
5912  *  \throw If reading the file fails.
5913  *  \throw If there is no field named \a fieldName in the file.
5914  */
5915 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, bool loadAll)
5916 {
5917   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,loadAll);
5918   ret->contentNotNull();
5919   return ret.retn();
5920 }
5921
5922 /*!
5923  * Returns a new instance of MEDFileField1TS holding data of a given time step of
5924  * a given field that has been read from a specified MED file.
5925  *  \param [in] fileName - the name of the MED file to read.
5926  *  \param [in] fieldName - the name of the field to read.
5927  *  \param [in] iteration - the iteration number of a required time step.
5928  *  \param [in] order - the iteration order number of required time step.
5929  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5930  *          is to delete this field using decrRef() as it is no more needed.
5931  *  \throw If reading the file fails.
5932  *  \throw If there is no field named \a fieldName in the file.
5933  *  \throw If the required time step is missing from the file.
5934  */
5935 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
5936 {
5937   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,iteration,order,loadAll);
5938   ret->contentNotNull();
5939   return ret.retn();
5940 }
5941
5942 /*!
5943  * Returns a new instance of MEDFileField1TS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5944  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5945  *
5946  * Returns a new instance of MEDFileField1TS holding either a shallow copy
5947  * of a given MEDFileField1TSWithoutSDA ( \a other ) or \a other itself.
5948  * \warning this is a shallow copy constructor
5949  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
5950  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
5951  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5952  *          is to delete this field using decrRef() as it is no more needed.
5953  */
5954 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5955 {
5956   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(other,shallowCopyOfContent);
5957   ret->contentNotNull();
5958   return ret.retn();
5959 }
5960
5961 /*!
5962  * Returns a new empty instance of MEDFileField1TS.
5963  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5964  *          is to delete this field using decrRef() as it is no more needed.
5965  */
5966 MEDFileField1TS *MEDFileField1TS::New()
5967 {
5968   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS;
5969   ret->contentNotNull();
5970   return ret.retn();
5971 }
5972
5973 /*!
5974  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
5975  * following the given input policy.
5976  *
5977  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
5978  *                            By default (true) the globals are deeply copied.
5979  * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
5980  */
5981 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool deepCpyGlobs) const
5982 {
5983   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret;
5984   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5985   if(content)
5986     {
5987       const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
5988       if(!contc)
5989         throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
5990       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
5991       ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc,getFileName()));
5992     }
5993   else
5994     ret=MEDFileIntField1TS::New();
5995   if(deepCpyGlobs)
5996     ret->deepCpyGlobs(*this);
5997   else
5998     ret->shallowCpyGlobs(*this);
5999   return ret.retn();
6000 }
6001
6002 const MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() const
6003 {
6004   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6005   if(!pt)
6006     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is null !");
6007   const MEDFileField1TSWithoutSDA *ret=dynamic_cast<const MEDFileField1TSWithoutSDA *>(pt);
6008   if(!ret)
6009     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 !");
6010   return ret;
6011 }
6012
6013 MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull()
6014 {
6015   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6016   if(!pt)
6017     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is null !");
6018   MEDFileField1TSWithoutSDA *ret=dynamic_cast<MEDFileField1TSWithoutSDA *>(pt);
6019   if(!ret)
6020     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 !");
6021   return ret;
6022 }
6023
6024 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6025 {
6026   if(!f)
6027     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
6028   if(!((DataArray*)arr))
6029     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
6030   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6031   if(!arrOutC)
6032     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6033   f->setArray(arrOutC);
6034 }
6035
6036 DataArrayDouble *MEDFileField1TS::ReturnSafelyDataArrayDouble(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6037 {
6038   if(!((DataArray*)arr))
6039     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : no array !");
6040   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6041   if(!arrOutC)
6042     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6043   arrOutC->incrRef();
6044   return arrOutC;
6045 }
6046
6047 MEDFileField1TS::MEDFileField1TS(const char *fileName, bool loadAll)
6048 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6049 {
6050 }
6051 catch(INTERP_KERNEL::Exception& e)
6052   { throw e; }
6053
6054 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, bool loadAll)
6055 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6056 {
6057 }
6058 catch(INTERP_KERNEL::Exception& e)
6059   { throw e; }
6060
6061 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
6062 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6063 {
6064 }
6065 catch(INTERP_KERNEL::Exception& e)
6066   { throw e; }
6067
6068 /*!
6069  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6070  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6071  *
6072  * \warning this is a shallow copy constructor
6073  */
6074 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
6075 try:MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6076 {
6077 }
6078 catch(INTERP_KERNEL::Exception& e)
6079   { throw e; }
6080
6081 MEDFileField1TS::MEDFileField1TS()
6082 {
6083   _content=new MEDFileField1TSWithoutSDA;
6084 }
6085
6086 /*!
6087  * Returns a new MEDCouplingFieldDouble of a given type lying on
6088  * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6089  * has not been constructed via file reading, an exception is thrown.
6090  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6091  *  \param [in] type - a spatial discretization of interest.
6092  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6093  *  \param [in] renumPol - specifies how to permute values of the result field according to
6094  *          the optional numbers of cells and nodes, if any. The valid values are
6095  *          - 0 - do not permute.
6096  *          - 1 - permute cells.
6097  *          - 2 - permute nodes.
6098  *          - 3 - permute cells and nodes.
6099  *
6100  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6101  *          caller is to delete this field using decrRef() as it is no more needed.
6102  *  \throw If \a this field has not been constructed via file reading.
6103  *  \throw If the MED file is not readable.
6104  *  \throw If there is no mesh in the MED file.
6105  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6106  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6107  *  \sa getFieldOnMeshAtLevel()
6108  */
6109 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const
6110 {
6111   if(getFileName2().empty())
6112     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6113   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6114   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNull());
6115   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6116   return ret.retn();
6117 }
6118
6119 /*!
6120  * Returns a new MEDCouplingFieldDouble of a given type lying on
6121  * the top level cells of the first mesh in MED file. If \a this field
6122  * has not been constructed via file reading, an exception is thrown.
6123  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6124  *  \param [in] type - a spatial discretization of interest.
6125  *  \param [in] renumPol - specifies how to permute values of the result field according to
6126  *          the optional numbers of cells and nodes, if any. The valid values are
6127  *          - 0 - do not permute.
6128  *          - 1 - permute cells.
6129  *          - 2 - permute nodes.
6130  *          - 3 - permute cells and nodes.
6131  *
6132  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6133  *          caller is to delete this field using decrRef() as it is no more needed.
6134  *  \throw If \a this field has not been constructed via file reading.
6135  *  \throw If the MED file is not readable.
6136  *  \throw If there is no mesh in the MED file.
6137  *  \throw If no field values of the given \a type.
6138  *  \throw If no field values lying on the top level support.
6139  *  \sa getFieldAtLevel()
6140  */
6141 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const
6142 {
6143   if(getFileName2().empty())
6144     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6145   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6146   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNull());
6147   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6148   return ret.retn();
6149 }
6150
6151 /*!
6152  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6153  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6154  *  \param [in] type - a spatial discretization of the new field.
6155  *  \param [in] mesh - the supporting mesh.
6156  *  \param [in] renumPol - specifies how to permute values of the result field according to
6157  *          the optional numbers of cells and nodes, if any. The valid values are
6158  *          - 0 - do not permute.
6159  *          - 1 - permute cells.
6160  *          - 2 - permute nodes.
6161  *          - 3 - permute cells and nodes.
6162  *
6163  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6164  *          caller is to delete this field using decrRef() as it is no more needed.
6165  *  \throw If no field of \a this is lying on \a mesh.
6166  *  \throw If the mesh is empty.
6167  *  \throw If no field values of the given \a type are available.
6168  *  \sa getFieldAtLevel()
6169  *  \sa getFieldOnMeshAtLevel()
6170  */
6171 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const
6172 {
6173   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6174   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull());
6175   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6176   return ret.retn();
6177 }
6178
6179 /*!
6180  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6181  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6182  *  \param [in] type - a spatial discretization of interest.
6183  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6184  *  \param [in] mesh - the supporting mesh.
6185  *  \param [in] renumPol - specifies how to permute values of the result field according to
6186  *          the optional numbers of cells and nodes, if any. The valid values are
6187  *          - 0 - do not permute.
6188  *          - 1 - permute cells.
6189  *          - 2 - permute nodes.
6190  *          - 3 - permute cells and nodes.
6191  *
6192  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6193  *          caller is to delete this field using decrRef() as it is no more needed.
6194  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6195  *  \throw If no field of \a this is lying on \a mesh.
6196  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6197  *  \sa getFieldAtLevel()
6198  *  \sa getFieldOnMeshAtLevel()
6199  */
6200 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
6201 {
6202   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6203   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull());
6204   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6205   return ret.retn();
6206 }
6207
6208 /*!
6209  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6210  * This method is called "Old" because in MED3 norm a field has only one meshName
6211  * attached, so this method is for readers of MED2 files. If \a this field
6212  * has not been constructed via file reading, an exception is thrown.
6213  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6214  *  \param [in] type - a spatial discretization of interest.
6215  *  \param [in] mName - a name of the supporting mesh.
6216  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6217  *  \param [in] renumPol - specifies how to permute values of the result field according to
6218  *          the optional numbers of cells and nodes, if any. The valid values are
6219  *          - 0 - do not permute.
6220  *          - 1 - permute cells.
6221  *          - 2 - permute nodes.
6222  *          - 3 - permute cells and nodes.
6223  *
6224  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6225  *          caller is to delete this field using decrRef() as it is no more needed.
6226  *  \throw If the MED file is not readable.
6227  *  \throw If there is no mesh named \a mName in the MED file.
6228  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6229  *  \throw If \a this field has not been constructed via file reading.
6230  *  \throw If no field of \a this is lying on the mesh named \a mName.
6231  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6232  *  \sa getFieldAtLevel()
6233  */
6234 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, int renumPol) const
6235 {
6236   if(getFileName2().empty())
6237     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6238   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6239   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
6240   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6241   return ret.retn();
6242 }
6243
6244 /*!
6245  * Returns values and a profile of the field of a given type lying on a given support.
6246  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6247  *  \param [in] type - a spatial discretization of the field.
6248  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6249  *  \param [in] mesh - the supporting mesh.
6250  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6251  *          field of interest lies on. If the field lies on all entities of the given
6252  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6253  *          using decrRef() as it is no more needed.
6254  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
6255  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6256  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6257  *  \throw If no field of \a this is lying on \a mesh.
6258  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6259  */
6260 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6261 {
6262   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6263   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
6264 }
6265
6266 /*!
6267  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6268  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6269  * "Sort By Type"), if not, an exception is thrown.
6270  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6271  *  \param [in] field - the field to add to \a this.
6272  *  \throw If the name of \a field is empty.
6273  *  \throw If the data array of \a field is not set.
6274  *  \throw If the data array is already allocated but has different number of components
6275  *         than \a field.
6276  *  \throw If the underlying mesh of \a field has no name.
6277  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6278  */
6279 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
6280 {
6281   setFileName("");
6282   contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
6283 }
6284
6285 /*!
6286  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6287  * can be an aggregation of several MEDCouplingFieldDouble instances.
6288  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6289  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6290  * and \a profile.
6291  *
6292  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6293  * A new profile is added only if no equal profile is missing.
6294  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6295  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
6296  *  \param [in] mesh - the supporting mesh of \a field.
6297  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6298  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6299  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6300  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6301  *  \throw If the data array of \a field is not set.
6302  *  \throw If the data array of \a this is already allocated but has different number of
6303  *         components than \a field.
6304  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6305  *  \sa setFieldNoProfileSBT()
6306  */
6307 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6308 {
6309   setFileName("");
6310   contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6311 }
6312
6313 MEDFileAnyTypeField1TS *MEDFileField1TS::shallowCpy() const
6314 {
6315   return new MEDFileField1TS(*this);
6316 }
6317
6318 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const
6319 {
6320   return contentNotNull()->getUndergroundDataArrayDouble();
6321 }
6322
6323 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6324 {
6325   return contentNotNull()->getUndergroundDataArrayDoubleExt(entries);
6326 }
6327
6328 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6329                                                                                       std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
6330 {
6331   return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
6332 }
6333
6334 //= MEDFileIntField1TS
6335
6336 MEDFileIntField1TS *MEDFileIntField1TS::New()
6337 {
6338   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS;
6339   ret->contentNotNull();
6340   return ret.retn();
6341 }
6342
6343 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, bool loadAll)
6344 {
6345   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,loadAll);
6346   ret->contentNotNull();
6347   return ret.retn();
6348 }
6349
6350 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, bool loadAll)
6351 {
6352   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,loadAll);
6353   ret->contentNotNull();
6354   return ret.retn();
6355 }
6356
6357 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
6358 {
6359   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,iteration,order,loadAll);
6360   ret->contentNotNull();
6361   return ret.retn();
6362 }
6363
6364 MEDFileIntField1TS *MEDFileIntField1TS::New(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent)
6365 {
6366   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(other,shallowCopyOfContent);
6367   ret->contentNotNull();
6368   return ret.retn();
6369 }
6370
6371 MEDFileIntField1TS::MEDFileIntField1TS()
6372 {
6373   _content=new MEDFileIntField1TSWithoutSDA;
6374 }
6375
6376 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, bool loadAll)
6377 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6378 {
6379 }
6380 catch(INTERP_KERNEL::Exception& e)
6381   { throw e; }
6382
6383 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, bool loadAll)
6384 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6385 {
6386 }
6387 catch(INTERP_KERNEL::Exception& e)
6388   { throw e; }
6389
6390 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll)
6391 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6392 {
6393 }
6394 catch(INTERP_KERNEL::Exception& e)
6395   { throw e; }
6396
6397 /*!
6398  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6399  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6400  *
6401  * \warning this is a shallow copy constructor
6402  */
6403 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6404 {
6405 }
6406
6407 MEDFileAnyTypeField1TS *MEDFileIntField1TS::shallowCpy() const
6408 {
6409   return new MEDFileIntField1TS(*this);
6410 }
6411
6412 /*!
6413  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
6414  * following the given input policy.
6415  *
6416  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6417  *                            By default (true) the globals are deeply copied.
6418  * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
6419  */
6420 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool deepCpyGlobs) const
6421 {
6422   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret;
6423   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6424   if(content)
6425     {
6426       const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
6427       if(!contc)
6428         throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
6429       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
6430       ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc,getFileName()));
6431     }
6432   else
6433     ret=MEDFileField1TS::New();
6434   if(deepCpyGlobs)
6435     ret->deepCpyGlobs(*this);
6436   else
6437     ret->shallowCpyGlobs(*this);
6438   return ret.retn();
6439 }
6440
6441 /*!
6442  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6443  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6444  * "Sort By Type"), if not, an exception is thrown.
6445  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6446  *  \param [in] field - the field to add to \a this. The field double values are ignored.
6447  *  \param [in] arrOfVals - the values of the field \a field used.
6448  *  \throw If the name of \a field is empty.
6449  *  \throw If the data array of \a field is not set.
6450  *  \throw If the data array is already allocated but has different number of components
6451  *         than \a field.
6452  *  \throw If the underlying mesh of \a field has no name.
6453  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6454  */
6455 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
6456 {
6457   setFileName("");
6458   contentNotNull()->setFieldNoProfileSBT(field,arrOfVals,*this,*contentNotNull());
6459 }
6460
6461 /*!
6462  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6463  * can be an aggregation of several MEDCouplingFieldDouble instances.
6464  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6465  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6466  * and \a profile.
6467  *
6468  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6469  * A new profile is added only if no equal profile is missing.
6470  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6471  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
6472  *  \param [in] arrOfVals - the values of the field \a field used.
6473  *  \param [in] mesh - the supporting mesh of \a field.
6474  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6475  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6476  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6477  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6478  *  \throw If the data array of \a field is not set.
6479  *  \throw If the data array of \a this is already allocated but has different number of
6480  *         components than \a field.
6481  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6482  *  \sa setFieldNoProfileSBT()
6483  */
6484 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6485 {
6486   setFileName("");
6487   contentNotNull()->setFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6488 }
6489
6490 const MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() const
6491 {
6492   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6493   if(!pt)
6494     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is null !");
6495   const MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(pt);
6496   if(!ret)
6497     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 !");
6498   return ret;
6499 }
6500
6501 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6502 {
6503   if(getFileName2().empty())
6504     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6505   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut2;
6506   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut2,*contentNotNull());
6507   DataArrayInt *arrOutC=dynamic_cast<DataArrayInt *>((DataArray *)arrOut2);
6508   if(!arrOutC)
6509     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : mismatch between dataArrays type and MEDFileIntField1TS ! Expected int32 !");
6510   arrOut=arrOutC;
6511   return ret.retn();
6512 }
6513
6514 DataArrayInt *MEDFileIntField1TS::ReturnSafelyDataArrayInt(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6515 {
6516   if(!((DataArray *)arr))
6517     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is NULL !");
6518   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>((DataArray *)arr);
6519   if(!arrC)
6520     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is not of type INT32 !");
6521   arrC->incrRef();
6522   return arrC;
6523 }
6524
6525 /*!
6526  * Returns a new MEDCouplingFieldDouble of a given type lying on
6527  * the top level cells of the first mesh in MED file. If \a this field
6528  * has not been constructed via file reading, an exception is thrown.
6529  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6530  *  \param [in] type - a spatial discretization of interest.
6531  *  \param [out] arrOut - the DataArrayInt containing values of field.
6532  *  \param [in] renumPol - specifies how to permute values of the result field according to
6533  *          the optional numbers of cells and nodes, if any. The valid values are
6534  *          - 0 - do not permute.
6535  *          - 1 - permute cells.
6536  *          - 2 - permute nodes.
6537  *          - 3 - permute cells and nodes.
6538  *
6539  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6540  *          caller is to delete this field using decrRef() as it is no more needed.
6541  *  \throw If \a this field has not been constructed via file reading.
6542  *  \throw If the MED file is not readable.
6543  *  \throw If there is no mesh in the MED file.
6544  *  \throw If no field values of the given \a type.
6545  *  \throw If no field values lying on the top level support.
6546  *  \sa getFieldAtLevel()
6547  */
6548 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, DataArrayInt* &arrOut, int renumPol) const
6549 {
6550   if(getFileName2().empty())
6551     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6552   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6553   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNull());
6554   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6555   return ret.retn();
6556 }
6557
6558 /*!
6559  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6560  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6561  *  \param [in] type - a spatial discretization of the new field.
6562  *  \param [in] mesh - the supporting mesh.
6563  *  \param [out] arrOut - the DataArrayInt containing values of field.
6564  *  \param [in] renumPol - specifies how to permute values of the result field according to
6565  *          the optional numbers of cells and nodes, if any. The valid values are
6566  *          - 0 - do not permute.
6567  *          - 1 - permute cells.
6568  *          - 2 - permute nodes.
6569  *          - 3 - permute cells and nodes.
6570  *
6571  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6572  *          caller is to delete this field using decrRef() as it is no more needed.
6573  *  \throw If no field of \a this is lying on \a mesh.
6574  *  \throw If the mesh is empty.
6575  *  \throw If no field values of the given \a type are available.
6576  *  \sa getFieldAtLevel()
6577  *  \sa getFieldOnMeshAtLevel()
6578  */
6579 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6580 {
6581   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6582   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNull());
6583   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6584   return ret.retn();
6585 }
6586
6587 /*!
6588  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6589  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6590  *  \param [in] type - a spatial discretization of interest.
6591  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6592  *  \param [out] arrOut - the DataArrayInt containing values of field.
6593  *  \param [in] mesh - the supporting mesh.
6594  *  \param [in] renumPol - specifies how to permute values of the result field according to
6595  *          the optional numbers of cells and nodes, if any. The valid values are
6596  *          - 0 - do not permute.
6597  *          - 1 - permute cells.
6598  *          - 2 - permute nodes.
6599  *          - 3 - permute cells and nodes.
6600  *
6601  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6602  *          caller is to delete this field using decrRef() as it is no more needed.
6603  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6604  *  \throw If no field of \a this is lying on \a mesh.
6605  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6606  *  \sa getFieldAtLevel()
6607  *  \sa getFieldOnMeshAtLevel()
6608  */
6609 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6610 {
6611   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6612   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNull());
6613   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6614   return ret.retn();
6615 }
6616
6617 /*!
6618  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6619  * This method is called "Old" because in MED3 norm a field has only one meshName
6620  * attached, so this method is for readers of MED2 files. If \a this field
6621  * has not been constructed via file reading, an exception is thrown.
6622  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6623  *  \param [in] type - a spatial discretization of interest.
6624  *  \param [in] mName - a name of the supporting mesh.
6625  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6626  *  \param [out] arrOut - the DataArrayInt containing values of field.
6627  *  \param [in] renumPol - specifies how to permute values of the result field according to
6628  *          the optional numbers of cells and nodes, if any. The valid values are
6629  *          - 0 - do not permute.
6630  *          - 1 - permute cells.
6631  *          - 2 - permute nodes.
6632  *          - 3 - permute cells and nodes.
6633  *
6634  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6635  *          caller is to delete this field using decrRef() as it is no more needed.
6636  *  \throw If the MED file is not readable.
6637  *  \throw If there is no mesh named \a mName in the MED file.
6638  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6639  *  \throw If \a this field has not been constructed via file reading.
6640  *  \throw If no field of \a this is lying on the mesh named \a mName.
6641  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6642  *  \sa getFieldAtLevel()
6643  */
6644 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6645 {
6646   if(getFileName2().empty())
6647     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6648   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6649   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNull());
6650   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6651   return ret.retn();
6652 }
6653
6654 /*!
6655  * Returns values and a profile of the field of a given type lying on a given support.
6656  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6657  *  \param [in] type - a spatial discretization of the field.
6658  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6659  *  \param [in] mesh - the supporting mesh.
6660  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6661  *          field of interest lies on. If the field lies on all entities of the given
6662  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6663  *          using decrRef() as it is no more needed.
6664  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
6665  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6666  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6667  *  \throw If no field of \a this is lying on \a mesh.
6668  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6669  */
6670 DataArrayInt *MEDFileIntField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6671 {
6672   MEDCouplingAutoRefCountObjectPtr<DataArray> arr=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6673   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6674 }
6675
6676 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull()
6677 {
6678   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6679   if(!pt)
6680     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is null !");
6681   MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<MEDFileIntField1TSWithoutSDA *>(pt);
6682   if(!ret)
6683     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 !");
6684   return ret;
6685 }
6686
6687 DataArrayInt *MEDFileIntField1TS::getUndergroundDataArray() const
6688 {
6689   return contentNotNull()->getUndergroundDataArrayInt();
6690 }
6691
6692 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
6693
6694 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
6695 {
6696 }
6697
6698 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const char *fieldName):MEDFileFieldNameScope(fieldName)
6699 {
6700 }
6701
6702 /*!
6703  * \param [in] fieldId field id in C mode
6704  */
6705 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
6706 {
6707   med_field_type typcha;
6708   std::string dtunitOut;
6709   int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,"",fieldId,false,_name,typcha,_infos,dtunitOut);
6710   setDtUnit(dtunitOut.c_str());
6711   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll);
6712 }
6713
6714 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)
6715 try:MEDFileFieldNameScope(fieldName),_infos(infos)
6716 {
6717   setDtUnit(dtunit.c_str());
6718   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll);
6719 }
6720 catch(INTERP_KERNEL::Exception& e)
6721 {
6722   throw e;
6723 }
6724
6725 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySizeWithoutChildren() const
6726 {
6727   std::size_t ret(_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA>));
6728   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6729     ret+=(*it).capacity();
6730   return ret;
6731 }
6732
6733 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTSWithoutSDA::getDirectChildren() const
6734 {
6735   std::vector<const BigMemoryObject *> ret;
6736   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6737     {
6738       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6739       if(cur)
6740         ret.push_back(cur);
6741     }
6742   return ret;
6743 }
6744
6745 /*!
6746  * 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
6747  * NULL.
6748  */
6749 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const
6750 {
6751   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6752   ret->setInfo(_infos);
6753   int sz=(int)_time_steps.size();
6754   for(const int *id=startIds;id!=endIds;id++)
6755     {
6756       if(*id>=0 && *id<sz)
6757         {
6758           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
6759           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6760           if(tse)
6761             {
6762               tse->incrRef();
6763               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6764             }
6765           ret->pushBackTimeStep(tse2);
6766         }
6767       else
6768         {
6769           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
6770           oss << " ! Should be in [0," << sz << ") !";
6771           throw INTERP_KERNEL::Exception(oss.str().c_str());
6772         }
6773     }
6774   if(ret->getNumberOfTS()>0)
6775     ret->synchronizeNameScope();
6776   ret->copyNameScope(*this);
6777   return ret.retn();
6778 }
6779
6780 /*!
6781  * 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
6782  * NULL.
6783  */
6784 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const
6785 {
6786   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
6787   int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
6788   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6789   ret->setInfo(_infos);
6790   int sz=(int)_time_steps.size();
6791   int j=bg;
6792   for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
6793     {
6794       if(j>=0 && j<sz)
6795         {
6796           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
6797           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6798           if(tse)
6799             {
6800               tse->incrRef();
6801               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6802             }
6803           ret->pushBackTimeStep(tse2);
6804         }
6805       else
6806         {
6807           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
6808           oss << " ! Should be in [0," << sz << ") !";
6809           throw INTERP_KERNEL::Exception(oss.str().c_str());
6810         }
6811     }
6812   if(ret->getNumberOfTS()>0)
6813     ret->synchronizeNameScope();
6814   ret->copyNameScope(*this);
6815   return ret.retn();
6816 }
6817
6818 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6819 {
6820   int id=0;
6821   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6822   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6823     {
6824       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6825       if(!cur)
6826         continue;
6827       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6828       if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
6829         ids->pushBackSilent(id);
6830     }
6831   return buildFromTimeStepIds(ids->begin(),ids->end());
6832 }
6833
6834 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6835 {
6836   int id=0;
6837   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6838   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6839     {
6840       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6841       if(!cur)
6842         continue;
6843       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6844       if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
6845         ids->pushBackSilent(id);
6846     }
6847   return buildFromTimeStepIds(ids->begin(),ids->end());
6848 }
6849
6850 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const
6851 {
6852   return _infos;
6853 }
6854
6855 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info)
6856 {
6857   _infos=info;
6858 }
6859
6860 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const
6861 {
6862   int ret=0;
6863   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
6864     {
6865       const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
6866       if(pt->isDealingTS(iteration,order))
6867         return ret;
6868     }
6869   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
6870   std::vector< std::pair<int,int> > vp=getIterations();
6871   for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
6872     oss << "(" << (*it2).first << "," << (*it2).second << ") ";
6873   throw INTERP_KERNEL::Exception(oss.str().c_str());
6874 }
6875
6876 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const
6877 {
6878   return *_time_steps[getTimeStepPos(iteration,order)];
6879 }
6880
6881 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order)
6882 {
6883   return *_time_steps[getTimeStepPos(iteration,order)];
6884 }
6885
6886 std::string MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshName() const
6887 {
6888   if(_time_steps.empty())
6889     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
6890   return _time_steps[0]->getMeshName();
6891 }
6892
6893 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setMeshName(const char *newMeshName)
6894 {
6895   std::string oldName(getMeshName());
6896   std::vector< std::pair<std::string,std::string> > v(1);
6897   v[0].first=oldName; v[0].second=newMeshName;
6898   changeMeshNames(v);
6899 }
6900
6901 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
6902 {
6903   bool ret=false;
6904   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6905     {
6906       MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6907       if(cur)
6908         ret=cur->changeMeshNames(modifTab) || ret;
6909     }
6910   return ret;
6911 }
6912
6913 /*!
6914  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
6915  */
6916 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const
6917 {
6918   return getTimeStepEntry(iteration,order).getUndergroundDataArray();
6919 }
6920
6921 /*!
6922  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
6923  */
6924 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6925 {
6926   return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
6927 }
6928
6929 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
6930                                                                 MEDFileFieldGlobsReal& glob)
6931 {
6932   bool ret=false;
6933   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6934     {
6935       MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
6936       if(f1ts)
6937         ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
6938     }
6939   return ret;
6940 }
6941
6942 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
6943 {
6944   std::string startLine(bkOffset,' ');
6945   oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
6946   if(fmtsId>=0)
6947     oss << " (" << fmtsId << ")";
6948   oss << " has the following name: \"" << _name << "\"." << std::endl;
6949   oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
6950   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6951     {
6952       oss << startLine << "  -  \"" << *it << "\"" << std::endl;
6953     }
6954   int i=0;
6955   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
6956     {
6957       std::string chapter(17,'0'+i);
6958       oss << startLine << chapter << std::endl;
6959       const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6960       if(cur)
6961         cur->simpleRepr(bkOffset+2,oss,i);
6962       else
6963         oss << startLine << "  Field on one time step #" << i << " is not defined !" << std::endl;
6964       oss << startLine << chapter << std::endl;
6965     }
6966 }
6967
6968 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const
6969 {
6970   std::size_t sz=_time_steps.size();
6971   std::vector< std::pair<int,int> > ret(sz);
6972   ret1.resize(sz);
6973   for(std::size_t i=0;i<sz;i++)
6974     {
6975       const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
6976       if(f1ts)
6977         {
6978           ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
6979         }
6980       else
6981         {
6982           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
6983           throw INTERP_KERNEL::Exception(oss.str().c_str());
6984         }
6985     }
6986   return ret;
6987 }
6988
6989 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>& tse)
6990 {
6991   MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
6992   if(!tse2)
6993     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
6994   checkCoherencyOfType(tse2);
6995   if(_time_steps.empty())
6996     {
6997       setName(tse2->getName().c_str());
6998       setInfo(tse2->getInfo());
6999     }
7000   checkThatComponentsMatch(tse2->getInfo());
7001   _time_steps.push_back(tse);
7002 }
7003
7004 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope()
7005 {
7006   std::size_t nbOfCompo=_infos.size();
7007   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7008     {
7009       MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
7010       if(cur)
7011         {
7012           if((cur->getInfo()).size()!=nbOfCompo)
7013             {
7014               std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
7015               oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
7016               throw INTERP_KERNEL::Exception(oss.str().c_str());
7017             }
7018           cur->copyNameScope(*this);
7019         }
7020     }
7021 }
7022
7023 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll)
7024 {
7025   _time_steps.resize(nbPdt);
7026   for(int i=0;i<nbPdt;i++)
7027     {
7028       std::vector< std::pair<int,int> > ts;
7029       med_int numdt=0,numo=0;
7030       med_int meshIt=0,meshOrder=0;
7031       med_float dt=0.0;
7032       MEDfieldComputingStepMeshInfo(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder);
7033       switch(fieldTyp)
7034         {
7035         case MED_FLOAT64:
7036           {
7037             _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7038             break;
7039           }
7040         case MED_INT32:
7041           {
7042             _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7043             break;
7044           }
7045         default:
7046           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
7047         }
7048       if(loadAll)
7049         _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this);
7050       else
7051         _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this);
7052     }
7053 }
7054
7055 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const
7056 {
7057   if(_time_steps.empty())
7058     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
7059   checkThatNbOfCompoOfTSMatchThis();
7060   std::vector<std::string> infos(getInfo());
7061   int nbComp=infos.size();
7062   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7063   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7064   for(int i=0;i<nbComp;i++)
7065     {
7066       std::string info=infos[i];
7067       std::string c,u;
7068       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
7069       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7070       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7071     }
7072   if(_name.empty())
7073     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
7074   MEDfieldCr(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
7075   int nbOfTS=_time_steps.size();
7076   for(int i=0;i<nbOfTS;i++)
7077     _time_steps[i]->writeLL(fid,opts,*this);
7078 }
7079
7080 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
7081 {
7082   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7083     {
7084       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7085       if(elt)
7086         elt->loadBigArraysRecursively(fid,nasc);
7087     }
7088 }
7089
7090 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
7091 {
7092   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7093     {
7094       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7095       if(elt)
7096         elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
7097     }
7098 }
7099
7100 void MEDFileAnyTypeFieldMultiTSWithoutSDA::unloadArrays()
7101 {
7102   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7103     {
7104       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7105       if(elt)
7106         elt->unloadArrays();
7107     }
7108 }
7109
7110 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
7111 {
7112   return _time_steps.size();
7113 }
7114
7115 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS()
7116 {
7117   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  > newTS;
7118   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7119     {
7120       const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
7121       if(tmp)
7122         newTS.push_back(*it);
7123     }
7124   _time_steps=newTS;
7125 }
7126
7127 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds)
7128 {
7129   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7130   int maxId=(int)_time_steps.size();
7131   int ii=0;
7132   std::set<int> idsToDel;
7133   for(const int *id=startIds;id!=endIds;id++,ii++)
7134     {
7135       if(*id>=0 && *id<maxId)
7136         {
7137           idsToDel.insert(*id);
7138         }
7139       else
7140         {
7141           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
7142           throw INTERP_KERNEL::Exception(oss.str().c_str());
7143         }
7144     }
7145   for(int iii=0;iii<maxId;iii++)
7146     if(idsToDel.find(iii)==idsToDel.end())
7147       newTS.push_back(_time_steps[iii]);
7148   _time_steps=newTS;
7149 }
7150
7151 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step)
7152 {
7153   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
7154   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7155   if(nbOfEntriesToKill==0)
7156     return ;
7157   std::size_t sz=_time_steps.size();
7158   std::vector<bool> b(sz,true);
7159   int j=bg;
7160   for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
7161     b[j]=false;
7162   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7163   for(std::size_t i=0;i<sz;i++)
7164     if(b[i])
7165       newTS.push_back(_time_steps[i]);
7166   _time_steps=newTS;
7167 }
7168
7169 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const
7170 {
7171   int ret=0;
7172   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
7173   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7174     {
7175       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7176       if(tmp)
7177         {
7178           int it2,ord;
7179           tmp->getTime(it2,ord);
7180           if(it2==iteration && order==ord)
7181             return ret;
7182           else
7183             oss << "(" << it2 << ","  << ord << "), ";
7184         }
7185     }
7186   throw INTERP_KERNEL::Exception(oss.str().c_str());
7187 }
7188
7189 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const
7190 {
7191   int ret=0;
7192   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
7193   oss.precision(15);
7194   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7195     {
7196       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7197       if(tmp)
7198         {
7199           int it2,ord;
7200           double ti=tmp->getTime(it2,ord);
7201           if(fabs(time-ti)<eps)
7202             return ret;
7203           else
7204             oss << ti << ", ";
7205         }
7206     }
7207   throw INTERP_KERNEL::Exception(oss.str().c_str());
7208 }
7209
7210 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
7211 {
7212   int lgth=_time_steps.size();
7213   std::vector< std::pair<int,int> > ret(lgth);
7214   for(int i=0;i<lgth;i++)
7215     _time_steps[i]->fillIteration(ret[i]);
7216   return ret;
7217 }
7218
7219 /*!
7220  * 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'
7221  * This method returns two things.
7222  * - The absolute dimension of 'this' in first parameter.
7223  * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
7224  *   to the first output parameter. The values in 'levs' will be returned in decreasing order.
7225  *
7226  * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
7227  * Only these 3 discretizations will be taken into account here.
7228  *
7229  * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
7230  * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
7231  * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
7232  *
7233  * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
7234  * 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'.
7235  *
7236  * Let's consider the typical following case :
7237  * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
7238  * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
7239  * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
7240  *   TETRA4 and SEG2
7241  * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
7242  *
7243  * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
7244  *
7245  * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
7246  * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
7247  * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
7248  * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
7249  */
7250 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const
7251 {
7252   return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
7253 }
7254
7255 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const
7256 {
7257   if(pos<0 || pos>=(int)_time_steps.size())
7258     {
7259       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7260       throw INTERP_KERNEL::Exception(oss.str().c_str());
7261     }
7262   const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7263   if(item==0)
7264     {
7265       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7266       oss << "\nTry to use following method eraseEmptyTS !";
7267       throw INTERP_KERNEL::Exception(oss.str().c_str());
7268     }
7269   return item;
7270 }
7271
7272 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos)
7273 {
7274   if(pos<0 || pos>=(int)_time_steps.size())
7275     {
7276       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7277       throw INTERP_KERNEL::Exception(oss.str().c_str());
7278     }
7279   MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7280   if(item==0)
7281     {
7282       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7283       oss << "\nTry to use following method eraseEmptyTS !";
7284       throw INTERP_KERNEL::Exception(oss.str().c_str());
7285     }
7286   return item;
7287 }
7288
7289 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
7290 {
7291   std::vector<std::string> ret;
7292   std::set<std::string> ret2;
7293   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7294     {
7295       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
7296       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7297         if(ret2.find(*it2)==ret2.end())
7298           {
7299             ret.push_back(*it2);
7300             ret2.insert(*it2);
7301           }
7302     }
7303   return ret;
7304 }
7305
7306 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
7307 {
7308   std::vector<std::string> ret;
7309   std::set<std::string> ret2;
7310   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7311     {
7312       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
7313       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7314         if(ret2.find(*it2)==ret2.end())
7315           {
7316             ret.push_back(*it2);
7317             ret2.insert(*it2);
7318           }
7319     }
7320   return ret;
7321 }
7322
7323 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
7324 {
7325   std::vector<std::string> ret;
7326   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7327     {
7328       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
7329       ret.insert(ret.end(),tmp.begin(),tmp.end());
7330     }
7331   return ret;
7332 }
7333
7334 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
7335 {
7336   std::vector<std::string> ret;
7337   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7338     {
7339       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
7340       ret.insert(ret.end(),tmp.begin(),tmp.end());
7341     }
7342   return ret;
7343 }
7344
7345 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(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)->changePflsRefsNamesGen2(mapOfModif);
7349 }
7350
7351 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7352 {
7353   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7354     (*it)->changeLocsRefsNamesGen2(mapOfModif);
7355 }
7356
7357 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const
7358 {
7359   int lgth=_time_steps.size();
7360   std::vector< std::vector<TypeOfField> > ret(lgth);
7361   for(int i=0;i<lgth;i++)
7362     _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
7363   return ret;
7364 }
7365
7366 /*!
7367  * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
7368  */
7369 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
7370 {
7371   return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
7372 }
7373
7374 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCpy() const
7375 {
7376   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
7377   std::size_t i=0;
7378   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7379     {
7380       if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
7381         ret->_time_steps[i]=(*it)->deepCpy();
7382     }
7383   return ret.retn();
7384 }
7385
7386 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const
7387 {
7388   std::size_t sz(_infos.size()),sz2(_time_steps.size());
7389   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
7390   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
7391   for(std::size_t i=0;i<sz;i++)
7392     {
7393       ret[i]=shallowCpy();
7394       ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
7395     }
7396   for(std::size_t i=0;i<sz2;i++)
7397     {
7398       std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
7399       if(ret1.size()!=sz)
7400         {
7401           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
7402           throw INTERP_KERNEL::Exception(oss.str().c_str());
7403         }
7404       ts[i]=ret1;
7405     }
7406   for(std::size_t i=0;i<sz;i++)
7407     for(std::size_t j=0;j<sz2;j++)
7408       ret[i]->_time_steps[j]=ts[j][i];
7409   return ret;
7410 }
7411
7412 /*!
7413  * This method splits into discretization each time steps in \a this.
7414  * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
7415  */
7416 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const
7417 {
7418   std::size_t sz(_time_steps.size());
7419   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7420   for(std::size_t i=0;i<sz;i++)
7421     {
7422       const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7423       if(!timeStep)
7424         {
7425           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
7426           throw INTERP_KERNEL::Exception(oss.str().c_str());
7427         }
7428       items[i]=timeStep->splitDiscretizations();
7429     }
7430   //
7431   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
7432   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
7433   std::vector< TypeOfField > types;
7434   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7435     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7436       {
7437         std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
7438         if(ts.size()!=1)
7439           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
7440         std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
7441         if(it2==types.end())
7442           types.push_back(ts[0]);
7443       }
7444   ret.resize(types.size()); ret2.resize(types.size());
7445   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7446     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7447       {
7448         TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
7449         std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
7450         ret2[pos].push_back(*it1);
7451       }
7452   for(std::size_t i=0;i<types.size();i++)
7453     {
7454       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=createNew();
7455       for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
7456         elt->pushBackTimeStep(*it1);//also updates infos in elt
7457       ret[i]=elt;
7458       elt->MEDFileFieldNameScope::operator=(*this);
7459     }
7460   return ret;
7461 }
7462
7463 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
7464 {
7465   _name=field->getName();
7466   if(_name.empty())
7467     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
7468   if(!arr)
7469     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
7470   _infos=arr->getInfoOnComponents();
7471 }
7472
7473 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const
7474 {
7475   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
7476   if(_name!=field->getName())
7477     {
7478       std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
7479       oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
7480       throw INTERP_KERNEL::Exception(oss.str().c_str());
7481     }
7482   if(!arr)
7483     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
7484   checkThatComponentsMatch(arr->getInfoOnComponents());
7485 }
7486
7487 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const
7488 {
7489   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
7490   if(getInfo().size()!=compos.size())
7491     {
7492       std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
7493       oss << " number of components of element to append (" << compos.size() << ") !";
7494       throw INTERP_KERNEL::Exception(oss.str().c_str());
7495     }
7496   if(_infos!=compos)
7497     {
7498       std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
7499       std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
7500       oss << " But compo in input fields are : ";
7501       std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
7502       oss << " !";
7503       throw INTERP_KERNEL::Exception(oss.str().c_str());
7504     }
7505 }
7506
7507 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const
7508 {
7509   std::size_t sz=_infos.size();
7510   int j=0;
7511   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
7512     {
7513       const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7514       if(elt)
7515         if(elt->getInfo().size()!=sz)
7516           {
7517             std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
7518             oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
7519             throw INTERP_KERNEL::Exception(oss.str().c_str());
7520           }
7521     }
7522 }
7523
7524 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
7525 {
7526   if(!field)
7527     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7528   if(!_time_steps.empty())
7529     checkCoherencyOfTinyInfo(field,arr);
7530   MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
7531   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7532   objC->setFieldNoProfileSBT(field,arr,glob,*this);
7533   copyTinyInfoFrom(field,arr);
7534   _time_steps.push_back(obj);
7535 }
7536
7537 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob)
7538 {
7539   if(!field)
7540     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7541   if(!_time_steps.empty())
7542     checkCoherencyOfTinyInfo(field,arr);
7543   MEDFileField1TSWithoutSDA *objC=new MEDFileField1TSWithoutSDA;
7544   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7545   objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
7546   copyTinyInfoFrom(field,arr);
7547   _time_steps.push_back(obj);
7548 }
7549
7550 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ts)
7551 {
7552   int sz=(int)_time_steps.size();
7553   if(i<0 || i>=sz)
7554     {
7555       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
7556       throw INTERP_KERNEL::Exception(oss.str().c_str());
7557     }
7558   const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
7559   if(tsPtr)
7560     {
7561       if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
7562         {
7563           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() <<  " !";
7564           throw INTERP_KERNEL::Exception(oss.str().c_str());
7565         }
7566     }
7567   _time_steps[i]=ts;
7568 }
7569
7570 //= MEDFileFieldMultiTSWithoutSDA
7571
7572 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)
7573 {
7574   return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7575 }
7576
7577 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
7578 {
7579 }
7580
7581 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7582 {
7583 }
7584
7585 /*!
7586  * \param [in] fieldId field id in C mode
7587  */
7588 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7589 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7590 {
7591 }
7592 catch(INTERP_KERNEL::Exception& e)
7593   { throw e; }
7594
7595 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)
7596 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7597 {
7598 }
7599 catch(INTERP_KERNEL::Exception& e)
7600 { throw e; }
7601
7602 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7603 {
7604   return new MEDFileField1TSWithoutSDA;
7605 }
7606
7607 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7608 {
7609   if(!f1ts)
7610     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7611   const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
7612   if(!f1tsC)
7613     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
7614 }
7615
7616 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const
7617 {
7618   return MEDFileField1TSWithoutSDA::TYPE_STR;
7619 }
7620
7621 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const
7622 {
7623   return new MEDFileFieldMultiTSWithoutSDA(*this);
7624 }
7625
7626 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const
7627 {
7628   return new MEDFileFieldMultiTSWithoutSDA;
7629 }
7630
7631 /*!
7632  * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
7633  * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
7634  */
7635 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
7636 {
7637   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
7638   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
7639   if(!myF1TSC)
7640     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
7641   return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
7642 }
7643
7644 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const
7645 {
7646   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
7647   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7648   int i=0;
7649   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7650     {
7651       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7652       if(eltToConv)
7653         {
7654           const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
7655           if(!eltToConvC)
7656             throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
7657           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
7658           ret->setIteration(i,elt);
7659         }
7660     }
7661   return ret.retn();
7662 }
7663
7664 //= MEDFileAnyTypeFieldMultiTS
7665
7666 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
7667 {
7668 }
7669
7670 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, bool loadAll)
7671 try:MEDFileFieldGlobsReal(fileName)
7672 {
7673   MEDFileUtilities::CheckFileForRead(fileName);
7674   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7675   _content=BuildContentFrom(fid,fileName,loadAll);
7676   loadGlobals(fid);
7677 }
7678 catch(INTERP_KERNEL::Exception& e)
7679   {
7680     throw e;
7681   }
7682
7683 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll)
7684 {
7685   med_field_type typcha;
7686   std::vector<std::string> infos;
7687   std::string dtunit;
7688   int i=-1;
7689   MEDFileAnyTypeField1TS::LocateField(fid,fileName,fieldName,i,typcha,infos,dtunit);
7690   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7691   switch(typcha)
7692     {
7693     case MED_FLOAT64:
7694       {
7695         ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll);
7696         break;
7697       }
7698     case MED_INT32:
7699       {
7700         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll);
7701         break;
7702       }
7703     default:
7704       {
7705         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] !";
7706         throw INTERP_KERNEL::Exception(oss.str().c_str());
7707       }
7708     }
7709   ret->setDtUnit(dtunit.c_str());
7710   return ret.retn();
7711 }
7712
7713 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll)
7714 {
7715   med_field_type typcha;
7716   //
7717   std::vector<std::string> infos;
7718   std::string dtunit,fieldName;
7719   MEDFileAnyTypeField1TS::LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
7720   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7721   switch(typcha)
7722     {
7723     case MED_FLOAT64:
7724       {
7725         ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll);
7726         break;
7727       }
7728     case MED_INT32:
7729       {
7730         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll);
7731         break;
7732       }
7733     default:
7734       {
7735         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] !";
7736         throw INTERP_KERNEL::Exception(oss.str().c_str());
7737       }
7738     }
7739   ret->setDtUnit(dtunit.c_str());
7740   return ret.retn();
7741 }
7742
7743 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, const char *fileName)
7744 {
7745   if(!c)
7746     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
7747   if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
7748     {
7749       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=MEDFileFieldMultiTS::New();
7750       ret->setFileName(fileName);
7751       ret->_content=c;  c->incrRef();
7752       return ret.retn();
7753     }
7754   if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
7755     {
7756       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=MEDFileIntFieldMultiTS::New();
7757       ret->setFileName(fileName);
7758       ret->_content=c;  c->incrRef();
7759       return ret.retn();
7760     }
7761   throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
7762 }
7763
7764 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll)
7765 try:MEDFileFieldGlobsReal(fileName)
7766 {
7767   MEDFileUtilities::CheckFileForRead(fileName);
7768   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7769   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
7770   loadGlobals(fid);
7771 }
7772 catch(INTERP_KERNEL::Exception& e)
7773   {
7774     throw e;
7775   }
7776
7777 //= MEDFileIntFieldMultiTSWithoutSDA
7778
7779 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)
7780 {
7781   return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7782 }
7783
7784 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
7785 {
7786 }
7787
7788 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7789 {
7790 }
7791
7792 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)
7793 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7794 {
7795 }
7796 catch(INTERP_KERNEL::Exception& e)
7797 { throw e; }
7798
7799 /*!
7800  * \param [in] fieldId field id in C mode
7801  */
7802 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7803 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7804 {
7805 }
7806 catch(INTERP_KERNEL::Exception& e)
7807   { throw e; }
7808
7809 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7810 {
7811   return new MEDFileIntField1TSWithoutSDA;
7812 }
7813
7814 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7815 {
7816   if(!f1ts)
7817     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7818   const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
7819   if(!f1tsC)
7820     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
7821 }
7822
7823 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const
7824 {
7825   return MEDFileIntField1TSWithoutSDA::TYPE_STR;
7826 }
7827
7828 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const
7829 {
7830   return new MEDFileIntFieldMultiTSWithoutSDA(*this);
7831 }
7832
7833 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const
7834 {
7835   return new MEDFileIntFieldMultiTSWithoutSDA;
7836 }
7837
7838 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const
7839 {
7840   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
7841   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7842   int i=0;
7843   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7844     {
7845       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7846       if(eltToConv)
7847         {
7848           const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
7849           if(!eltToConvC)
7850             throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
7851           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
7852           ret->setIteration(i,elt);
7853         }
7854     }
7855   return ret.retn();
7856 }
7857
7858 //= MEDFileAnyTypeFieldMultiTS
7859
7860 /*!
7861  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
7862  * that has been read from a specified MED file.
7863  *  \param [in] fileName - the name of the MED file to read.
7864  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7865  *          is to delete this field using decrRef() as it is no more needed.
7866  *  \throw If reading the file fails.
7867  */
7868 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, bool loadAll)
7869 {
7870   MEDFileUtilities::CheckFileForRead(fileName);
7871   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7872   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
7873   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7874   ret->loadGlobals(fid);
7875   return ret.retn();
7876 }
7877
7878 /*!
7879  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
7880  * that has been read from a specified MED file.
7881  *  \param [in] fileName - the name of the MED file to read.
7882  *  \param [in] fieldName - the name of the field to read.
7883  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7884  *          is to delete this field using decrRef() as it is no more needed.
7885  *  \throw If reading the file fails.
7886  *  \throw If there is no field named \a fieldName in the file.
7887  */
7888 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll)
7889 {
7890   MEDFileUtilities::CheckFileForRead(fileName);
7891   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7892   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
7893   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7894   ret->loadGlobals(fid);
7895   return ret.retn();
7896 }
7897
7898 /*!
7899  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
7900  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
7901  *
7902  * \warning this is a shallow copy constructor
7903  */
7904 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
7905 {
7906   if(!shallowCopyOfContent)
7907     {
7908       const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
7909       otherPtr->incrRef();
7910       _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
7911     }
7912   else
7913     {
7914       _content=other.shallowCpy();
7915     }
7916 }
7917
7918 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase()
7919 {
7920   MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7921   if(!ret)
7922     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
7923   return ret;
7924 }
7925
7926 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const
7927 {
7928   const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7929   if(!ret)
7930     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
7931   return ret;
7932 }
7933
7934 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
7935 {
7936   return contentNotNullBase()->getPflsReallyUsed2();
7937 }
7938
7939 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
7940 {
7941   return contentNotNullBase()->getLocsReallyUsed2();
7942 }
7943
7944 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
7945 {
7946   return contentNotNullBase()->getPflsReallyUsedMulti2();
7947 }
7948
7949 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
7950 {
7951   return contentNotNullBase()->getLocsReallyUsedMulti2();
7952 }
7953
7954 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7955 {
7956   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
7957 }
7958
7959 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7960 {
7961   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
7962 }
7963
7964 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
7965 {
7966   return contentNotNullBase()->getNumberOfTS();
7967 }
7968
7969 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS()
7970 {
7971   contentNotNullBase()->eraseEmptyTS();
7972 }
7973
7974 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
7975 {
7976   contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
7977 }
7978
7979 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step)
7980 {
7981   contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
7982 }
7983
7984 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const
7985 {
7986   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
7987   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7988   ret->_content=c;
7989   return ret.retn();
7990 }
7991
7992 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const
7993 {
7994   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
7995   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7996   ret->_content=c;
7997   return ret.retn();
7998 }
7999
8000 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
8001 {
8002   return contentNotNullBase()->getIterations();
8003 }
8004
8005 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts)
8006 {
8007   for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
8008     pushBackTimeStep(*it);
8009 }
8010
8011 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts)
8012 {
8013   if(!f1ts)
8014     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
8015   checkCoherencyOfType(f1ts);
8016   f1ts->incrRef();
8017   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
8018   MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
8019   c->incrRef();
8020   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
8021   if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
8022     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
8023   _content->pushBackTimeStep(cSafe);
8024   appendGlobs(*f1ts,1e-12);
8025 }
8026
8027 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope()
8028 {
8029   contentNotNullBase()->synchronizeNameScope();
8030 }
8031
8032 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const
8033 {
8034   return contentNotNullBase()->getPosOfTimeStep(iteration,order);
8035 }
8036
8037 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const
8038 {
8039   return contentNotNullBase()->getPosGivenTime(time,eps);
8040 }
8041
8042 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const
8043 {
8044   return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
8045 }
8046
8047 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const
8048 {
8049   return contentNotNullBase()->getTypesOfFieldAvailable();
8050 }
8051
8052 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
8053 {
8054   return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
8055 }
8056
8057 std::string MEDFileAnyTypeFieldMultiTS::getName() const
8058 {
8059   return contentNotNullBase()->getName();
8060 }
8061
8062 void MEDFileAnyTypeFieldMultiTS::setName(const char *name)
8063 {
8064   contentNotNullBase()->setName(name);
8065 }
8066
8067 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const
8068 {
8069   return contentNotNullBase()->getDtUnit();
8070 }
8071
8072 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const char *dtUnit)
8073 {
8074   contentNotNullBase()->setDtUnit(dtUnit);
8075 }
8076
8077 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
8078 {
8079   contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
8080 }
8081
8082 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const
8083 {
8084   return contentNotNullBase()->getTimeSteps(ret1);
8085 }
8086
8087 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const
8088 {
8089   return contentNotNullBase()->getMeshName();
8090 }
8091
8092 void MEDFileAnyTypeFieldMultiTS::setMeshName(const char *newMeshName)
8093 {
8094   contentNotNullBase()->setMeshName(newMeshName);
8095 }
8096
8097 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
8098 {
8099   return contentNotNullBase()->changeMeshNames(modifTab);
8100 }
8101
8102 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const
8103 {
8104   return contentNotNullBase()->getInfo();
8105 }
8106
8107 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info)
8108 {
8109   return contentNotNullBase()->setInfo(info);
8110 }
8111
8112 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const
8113 {
8114   const std::vector<std::string> ret=getInfo();
8115   return (int)ret.size();
8116 }
8117
8118 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const
8119 {
8120   writeGlobals(fid,*this);
8121   contentNotNullBase()->writeLL(fid,*this);
8122 }
8123
8124 /*!
8125  * Writes \a this field into a MED file specified by its name.
8126  *  \param [in] fileName - the MED file name.
8127  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
8128  * - 2 - erase; an existing file is removed.
8129  * - 1 - append; same data should not be present in an existing file.
8130  * - 0 - overwrite; same data present in an existing file is overwritten.
8131  *  \throw If the field name is not set.
8132  *  \throw If no field data is set.
8133  *  \throw If \a mode == 1 and the same data is present in an existing file.
8134  */
8135 void MEDFileAnyTypeFieldMultiTS::write(const char *fileName, int mode) const
8136 {
8137   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
8138   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
8139   writeLL(fid);
8140 }
8141
8142 /*!
8143  * This method alloc the arrays and load potentially huge arrays contained in this field.
8144  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
8145  * This method can be also called to refresh or reinit values from a file.
8146  *
8147  * \throw If the fileName is not set or points to a non readable MED file.
8148  */
8149 void MEDFileAnyTypeFieldMultiTS::loadArrays()
8150 {
8151   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8152   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
8153 }
8154
8155 /*!
8156  * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
8157  * But once data loaded once, this method does nothing.
8158  *
8159  * \throw If the fileName is not set or points to a non readable MED file.
8160  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::unloadArrays
8161  */
8162 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary()
8163 {
8164   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8165   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
8166 }
8167
8168 /*!
8169  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
8170  * This method does not release arrays set outside the context of a MED file.
8171  *
8172  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
8173  */
8174 void MEDFileAnyTypeFieldMultiTS::unloadArrays()
8175 {
8176   contentNotNullBase()->unloadArrays();
8177 }
8178
8179 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
8180 {
8181   std::ostringstream oss;
8182   contentNotNullBase()->simpleRepr(0,oss,-1);
8183   simpleReprGlobs(oss);
8184   return oss.str();
8185 }
8186
8187 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySizeWithoutChildren() const
8188 {
8189   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
8190 }
8191
8192 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTS::getDirectChildren() const
8193 {
8194   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
8195   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8196     ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content);
8197   return ret;
8198 }
8199
8200 /*!
8201  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
8202  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8203  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
8204  */
8205 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const
8206 {
8207   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8208   if(!content)
8209     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
8210   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
8211   std::size_t sz(contentsSplit.size());
8212   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8213   for(std::size_t i=0;i<sz;i++)
8214     {
8215       ret[i]=shallowCpy();
8216       ret[i]->_content=contentsSplit[i];
8217     }
8218   return ret;
8219 }
8220
8221 /*!
8222  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
8223  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8224  */
8225 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const
8226 {
8227   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8228   if(!content)
8229     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
8230   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitDiscretizations();
8231   std::size_t sz(contentsSplit.size());
8232   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8233   for(std::size_t i=0;i<sz;i++)
8234     {
8235       ret[i]=shallowCpy();
8236       ret[i]->_content=contentsSplit[i];
8237     }
8238   return ret;
8239 }
8240
8241 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCpy() const
8242 {
8243   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8244   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8245     ret->_content=_content->deepCpy();
8246   ret->deepCpyGlobs(*this);
8247   return ret.retn();
8248 }
8249
8250 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
8251 {
8252   return _content;
8253 }
8254
8255 /*!
8256  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8257  *  \param [in] iteration - the iteration number of a required time step.
8258  *  \param [in] order - the iteration order number of required time step.
8259  *  \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
8260  *          delete this field using decrRef() as it is no more needed.
8261  *  \throw If there is no required time step in \a this field.
8262  */
8263 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const
8264 {
8265   int pos=getPosOfTimeStep(iteration,order);
8266   return getTimeStepAtPos(pos);
8267 }
8268
8269 /*!
8270  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8271  *  \param [in] time - the time of the time step of interest.
8272  *  \param [in] eps - a precision used to compare time values.
8273  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8274  *          delete this field using decrRef() as it is no more needed.
8275  *  \throw If there is no required time step in \a this field.
8276  */
8277 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const
8278 {
8279   int pos=getPosGivenTime(time,eps);
8280   return getTimeStepAtPos(pos);
8281 }
8282
8283 /*!
8284  * 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.
8285  * The float64 value of time attached to the pair of integers are not considered here.
8286  *
8287  * \param [in] vectFMTS - vector of not null fields defined on a same global data pointer.
8288  * \throw If there is a null pointer in \a vectFMTS.
8289  */
8290 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS)
8291 {
8292   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries : presence of null instance in input vector !";
8293   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8294   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8295   while(!lstFMTS.empty())
8296     {
8297       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8298       MEDFileAnyTypeFieldMultiTS *curIt(*it);
8299       if(!curIt)
8300         throw INTERP_KERNEL::Exception(msg);
8301       std::vector< std::pair<int,int> > refIts=curIt->getIterations();
8302       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8303       elt.push_back(curIt); it=lstFMTS.erase(it);
8304       while(it!=lstFMTS.end())
8305         {
8306           curIt=*it;
8307           if(!curIt)
8308             throw INTERP_KERNEL::Exception(msg);
8309           std::vector< std::pair<int,int> > curIts=curIt->getIterations();
8310           if(refIts==curIts)
8311             { elt.push_back(curIt); it=lstFMTS.erase(it); }
8312           else
8313             it++;
8314         }
8315       ret.push_back(elt);
8316     }
8317   return ret;
8318 }
8319
8320 /*!
8321  * This method splits the input list \a vectFMTS considering the aspect of the geometrical support over time.
8322  * All returned instances in a subvector can be safely loaded, rendered along time
8323  * All items must be defined on the same time step ids ( see MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries method ).
8324  * Each item in \a vectFMTS is expected to have one and exactly one spatial discretization along time.
8325  * 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).
8326  * All items in \a vectFMTS whose spatial discretization is not ON_NODES will appear once.
8327  * 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.
8328  *
8329  * \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().
8330  * \param [in] mesh - the mesh shared by all items in \a vectFMTS across time.
8331  * \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.
8332  *
8333  * \throw If an element in \a vectFMTS has not only one spatial discretization set.
8334  * \throw If an element in \a vectFMTS change of spatial discretization along time.
8335  * \throw If an element in \a vectFMTS lies on a mesh with meshname different from those in \a mesh.
8336  * \thorw If some elements in \a vectFMTS do not have the same times steps.
8337  * \throw If mesh is null.
8338  * \throw If an element in \a vectFMTS is null.
8339  * \sa MEDFileAnyTypeFieldMultiTS::AreOnSameSupportAcrossTime
8340  */
8341 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& fsc)
8342 {
8343   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : presence of a null instance in the input vector !";
8344   if(!mesh)
8345     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : input mesh is null !");
8346   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8347   if(vectFMTS.empty())
8348     return ret;
8349   std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it(vectFMTS.begin());
8350   MEDFileAnyTypeFieldMultiTS *frstElt(*it);
8351   std::size_t i=0;
8352   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNotNodes;
8353   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNodes;
8354   for(;it!=vectFMTS.end();it++,i++)
8355     {
8356       TypeOfField tof0,tof1;
8357       int ret=CheckSupportAcrossTime(frstElt,*it,mesh,tof0,tof1);
8358       if(ret>0)
8359         {
8360           if(tof1!=ON_NODES)
8361             vectFMTSNotNodes.push_back(*it);
8362           else
8363             vectFMTSNodes.push_back(*it);
8364         }
8365       else
8366         vectFMTSNotNodes.push_back(*it);
8367     }
8368   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> > cmps;
8369   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > retCell=SplitPerCommonSupportNotNodesAlg(vectFMTSNotNodes,mesh,cmps);
8370   ret=retCell;
8371   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it2=vectFMTSNodes.begin();it2!=vectFMTSNodes.end();it2++)
8372     {
8373       i=0;
8374       bool isFetched(false);
8375       for(std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> >::const_iterator it0=retCell.begin();it0!=retCell.end();it0++,i++)
8376         {
8377           if((*it0).empty())
8378             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : internal error !");
8379           if(cmps[i]->isCompatibleWithNodesDiscr(*it2))
8380             { ret[i].push_back(*it2); isFetched=true; }
8381         }
8382       if(!isFetched)
8383         {
8384           std::vector<MEDFileAnyTypeFieldMultiTS *> tmp(1,*it2);
8385           MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> tmp2(MEDFileMeshStruct::New(mesh));
8386           ret.push_back(tmp); retCell.push_back(tmp); cmps.push_back(MEDFileFastCellSupportComparator::New(tmp2,*it2));
8387         }
8388     }
8389   fsc=cmps;
8390   return ret;
8391 }
8392
8393 /*!
8394  * 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.
8395  * \param [out] cmps - same size than the returned vector.
8396  */
8397 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupportNotNodesAlg(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& cmps)
8398 {
8399   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8400   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8401   while(!lstFMTS.empty())
8402     {
8403       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8404       MEDFileAnyTypeFieldMultiTS *ref(*it);
8405       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8406       elt.push_back(ref); it=lstFMTS.erase(it);
8407       MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(mesh));
8408       MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> cmp(MEDFileFastCellSupportComparator::New(mst,ref));
8409       while(it!=lstFMTS.end())
8410         {
8411           MEDFileAnyTypeFieldMultiTS *curIt(*it);
8412           if(cmp->isEqual(curIt))
8413             { elt.push_back(curIt); it=lstFMTS.erase(it); }
8414           else
8415             it++;
8416         }
8417       ret.push_back(elt); cmps.push_back(cmp);
8418     }
8419   return ret;
8420 }
8421
8422 /*!
8423  * 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.
8424  * \a f0 and \a f1 must be defined each only on a same spatial discretization even if this can be different each other.
8425  *
8426  * \throw If \a f0 or \a f1 has not only one spatial discretization set.
8427  * \throw If \a f0 or \a f1 change of spatial discretization along time.
8428  * \throw If \a f0 or \a f1 on a mesh with meshname different from those in \a mesh.
8429  * \thorw If \a f0 and \a f1 do not have the same times steps.
8430  * \throw If mesh is null.
8431  * \throw If \a f0 or \a f1 is null.
8432  * \sa MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport
8433  */
8434 int MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime(MEDFileAnyTypeFieldMultiTS *f0, MEDFileAnyTypeFieldMultiTS *f1, const MEDFileMesh *mesh, TypeOfField& tof0, TypeOfField& tof1)
8435 {
8436   if(!mesh)
8437     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : input mesh is null !");
8438   if(!f0 || !f1)
8439     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : presence of null instance in fields over time !");
8440   if(f0->getMeshName()!=mesh->getName())
8441     {
8442       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh \""<< f0->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8443       throw INTERP_KERNEL::Exception(oss.str().c_str());
8444     }
8445   if(f1->getMeshName()!=mesh->getName())
8446     {
8447       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh \""<< f1->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8448       throw INTERP_KERNEL::Exception(oss.str().c_str());
8449     }
8450   int nts=f0->getNumberOfTS();
8451   if(nts!=f1->getNumberOfTS())
8452     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : number of time steps are not the same !");
8453   if(nts==0)
8454     return nts;
8455   for(int i=0;i<nts;i++)
8456     {
8457       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f0cur=f0->getTimeStepAtPos(i);
8458       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1cur=f1->getTimeStepAtPos(i);
8459       std::vector<TypeOfField> tofs0(f0cur->getTypesOfFieldAvailable()),tofs1(f1cur->getTypesOfFieldAvailable());
8460       if(tofs0.size()!=1 || tofs1.size()!=1)
8461         throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : All time steps must be defined on only one spatial discretization !");
8462       if(i!=0)
8463         {
8464           if(tof0!=tofs0[0] || tof1!=tofs1[0])
8465             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : Across times steps MEDFileAnyTypeFieldMultiTS instances have to keep the same unique spatial discretization !");
8466         }
8467       else
8468         { tof0=tofs0[0]; tof1=tofs1[0]; }
8469       if(f0cur->getMeshIteration()!=mesh->getIteration() || f0cur->getMeshOrder()!=mesh->getOrder())
8470         {
8471           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() << ") !";
8472           throw INTERP_KERNEL::Exception(oss.str().c_str());
8473         }
8474       if(f1cur->getMeshIteration()!=mesh->getIteration() || f1cur->getMeshOrder()!=mesh->getOrder())
8475         {
8476           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() << ") !";
8477           throw INTERP_KERNEL::Exception(oss.str().c_str());
8478         }
8479       if(f0cur->getIteration()!=f1cur->getIteration() || f0cur->getOrder()!=f1cur->getOrder())
8480         {
8481           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() << ") !";
8482           throw INTERP_KERNEL::Exception(oss.str().c_str());
8483         }
8484     }
8485   return nts;
8486 }
8487
8488 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator()
8489 {
8490   return new MEDFileAnyTypeFieldMultiTSIterator(this);
8491 }
8492
8493 //= MEDFileFieldMultiTS
8494
8495 /*!
8496  * Returns a new empty instance of MEDFileFieldMultiTS.
8497  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8498  *          is to delete this field using decrRef() as it is no more needed.
8499  */
8500 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
8501 {
8502   return new MEDFileFieldMultiTS;
8503 }
8504
8505 /*!
8506  * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
8507  * that has been read from a specified MED file.
8508  *  \param [in] fileName - the name of the MED file to read.
8509  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8510  *          is to delete this field using decrRef() as it is no more needed.
8511  *  \throw If reading the file fails.
8512  */
8513 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, bool loadAll)
8514 {
8515   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,loadAll);
8516   ret->contentNotNull();//to check that content type matches with \a this type.
8517   return ret.retn();
8518 }
8519
8520 /*!
8521  * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
8522  * that has been read from a specified MED file.
8523  *  \param [in] fileName - the name of the MED file to read.
8524  *  \param [in] fieldName - the name of the field to read.
8525  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8526  *          is to delete this field using decrRef() as it is no more needed.
8527  *  \throw If reading the file fails.
8528  *  \throw If there is no field named \a fieldName in the file.
8529  */
8530 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll)
8531 {
8532   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,fieldName,loadAll);
8533   ret->contentNotNull();//to check that content type matches with \a this type.
8534   return ret.retn();
8535 }
8536
8537 /*!
8538  * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8539  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8540  *
8541  * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
8542  * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8543  * \warning this is a shallow copy constructor
8544  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
8545  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8546  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8547  *          is to delete this field using decrRef() as it is no more needed.
8548  */
8549 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8550 {
8551   return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
8552 }
8553
8554 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const
8555 {
8556   return new MEDFileFieldMultiTS(*this);
8557 }
8558
8559 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
8560 {
8561   if(!f1ts)
8562     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8563   const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
8564   if(!f1tsC)
8565     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8566 }
8567
8568 /*!
8569  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
8570  * following the given input policy.
8571  *
8572  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8573  *                            By default (true) the globals are deeply copied.
8574  * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
8575  */
8576 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool deepCpyGlobs) const
8577 {
8578   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret;
8579   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8580   if(content)
8581     {
8582       const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
8583       if(!contc)
8584         throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
8585       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
8586       ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc,getFileName()));
8587     }
8588   else
8589     ret=MEDFileIntFieldMultiTS::New();
8590   if(deepCpyGlobs)
8591     ret->deepCpyGlobs(*this);
8592   else
8593     ret->shallowCpyGlobs(*this);
8594   return ret.retn();
8595 }
8596
8597 /*!
8598  * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
8599  *  \param [in] pos - a time step id.
8600  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8601  *          delete this field using decrRef() as it is no more needed.
8602  *  \throw If \a pos is not a valid time step id.
8603  */
8604 MEDFileAnyTypeField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const
8605 {
8606   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8607   if(!item)
8608     {
8609       std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8610       throw INTERP_KERNEL::Exception(oss.str().c_str());
8611     }
8612   const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
8613   if(itemC)
8614     {
8615       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
8616       ret->shallowCpyGlobs(*this);
8617       return ret.retn();
8618     }
8619   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
8620   throw INTERP_KERNEL::Exception(oss.str().c_str());
8621 }
8622
8623 /*!
8624  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8625  * mesh entities of a given dimension of the first mesh in MED file.
8626  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8627  *  \param [in] type - a spatial discretization of interest.
8628  *  \param [in] iteration - the iteration number of a required time step.
8629  *  \param [in] order - the iteration order number of required time step.
8630  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8631  *  \param [in] renumPol - specifies how to permute values of the result field according to
8632  *          the optional numbers of cells and nodes, if any. The valid values are
8633  *          - 0 - do not permute.
8634  *          - 1 - permute cells.
8635  *          - 2 - permute nodes.
8636  *          - 3 - permute cells and nodes.
8637  *
8638  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8639  *          caller is to delete this field using decrRef() as it is no more needed.
8640  *  \throw If the MED file is not readable.
8641  *  \throw If there is no mesh in the MED file.
8642  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8643  *  \throw If no field values of the required parameters are available.
8644  */
8645 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const
8646 {
8647   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8648   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8649   if(!myF1TSC)
8650     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
8651   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8652   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNullBase());
8653   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8654   return ret.retn();
8655 }
8656
8657 /*!
8658  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8659  * the top level cells of the first mesh in MED file.
8660  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8661  *  \param [in] type - a spatial discretization of interest.
8662  *  \param [in] iteration - the iteration number of a required time step.
8663  *  \param [in] order - the iteration order number of required time step.
8664  *  \param [in] renumPol - specifies how to permute values of the result field according to
8665  *          the optional numbers of cells and nodes, if any. The valid values are
8666  *          - 0 - do not permute.
8667  *          - 1 - permute cells.
8668  *          - 2 - permute nodes.
8669  *          - 3 - permute cells and nodes.
8670  *
8671  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8672  *          caller is to delete this field using decrRef() as it is no more needed.
8673  *  \throw If the MED file is not readable.
8674  *  \throw If there is no mesh in the MED file.
8675  *  \throw If no field values of the required parameters are available.
8676  */
8677 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const
8678 {
8679   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8680   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8681   if(!myF1TSC)
8682     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
8683   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8684   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNullBase());
8685   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8686   return ret.retn();
8687 }
8688
8689 /*!
8690  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8691  * a given support.
8692  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8693  *  \param [in] type - a spatial discretization of interest.
8694  *  \param [in] iteration - the iteration number of a required time step.
8695  *  \param [in] order - the iteration order number of required time step.
8696  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8697  *  \param [in] mesh - the supporting mesh.
8698  *  \param [in] renumPol - specifies how to permute values of the result field according to
8699  *          the optional numbers of cells and nodes, if any. The valid values are
8700  *          - 0 - do not permute.
8701  *          - 1 - permute cells.
8702  *          - 2 - permute nodes.
8703  *          - 3 - permute cells and nodes.
8704  *
8705  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8706  *          caller is to delete this field using decrRef() as it is no more needed.
8707  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8708  *  \throw If no field of \a this is lying on \a mesh.
8709  *  \throw If no field values of the required parameters are available.
8710  */
8711 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
8712 {
8713   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8714   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8715   if(!myF1TSC)
8716     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8717   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8718   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
8719   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8720   return ret.retn();
8721 }
8722
8723 /*!
8724  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8725  * given support.
8726  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8727  *  \param [in] type - a spatial discretization of the new field.
8728  *  \param [in] iteration - the iteration number of a required time step.
8729  *  \param [in] order - the iteration order number of required time step.
8730  *  \param [in] mesh - the supporting mesh.
8731  *  \param [in] renumPol - specifies how to permute values of the result field according to
8732  *          the optional numbers of cells and nodes, if any. The valid values are
8733  *          - 0 - do not permute.
8734  *          - 1 - permute cells.
8735  *          - 2 - permute nodes.
8736  *          - 3 - permute cells and nodes.
8737  *
8738  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8739  *          caller is to delete this field using decrRef() as it is no more needed.
8740  *  \throw If no field of \a this is lying on \a mesh.
8741  *  \throw If no field values of the required parameters are available.
8742  */
8743 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const
8744 {
8745   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8746   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8747   if(!myF1TSC)
8748     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8749   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8750   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
8751   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8752   return ret.retn();
8753 }
8754
8755 /*!
8756  * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
8757  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8758  * This method is useful for MED2 file format when field on different mesh was autorized.
8759  */
8760 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const char *mname, int iteration, int order, int meshDimRelToMax, int renumPol) const
8761 {
8762   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8763   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8764   if(!myF1TSC)
8765     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
8766   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8767   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
8768   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8769   return ret.retn();
8770 }
8771
8772 /*!
8773  * Returns values and a profile of the field of a given type, of a given time step,
8774  * lying on a given support.
8775  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8776  *  \param [in] type - a spatial discretization of the field.
8777  *  \param [in] iteration - the iteration number of a required time step.
8778  *  \param [in] order - the iteration order number of required time step.
8779  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8780  *  \param [in] mesh - the supporting mesh.
8781  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8782  *          field of interest lies on. If the field lies on all entities of the given
8783  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8784  *          using decrRef() as it is no more needed.
8785  *  \param [in] glob - the global data storing profiles and localization.
8786  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
8787  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8788  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8789  *  \throw If no field of \a this is lying on \a mesh.
8790  *  \throw If no field values of the required parameters are available.
8791  */
8792 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
8793 {
8794   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8795   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8796   if(!myF1TSC)
8797     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
8798   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8799   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
8800 }
8801
8802 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const
8803 {
8804   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8805   if(!pt)
8806     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
8807   const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
8808   if(!ret)
8809     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 !");
8810   return ret;
8811 }
8812
8813  MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull()
8814 {
8815   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8816   if(!pt)
8817     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
8818   MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
8819   if(!ret)
8820     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 !");
8821   return ret;
8822 }
8823
8824 /*!
8825  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8826  * the given field is checked if its elements are sorted suitable for writing to MED file
8827  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8828  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8829  *  \param [in] field - the field to add to \a this.
8830  *  \throw If the name of \a field is empty.
8831  *  \throw If the data array of \a field is not set.
8832  *  \throw If existing time steps have different name or number of components than \a field.
8833  *  \throw If the underlying mesh of \a field has no name.
8834  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8835  */
8836 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
8837 {
8838   const DataArrayDouble *arr=0;
8839   if(field)
8840     arr=field->getArray();
8841   contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
8842 }
8843
8844 /*!
8845  * Adds a MEDCouplingFieldDouble to \a this as another time step.
8846  * The mesh support of input parameter \a field is ignored here, it can be NULL.
8847  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
8848  * and \a profile.
8849  *
8850  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
8851  * A new profile is added only if no equal profile is missing.
8852  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8853  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
8854  *  \param [in] mesh - the supporting mesh of \a field.
8855  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
8856  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
8857  *  \throw If either \a field or \a mesh or \a profile has an empty name.
8858  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8859  *  \throw If the data array of \a field is not set.
8860  *  \throw If the data array of \a this is already allocated but has different number of
8861  *         components than \a field.
8862  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
8863  *  \sa setFieldNoProfileSBT()
8864  */
8865 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
8866 {
8867   const DataArrayDouble *arr=0;
8868   if(field)
8869     arr=field->getArray();
8870   contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
8871 }
8872
8873 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
8874 {
8875   _content=new MEDFileFieldMultiTSWithoutSDA;
8876 }
8877
8878 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, bool loadAll)
8879 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
8880 {
8881 }
8882 catch(INTERP_KERNEL::Exception& e)
8883   { throw e; }
8884
8885 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll)
8886 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
8887 {
8888 }
8889 catch(INTERP_KERNEL::Exception& e)
8890   { throw e; }
8891
8892 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
8893 {
8894 }
8895
8896 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
8897 {
8898   return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
8899 }
8900
8901 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
8902 {
8903   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
8904 }
8905
8906 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
8907 {
8908   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
8909 }
8910
8911 //= MEDFileAnyTypeFieldMultiTSIterator
8912
8913 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
8914 {
8915   if(fmts)
8916     {
8917       fmts->incrRef();
8918       _nb_iter=fmts->getNumberOfTS();
8919     }
8920 }
8921
8922 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
8923 {
8924 }
8925
8926 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt()
8927 {
8928   if(_iter_id<_nb_iter)
8929     {
8930       MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
8931       if(fmts)
8932         return fmts->getTimeStepAtPos(_iter_id++);
8933       else
8934         return 0;
8935     }
8936   else
8937     return 0;
8938 }
8939
8940 //= MEDFileIntFieldMultiTS
8941
8942 /*!
8943  * Returns a new empty instance of MEDFileFieldMultiTS.
8944  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8945  *          is to delete this field using decrRef() as it is no more needed.
8946  */
8947 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
8948 {
8949   return new MEDFileIntFieldMultiTS;
8950 }
8951
8952 /*!
8953  * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
8954  * that has been read from a specified MED file.
8955  *  \param [in] fileName - the name of the MED file to read.
8956  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8957  *          is to delete this field using decrRef() as it is no more needed.
8958  *  \throw If reading the file fails.
8959  */
8960 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, bool loadAll)
8961 {
8962   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,loadAll);
8963   ret->contentNotNull();//to check that content type matches with \a this type.
8964   return ret.retn();
8965 }
8966
8967 /*!
8968  * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
8969  * that has been read from a specified MED file.
8970  *  \param [in] fileName - the name of the MED file to read.
8971  *  \param [in] fieldName - the name of the field to read.
8972  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8973  *          is to delete this field using decrRef() as it is no more needed.
8974  *  \throw If reading the file fails.
8975  *  \throw If there is no field named \a fieldName in the file.
8976  */
8977 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll)
8978 {
8979   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,fieldName,loadAll);
8980   ret->contentNotNull();//to check that content type matches with \a this type.
8981   return ret.retn();
8982 }
8983
8984 /*!
8985  * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8986  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8987  *
8988  * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
8989  * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8990  * \warning this is a shallow copy constructor
8991  *  \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
8992  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8993  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8994  *          is to delete this field using decrRef() as it is no more needed.
8995  */
8996 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8997 {
8998   return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
8999 }
9000
9001 /*!
9002  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
9003  * following the given input policy.
9004  *
9005  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
9006  *                            By default (true) the globals are deeply copied.
9007  * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
9008  */
9009 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool deepCpyGlobs) const
9010 {
9011   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret;
9012   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9013   if(content)
9014     {
9015       const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
9016       if(!contc)
9017         throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
9018       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
9019       ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc,getFileName()));
9020     }
9021   else
9022     ret=MEDFileFieldMultiTS::New();
9023   if(deepCpyGlobs)
9024     ret->deepCpyGlobs(*this);
9025   else
9026     ret->shallowCpyGlobs(*this);
9027   return ret.retn();
9028 }
9029
9030 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const
9031 {
9032   return new MEDFileIntFieldMultiTS(*this);
9033 }
9034
9035 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
9036 {
9037   if(!f1ts)
9038     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
9039   const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
9040   if(!f1tsC)
9041     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
9042 }
9043
9044 /*!
9045  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9046  * mesh entities of a given dimension of the first mesh in MED file.
9047  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9048  *  \param [in] type - a spatial discretization of interest.
9049  *  \param [in] iteration - the iteration number of a required time step.
9050  *  \param [in] order - the iteration order number of required time step.
9051  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9052  *  \param [out] arrOut - the DataArrayInt containing values of field.
9053  *  \param [in] renumPol - specifies how to permute values of the result field according to
9054  *          the optional numbers of cells and nodes, if any. The valid values are
9055  *          - 0 - do not permute.
9056  *          - 1 - permute cells.
9057  *          - 2 - permute nodes.
9058  *          - 3 - permute cells and nodes.
9059  *
9060  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9061  *          caller is to delete this field using decrRef() as it is no more needed.
9062  *  \throw If the MED file is not readable.
9063  *  \throw If there is no mesh in the MED file.
9064  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9065  *  \throw If no field values of the required parameters are available.
9066  */
9067 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9068 {
9069   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9070   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9071   if(!myF1TSC)
9072     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
9073   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9074   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arr,*contentNotNullBase());
9075   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9076   return ret.retn();
9077 }
9078
9079 /*!
9080  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9081  * the top level cells of the first mesh in MED file.
9082  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9083  *  \param [in] type - a spatial discretization of interest.
9084  *  \param [in] iteration - the iteration number of a required time step.
9085  *  \param [in] order - the iteration order number of required time step.
9086  *  \param [out] arrOut - the DataArrayInt containing values of field.
9087  *  \param [in] renumPol - specifies how to permute values of the result field according to
9088  *          the optional numbers of cells and nodes, if any. The valid values are
9089  *          - 0 - do not permute.
9090  *          - 1 - permute cells.
9091  *          - 2 - permute nodes.
9092  *          - 3 - permute cells and nodes.
9093  *
9094  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9095  *          caller is to delete this field using decrRef() as it is no more needed.
9096  *  \throw If the MED file is not readable.
9097  *  \throw If there is no mesh in the MED file.
9098  *  \throw If no field values of the required parameters are available.
9099  */
9100 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, DataArrayInt* &arrOut, int renumPol) const
9101 {
9102   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9103   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9104   if(!myF1TSC)
9105     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
9106   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9107   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNullBase());
9108   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9109   return ret.retn();
9110 }
9111
9112 /*!
9113  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9114  * a given support.
9115  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9116  *  \param [in] type - a spatial discretization of interest.
9117  *  \param [in] iteration - the iteration number of a required time step.
9118  *  \param [in] order - the iteration order number of required time step.
9119  *  \param [out] arrOut - the DataArrayInt containing values of field.
9120  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9121  *  \param [in] mesh - the supporting mesh.
9122  *  \param [in] renumPol - specifies how to permute values of the result field according to
9123  *          the optional numbers of cells and nodes, if any. The valid values are
9124  *          - 0 - do not permute.
9125  *          - 1 - permute cells.
9126  *          - 2 - permute nodes.
9127  *          - 3 - permute cells and nodes.
9128  *
9129  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9130  *          caller is to delete this field using decrRef() as it is no more needed.
9131  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9132  *  \throw If no field of \a this is lying on \a mesh.
9133  *  \throw If no field values of the required parameters are available.
9134  */
9135 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9136 {
9137   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9138   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9139   if(!myF1TSC)
9140     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9141   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9142   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase());
9143   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9144   return ret.retn();
9145 }
9146
9147 /*!
9148  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
9149  * given support.
9150  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9151  *  \param [in] type - a spatial discretization of the new field.
9152  *  \param [in] iteration - the iteration number of a required time step.
9153  *  \param [in] order - the iteration order number of required time step.
9154  *  \param [in] mesh - the supporting mesh.
9155  *  \param [out] arrOut - the DataArrayInt containing values of field.
9156  *  \param [in] renumPol - specifies how to permute values of the result field according to
9157  *          the optional numbers of cells and nodes, if any. The valid values are
9158  *          - 0 - do not permute.
9159  *          - 1 - permute cells.
9160  *          - 2 - permute nodes.
9161  *          - 3 - permute cells and nodes.
9162  *
9163  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9164  *          caller is to delete this field using decrRef() as it is no more needed.
9165  *  \throw If no field of \a this is lying on \a mesh.
9166  *  \throw If no field values of the required parameters are available.
9167  */
9168 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9169 {
9170   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9171   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9172   if(!myF1TSC)
9173     throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9174   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9175   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase());
9176   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9177   return ret.retn();
9178 }
9179
9180 /*!
9181  * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
9182  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
9183  * This method is useful for MED2 file format when field on different mesh was autorized.
9184  */
9185 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9186 {
9187   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9188   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9189   if(!myF1TSC)
9190     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9191   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9192   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase());
9193   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9194   return ret.retn();
9195 }
9196
9197 /*!
9198  * Returns values and a profile of the field of a given type, of a given time step,
9199  * lying on a given support.
9200  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9201  *  \param [in] type - a spatial discretization of the field.
9202  *  \param [in] iteration - the iteration number of a required time step.
9203  *  \param [in] order - the iteration order number of required time step.
9204  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9205  *  \param [in] mesh - the supporting mesh.
9206  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
9207  *          field of interest lies on. If the field lies on all entities of the given
9208  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
9209  *          using decrRef() as it is no more needed.
9210  *  \param [in] glob - the global data storing profiles and localization.
9211  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
9212  *          field. The caller is to delete this array using decrRef() as it is no more needed.
9213  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9214  *  \throw If no field of \a this is lying on \a mesh.
9215  *  \throw If no field values of the required parameters are available.
9216  */
9217 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
9218 {
9219   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9220   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9221   if(!myF1TSC)
9222     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
9223   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
9224   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(ret);
9225 }
9226
9227 /*!
9228  * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
9229  *  \param [in] pos - a time step id.
9230  *  \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
9231  *          delete this field using decrRef() as it is no more needed.
9232  *  \throw If \a pos is not a valid time step id.
9233  */
9234 MEDFileAnyTypeField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const
9235 {
9236   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
9237   if(!item)
9238     {
9239       std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
9240       throw INTERP_KERNEL::Exception(oss.str().c_str());
9241     }
9242   const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
9243   if(itemC)
9244     {
9245       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
9246       ret->shallowCpyGlobs(*this);
9247       return ret.retn();
9248     }
9249   std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
9250   throw INTERP_KERNEL::Exception(oss.str().c_str());
9251 }
9252
9253 /*!
9254  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
9255  * the given field is checked if its elements are sorted suitable for writing to MED file
9256  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
9257  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9258  *  \param [in] field - the field to add to \a this.
9259  *  \throw If the name of \a field is empty.
9260  *  \throw If the data array of \a field is not set.
9261  *  \throw If existing time steps have different name or number of components than \a field.
9262  *  \throw If the underlying mesh of \a field has no name.
9263  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
9264  */
9265 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
9266 {
9267   contentNotNull()->appendFieldNoProfileSBT(field,arrOfVals,*this);
9268 }
9269
9270 /*!
9271  * Adds a MEDCouplingFieldDouble to \a this as another time step.
9272  * The mesh support of input parameter \a field is ignored here, it can be NULL.
9273  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
9274  * and \a profile.
9275  *
9276  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
9277  * A new profile is added only if no equal profile is missing.
9278  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9279  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
9280  *  \param [in] arrOfVals - the values of the field \a field used.
9281  *  \param [in] mesh - the supporting mesh of \a field.
9282  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
9283  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
9284  *  \throw If either \a field or \a mesh or \a profile has an empty name.
9285  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9286  *  \throw If the data array of \a field is not set.
9287  *  \throw If the data array of \a this is already allocated but has different number of
9288  *         components than \a field.
9289  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
9290  *  \sa setFieldNoProfileSBT()
9291  */
9292 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
9293 {
9294   contentNotNull()->appendFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this);
9295 }
9296
9297 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const
9298 {
9299   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9300   if(!pt)
9301     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
9302   const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9303   if(!ret)
9304     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 !");
9305   return ret;
9306 }
9307
9308  MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull()
9309 {
9310   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9311   if(!pt)
9312     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
9313   MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9314   if(!ret)
9315     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 !");
9316   return ret;
9317 }
9318
9319 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
9320 {
9321   _content=new MEDFileIntFieldMultiTSWithoutSDA;
9322 }
9323
9324 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
9325 {
9326 }
9327
9328 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, bool loadAll)
9329 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
9330 {
9331 }
9332 catch(INTERP_KERNEL::Exception& e)
9333   { throw e; }
9334
9335 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll)
9336 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
9337 {
9338 }
9339 catch(INTERP_KERNEL::Exception& e)
9340   { throw e; }
9341
9342 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
9343 {
9344   return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
9345 }
9346
9347 //= MEDFileFields
9348
9349 MEDFileFields *MEDFileFields::New()
9350 {
9351   return new MEDFileFields;
9352 }
9353
9354 MEDFileFields *MEDFileFields::New(const char *fileName, bool loadAll)
9355 {
9356   return new MEDFileFields(fileName,loadAll);
9357 }
9358
9359 std::size_t MEDFileFields::getHeapMemorySizeWithoutChildren() const
9360 {
9361   std::size_t ret(MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren());
9362   ret+=_fields.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
9363   return ret;
9364 }
9365
9366 std::vector<const BigMemoryObject *> MEDFileFields::getDirectChildren() const
9367 {
9368   std::vector<const BigMemoryObject *> ret;
9369   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9370     {
9371       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9372       if(cur)
9373         ret.push_back(cur);
9374     }
9375   return ret;
9376 }
9377
9378 MEDFileFields *MEDFileFields::deepCpy() const
9379 {
9380   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9381   std::size_t i=0;
9382   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9383     {
9384       if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9385         ret->_fields[i]=(*it)->deepCpy();
9386     }
9387   ret->deepCpyGlobs(*this);
9388   return ret.retn();
9389 }
9390
9391 MEDFileFields *MEDFileFields::shallowCpy() const
9392 {
9393   return new MEDFileFields(*this);
9394 }
9395
9396 /*!
9397  * 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
9398  * 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.
9399  * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
9400  *
9401  * \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.
9402  * \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.
9403  *
9404  * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9405  */
9406 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const
9407 {
9408   std::set< std::pair<int,int> > s;
9409   bool firstShot=true;
9410   areThereSomeForgottenTS=false;
9411   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9412     {
9413       if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9414         continue;
9415       std::vector< std::pair<int,int> > v=(*it)->getIterations();
9416       std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
9417       if(firstShot)
9418         { s=s1; firstShot=false; }
9419       else
9420         {
9421           std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
9422           if(s!=s2)
9423             areThereSomeForgottenTS=true;
9424           s=s2;
9425         }
9426     }
9427   std::vector< std::pair<int,int> > ret;
9428   std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
9429   return ret;
9430 }
9431
9432 int MEDFileFields::getNumberOfFields() const
9433 {
9434   return _fields.size();
9435 }
9436
9437 std::vector<std::string> MEDFileFields::getFieldsNames() const
9438 {
9439   std::vector<std::string> ret(_fields.size());
9440   int i=0;
9441   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9442     {
9443       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
9444       if(f)
9445         {
9446           ret[i]=f->getName();
9447         }
9448       else
9449         {
9450           std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
9451           throw INTERP_KERNEL::Exception(oss.str().c_str());
9452         }
9453     }
9454   return ret;
9455 }
9456
9457 std::vector<std::string> MEDFileFields::getMeshesNames() const
9458 {
9459   std::vector<std::string> ret;
9460   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9461     {
9462       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9463       if(cur)
9464         ret.push_back(cur->getMeshName());
9465     }
9466   return ret;
9467 }
9468
9469 std::string MEDFileFields::simpleRepr() const
9470 {
9471   std::ostringstream oss;
9472   oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
9473   simpleRepr(0,oss);
9474   return oss.str();
9475 }
9476
9477 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
9478 {
9479   int nbOfFields=getNumberOfFields();
9480   std::string startLine(bkOffset,' ');
9481   oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
9482   int i=0;
9483   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9484     {
9485       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9486       if(cur)
9487         {
9488           oss << startLine << "  - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
9489         }
9490       else
9491         {
9492           oss << startLine << "  - not defined !" << std::endl;
9493         }
9494     }
9495   i=0;
9496   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9497     {
9498       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9499       std::string chapter(17,'0'+i);
9500       oss << startLine << chapter << std::endl;
9501       if(cur)
9502         {
9503           cur->simpleRepr(bkOffset+2,oss,i);
9504         }
9505       else
9506         {
9507           oss << startLine << "  - not defined !" << std::endl;
9508         }
9509       oss << startLine << chapter << std::endl;
9510     }
9511   simpleReprGlobs(oss);
9512 }
9513
9514 MEDFileFields::MEDFileFields()
9515 {
9516 }
9517
9518 MEDFileFields::MEDFileFields(const char *fileName, bool loadAll)
9519 try:MEDFileFieldGlobsReal(fileName)
9520   {
9521     MEDFileUtilities::CheckFileForRead(fileName);
9522     MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
9523     int nbFields=MEDnField(fid);
9524     _fields.resize(nbFields);
9525     med_field_type typcha;
9526     for(int i=0;i<nbFields;i++)
9527       {
9528         std::vector<std::string> infos;
9529         std::string fieldName,dtunit;
9530         int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,fileName,i,false,fieldName,typcha,infos,dtunit);
9531         switch(typcha)
9532           {
9533           case MED_FLOAT64:
9534             {
9535               _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9536               break;
9537             }
9538           case MED_INT32:
9539             {
9540               _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9541               break;
9542             }
9543           default:
9544             {
9545               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] !";
9546               throw INTERP_KERNEL::Exception(oss.str().c_str());
9547             }
9548           }
9549       }
9550     loadAllGlobals(fid);
9551   }
9552 catch(INTERP_KERNEL::Exception& e)
9553   {
9554     throw e;
9555   }
9556
9557 void MEDFileFields::writeLL(med_idt fid) const
9558 {
9559   int i=0;
9560   writeGlobals(fid,*this);
9561   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9562     {
9563       const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
9564       if(!elt)
9565         {
9566           std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
9567           throw INTERP_KERNEL::Exception(oss.str().c_str());
9568         }
9569       elt->writeLL(fid,*this);
9570     }
9571 }
9572
9573 void MEDFileFields::write(const char *fileName, int mode) const
9574 {
9575   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
9576   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
9577   writeLL(fid);
9578 }
9579
9580 /*!
9581  * This method alloc the arrays and load potentially huge arrays contained in this field.
9582  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
9583  * This method can be also called to refresh or reinit values from a file.
9584  *
9585  * \throw If the fileName is not set or points to a non readable MED file.
9586  */
9587 void MEDFileFields::loadArrays()
9588 {
9589   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9590   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9591     {
9592       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9593       if(elt)
9594         elt->loadBigArraysRecursively(fid,*elt);
9595     }
9596 }
9597
9598 /*!
9599  * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
9600  * But once data loaded once, this method does nothing.
9601  *
9602  * \throw If the fileName is not set or points to a non readable MED file.
9603  * \sa MEDFileFields::loadArrays, MEDFileFields::unloadArrays
9604  */
9605 void MEDFileFields::loadArraysIfNecessary()
9606 {
9607   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9608   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9609     {
9610       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9611       if(elt)
9612         elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
9613     }
9614 }
9615
9616 /*!
9617  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
9618  * This method does not release arrays set outside the context of a MED file.
9619  *
9620  * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary
9621  */
9622 void MEDFileFields::unloadArrays()
9623 {
9624   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9625   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9626     {
9627       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9628       if(elt)
9629         elt->unloadArrays();
9630     }
9631 }
9632
9633 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
9634 {
9635   std::vector<std::string> ret;
9636   std::set<std::string> ret2;
9637   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9638     {
9639       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
9640       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9641         if(ret2.find(*it2)==ret2.end())
9642           {
9643             ret.push_back(*it2);
9644             ret2.insert(*it2);
9645           }
9646     }
9647   return ret;
9648 }
9649
9650 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
9651 {
9652   std::vector<std::string> ret;
9653   std::set<std::string> ret2;
9654   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9655     {
9656       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9657       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9658         if(ret2.find(*it2)==ret2.end())
9659           {
9660             ret.push_back(*it2);
9661             ret2.insert(*it2);
9662           }
9663     }
9664   return ret;
9665 }
9666
9667 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
9668 {
9669   std::vector<std::string> ret;
9670   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9671     {
9672       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
9673       ret.insert(ret.end(),tmp.begin(),tmp.end());
9674     }
9675   return ret;
9676 }
9677
9678 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
9679 {
9680   std::vector<std::string> ret;
9681   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9682     {
9683       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9684       ret.insert(ret.end(),tmp.begin(),tmp.end());
9685     }
9686   return ret;
9687 }
9688
9689 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9690 {
9691   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9692     (*it)->changePflsRefsNamesGen2(mapOfModif);
9693 }
9694
9695 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9696 {
9697   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9698     (*it)->changeLocsRefsNamesGen2(mapOfModif);
9699 }
9700
9701 void MEDFileFields::resize(int newSize)
9702 {
9703   _fields.resize(newSize);
9704 }
9705
9706 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields)
9707 {
9708   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
9709     pushField(*it);
9710 }
9711
9712 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field)
9713 {
9714   if(!field)
9715     throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
9716   _fields.push_back(field->getContent());
9717   appendGlobs(*field,1e-12);
9718 }
9719
9720 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field)
9721 {
9722   if(!field)
9723     throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
9724   if(i>=(int)_fields.size())
9725     _fields.resize(i+1);
9726   _fields[i]=field->getContent();
9727   appendGlobs(*field,1e-12);
9728 }
9729
9730 void MEDFileFields::destroyFieldAtPos(int i)
9731 {
9732   destroyFieldsAtPos(&i,&i+1);
9733 }
9734
9735 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds)
9736 {
9737   std::vector<bool> b(_fields.size(),true);
9738   for(const int *i=startIds;i!=endIds;i++)
9739     {
9740       if(*i<0 || *i>=(int)_fields.size())
9741         {
9742           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9743           throw INTERP_KERNEL::Exception(oss.str().c_str());
9744         }
9745       b[*i]=false;
9746     }
9747   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9748   std::size_t j=0;
9749   for(std::size_t i=0;i<_fields.size();i++)
9750     if(b[i])
9751       fields[j++]=_fields[i];
9752   _fields=fields;
9753 }
9754
9755 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step)
9756 {
9757   static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
9758   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
9759   std::vector<bool> b(_fields.size(),true);
9760   int k=bg;
9761   for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
9762     {
9763       if(k<0 || k>=(int)_fields.size())
9764         {
9765           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
9766           throw INTERP_KERNEL::Exception(oss.str().c_str());
9767         }
9768       b[k]=false;
9769     }
9770   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9771   std::size_t j=0;
9772   for(std::size_t i=0;i<_fields.size();i++)
9773     if(b[i])
9774       fields[j++]=_fields[i];
9775   _fields=fields;
9776 }
9777
9778 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
9779 {
9780   bool ret=false;
9781   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9782     {
9783       MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9784       if(cur)
9785         ret=cur->changeMeshNames(modifTab) || ret;
9786     }
9787   return ret;
9788 }
9789
9790 /*!
9791  * \param [in] meshName the name of the mesh that will be renumbered.
9792  * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
9793  *             This code corresponds to the distribution of types in the corresponding mesh.
9794  * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
9795  * \param [in] renumO2N the old to new renumber array.
9796  * \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
9797  *         field in \a this.
9798  */
9799 bool MEDFileFields::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N)
9800 {
9801   bool ret=false;
9802   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9803     {
9804       MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
9805       if(fmts)
9806         {
9807           ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
9808         }
9809     }
9810   return ret;
9811 }
9812
9813 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const
9814 {
9815   if(i<0 || i>=(int)_fields.size())
9816     {
9817       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
9818       throw INTERP_KERNEL::Exception(oss.str().c_str());
9819     }
9820   const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
9821   if(!fmts)
9822     return 0;
9823   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret;
9824   const MEDFileFieldMultiTSWithoutSDA *fmtsC=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts);
9825   const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts);
9826   if(fmtsC)
9827     ret=MEDFileFieldMultiTS::New(*fmtsC,false);
9828   else if(fmtsC2)
9829     ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
9830   else
9831     {
9832       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
9833       throw INTERP_KERNEL::Exception(oss.str().c_str());
9834     }
9835   ret->shallowCpyGlobs(*this);
9836   return ret.retn();
9837 }
9838
9839 /*!
9840  * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
9841  * This method is accessible in python using __getitem__ with a list in input.
9842  * \return a new object that the caller should deal with.
9843  */
9844 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const
9845 {
9846   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9847   std::size_t sz=std::distance(startIds,endIds);
9848   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
9849   int j=0;
9850   for(const int *i=startIds;i!=endIds;i++,j++)
9851     {
9852       if(*i<0 || *i>=(int)_fields.size())
9853         {
9854           std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9855           throw INTERP_KERNEL::Exception(oss.str().c_str());
9856         }
9857       fields[j]=_fields[*i];
9858     }
9859   ret->_fields=fields;
9860   return ret.retn();
9861 }
9862
9863 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const char *fieldName) const
9864 {
9865   return getFieldAtPos(getPosFromFieldName(fieldName));
9866 }
9867
9868 /*!
9869  * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
9870  * This method can be seen as a filter applied on \a this, that returns an object containing
9871  * 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
9872  * shallow copied from \a this.
9873  *
9874  * \param [in] meshName - the name of the mesh on w
9875  * \return a new object that the caller should deal with.
9876  */
9877 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const char *meshName) const
9878 {
9879   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9880   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9881     {
9882       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9883       if(!cur)
9884         continue;
9885       if(cur->getMeshName()==meshName)
9886         {
9887           cur->incrRef();
9888           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
9889           ret->_fields.push_back(cur2);
9890         }
9891     }
9892   ret->shallowCpyOnlyUsedGlobs(*this);
9893   return ret.retn();
9894 }
9895
9896 /*!
9897  * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
9898  * Input time steps are specified using a pair of integer (iteration, order).
9899  * 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,
9900  * but for each multitimestep only the time steps in \a timeSteps are kept.
9901  * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
9902  *
9903  * The returned object points to shallow copy of elements in \a this.
9904  *
9905  * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
9906  * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
9907  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9908  */
9909 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
9910 {
9911   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9912   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9913     {
9914       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9915       if(!cur)
9916         continue;
9917       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
9918       ret->_fields.push_back(elt);
9919     }
9920   ret->shallowCpyOnlyUsedGlobs(*this);
9921   return ret.retn();
9922 }
9923
9924 /*!
9925  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
9926  */
9927 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
9928 {
9929   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9930   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9931     {
9932       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9933       if(!cur)
9934         continue;
9935       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
9936       if(elt->getNumberOfTS()!=0)
9937         ret->_fields.push_back(elt);
9938     }
9939   ret->shallowCpyOnlyUsedGlobs(*this);
9940   return ret.retn();
9941 }
9942
9943 MEDFileFieldsIterator *MEDFileFields::iterator()
9944 {
9945   return new MEDFileFieldsIterator(this);
9946 }
9947
9948 int MEDFileFields::getPosFromFieldName(const char *fieldName) const
9949 {
9950   std::string tmp(fieldName);
9951   std::vector<std::string> poss;
9952   for(std::size_t i=0;i<_fields.size();i++)
9953     {
9954       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=_fields[i];
9955       if(f)
9956         {
9957           std::string fname(f->getName());
9958           if(tmp==fname)
9959             return i;
9960           else
9961             poss.push_back(fname);
9962         }
9963     }
9964   std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
9965   std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
9966   oss << " !";
9967   throw INTERP_KERNEL::Exception(oss.str().c_str());
9968 }
9969
9970 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
9971 {
9972   if(fs)
9973     {
9974       fs->incrRef();
9975       _nb_iter=fs->getNumberOfFields();
9976     }
9977 }
9978
9979 MEDFileFieldsIterator::~MEDFileFieldsIterator()
9980 {
9981 }
9982
9983 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
9984 {
9985   if(_iter_id<_nb_iter)
9986     {
9987       MEDFileFields *fs(_fs);
9988       if(fs)
9989         return fs->getFieldAtPos(_iter_id++);
9990       else
9991         return 0;
9992     }
9993   else
9994     return 0;
9995 }