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