src/MEDLoader/MEDFileField.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "MEDFileField.hxx"
  22 #include "MEDFileMesh.hxx"
  23 #include "MEDLoaderBase.hxx"
  24 #include "MEDFileUtilities.hxx"
  25
  26 #include "MEDCouplingFieldDouble.hxx"
  27 #include "MEDCouplingFieldDiscretization.hxx"
  28
  29 #include "InterpKernelAutoPtr.hxx"
  30 #include "CellModel.hxx"
  31
  32 #include <algorithm>
  33 #include <iterator>
  34
  35 extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
  36 extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
  37 extern med_geometry_type typmainoeud[1];
  38 extern med_geometry_type typmai3[32];
  39
  40 using namespace ParaMEDMEM;
  41
  42 const char MEDFileField1TSWithoutSDA::TYPE_STR[]="FLOAT64";
  43 const char MEDFileIntField1TSWithoutSDA::TYPE_STR[]="INT32";
  44
  45 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, const char *locName)
  46 {
  47   return new MEDFileFieldLoc(fid,locName);
  48 }
  49
  50 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, int id)
  51 {
  52   return new MEDFileFieldLoc(fid,id);
  53 }
  54
  55 MEDFileFieldLoc *MEDFileFieldLoc::New(const char *locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
  56 {
  57   return new MEDFileFieldLoc(locName,geoType,refCoo,gsCoo,w);
  58 }
  59
  60 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, const char *locName):_name(locName)
  61 {
  62   med_geometry_type geotype;
  63   med_geometry_type sectiongeotype;
  64   int nsectionmeshcell;
  65   INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  66   INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  67   MEDlocalizationInfoByName(fid,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
  68   _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+32,geotype)));
  69   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
  70   _nb_node_per_cell=cm.getNumberOfNodes();
  71   _ref_coo.resize(_dim*_nb_node_per_cell);
  72   _gs_coo.resize(_dim*_nb_gauss_pt);
  73   _w.resize(_nb_gauss_pt);
  74   MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
  75 }
  76
  77 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, int id)
  78 {
  79   med_geometry_type geotype;
  80   med_geometry_type sectiongeotype;
  81   int nsectionmeshcell;
  82   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  83   INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  84   INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  85   MEDlocalizationInfo(fid,id+1,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
  86   _name=locName;
  87   _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+32,geotype)));
  88   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
  89   _nb_node_per_cell=cm.getNumberOfNodes();
  90   _ref_coo.resize(_dim*_nb_node_per_cell);
  91   _gs_coo.resize(_dim*_nb_gauss_pt);
  92   _w.resize(_nb_gauss_pt);
  93   MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
  94 }
  95
  96 MEDFileFieldLoc::MEDFileFieldLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType,
  97                                  const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w):_name(locName),_geo_type(geoType),_ref_coo(refCoo),_gs_coo(gsCoo),
  98                                                                                                                                     _w(w)
  99 {
 100   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
 101   _dim=cm.getDimension();
 102   _nb_node_per_cell=cm.getNumberOfNodes();
 103   _nb_gauss_pt=_w.size();
 104 }
 105
 106 MEDFileFieldLoc *MEDFileFieldLoc::deepCpy() const
 107 {
 108   return new MEDFileFieldLoc(*this);
 109 }
 110
 111 std::size_t MEDFileFieldLoc::getHeapMemorySize() const
 112 {
 113   return (_ref_coo.capacity()+_gs_coo.capacity()+_w.capacity())*sizeof(double)+_name.capacity();
 114 }
 115
 116 void MEDFileFieldLoc::simpleRepr(std::ostream& oss) const
 117 {
 118   static const char OFF7[]="\n    ";
 119   oss << "\"" << _name << "\"" << OFF7;
 120   oss << "GeoType=" << INTERP_KERNEL::CellModel::GetCellModel(_geo_type).getRepr() << OFF7;
 121   oss << "Dimension=" << _dim << OFF7;
 122   oss << "Number of Gauss points=" << _nb_gauss_pt << OFF7;
 123   oss << "Number of nodes per cell=" << _nb_node_per_cell << OFF7;
 124   oss << "RefCoords="; std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 125   oss << "Weights="; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 126   oss << "GaussPtsCoords="; std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," ")); oss << std::endl;
 127 }
 128
 129 void MEDFileFieldLoc::setName(const char *name)
 130 {
 131   _name=name;
 132 }
 133
 134 bool MEDFileFieldLoc::isEqual(const MEDFileFieldLoc& other, double eps) const
 135 {
 136   if(_name!=other._name)
 137     return false;
 138   if(_dim!=other._dim)
 139     return false;
 140   if(_nb_gauss_pt!=other._nb_gauss_pt)
 141     return false;
 142   if(_nb_node_per_cell!=other._nb_node_per_cell)
 143     return false;
 144   if(_geo_type!=other._geo_type)
 145     return false;
 146   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_ref_coo,other._ref_coo,eps))
 147     return false;
 148   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_gs_coo,other._gs_coo,eps))
 149     return false;
 150   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_w,other._w,eps))
 151     return false;
 152
 153   return true;
 154 }
 155
 156 void MEDFileFieldLoc::writeLL(med_idt fid) const
 157 {
 158   MEDlocalizationWr(fid,_name.c_str(),typmai3[(int)_geo_type],_dim,&_ref_coo[0],MED_FULL_INTERLACE,_nb_gauss_pt,&_gs_coo[0],&_w[0],MED_NO_INTERPOLATION,MED_NO_MESH_SUPPORT);
 159 }
 160
 161 std::string MEDFileFieldLoc::repr() const
 162 {
 163   std::ostringstream oss; oss.precision(15);
 164   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
 165   oss << "Localization \"" << _name << "\" :\n" << "  - Geometric Type : " << cm.getRepr();
 166   oss << "\n  - Dimension : " << _dim << "\n  - Number of gauss points : ";
 167   oss << _nb_gauss_pt << "\n  - Number of nodes in cell : " << _nb_node_per_cell;
 168   oss << "\n  - Ref coords are : ";
 169   int sz=_ref_coo.size();
 170   if(sz%_dim==0)
 171     {
 172       int nbOfTuples=sz/_dim;
 173       for(int i=0;i<nbOfTuples;i++)
 174         {
 175           oss << "(";
 176           for(int j=0;j<_dim;j++)
 177             { oss << _ref_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 178           oss << ") ";
 179         }
 180     }
 181   else
 182     std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," "));
 183   oss << "\n  - Gauss coords in reference element : ";
 184   sz=_gs_coo.size();
 185   if(sz%_dim==0)
 186     {
 187       int nbOfTuples=sz/_dim;
 188       for(int i=0;i<nbOfTuples;i++)
 189         {
 190           oss << "(";
 191           for(int j=0;j<_dim;j++)
 192             { oss << _gs_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 193           oss << ") ";
 194         }
 195     }
 196   else
 197     std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," "));
 198   oss << "\n  - Weights of Gauss coords are : "; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," "));
 199   return oss.str();
 200 }
 201
 202 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 203 {
 204   _type=field->getTypeOfField();
 205   _start=start;
 206   switch(_type)
 207     {
 208     case ON_CELLS:
 209       {
 210         getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,offset,offset+nbOfCells,1);
 211         _end=_start+nbOfCells;
 212         _nval=nbOfCells;
 213         break;
 214       }
 215     case ON_GAUSS_NE:
 216       {
 217         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(field->getMesh());
 218         const int *arrPtr=arr->getConstPointer();
 219         getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,arrPtr[offset],arrPtr[offset+nbOfCells],1);
 220         _end=_start+(arrPtr[offset+nbOfCells]-arrPtr[offset]);
 221         _nval=nbOfCells;
 222         break;
 223       }
 224     case ON_GAUSS_PT:
 225       {
 226         const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
 227         const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
 228         const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
 229         if(!disc2)
 230           throw INTERP_KERNEL::Exception("assignFieldNoProfile : invalid call to this method ! Internal Error !");
 231         const DataArrayInt *dai=disc2->getArrayOfDiscIds();
 232         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai2=disc2->getOffsetArr(field->getMesh());
 233         const int *dai2Ptr=dai2->getConstPointer();
 234         int nbi=gsLoc.getWeights().size();
 235         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=dai->selectByTupleId2(offset,offset+nbOfCells,1);
 236         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
 237         const int *da3Ptr=da3->getConstPointer();
 238         if(da3->getNumberOfTuples()!=nbOfCells)
 239           {//profile : for gauss even in NoProfile !!!
 240             std::ostringstream oss; oss << "Pfl_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 241             _profile=oss.str();
 242             da3->setName(_profile.c_str());
 243             glob.appendProfile(da3);
 244           }
 245         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=DataArrayInt::New();
 246         _nval=da3->getNbOfElems();
 247         da4->alloc(_nval*nbi,1);
 248         int *da4Ptr=da4->getPointer();
 249         for(int i=0;i<_nval;i++)
 250           {
 251             int ref=dai2Ptr[offset+da3Ptr[i]];
 252             for(int j=0;j<nbi;j++)
 253               *da4Ptr++=ref+j;
 254           }
 255         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 256         _localization=oss2.str();
 257         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,da4);
 258         _end=_start+_nval*nbi;
 259         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 260         break;
 261       }
 262     default:
 263       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile : not implemented yet for such discretization type of field !");
 264     }
 265   start=_end;
 266 }
 267
 268 /*!
 269  * Leaf method of field with profile assignement. This method is the most general one. No optimization is done here.
 270  * \param [in] pflName input containing name of profile if any. 0 if no profile (except for GAUSS_PT where a no profile can hide a profile when splitted by loc_id).
 271  * \param [in] multiTypePfl is the end user profile specified in high level API
 272  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
 273  * \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
 274  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
 275  * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
 276  */
 277 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const DataArray *arrr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 278 {
 279   _profile.clear();
 280   _type=field->getTypeOfField();
 281   std::string pflName(multiTypePfl->getName());
 282   std::ostringstream oss; oss << pflName;
 283   if(_type!=ON_NODES) { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType()); oss << "_" <<  cm.getRepr(); } else { oss << "_NODE"; }
 284   if(locIds)
 285     {
 286       if(pflName.empty())
 287         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : existing profile with empty name !");
 288       if(_type!=ON_GAUSS_PT)
 289         {
 290           locIds->setName(oss.str().c_str());
 291           glob.appendProfile(locIds);
 292           _profile=oss.str();
 293         }
 294     }
 295   _start=start;
 296   switch(_type)
 297     {
 298     case ON_NODES:
 299       {
 300          _nval=idsInPfl->getNumberOfTuples();
 301          getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,arrr->getNumberOfTuples(),1);
 302          _end=_start+_nval;
 303          break;
 304       }
 305     case ON_CELLS:
 306       {
 307         _nval=idsInPfl->getNumberOfTuples();
 308         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,idsInPfl);
 309         _end=_start+_nval;
 310         break;
 311       }
 312     case ON_GAUSS_NE:
 313       {
 314         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(mesh);
 315         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr->deltaShiftIndex();
 316         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3=arr2->selectByTupleId(multiTypePfl->begin(),multiTypePfl->end());
 317         arr3->computeOffsets2();
 318         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=idsInPfl->buildExplicitArrByRanges(arr3);
 319         int trueNval=tmp->getNumberOfTuples();
 320         _nval=idsInPfl->getNumberOfTuples();
 321         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 322         _end=_start+trueNval;
 323         break;
 324       }
 325     case ON_GAUSS_PT:
 326       {
 327         const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
 328         if(!disc2)
 329           throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
 330         const DataArrayInt *da1=disc2->getArrayOfDiscIds();
 331         const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
 332         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da1->selectByTupleId(idsInPfl->begin(),idsInPfl->end());
 333         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
 334         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=idsInPfl->selectByTupleId(da3->begin(),da3->end());
 335         //
 336         MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPart(multiTypePfl->begin(),multiTypePfl->end());
 337         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=disc2->getOffsetArr(mesh2);
 338         //
 339         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=DataArrayInt::New();
 340         int trueNval=0;
 341         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 342           trueNval+=arr->getIJ(*pt+1,0)-arr->getIJ(*pt,0);
 343         tmp->alloc(trueNval,1);
 344         int *tmpPtr=tmp->getPointer();
 345         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 346           for(int j=arr->getIJ(*pt,0);j<arr->getIJ(*pt+1,0);j++)
 347             *tmpPtr++=j;
 348         //
 349         _nval=da4->getNumberOfTuples();
 350         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 351         _end=_start+trueNval;
 352         oss << "_loc_" << _loc_id;
 353         if(locIds)
 354           {
 355             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da5=locIds->selectByTupleId(da3->begin(),da3->end());
 356             da5->setName(oss.str().c_str());
 357             glob.appendProfile(da5);
 358             _profile=oss.str();
 359           }
 360         else
 361           {
 362             if(da3->getNumberOfTuples()!=nbOfEltsInWholeMesh || !da3->isIdentity())
 363               {
 364                 da3->setName(oss.str().c_str());
 365                 glob.appendProfile(da3);
 366                 _profile=oss.str();
 367               }
 368           }
 369         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 370         _localization=oss2.str();
 371         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 372         break;
 373       }
 374     default:
 375       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : not implemented yet for such discretization type of field !");
 376     }
 377   start=_end;
 378 }
 379
 380 void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
 381 {
 382   _start=start;
 383   _nval=arrr->getNumberOfTuples();
 384   getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,_nval,1);
 385   _end=_start+_nval;
 386   start=_end;
 387 }
 388
 389 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int profileIt) throw(INTERP_KERNEL::Exception)
 390 {
 391   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,profileIt);
 392 }
 393
 394 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId)
 395 {
 396   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,locId,std::string());
 397 }
 398
 399 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(const MEDFileFieldPerMeshPerTypePerDisc& other)
 400 {
 401   return new MEDFileFieldPerMeshPerTypePerDisc(other);
 402 }
 403
 404 std::size_t MEDFileFieldPerMeshPerTypePerDisc::getHeapMemorySize() const
 405 {
 406   return _profile.capacity()+_localization.capacity()+5*sizeof(int);
 407 }
 408
 409 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::deepCpy(MEDFileFieldPerMeshPerType *father) const throw(INTERP_KERNEL::Exception)
 410 {
 411   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> ret=new MEDFileFieldPerMeshPerTypePerDisc(*this);
 412   ret->_father=father;
 413   return ret.retn();
 414 }
 415
 416 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField atype, int profileIt) throw(INTERP_KERNEL::Exception)
 417 try:_type(atype),_father(fath)
 418   {
 419   }
 420 catch(INTERP_KERNEL::Exception& e)
 421 {
 422   throw e;
 423 }
 424
 425 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId, const std::string& dummy):_type(type),_father(fath),_loc_id(locId)
 426 {
 427 }
 428
 429 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc& other):_type(other._type),_father(0),_start(other._start),_end(other._end),_nval(other._nval),_profile(other._profile),_localization(other._localization),_loc_id(other._loc_id),_tmp_work1(other._tmp_work1)
 430 {
 431 }
 432
 433 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(0),_start(-std::numeric_limits<int>::max()),_end(-std::numeric_limits<int>::max()),
 434                                                                        _nval(-std::numeric_limits<int>::max()),_loc_id(-std::numeric_limits<int>::max())
 435 {
 436 }
 437
 438 const MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerTypePerDisc::getFather() const
 439 {
 440   return _father;
 441 }
 442
 443 void MEDFileFieldPerMeshPerTypePerDisc::loadOnlyStructureOfDataRecursively(med_idt fid, int profileIt, int& start, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 444 {
 445   INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 446   INTERP_KERNEL::AutoPtr<char> pflname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 447   std::string fieldName=nasc.getName();
 448   std::string meshName=getMeshName();
 449   int iteration=getIteration();
 450   int order=getOrder();
 451   TypeOfField type=getType();
 452   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 453   int profilesize,nbi;
 454   med_geometry_type mgeoti;
 455   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 456   _nval=MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,profileIt,MED_COMPACT_PFLMODE,
 457                                   pflname,&profilesize,locname,&nbi);
 458   _profile=MEDLoaderBase::buildStringFromFortran(pflname,MED_NAME_SIZE);
 459   _localization=MEDLoaderBase::buildStringFromFortran(locname,MED_NAME_SIZE);
 460   _start=start;
 461   _end=start+_nval*nbi;
 462   start=_end;
 463   if(type==ON_CELLS && !_localization.empty())
 464     {
 465       if(_localization!="MED_GAUSS_ELNO")//For compatibily with MED2.3
 466         setType(ON_GAUSS_PT);
 467       else
 468         {
 469           setType(ON_GAUSS_NE);
 470           _localization.clear();
 471         }
 472     }
 473 }
 474
 475 void MEDFileFieldPerMeshPerTypePerDisc::loadBigArray(med_idt fid, int profileIt, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 476 {
 477   std::string fieldName=nasc.getName();
 478   std::string meshName=getMeshName();
 479   int iteration=getIteration();
 480   int order=getOrder();
 481   TypeOfField type=getType();
 482   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 483   med_geometry_type mgeoti;
 484   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 485   if(_start>_end)
 486     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : internal error in range !");
 487   if(_start==_end)
 488     return ;
 489   DataArray *arr=getOrCreateAndGetArray();//arr is not null due to the spec of getOrCreateAndGetArray
 490   if(_start<0 || _start>=arr->getNumberOfTuples())
 491     {
 492       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << ") !";
 493       throw INTERP_KERNEL::Exception(oss.str().c_str());
 494     }
 495   if(_end<0 || _end>arr->getNumberOfTuples())
 496     {
 497       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << "] !";
 498       throw INTERP_KERNEL::Exception(oss.str().c_str());
 499     }
 500   med_int tmp1,nbi;
 501   INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 502   med_int nbValsInFile=MEDfieldnValueWithProfileByName(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile.c_str(),MED_COMPACT_PFLMODE,&tmp1,locname,&nbi);
 503   int nbOfCompo=arr->getNumberOfComponents();
 504   if(_end-_start!=nbValsInFile*nbi)
 505     {
 506       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : The number of tuples to read is " << nbValsInFile << "*" << nbi <<  " (nb integration points) ! But in data structure it values " << _end-_start << " is expected !";
 507       throw INTERP_KERNEL::Exception(oss.str().c_str());
 508     }
 509   DataArrayDouble *arrD=dynamic_cast<DataArrayDouble *>(arr);
 510   if(arrD)
 511     {
 512       double *startFeeding=arrD->getPointer()+_start*nbOfCompo;
 513       MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
 514                                  _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
 515       return ;
 516     }
 517   DataArrayInt *arrI=dynamic_cast<DataArrayInt *>(arr);
 518   if(arrI)
 519     {
 520       int *startFeeding=arrI->getPointer()+_start*nbOfCompo;
 521       MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
 522                                  _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
 523       return ;
 524     }
 525   throw INTERP_KERNEL::Exception("Error on array reading ! Unrecognized type of field ! Should be in FLOAT64 or INT32 !");
 526 }
 527
 528 /*!
 529  * Set a \c this->_start **and** \c this->_end keeping the same delta between the two.
 530  */
 531 void MEDFileFieldPerMeshPerTypePerDisc::setNewStart(int newValueOfStart) throw(INTERP_KERNEL::Exception)
 532 {
 533   int delta=_end-_start;
 534   _start=newValueOfStart;
 535   _end=_start+delta;
 536 }
 537
 538 int MEDFileFieldPerMeshPerTypePerDisc::getIteration() const
 539 {
 540   return _father->getIteration();
 541 }
 542
 543 int MEDFileFieldPerMeshPerTypePerDisc::getOrder() const
 544 {
 545   return _father->getOrder();
 546 }
 547
 548 double MEDFileFieldPerMeshPerTypePerDisc::getTime() const
 549 {
 550   return _father->getTime();
 551 }
 552
 553 std::string MEDFileFieldPerMeshPerTypePerDisc::getMeshName() const
 554 {
 555   return _father->getMeshName();
 556 }
 557
 558 void MEDFileFieldPerMeshPerTypePerDisc::simpleRepr(int bkOffset, std::ostream& oss, int id) const
 559 {
 560   const char startLine[]="    ## ";
 561   std::string startLine2(bkOffset,' ');
 562   startLine2+=startLine;
 563   MEDCouplingFieldDiscretization *tmp=MEDCouplingFieldDiscretization::New(_type);
 564   oss << startLine2 << "Localization #" << id << "." << std::endl;
 565   oss << startLine2 << "  Type=" << tmp->getRepr() << "." << std::endl;
 566   delete tmp;
 567   oss << startLine2 << "  This type discretization lies on profile : \"" << _profile << "\" and on the following localization : \"" << _localization << "\"." << std::endl;
 568   oss << startLine2 << "  This type discretization has " << _end-_start << " tuples (start=" << _start << ", end=" << _end << ")." << std::endl;
 569   oss << startLine2 << "  This type discretization has " << (_end-_start)/_nval << " integration points." << std::endl;
 570 }
 571
 572 TypeOfField MEDFileFieldPerMeshPerTypePerDisc::getType() const
 573 {
 574   return _type;
 575 }
 576
 577 void MEDFileFieldPerMeshPerTypePerDisc::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
 578 {
 579   types.insert(_type);
 580 }
 581
 582 void MEDFileFieldPerMeshPerTypePerDisc::setType(TypeOfField newType)
 583 {
 584   _type=newType;
 585 }
 586
 587 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerTypePerDisc::getGeoType() const
 588 {
 589   return _father->getGeoType();
 590 }
 591
 592 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfComponents() const
 593 {
 594   return _father->getNumberOfComponents();
 595 }
 596
 597 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfTuples() const
 598 {
 599   return _end-_start;
 600 }
 601
 602 DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray()
 603 {
 604   return _father->getOrCreateAndGetArray();
 605 }
 606
 607 const DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray() const
 608 {
 609   const MEDFileFieldPerMeshPerType *fath=_father;
 610   return fath->getOrCreateAndGetArray();
 611 }
 612
 613 const std::vector<std::string>& MEDFileFieldPerMeshPerTypePerDisc::getInfo() const
 614 {
 615   return _father->getInfo();
 616 }
 617
 618 std::string MEDFileFieldPerMeshPerTypePerDisc::getProfile() const
 619 {
 620   return _profile;
 621 }
 622
 623 void MEDFileFieldPerMeshPerTypePerDisc::setProfile(const char *newPflName)
 624 {
 625   _profile=newPflName;
 626 }
 627
 628 std::string MEDFileFieldPerMeshPerTypePerDisc::getLocalization() const
 629 {
 630   return _localization;
 631 }
 632
 633 void MEDFileFieldPerMeshPerTypePerDisc::setLocalization(const char *newLocName)
 634 {
 635   _localization=newLocName;
 636 }
 637
 638 void MEDFileFieldPerMeshPerTypePerDisc::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
 639 {
 640   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 641     {
 642       if(std::find((*it2).first.begin(),(*it2).first.end(),_profile)!=(*it2).first.end())
 643         {
 644           _profile=(*it2).second;
 645           return;
 646         }
 647     }
 648 }
 649
 650 void MEDFileFieldPerMeshPerTypePerDisc::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
 651 {
 652   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 653     {
 654       if(std::find((*it2).first.begin(),(*it2).first.end(),_localization)!=(*it2).first.end())
 655         {
 656           _localization=(*it2).second;
 657           return;
 658         }
 659     }
 660 }
 661
 662 void MEDFileFieldPerMeshPerTypePerDisc::getFieldAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<int,int> >& dads, std::vector<const DataArrayInt *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const
 663 {
 664   if(type!=_type)
 665     return ;
 666   dads.push_back(std::pair<int,int>(_start,_end));
 667   geoTypes.push_back(getGeoType());
 668   if(_profile.empty())
 669     pfls.push_back(0);
 670   else
 671     {
 672       pfls.push_back(glob->getProfile(_profile.c_str()));
 673     }
 674   if(_localization.empty())
 675     locs.push_back(-1);
 676   else
 677     {
 678       locs.push_back(glob->getLocalizationId(_localization.c_str()));
 679     }
 680 }
 681
 682 void MEDFileFieldPerMeshPerTypePerDisc::fillValues(int discId, int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
 683 {
 684   entries[startEntryId]=std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int> ,std::pair<int,int> >(std::pair<INTERP_KERNEL::NormalizedCellType,int>(getGeoType(),discId),std::pair<int,int>(_start,_end));
 685   startEntryId++;
 686 }
 687
 688 void MEDFileFieldPerMeshPerTypePerDisc::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
 689 {
 690   TypeOfField type=getType();
 691   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 692   med_geometry_type mgeoti;
 693   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 694   const DataArray *arr=getOrCreateAndGetArray();
 695   if(!arr)
 696     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : no array set !");
 697   const DataArrayDouble *arrD=dynamic_cast<const DataArrayDouble *>(arr);
 698   const DataArrayInt *arrI=dynamic_cast<const DataArrayInt *>(arr);
 699   const unsigned char *locToWrite=0;
 700   if(arrD)
 701     locToWrite=reinterpret_cast<const unsigned char *>(arrD->getConstPointer()+_start*arr->getNumberOfComponents());
 702   else if(arrI)
 703     locToWrite=reinterpret_cast<const unsigned char *>(arrI->getConstPointer()+_start*arr->getNumberOfComponents());
 704   else
 705     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : not recognized type of values ! Supported are FLOAT64 and INT32 !");
 706   MEDfieldValueWithProfileWr(fid,nasc.getName().c_str(),getIteration(),getOrder(),getTime(),menti,mgeoti,
 707                              MED_COMPACT_PFLMODE,_profile.c_str(),_localization.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,_nval,
 708                              locToWrite);
 709 }
 710
 711 void MEDFileFieldPerMeshPerTypePerDisc::getCoarseData(TypeOfField& type, std::pair<int,int>& dad, std::string& pfl, std::string& loc) const throw(INTERP_KERNEL::Exception)
 712 {
 713   type=_type;
 714   pfl=_profile;
 715   loc=_localization;
 716   dad.first=_start; dad.second=_end;
 717 }
 718
 719 /*!
 720  * \param [in] codeOfMesh is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
 721  *             This code corresponds to the distribution of types in the corresponding mesh.
 722  * \param [out] ptToFill memory zone where the output will be stored.
 723  * \return the size of data pushed into output param \a ptToFill
 724  */
 725 int MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode(int offset, const std::vector<int>& codeOfMesh, const MEDFileFieldGlobsReal& glob, int *ptToFill) const throw(INTERP_KERNEL::Exception)
 726 {
 727   _loc_id=offset;
 728   std::ostringstream oss;
 729   std::size_t nbOfType=codeOfMesh.size()/3;
 730   int found=-1;
 731   for(std::size_t i=0;i<nbOfType && found==-1;i++)
 732     if(getGeoType()==(INTERP_KERNEL::NormalizedCellType)codeOfMesh[3*i])
 733       found=(int)i;
 734   if(found==-1)
 735     {
 736       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 737       oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : not found geometric type " << cm.getRepr() << " in the referenced mesh of field !";
 738       throw INTERP_KERNEL::Exception(oss.str().c_str());
 739     }
 740   int *work=ptToFill;
 741   if(_profile.empty())
 742     {
 743       if(_nval!=codeOfMesh[3*found+1])
 744         {
 745           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 746           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << " number of elt ids in mesh is equal to " << _nval;
 747           oss << " whereas mesh has " << codeOfMesh[3*found+1] << " for this geometric type !";
 748           throw INTERP_KERNEL::Exception(oss.str().c_str());
 749         }
 750       for(int ii=codeOfMesh[3*found+2];ii<codeOfMesh[3*found+2]+_nval;ii++)
 751         *work++=ii;
 752     }
 753   else
 754     {
 755       const DataArrayInt *pfl=glob.getProfile(_profile.c_str());
 756       if(pfl->getNumberOfTuples()!=_nval)
 757         {
 758           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 759           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << ", field is defined on profile \"" << _profile << "\" and size of profile is ";
 760           oss << _nval;
 761           oss << pfl->getNumberOfTuples() << " whereas the number of ids is set to " << _nval << " for this geometric type !";
 762           throw INTERP_KERNEL::Exception(oss.str().c_str());
 763         }
 764       int offset2=codeOfMesh[3*found+2];
 765       for(const int *pflId=pfl->begin();pflId!=pfl->end();pflId++)
 766         {
 767           if(*pflId<codeOfMesh[3*found+1])
 768             *work++=offset2+*pflId;
 769         }
 770     }
 771   return _nval;
 772 }
 773
 774 int MEDFileFieldPerMeshPerTypePerDisc::fillTupleIds(int *ptToFill) const throw(INTERP_KERNEL::Exception)
 775 {
 776   for(int i=_start;i<_end;i++)
 777     *ptToFill++=i;
 778   return _end-_start;
 779 }
 780
 781 int MEDFileFieldPerMeshPerTypePerDisc::ConvertType(TypeOfField type, int locId) throw(INTERP_KERNEL::Exception)
 782 {
 783   switch(type)
 784     {
 785     case ON_CELLS:
 786       return -2;
 787     case ON_GAUSS_NE:
 788       return -1;
 789     case ON_GAUSS_PT:
 790       return locId;
 791     default:
 792       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::ConvertType : not managed type of field !");
 793     }
 794 }
 795
 796 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entries)
 797 {
 798   int id=0;
 799   std::map<std::pair<std::string,TypeOfField>,int> m;
 800   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > ret;
 801   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 802     if(m.find(std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType()))==m.end())
 803       m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]=id++;
 804   ret.resize(id);
 805   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 806     ret[m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]].push_back(*it);
 807   return ret;
 808 }
 809
 810 /*!
 811  * - \c this->_loc_id mutable attribute is used for elt id in mesh offsets.
 812  *
 813  * \param [in] offset the offset id used to take into account that \a result is not compulsary empty in input
 814  * \param [in] entriesOnSameDisc some entries **on same localization** if not the result can be invalid. The _start and _end on them are relative to \a arr parameter.
 815  * \param [in] explicitIdsInMesh ids in mesh of the considered chunk.
 816  * \param [in] newCode one of the input parameter to explicit the new geo type dispatch (in classical format same than those asked by MEDFileFields::renumberEntitiesLyingOnMesh)
 817  * \param [in,out] glob if necessary by the method, new profiles can be added to it
 818  * \param [in,out] arr after the call of this method \a arr is renumbered to be compliant with added entries to \a result.
 819  * \param [out] result All new entries will be appended on it.
 820  * \return false if the configuration of renumbering leads to an unnecessary resplit of input \a entriesOnSameDisc. If not true is returned (the most general case !)
 821  */
 822 bool MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(int offset, const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
 823                                                        const DataArrayInt *explicitIdsInMesh,
 824                                                        const std::vector<int>& newCode,
 825                                                        MEDFileFieldGlobsReal& glob, DataArrayDouble *arr,
 826                                                        std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >& result)
 827 {
 828   if(entriesOnSameDisc.empty())
 829     return false;
 830   TypeOfField type=entriesOnSameDisc[0]->getType();
 831   int szEntities=0,szTuples=0;
 832   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++)
 833     { szEntities+=(*it)->_nval; szTuples+=(*it)->_end-(*it)->_start; }
 834   int nbi=szTuples/szEntities;
 835   if(szTuples%szEntities!=0)
 836     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks : internal error the splitting into same dicretization failed !");
 837   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTuples=DataArrayInt::New(); renumTuples->alloc(szTuples,1);
 838   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ranges=MEDCouplingUMesh::ComputeRangesFromTypeDistribution(newCode);
 839   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk(entriesOnSameDisc.size());
 840   std::vector< const DataArrayInt * > newGeoTypesPerChunk2(entriesOnSameDisc.size());
 841   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk_bis(entriesOnSameDisc.size());
 842   std::vector< const DataArrayInt * > newGeoTypesPerChunk3(entriesOnSameDisc.size());
 843   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesPerChunk4=DataArrayInt::New(); newGeoTypesPerChunk4->alloc(szEntities,nbi);
 844   int id=0;
 845   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
 846     {
 847       int startOfEltIdOfChunk=(*it)->_start;
 848       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newEltIds=explicitIdsInMesh->substr(startOfEltIdOfChunk,startOfEltIdOfChunk+(*it)->_nval);
 849       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> rangeIdsForChunk=newEltIds->findRangeIdForEachTuple(ranges);
 850       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idsInRrangeForChunk=newEltIds->findIdInRangeForEachTuple(ranges);
 851       //
 852       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=rangeIdsForChunk->duplicateEachTupleNTimes(nbi); rangeIdsForChunk->rearrange(nbi);
 853       newGeoTypesPerChunk4->setPartOfValues1(tmp,(*it)->_tmp_work1-offset,(*it)->_tmp_work1+(*it)->_nval*nbi-offset,1,0,nbi,1);
 854       //
 855       newGeoTypesPerChunk[id]=rangeIdsForChunk; newGeoTypesPerChunk2[id]=rangeIdsForChunk;
 856       newGeoTypesPerChunk_bis[id]=idsInRrangeForChunk; newGeoTypesPerChunk3[id]=idsInRrangeForChunk;
 857     }
 858   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather=DataArrayInt::Aggregate(newGeoTypesPerChunk2); newGeoTypesPerChunk.clear(); newGeoTypesPerChunk2.clear();
 859   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather2=DataArrayInt::Aggregate(newGeoTypesPerChunk3); newGeoTypesPerChunk_bis.clear(); newGeoTypesPerChunk3.clear();
 860   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> diffVals=newGeoTypesEltIdsAllGather->getDifferentValues();
 861   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
 862   //
 863   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTupleIds=newGeoTypesPerChunk4->buildPermArrPerLevel();
 864   //
 865   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arrPart=arr->substr(offset,offset+szTuples);
 866   arrPart->renumberInPlace(renumTupleIds->begin());
 867   arr->setPartOfValues1(arrPart,offset,offset+szTuples,1,0,arrPart->getNumberOfComponents(),1);
 868   bool ret=false;
 869   const int *idIt=diffVals->begin();
 870   std::list<const MEDFileFieldPerMeshPerTypePerDisc *> li(entriesOnSameDisc.begin(),entriesOnSameDisc.end());
 871   int offset2=0;
 872   for(int i=0;i<diffVals->getNumberOfTuples();i++,idIt++)
 873     {
 874       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=newGeoTypesEltIdsAllGather->getIdsEqual(*idIt);
 875       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> subIds=newGeoTypesEltIdsAllGather2->selectByTupleId(ids->begin(),ids->end());
 876       int nbEntityElts=subIds->getNumberOfTuples();
 877       bool ret2;
 878       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
 879         NewObjectOnSameDiscThanPool(type,(INTERP_KERNEL::NormalizedCellType)newCode[3*(*idIt)],subIds,!subIds->isIdentity() || nbEntityElts!=newCode[3*(*idIt)+1],nbi,
 880                                     offset+offset2,
 881                                     li,glob,ret2);
 882       ret=ret || ret2;
 883       result.push_back(eltToAdd);
 884       offset2+=nbEntityElts*nbi;
 885     }
 886   ret=ret || li.empty();
 887   return ret;
 888 }
 889
 890 /*!
 891  * \param [in] typeF type of field of new chunk
 892  * \param [in] geoType the geometric type of the chunk
 893  * \param [in] idsOfMeshElt the entity ids of mesh (cells or nodes) of the new chunk.
 894  * \param [in] isPfl specifies if a profile is requested regarding size of \a idsOfMeshElt and the number of such entities regarding underlying mesh.
 895  * \param [in] nbi number of integration points
 896  * \param [in] offset The offset in the **global array of data**.
 897  * \param [in,out] entriesOnSameDisc the pool **on the same discretization** inside which it will be attempted to find an existing entry corresponding exactly
 898  *                 to the new chunk to create.
 899  * \param [in,out] glob the global shared info that will be requested for existing profiles or to append a new profile if needed.
 900  * \param [out] notInExisting If false the return newly allocated entry is not coming from \a entriesOnSameDisc. If true the output comes from copy of \a entriesOnSameDisc
 901  *              and corresponding entry erased from \a entriesOnSameDisc.
 902  * \return a newly allocated chunk
 903  */
 904 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewObjectOnSameDiscThanPool(TypeOfField typeF, INTERP_KERNEL::NormalizedCellType geoType, DataArrayInt *idsOfMeshElt,
 905                                                                                                   bool isPfl, int nbi, int offset,
 906                                                                                                   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
 907                                                                                                   MEDFileFieldGlobsReal& glob,
 908                                                                                                   bool &notInExisting) throw(INTERP_KERNEL::Exception)
 909 {
 910   int nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
 911   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>::iterator it=entriesOnSameDisc.begin();
 912   for(;it!=entriesOnSameDisc.end();it++)
 913     {
 914       if(((INTERP_KERNEL::NormalizedCellType)(*it)->_loc_id)==geoType && (*it)->_nval==nbMeshEntities)
 915         {
 916           if(!isPfl)
 917             {
 918               if((*it)->_profile.empty())
 919                 break;
 920               else
 921                 if(!(*it)->_profile.empty())
 922                   {
 923                     const DataArrayInt *pfl=glob.getProfile((*it)->_profile.c_str());
 924                     if(pfl->isEqualWithoutConsideringStr(*idsOfMeshElt))
 925                       break;
 926                   }
 927             }
 928         }
 929     }
 930   if(it==entriesOnSameDisc.end())
 931     {
 932       notInExisting=true;
 933       MEDFileFieldPerMeshPerTypePerDisc *ret=new MEDFileFieldPerMeshPerTypePerDisc;
 934       ret->_type=typeF;
 935       ret->_loc_id=(int)geoType;
 936       ret->_nval=nbMeshEntities;
 937       ret->_start=offset;
 938       ret->_end=ret->_start+ret->_nval*nbi;
 939       if(isPfl)
 940         {
 941           idsOfMeshElt->setName(glob.createNewNameOfPfl().c_str());
 942           glob.appendProfile(idsOfMeshElt);
 943           ret->_profile=idsOfMeshElt->getName();
 944         }
 945       //tony treatment of localization
 946       return ret;
 947     }
 948   else
 949     {
 950       notInExisting=false;
 951       MEDFileFieldPerMeshPerTypePerDisc *ret=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
 952       ret->_loc_id=(int)geoType;
 953       ret->setNewStart(offset);
 954       entriesOnSameDisc.erase(it);
 955       return ret;
 956     }
 957
 958 }
 959
 960 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 961 {
 962   return new MEDFileFieldPerMeshPerType(fid,fath,type,geoType,nasc);
 963 }
 964
 965 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::New(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType) throw(INTERP_KERNEL::Exception)
 966 {
 967   return new MEDFileFieldPerMeshPerType(fath,geoType);
 968 }
 969
 970 std::size_t MEDFileFieldPerMeshPerType::getHeapMemorySize() const
 971 {
 972   std::size_t ret=_field_pm_pt_pd.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc>);
 973   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
 974     ret+=(*it)->getHeapMemorySize();
 975   return ret;
 976 }
 977
 978 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::deepCpy(MEDFileFieldPerMesh *father) const throw(INTERP_KERNEL::Exception)
 979 {
 980   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> ret=new MEDFileFieldPerMeshPerType(*this);
 981   ret->_father=father;
 982   std::size_t i=0;
 983   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
 984     {
 985       if((const MEDFileFieldPerMeshPerTypePerDisc *)*it)
 986         ret->_field_pm_pt_pd[i]=(*it)->deepCpy((MEDFileFieldPerMeshPerType *)ret);
 987     }
 988   return ret.retn();
 989 }
 990
 991 void MEDFileFieldPerMeshPerType::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
 992 {
 993   std::vector<int> pos=addNewEntryIfNecessary(field,offset,nbOfCells);
 994   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
 995     _field_pm_pt_pd[*it]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
 996 }
 997
 998 /*!
 999  * This method is the most general one. No optimization is done here.
1000  * \param [in] multiTypePfl is the end user profile specified in high level API
1001  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
1002  * \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
1003  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
1004  * \param [in] nbOfEltsInWholeMesh nb of elts of type \a this->_geo_type in \b WHOLE mesh
1005  * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
1006  */
1007 void MEDFileFieldPerMeshPerType::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1008 {
1009   std::vector<int> pos=addNewEntryIfNecessary(field,idsInPfl);
1010   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1011     _field_pm_pt_pd[*it]->assignFieldProfile(start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,arr,mesh,glob,nasc);
1012 }
1013
1014 void MEDFileFieldPerMeshPerType::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1015 {
1016   _field_pm_pt_pd.resize(1);
1017   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1018   _field_pm_pt_pd[0]->assignNodeFieldNoProfile(start,field,arr,glob);
1019 }
1020
1021 void MEDFileFieldPerMeshPerType::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1022 {
1023   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2=pfl->deepCpy();
1024   //
1025   _field_pm_pt_pd.resize(1);
1026   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1027   _field_pm_pt_pd[0]->assignFieldProfile(start,pfl,pfl2,pfl2,-1,field,arr,0,glob,nasc);//mesh is not requested so 0 is send.
1028 }
1029
1030 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, int offset, int nbOfCells) throw(INTERP_KERNEL::Exception)
1031 {
1032   TypeOfField type=field->getTypeOfField();
1033   if(type!=ON_GAUSS_PT)
1034     {
1035       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1036       int sz=_field_pm_pt_pd.size();
1037       bool found=false;
1038       for(int j=0;j<sz && !found;j++)
1039         {
1040           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1041             {
1042               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1043               found=true;
1044             }
1045         }
1046       if(!found)
1047         {
1048           _field_pm_pt_pd.resize(sz+1);
1049           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1050         }
1051       std::vector<int> ret(1,(int)sz);
1052       return ret;
1053     }
1054   else
1055     {
1056       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
1057       int sz2=ret2.size();
1058       std::vector<int> ret3(sz2);
1059       int k=0;
1060       for(int i=0;i<sz2;i++)
1061         {
1062           int sz=_field_pm_pt_pd.size();
1063           int locIdToFind=ret2[i];
1064           bool found=false;
1065           for(int j=0;j<sz && !found;j++)
1066             {
1067               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1068                 {
1069                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1070                   ret3[k++]=j;
1071                   found=true;
1072                 }
1073             }
1074           if(!found)
1075             {
1076               _field_pm_pt_pd.resize(sz+1);
1077               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1078               ret3[k++]=sz;
1079             }
1080         }
1081       return ret3;
1082     }
1083 }
1084
1085 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, int offset, int nbOfCells) throw(INTERP_KERNEL::Exception)
1086 {
1087   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1088   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1089   if(!disc2)
1090     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1091   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1092   if(!da)
1093     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss (no profile) : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1094   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleId2(offset,offset+nbOfCells,1);
1095   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1096   if(retTmp->presenceOfValue(-1))
1097     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1098   std::vector<int> ret(retTmp->begin(),retTmp->end());
1099   return ret;
1100 }
1101
1102 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells) throw(INTERP_KERNEL::Exception)
1103 {
1104   TypeOfField type=field->getTypeOfField();
1105   if(type!=ON_GAUSS_PT)
1106     {
1107       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1108       int sz=_field_pm_pt_pd.size();
1109       bool found=false;
1110       for(int j=0;j<sz && !found;j++)
1111         {
1112           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1113             {
1114               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1115               found=true;
1116             }
1117         }
1118       if(!found)
1119         {
1120           _field_pm_pt_pd.resize(sz+1);
1121           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1122         }
1123       std::vector<int> ret(1,0);
1124       return ret;
1125     }
1126   else
1127     {
1128       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,subCells);
1129       int sz2=ret2.size();
1130       std::vector<int> ret3(sz2);
1131       int k=0;
1132       for(int i=0;i<sz2;i++)
1133         {
1134           int sz=_field_pm_pt_pd.size();
1135           int locIdToFind=ret2[i];
1136           bool found=false;
1137           for(int j=0;j<sz && !found;j++)
1138             {
1139               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1140                 {
1141                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1142                   ret3[k++]=j;
1143                   found=true;
1144                 }
1145             }
1146           if(!found)
1147             {
1148               _field_pm_pt_pd.resize(sz+1);
1149               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1150               ret3[k++]=sz;
1151             }
1152         }
1153       return ret3;
1154     }
1155 }
1156
1157 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells) throw(INTERP_KERNEL::Exception)
1158 {
1159   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1160   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1161   if(!disc2)
1162     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1163   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1164   if(!da)
1165     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1166   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleIdSafe(subCells->getConstPointer(),subCells->getConstPointer()+subCells->getNumberOfTuples());
1167   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1168   if(retTmp->presenceOfValue(-1))
1169     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1170   std::vector<int> ret(retTmp->begin(),retTmp->end());
1171   return ret;
1172 }
1173
1174 const MEDFileFieldPerMesh *MEDFileFieldPerMeshPerType::getFather() const
1175 {
1176   return _father;
1177 }
1178
1179 void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
1180 {
1181   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1182   int curDim=(int)cm.getDimension();
1183   dim=std::max(dim,curDim);
1184 }
1185
1186 void MEDFileFieldPerMeshPerType::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
1187 {
1188   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1189     {
1190       (*it)->fillTypesOfFieldAvailable(types);
1191     }
1192 }
1193
1194 void MEDFileFieldPerMeshPerType::fillFieldSplitedByType(std::vector< std::pair<int,int> >& dads, std::vector<TypeOfField>& types, std::vector<std::string>& pfls, std::vector<std::string>& locs) const throw(INTERP_KERNEL::Exception)
1195 {
1196   int sz=_field_pm_pt_pd.size();
1197   dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
1198   for(int i=0;i<sz;i++)
1199     {
1200       _field_pm_pt_pd[i]->getCoarseData(types[i],dads[i],pfls[i],locs[i]);
1201     }
1202 }
1203
1204 int MEDFileFieldPerMeshPerType::getIteration() const
1205 {
1206   return _father->getIteration();
1207 }
1208
1209 int MEDFileFieldPerMeshPerType::getOrder() const
1210 {
1211   return _father->getOrder();
1212 }
1213
1214 double MEDFileFieldPerMeshPerType::getTime() const
1215 {
1216   return _father->getTime();
1217 }
1218
1219 std::string MEDFileFieldPerMeshPerType::getMeshName() const
1220 {
1221   return _father->getMeshName();
1222 }
1223
1224 void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1225 {
1226   const char startLine[]="  ## ";
1227   std::string startLine2(bkOffset,' ');
1228   std::string startLine3(startLine2);
1229   startLine3+=startLine;
1230   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1231     {
1232       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1233       oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry types " << cm.getRepr() << "." << std::endl;
1234     }
1235   else
1236     oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
1237   oss << startLine3 << "Entry is defined on " <<  _field_pm_pt_pd.size() << " localizations." << std::endl;
1238   int i=0;
1239   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1240     {
1241       const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
1242       if(cur)
1243         cur->simpleRepr(bkOffset,oss,i);
1244       else
1245         {
1246           oss << startLine2 << "    ## " << "Localization #" << i << " is empty !" << std::endl;
1247         }
1248     }
1249 }
1250
1251 void MEDFileFieldPerMeshPerType::getSizes(int& globalSz, int& nbOfEntries) const
1252 {
1253   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1254     {
1255       globalSz+=(*it)->getNumberOfTuples();
1256     }
1257   nbOfEntries+=(int)_field_pm_pt_pd.size();
1258 }
1259
1260 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
1261 {
1262   return _geo_type;
1263 }
1264
1265
1266 int MEDFileFieldPerMeshPerType::getNumberOfComponents() const
1267 {
1268   return _father->getNumberOfComponents();
1269 }
1270
1271 DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray()
1272 {
1273   return _father->getOrCreateAndGetArray();
1274 }
1275
1276 const DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray() const
1277 {
1278   const MEDFileFieldPerMesh *fath=_father;
1279   return fath->getOrCreateAndGetArray();
1280 }
1281
1282 const std::vector<std::string>& MEDFileFieldPerMeshPerType::getInfo() const
1283 {
1284   return _father->getInfo();
1285 }
1286
1287 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsed() const
1288 {
1289   std::vector<std::string> ret;
1290   std::set<std::string> ret2;
1291   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1292     {
1293       std::string tmp=(*it1)->getProfile();
1294       if(!tmp.empty())
1295         if(ret2.find(tmp)==ret2.end())
1296           {
1297             ret.push_back(tmp);
1298             ret2.insert(tmp);
1299           }
1300     }
1301   return ret;
1302 }
1303
1304 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsed() const
1305 {
1306   std::vector<std::string> ret;
1307   std::set<std::string> ret2;
1308   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1309     {
1310       std::string tmp=(*it1)->getLocalization();
1311       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1312         if(ret2.find(tmp)==ret2.end())
1313           {
1314             ret.push_back(tmp);
1315             ret2.insert(tmp);
1316           }
1317     }
1318   return ret;
1319 }
1320
1321 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsedMulti() const
1322 {
1323   std::vector<std::string> ret;
1324   std::set<std::string> ret2;
1325   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1326     {
1327       std::string tmp=(*it1)->getProfile();
1328       if(!tmp.empty())
1329         ret.push_back(tmp);
1330     }
1331   return ret;
1332 }
1333
1334 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsedMulti() const
1335 {
1336   std::vector<std::string> ret;
1337   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1338     {
1339       std::string tmp=(*it1)->getLocalization();
1340       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1341         ret.push_back(tmp);
1342     }
1343   return ret;
1344 }
1345
1346 void MEDFileFieldPerMeshPerType::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1347 {
1348   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1349     (*it1)->changePflsRefsNamesGen(mapOfModif);
1350 }
1351
1352 void MEDFileFieldPerMeshPerType::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1353 {
1354   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1355     (*it1)->changeLocsRefsNamesGen(mapOfModif);
1356 }
1357
1358 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) throw(INTERP_KERNEL::Exception)
1359 {
1360   if(_field_pm_pt_pd.empty())
1361     {
1362       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1363       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1364       throw INTERP_KERNEL::Exception(oss.str().c_str());
1365     }
1366   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1367     return _field_pm_pt_pd[locId];
1368   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1369   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1370   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1371   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1372   return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
1373 }
1374
1375 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) const throw(INTERP_KERNEL::Exception)
1376 {
1377   if(_field_pm_pt_pd.empty())
1378     {
1379       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1380       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1381       throw INTERP_KERNEL::Exception(oss.str().c_str());
1382     }
1383   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1384     return _field_pm_pt_pd[locId];
1385   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1386   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1387   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1388   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1389   return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
1390 }
1391
1392 void MEDFileFieldPerMeshPerType::getFieldAtLevel(int meshDim, TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<int,int> >& dads, std::vector<const DataArrayInt *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const
1393 {
1394   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1395     {
1396       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1397       if(meshDim!=(int)cm.getDimension())
1398         return ;
1399     }
1400   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1401     (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
1402 }
1403
1404 void MEDFileFieldPerMeshPerType::fillValues(int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
1405 {
1406   int i=0;
1407   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1408     {
1409       (*it)->fillValues(i,startEntryId,entries);
1410     }
1411 }
1412
1413 void MEDFileFieldPerMeshPerType::setLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves) throw(INTERP_KERNEL::Exception)
1414 {
1415   _field_pm_pt_pd=leaves;
1416   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1417     (*it)->setFather(this);
1418 }
1419
1420 /*!
1421  *  \param [in,out] globalNum a global numbering counter for the renumbering.
1422  *  \param [out] its - list of pair (start,stop) kept
1423  *  \return bool - false if the type of field \a tof is not contained in \a this.
1424  */
1425 bool MEDFileFieldPerMeshPerType::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its) throw(INTERP_KERNEL::Exception)
1426 {
1427   bool ret=false;
1428   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd;
1429   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1430     if((*it)->getType()==tof)
1431       {
1432         newPmPtPd.push_back(*it);
1433         std::pair<int,int> bgEnd; bgEnd.first=(*it)->getStart(); bgEnd.second=(*it)->getEnd();
1434         (*it)->setNewStart(globalNum);
1435         globalNum=(*it)->getEnd();
1436         its.push_back(bgEnd);
1437         ret=true;
1438       }
1439   if(ret)
1440     _field_pm_pt_pd=newPmPtPd;
1441   return ret;
1442 }
1443
1444 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType) throw(INTERP_KERNEL::Exception):_father(fath),_geo_type(geoType)
1445 {
1446 }
1447
1448 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception):_father(fath),_geo_type(geoType)
1449 {
1450   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1451   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1452   med_geometry_type mgeoti;
1453   med_entity_type menti=ConvertIntoMEDFileType(type,geoType,mgeoti);
1454   int nbProfiles=MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),menti,mgeoti,pflName,locName);
1455   _field_pm_pt_pd.resize(nbProfiles);
1456   for(int i=0;i<nbProfiles;i++)
1457     {
1458       _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,type,i+1);
1459     }
1460 }
1461
1462 void MEDFileFieldPerMeshPerType::loadOnlyStructureOfDataRecursively(med_idt fid, int &start, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1463 {
1464   int pflId=0;
1465   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,pflId++)
1466     {
1467       (*it)->loadOnlyStructureOfDataRecursively(fid,pflId+1,start,nasc);//tony
1468     }
1469 }
1470
1471 void MEDFileFieldPerMeshPerType::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1472 {
1473   int pflId=0;
1474   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,pflId++)
1475     {
1476       (*it)->loadBigArray(fid,pflId+1,nasc);//tony
1477     }
1478 }
1479
1480 void MEDFileFieldPerMeshPerType::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
1481 {
1482   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1483     {
1484       (*it)->copyOptionsFrom(*this);
1485       (*it)->writeLL(fid,nasc);
1486     }
1487 }
1488
1489 med_entity_type MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(TypeOfField ikType, INTERP_KERNEL::NormalizedCellType ikGeoType, med_geometry_type& medfGeoType)
1490 {
1491   switch(ikType)
1492     {
1493     case ON_CELLS:
1494       medfGeoType=typmai3[(int)ikGeoType];
1495       return MED_CELL;
1496     case ON_NODES:
1497       medfGeoType=MED_NONE;
1498       return MED_NODE;
1499     case ON_GAUSS_NE:
1500       medfGeoType=typmai3[(int)ikGeoType];
1501       return MED_NODE_ELEMENT;
1502     case ON_GAUSS_PT:
1503       medfGeoType=typmai3[(int)ikGeoType];
1504       return MED_CELL;
1505     default:
1506       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType : unexpected entity type ! internal error");
1507     }
1508   return MED_UNDEF_ENTITY_TYPE;
1509 }
1510
1511 MEDFileFieldPerMesh *MEDFileFieldPerMesh::NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1512 {
1513   return new MEDFileFieldPerMesh(fid,fath,meshCsit,meshIteration,meshOrder,nasc);
1514 }
1515
1516 MEDFileFieldPerMesh *MEDFileFieldPerMesh::New(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh)
1517 {
1518   return new MEDFileFieldPerMesh(fath,mesh);
1519 }
1520
1521 std::size_t MEDFileFieldPerMesh::getHeapMemorySize() const
1522 {
1523   std::size_t ret=_mesh_name.capacity()+_field_pm_pt.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType >);
1524   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1525     if((const MEDFileFieldPerMeshPerType *)*it)
1526       ret+=(*it)->getHeapMemorySize();
1527   return ret;
1528 }
1529
1530 MEDFileFieldPerMesh *MEDFileFieldPerMesh::deepCpy(MEDFileAnyTypeField1TSWithoutSDA *father) const throw(INTERP_KERNEL::Exception)
1531 {
1532   MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
1533   ret->_father=father;
1534   std::size_t i=0;
1535   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1536     {
1537       if((const MEDFileFieldPerMeshPerType *)*it)
1538         ret->_field_pm_pt[i]=(*it)->deepCpy((MEDFileFieldPerMesh *)(ret));
1539     }
1540   return ret.retn();
1541 }
1542
1543 void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1544 {
1545   std::string startLine(bkOffset,' ');
1546   oss << startLine << "## Field part (" << id << ") lying on mesh \"" << _mesh_name << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
1547   oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
1548   int i=0;
1549   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1550     {
1551       const MEDFileFieldPerMeshPerType *cur=*it;
1552       if(cur)
1553         cur->simpleRepr(bkOffset,oss,i);
1554       else
1555         {
1556           oss << startLine << "  ## Entry geometry type #" << i << " is empty !" << std::endl;
1557         }
1558     }
1559 }
1560
1561 void MEDFileFieldPerMesh::copyTinyInfoFrom(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
1562 {
1563   _mesh_name=mesh->getName();
1564   mesh->getTime(_mesh_iteration,_mesh_order);
1565 }
1566
1567 void MEDFileFieldPerMesh::assignFieldNoProfileNoRenum(int& start, const std::vector<int>& code, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1568 {
1569   int nbOfTypes=code.size()/3;
1570   int offset=0;
1571   for(int i=0;i<nbOfTypes;i++)
1572     {
1573       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1574       int nbOfCells=code[3*i+1];
1575       int pos=addNewEntryIfNecessary(type);
1576       _field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1577       offset+=nbOfCells;
1578     }
1579 }
1580
1581 /*!
1582  * This method is the most general one. No optimization is done here.
1583  * \param [in] multiTypePfl is the end user profile specified in high level API
1584  * \param [in] code is the code of \a mesh[multiTypePfl] mesh. It is of size of number of different geometric types into \a mesh[multiTypePfl].
1585  * \param [in] code2 is the code of the \b WHOLE mesh on the same level. So all types in \a code are in \a code2.
1586  * \param [in] idsInPflPerType is the selection into the \a multiTypePfl whole profile that corresponds to the given geometric type. This vector is always 3 times smaller than \a code.
1587  * \param [in] idsPerType is a vector containing the profiles needed to be created for MED file format. \b WARNING these processed MED file profiles can be subdivided again in case of Gauss points.
1588  * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
1589  */
1590 void MEDFileFieldPerMesh::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const std::vector<int>& code, const std::vector<int>& code2, const std::vector<DataArrayInt *>& idsInPflPerType, const std::vector<DataArrayInt *>& idsPerType, const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1591 {
1592   int nbOfTypes=code.size()/3;
1593   for(int i=0;i<nbOfTypes;i++)
1594     {
1595       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1596       int pos=addNewEntryIfNecessary(type);
1597       DataArrayInt *pfl=0;
1598       if(code[3*i+2]!=-1)
1599         pfl=idsPerType[code[3*i+2]];
1600       int nbOfTupes2=code2.size()/3;
1601       int found=0;
1602       for(;found<nbOfTupes2;found++)
1603         if(code[3*i]==code2[3*found])
1604           break;
1605       if(found==nbOfTupes2)
1606         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::assignFieldProfile : internal problem ! Should never happen ! Please report bug to anthony.geay@cea.fr !");
1607       _field_pm_pt[pos]->assignFieldProfile(start,multiTypePfl,idsInPflPerType[i],pfl,code2[3*found+1],field,arr,mesh,glob,nasc);
1608     }
1609 }
1610
1611 void MEDFileFieldPerMesh::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1612 {
1613   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1614   _field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
1615 }
1616
1617 void MEDFileFieldPerMesh::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1618 {
1619   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1620   _field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,arr,glob,nasc);
1621 }
1622
1623 void MEDFileFieldPerMesh::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1624 {
1625   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1626     (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1627 }
1628
1629 void MEDFileFieldPerMesh::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1630 {
1631   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1632     (*it)->loadBigArraysRecursively(fid,nasc);
1633 }
1634
1635 void MEDFileFieldPerMesh::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
1636 {
1637   int nbOfTypes=_field_pm_pt.size();
1638   for(int i=0;i<nbOfTypes;i++)
1639     {
1640       _field_pm_pt[i]->copyOptionsFrom(*this);
1641       _field_pm_pt[i]->writeLL(fid,nasc);
1642     }
1643 }
1644
1645 void MEDFileFieldPerMesh::getDimension(int& dim) const
1646 {
1647   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1648     (*it)->getDimension(dim);
1649 }
1650
1651 void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
1652 {
1653   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1654     (*it)->fillTypesOfFieldAvailable(types);
1655 }
1656
1657 std::vector< std::vector< std::pair<int,int> > > MEDFileFieldPerMesh::getFieldSplitedByType(std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> > & locs) const throw(INTERP_KERNEL::Exception)
1658 {
1659   int sz=_field_pm_pt.size();
1660   std::vector< std::vector<std::pair<int,int> > > ret(sz);
1661   types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
1662   for(int i=0;i<sz;i++)
1663     {
1664       types[i]=_field_pm_pt[i]->getGeoType();
1665       _field_pm_pt[i]->fillFieldSplitedByType(ret[i],typesF[i],pfls[i],locs[i]);
1666     }
1667   return ret;
1668 }
1669
1670 double MEDFileFieldPerMesh::getTime() const
1671 {
1672   int tmp1,tmp2;
1673   return _father->getTime(tmp1,tmp2);
1674 }
1675
1676 int MEDFileFieldPerMesh::getIteration() const
1677 {
1678   return _father->getIteration();
1679 }
1680
1681 int MEDFileFieldPerMesh::getOrder() const
1682 {
1683   return _father->getOrder();
1684 }
1685
1686 int MEDFileFieldPerMesh::getNumberOfComponents() const
1687 {
1688   return _father->getNumberOfComponents();
1689 }
1690
1691 DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray()
1692 {
1693   if(!_father)
1694     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1695   return _father->getOrCreateAndGetArray();
1696 }
1697
1698 const DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray() const
1699 {
1700   if(!_father)
1701     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1702   return _father->getOrCreateAndGetArray();
1703 }
1704
1705 const std::vector<std::string>& MEDFileFieldPerMesh::getInfo() const
1706 {
1707   return _father->getInfo();
1708 }
1709
1710 /*!
1711  * type,geoTypes,dads,pfls,locs are input parameters. They should have the same size.
1712  * Before the call of this method 'geoTypes','dads','pfls','locs' must be reorganized so that types in geoTypes are contiguous and ordered following typmai2 array.
1713  * It returns 2 output vectors :
1714  * - 'code' of size 3*sz where sz is the number of different values into 'geoTypes'
1715  * - 'notNullPfls' contains sz2 values that are extracted from 'pfls' in which null profiles have been removed.
1716  * 'code' and 'notNullPfls' are in MEDCouplingUMesh::checkTypeConsistencyAndContig format.
1717  */
1718 void MEDFileFieldPerMesh::SortArraysPerType(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<int,int> >& dads, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& locs, std::vector<int>& code, std::vector<DataArrayInt *>& notNullPfls)
1719 {
1720   int notNullPflsSz=0;
1721   int nbOfArrs=geoTypes.size();
1722   for(int i=0;i<nbOfArrs;i++)
1723     if(pfls[i])
1724       notNullPflsSz++;
1725   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
1726   int nbOfDiffGeoTypes=geoTypes3.size();
1727   code.resize(3*nbOfDiffGeoTypes);
1728   notNullPfls.resize(notNullPflsSz);
1729   notNullPflsSz=0;
1730   int j=0;
1731   for(int i=0;i<nbOfDiffGeoTypes;i++)
1732     {
1733       int startZone=j;
1734       INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
1735       std::vector<const DataArrayInt *> notNullTmp;
1736       if(pfls[j])
1737         notNullTmp.push_back(pfls[j]);
1738       j++;
1739       for(;j<nbOfArrs;j++)
1740         if(geoTypes[j]==refType)
1741           {
1742             if(pfls[j])
1743               notNullTmp.push_back(pfls[j]);
1744           }
1745         else
1746           break;
1747       std::vector< std::pair<int,int> > tmpDads(dads.begin()+startZone,dads.begin()+j);
1748       std::vector<const DataArrayInt *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
1749       std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
1750       code[3*i]=(int)refType;
1751       std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
1752       code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
1753       if(notNullTmp.empty())
1754         code[3*i+2]=-1;
1755       else
1756         {
1757           notNullPfls[notNullPflsSz]=DataArrayInt::Aggregate(notNullTmp);
1758           code[3*i+2]=notNullPflsSz++;
1759         }
1760     }
1761 }
1762
1763 /*!
1764  * 'dads' 'geoTypes' and 'locs' are input parameters that should have same size sz. sz should be >=1.
1765  */
1766 int MEDFileFieldPerMesh::ComputeNbOfElems(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs) throw(INTERP_KERNEL::Exception)
1767 {
1768   int sz=dads.size();
1769   int ret=0;
1770   for(int i=0;i<sz;i++)
1771     {
1772       if(locs[i]==-1)
1773         {
1774           if(type!=ON_GAUSS_NE)
1775             ret+=dads[i].second-dads[i].first;
1776           else
1777             {
1778               const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(geoTypes[i]);
1779               ret+=(dads[i].second-dads[i].first)/cm.getNumberOfNodes();
1780             }
1781         }
1782       else
1783         {
1784           int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
1785           ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
1786         }
1787     }
1788   return ret;
1789 }
1790
1791 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsed() const
1792 {
1793   std::vector<std::string> ret;
1794   std::set<std::string> ret2;
1795   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1796     {
1797       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
1798       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1799         if(ret2.find(*it2)==ret2.end())
1800           {
1801             ret.push_back(*it2);
1802             ret2.insert(*it2);
1803           }
1804     }
1805   return ret;
1806 }
1807
1808 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
1809 {
1810   std::vector<std::string> ret;
1811   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1812     {
1813       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
1814       ret.insert(ret.end(),tmp.begin(),tmp.end());
1815     }
1816   return ret;
1817 }
1818
1819 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsed() const
1820 {
1821   std::vector<std::string> ret;
1822   std::set<std::string> ret2;
1823   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1824     {
1825       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
1826       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1827         if(ret2.find(*it2)==ret2.end())
1828           {
1829             ret.push_back(*it2);
1830             ret2.insert(*it2);
1831           }
1832     }
1833   return ret;
1834 }
1835
1836 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
1837 {
1838   std::vector<std::string> ret;
1839   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1840     {
1841       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
1842       ret.insert(ret.end(),tmp.begin(),tmp.end());
1843     }
1844   return ret;
1845 }
1846
1847 bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
1848 {
1849   for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
1850     {
1851       if((*it).first==_mesh_name)
1852         {
1853           _mesh_name=(*it).second;
1854           return true;
1855         }
1856     }
1857   return false;
1858 }
1859
1860 bool MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
1861                                                       MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1862 {
1863   if(_mesh_name!=meshName)
1864     return false;
1865   std::set<INTERP_KERNEL::NormalizedCellType> typesToKeep;
1866   for(std::size_t i=0;i<oldCode.size()/3;i++) typesToKeep.insert((INTERP_KERNEL::NormalizedCellType)oldCode[3*i]);
1867   std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > > entries;
1868   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKept;
1869   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> otherEntries;
1870   getUndergroundDataArrayExt(entries);
1871   DataArray *arr0=getOrCreateAndGetArray();//tony
1872   if(!arr0)
1873     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values of field is null !");
1874   DataArrayDouble *arr=dynamic_cast<DataArrayDouble *>(arr0);//tony
1875   if(!arr0)
1876     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values is double ! Not managed for the moment !");
1877   int sz=0;
1878   if(!arr)
1879     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
1880   for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >::const_iterator it=entries.begin();it!=entries.end();it++)
1881     {
1882       if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
1883         {
1884           entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1885           sz+=(*it).second.second-(*it).second.first;
1886         }
1887       else
1888         otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1889     }
1890   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumDefrag=DataArrayInt::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
1891   ////////////////////
1892   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInMesh=DataArrayInt::New(); explicitIdsOldInMesh->alloc(sz,1);//sz is a majorant of the real size. A realloc will be done after
1893   int *workI2=explicitIdsOldInMesh->getPointer();
1894   int sz1=0,sz2=0,sid=1;
1895   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptML=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKept);
1896   // std::vector<int> tupleIdOfStartOfNewChuncksV(entriesKeptML.size());
1897   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator itL1=entriesKeptML.begin();itL1!=entriesKeptML.end();itL1++,sid++)
1898     {
1899       //  tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
1900       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInArr=DataArrayInt::New(); explicitIdsOldInArr->alloc(sz,1);
1901       int *workI=explicitIdsOldInArr->getPointer();
1902       for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
1903         {
1904           int delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
1905           (*itL2)->setLocId(sz2);
1906           (*itL2)->_tmp_work1=(*itL2)->getStart();
1907           int delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
1908         }
1909       renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
1910     }
1911   explicitIdsOldInMesh->reAlloc(sz2);
1912   int tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
1913   ////////////////////
1914   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
1915   // perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
1916   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
1917   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
1918     {
1919       otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
1920       otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
1921       otherEntriesNew.back()->setLocId((*it)->getGeoType());
1922     }
1923   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
1924   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
1925   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
1926     {
1927       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
1928       int newStart=elt->getLocId();
1929       elt->setLocId((*it)->getGeoType());
1930       elt->setNewStart(newStart);
1931       elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
1932       entriesKeptNew.push_back(elt);
1933       entriesKeptNew2.push_back(elt);
1934     }
1935   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
1936   // perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
1937   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
1938   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
1939   bool ret=false;
1940   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
1941     {
1942       sid=0;
1943       /*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
1944         {
1945           MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
1946           curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
1947           }*/
1948       ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
1949                                                             glob,arr2,otherEntriesNew) || ret;
1950     }
1951   if(!ret)
1952     return false;
1953   // Assign new dispatching
1954   assignNewLeaves(otherEntriesNew);
1955   arr->cpyFrom(*arr2);
1956   return true;
1957 }
1958
1959 /*!
1960  * \param [in,out] globalNum a global numbering counter for the renumbering.
1961  * \param [out] its - list of pair (start,stop) kept
1962  */
1963 void MEDFileFieldPerMesh::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its) throw(INTERP_KERNEL::Exception)
1964 {
1965   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > ret;
1966   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1967     {
1968       std::vector< std::pair<int,int> > its2;
1969       if((*it)->keepOnlySpatialDiscretization(tof,globalNum,its2))
1970         {
1971           ret.push_back(*it);
1972           its.insert(its.end(),its2.begin(),its2.end());
1973         }
1974     }
1975   _field_pm_pt=ret;
1976 }
1977
1978 void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves) throw(INTERP_KERNEL::Exception)
1979 {
1980   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > > types;
1981   for( std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
1982     types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
1983   //
1984   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > fieldPmPt(types.size());
1985   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
1986   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=fieldPmPt.begin();
1987   for(;it1!=types.end();it1++,it2++)
1988     {
1989       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
1990       elt->setLeaves((*it1).second);
1991       *it2=elt;
1992     }
1993   _field_pm_pt=fieldPmPt;
1994 }
1995
1996 void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1997 {
1998   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1999     (*it)->changePflsRefsNamesGen(mapOfModif);
2000 }
2001
2002 void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2003 {
2004   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2005     (*it)->changeLocsRefsNamesGen(mapOfModif);
2006 }
2007
2008 /*!
2009  * \param [in] mesh is the whole mesh
2010  */
2011 MEDCouplingFieldDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2012 {
2013   if(_field_pm_pt.empty())
2014     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2015   //
2016   std::vector< std::pair<int,int> > dads;
2017   std::vector<const DataArrayInt *> pfls;
2018   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2019   std::vector<int> locs,code;
2020   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2021   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2022     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2023   // Sort by types
2024   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2025   if(code.empty())
2026     {
2027       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2028       throw INTERP_KERNEL::Exception(oss.str().c_str());
2029     }
2030   //
2031   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2032   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2033   if(type!=ON_NODES)
2034     {
2035       DataArrayInt *arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2036       if(!arr)
2037         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2038       else
2039         {
2040           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr);
2041           return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl,arrOut,nasc);
2042         }
2043     }
2044   else
2045     {
2046       if(code.size()!=3)
2047         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2048       int nb=code[1];
2049       if(code[2]==-1)
2050         {
2051           if(nb!=mesh->getNumberOfNodes())
2052             {
2053               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2054               oss << " nodes in mesh !";
2055               throw INTERP_KERNEL::Exception(oss.str().c_str());
2056             }
2057           return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2058         }
2059       else
2060         return finishFieldNode2(glob,dads,locs,mesh,notNullPflsPerGeoType3[0],isPfl,arrOut,nasc);
2061     }
2062 }
2063
2064 DataArray *MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2065 {
2066   if(_field_pm_pt.empty())
2067     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2068   //
2069   std::vector<std::pair<int,int> > dads;
2070   std::vector<const DataArrayInt *> pfls;
2071   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2072   std::vector<int> locs,code;
2073   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2074   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2075     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2076   // Sort by types
2077   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2078   if(code.empty())
2079     {
2080       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2081       throw INTERP_KERNEL::Exception(oss.str().c_str());
2082     }
2083   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2084   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2085   if(type!=ON_NODES)
2086     {
2087       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2088       return finishField4(dads,arr,mesh->getNumberOfCells(),pfl);
2089     }
2090   else
2091     {
2092       if(code.size()!=3)
2093         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2094       int nb=code[1];
2095       if(code[2]==-1)
2096         {
2097           if(nb!=mesh->getNumberOfNodes())
2098             {
2099               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2100               oss << " nodes in mesh !";
2101               throw INTERP_KERNEL::Exception(oss.str().c_str());
2102             }
2103         }
2104       return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
2105     }
2106   //
2107   return 0;
2108 }
2109
2110 void MEDFileFieldPerMesh::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
2111 {
2112   int globalSz=0;
2113   int nbOfEntries=0;
2114   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2115     {
2116       (*it)->getSizes(globalSz,nbOfEntries);
2117     }
2118   entries.resize(nbOfEntries);
2119   nbOfEntries=0;
2120   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2121     {
2122       (*it)->fillValues(nbOfEntries,entries);
2123     }
2124 }
2125
2126 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
2127 {
2128   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2129     {
2130       if((*it)->getGeoType()==typ)
2131         return (*it)->getLeafGivenLocId(locId);
2132     }
2133   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2134   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2135   oss << "Possiblities are : ";
2136   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2137     {
2138       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2139       oss << "\"" << cm2.getRepr() << "\", ";
2140     }
2141   throw INTERP_KERNEL::Exception(oss.str().c_str());
2142 }
2143
2144 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
2145 {
2146   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2147     {
2148       if((*it)->getGeoType()==typ)
2149         return (*it)->getLeafGivenLocId(locId);
2150     }
2151   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2152   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2153   oss << "Possiblities are : ";
2154   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2155     {
2156       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2157       oss << "\"" << cm2.getRepr() << "\", ";
2158     }
2159   throw INTERP_KERNEL::Exception(oss.str().c_str());
2160 }
2161
2162 int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
2163 {
2164   int i=0;
2165   int pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
2166   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=_field_pm_pt.begin();
2167   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
2168     {
2169       INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
2170       if(type==curType)
2171         return i;
2172       else
2173         {
2174           int pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
2175           if(pos>pos2)
2176             it2=it+1;
2177         }
2178     }
2179   int ret=std::distance(_field_pm_pt.begin(),it2);
2180   _field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
2181   return ret;
2182 }
2183
2184 /*!
2185  * 'dads' and 'locs' input parameters have the same number of elements
2186  * \param [in] mesh is \b NOT the global mesh, but the possibly reduced mesh. \a mesh parameter will be directly aggregated in the returned field
2187  */
2188 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2189                                                          const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs,
2190                                                          const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2191 {
2192   isPfl=false;
2193   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(type,ONE_TIME);
2194   ret->setMesh(mesh); ret->setName(nasc.getName().c_str()); ret->setTime(getTime(),getIteration(),getOrder()); ret->setTimeUnit(nasc.getDtUnit().c_str());
2195   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2196   const std::vector<std::string>& infos=getInfo();
2197   da->setInfoOnComponents(infos);
2198   da->setName("");
2199   if(type==ON_GAUSS_PT)
2200     {
2201       int offset=0;
2202       int nbOfArrs=dads.size();
2203       for(int i=0;i<nbOfArrs;i++)
2204         {
2205           std::vector<std::pair<int,int> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
2206           const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
2207           int nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
2208           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> di=DataArrayInt::New();
2209           di->alloc(nbOfElems,1);
2210           di->iota(offset);
2211           const MEDFileFieldLoc& fl=glob->getLocalizationFromId(locs[i]);
2212           ret->setGaussLocalizationOnCells(di->getConstPointer(),di->getConstPointer()+nbOfElems,fl.getRefCoords(),fl.getGaussCoords(),fl.getGaussWeights());
2213           offset+=nbOfElems;
2214         }
2215     }
2216   arrOut=da;
2217   return ret.retn();
2218 }
2219
2220 /*!
2221  * This method is an extension of MEDFileFieldPerMesh::finishField method. It deals with profiles. This method should be called when type is different from ON_NODES.
2222  * 'dads', 'locs' and 'geoTypes' input parameters have the same number of elements.
2223  * No check of this is performed. 'da' array contains an array in old2New style to be applyied to mesh to obtain the right support.
2224  * The order of cells in the returned field is those imposed by the profile.
2225  * \param [in] mesh is the global mesh.
2226  */
2227 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2228                                                           const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2229                                                           const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
2230                                                           const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2231 {
2232   if(da->isIdentity())
2233     {
2234       int nbOfTuples=da->getNumberOfTuples();
2235       if(nbOfTuples==mesh->getNumberOfCells())
2236         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2237     }
2238   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m2=mesh->buildPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2239   m2->setName(mesh->getName());
2240   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(type,glob,dads,locs,m2,isPfl,arrOut,nasc);
2241   isPfl=true;
2242   return ret.retn();
2243 }
2244
2245 /*!
2246  * This method is the complement of MEDFileFieldPerMesh::finishField2 method except that this method works for node profiles.
2247  */
2248 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishFieldNode2(const MEDFileFieldGlobsReal *glob,
2249                                                               const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2250                                                               const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2251 {
2252   if(da->isIdentity())
2253     {
2254       int nbOfTuples=da->getNumberOfTuples();
2255       if(nbOfTuples==mesh->getNumberOfNodes())//No problem for NORM_ERROR because it is in context of node
2256         return finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2257     }
2258   // Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
2259   const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
2260   if(meshu)
2261     {
2262       if(meshu->getNodalConnectivity()==0)
2263         {
2264           MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2265           int nb=da->getNbOfElems();
2266           const int *ptr=da->getConstPointer();
2267           MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
2268           meshuc->allocateCells(nb);
2269           for(int i=0;i<nb;i++)
2270             meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
2271           meshuc->finishInsertingCells();
2272           ret->setMesh(meshuc);
2273           const MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
2274           if(!disc) throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::finishFieldNode2 : internal error, no discretization on field !");
2275           disc->checkCoherencyBetween(meshuc,arrOut);
2276           return ret.retn();
2277         }
2278     }
2279   //
2280   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2281   isPfl=true;
2282   DataArrayInt *arr2=0;
2283   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2284   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
2285   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3(arr2);
2286   int nnodes=mesh2->getNumberOfNodes();
2287   if(nnodes==(int)da->getNbOfElems())
2288     {
2289       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
2290       arrOut->renumberInPlace(da3->getConstPointer());
2291       mesh2->setName(mesh->getName());
2292       ret->setMesh(mesh2);
2293       return ret.retn();
2294     }
2295   else
2296     {
2297       std::ostringstream oss; oss << "MEDFileFieldPerMesh::finishFieldNode2 : The field on nodes lies on a node profile so that it is impossible to find a submesh having exactly the same nodes of that profile !!!";
2298       oss << "So it is impossible to return a well definied MEDCouplingFieldDouble instance on specified mesh on a specified meshDim !" << std::endl;
2299       oss << "To retrieve correctly such a field you have 3 possibilities :" << std::endl;
2300       oss << " - use an another meshDim compatible with the field on nodes (MED file does not have such information)" << std::endl;
2301       oss << " - use an another a meshDimRelToMax equal to 1 -> it will return a mesh with artificial cell POINT1 containing the profile !" << std::endl;
2302       oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
2303       throw INTERP_KERNEL::Exception(oss.str().c_str());
2304     }
2305   return 0;
2306 }
2307
2308 /*!
2309  * This method is the most light method of field retrieving.
2310  */
2311 DataArray *MEDFileFieldPerMesh::finishField4(const std::vector<std::pair<int,int> >& dads, const DataArrayInt *pflIn, int nbOfElems, DataArrayInt *&pflOut) const throw(INTERP_KERNEL::Exception)
2312 {
2313   if(!pflIn)
2314     {
2315       pflOut=DataArrayInt::New();
2316       pflOut->alloc(nbOfElems,1);
2317       pflOut->iota(0);
2318     }
2319   else
2320     {
2321       pflOut=const_cast<DataArrayInt*>(pflIn);
2322       pflOut->incrRef();
2323     }
2324   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> safePfl(pflOut);
2325   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2326   const std::vector<std::string>& infos=getInfo();
2327   int nbOfComp=infos.size();
2328   for(int i=0;i<nbOfComp;i++)
2329     da->setInfoOnComponent(i,infos[i].c_str());
2330   safePfl->incrRef();
2331   return da.retn();
2332 }
2333
2334 MEDFileFieldPerMesh::MEDFileFieldPerMesh(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception):_mesh_iteration(meshIteration),_mesh_order(meshOrder),
2335                                                                                                                                                                                                                  _mesh_csit(meshCsit),_father(fath)
2336 {
2337   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2338   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2339   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2340   for(int i=0;i<MED_N_CELL_FIXED_GEO;i++)
2341     {
2342       int nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL,typmai[i],_mesh_csit,meshName,pflName,locName);
2343       if(nbProfile>0)
2344         {
2345           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[i],nasc));
2346           _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2347         }
2348       nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[i],_mesh_csit,meshName,pflName,locName);
2349       if(nbProfile>0)
2350         {
2351           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_GAUSS_NE,typmai2[i],nasc));
2352           _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2353         }
2354     }
2355   int nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,_mesh_csit,meshName,pflName,locName);
2356   if(nbProfile>0)
2357     {
2358       _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc));
2359       _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2360     }
2361 }
2362
2363 MEDFileFieldPerMesh::MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh):_father(fath)
2364 {
2365   copyTinyInfoFrom(mesh);
2366 }
2367
2368 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int id, const char *pflName) throw(INTERP_KERNEL::Exception)
2369 {
2370   if(id>=(int)_pfls.size())
2371     _pfls.resize(id+1);
2372   _pfls[id]=DataArrayInt::New();
2373   int lgth=MEDprofileSizeByName(fid,pflName);
2374   _pfls[id]->setName(pflName);
2375   _pfls[id]->alloc(lgth,1);
2376   MEDprofileRd(fid,pflName,_pfls[id]->getPointer());
2377   _pfls[id]->applyLin(1,-1,0);//Converting into C format
2378 }
2379
2380 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int i)
2381 {
2382   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2383   int sz;
2384   MEDprofileInfo(fid,i+1,pflName,&sz);
2385   std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
2386   if(i>=(int)_pfls.size())
2387     _pfls.resize(i+1);
2388   _pfls[i]=DataArrayInt::New();
2389   _pfls[i]->alloc(sz,1);
2390   _pfls[i]->setName(pflCpp.c_str());
2391   MEDprofileRd(fid,pflName,_pfls[i]->getPointer());
2392   _pfls[i]->applyLin(1,-1,0);//Converting into C format
2393 }
2394
2395 void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const throw(INTERP_KERNEL::Exception)
2396 {
2397   int nbOfPfls=_pfls.size();
2398   for(int i=0;i<nbOfPfls;i++)
2399     {
2400       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cpy=_pfls[i]->deepCpy();
2401       cpy->applyLin(1,1,0);
2402       INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2403       MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
2404       MEDprofileWr(fid,pflName,_pfls[i]->getNumberOfTuples(),cpy->getConstPointer());
2405     }
2406   //
2407   int nbOfLocs=_locs.size();
2408   for(int i=0;i<nbOfLocs;i++)
2409     _locs[i]->writeLL(fid);
2410 }
2411
2412 void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps) throw(INTERP_KERNEL::Exception)
2413 {
2414   std::vector<std::string> pfls=getPfls();
2415   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
2416     {
2417       std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
2418       if(it2==pfls.end())
2419         {
2420           _pfls.push_back(*it);
2421         }
2422       else
2423         {
2424           int id=std::distance(pfls.begin(),it2);
2425           if(!(*it)->isEqual(*_pfls[id]))
2426             {
2427               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2428               throw INTERP_KERNEL::Exception(oss.str().c_str());
2429             }
2430         }
2431     }
2432   std::vector<std::string> locs=getLocs();
2433   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=other._locs.begin();it!=other._locs.end();it++)
2434     {
2435       std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
2436       if(it2==locs.end())
2437         {
2438           _locs.push_back(*it);
2439         }
2440       else
2441         {
2442           int id=std::distance(locs.begin(),it2);
2443           if(!(*it)->isEqual(*_locs[id],eps))
2444             {
2445               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2446               throw INTERP_KERNEL::Exception(oss.str().c_str());
2447             }
2448         }
2449     }
2450 }
2451
2452 void MEDFileFieldGlobs::checkGlobsPflsPartCoherency(const std::vector<std::string>& pflsUsed) const throw(INTERP_KERNEL::Exception)
2453 {
2454   for(std::vector<std::string>::const_iterator it=pflsUsed.begin();it!=pflsUsed.end();it++)
2455     getProfile((*it).c_str());
2456 }
2457
2458 void MEDFileFieldGlobs::checkGlobsLocsPartCoherency(const std::vector<std::string>& locsUsed) const throw(INTERP_KERNEL::Exception)
2459 {
2460   for(std::vector<std::string>::const_iterator it=locsUsed.begin();it!=locsUsed.end();it++)
2461     getLocalization((*it).c_str());
2462 }
2463
2464 void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real) throw(INTERP_KERNEL::Exception)
2465 {
2466   std::vector<std::string> profiles=real.getPflsReallyUsed();
2467   int sz=profiles.size();
2468   _pfls.resize(sz);
2469   for(int i=0;i<sz;i++)
2470     loadProfileInFile(fid,i,profiles[i].c_str());
2471   //
2472   std::vector<std::string> locs=real.getLocsReallyUsed();
2473   sz=locs.size();
2474   _locs.resize(sz);
2475   for(int i=0;i<sz;i++)
2476     _locs[i]=MEDFileFieldLoc::New(fid,locs[i].c_str());
2477 }
2478
2479 void MEDFileFieldGlobs::loadAllGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
2480 {
2481   int nProfil=MEDnProfile(fid);
2482   for(int i=0;i<nProfil;i++)
2483     loadProfileInFile(fid,i);
2484   int sz=MEDnLocalization(fid);
2485   _locs.resize(sz);
2486   for(int i=0;i<sz;i++)
2487     {
2488       _locs[i]=MEDFileFieldLoc::New(fid,i);
2489     }
2490 }
2491
2492 MEDFileFieldGlobs *MEDFileFieldGlobs::New(const char *fname)
2493 {
2494   return new MEDFileFieldGlobs(fname);
2495 }
2496
2497 MEDFileFieldGlobs *MEDFileFieldGlobs::New()
2498 {
2499   return new MEDFileFieldGlobs;
2500 }
2501
2502 std::size_t MEDFileFieldGlobs::getHeapMemorySize() const
2503 {
2504   std::size_t ret=_file_name.capacity()+_pfls.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<DataArrayInt>)+_locs.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>);
2505   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2506     ret+=(*it)->getHeapMemorySize();
2507   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2508     ret+=(*it)->getHeapMemorySize();
2509   return ret;
2510 }
2511
2512 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpy() const throw(INTERP_KERNEL::Exception)
2513 {
2514   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
2515   std::size_t i=0;
2516   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2517     {
2518       if((const DataArrayInt *)*it)
2519         ret->_pfls[i]=(*it)->deepCpy();
2520     }
2521   i=0;
2522   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2523     {
2524       if((const MEDFileFieldLoc*)*it)
2525         ret->_locs[i]=(*it)->deepCpy();
2526     }
2527   return ret.retn();
2528 }
2529
2530 /*!
2531  * \throw if a profile in \a pfls in not in \a this.
2532  * \throw if a localization in \a locs in not in \a this.
2533  * \sa MEDFileFieldGlobs::deepCpyPart
2534  */
2535 MEDFileFieldGlobs *MEDFileFieldGlobs::shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const throw(INTERP_KERNEL::Exception)
2536 {
2537   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2538   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2539     {
2540       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2541       if(!pfl)
2542         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! pfl null !");
2543       pfl->incrRef();
2544       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2(pfl);
2545       ret->_pfls.push_back(pfl2);
2546     }
2547   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2548     {
2549       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2550       if(!loc)
2551         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! loc null !");
2552       loc->incrRef();
2553       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> loc2(loc);
2554       ret->_locs.push_back(loc2);
2555     }
2556   ret->setFileName(getFileName());
2557   return ret.retn();
2558 }
2559
2560 /*!
2561  * \throw if a profile in \a pfls in not in \a this.
2562  * \throw if a localization in \a locs in not in \a this.
2563  * \sa MEDFileFieldGlobs::shallowCpyPart
2564  */
2565 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const throw(INTERP_KERNEL::Exception)
2566 {
2567   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2568   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2569     {
2570       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2571       if(!pfl)
2572         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! pfl null !");
2573       ret->_pfls.push_back(pfl->deepCpy());
2574     }
2575   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2576     {
2577       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2578       if(!loc)
2579         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! loc null !");
2580       ret->_locs.push_back(loc->deepCpy());
2581     }
2582   ret->setFileName(getFileName());
2583   return ret.retn();
2584 }
2585
2586 MEDFileFieldGlobs::MEDFileFieldGlobs(const char *fname):_file_name(fname)
2587 {
2588 }
2589
2590 MEDFileFieldGlobs::MEDFileFieldGlobs()
2591 {
2592 }
2593
2594 MEDFileFieldGlobs::~MEDFileFieldGlobs()
2595 {
2596 }
2597
2598 void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
2599 {
2600   oss << "Profiles :\n";
2601   std::size_t n=_pfls.size();
2602   for(std::size_t i=0;i<n;i++)
2603     {
2604       oss << "  - #" << i << " ";
2605       const DataArrayInt *pfl=_pfls[i];
2606       if(pfl)
2607         oss << "\"" << pfl->getName() << "\"\n";
2608       else
2609         oss << "EMPTY !\n";
2610     }
2611   n=_locs.size();
2612   oss << "Localizations :\n";
2613   for(std::size_t i=0;i<n;i++)
2614     {
2615       oss << "  - #" << i << " ";
2616       const MEDFileFieldLoc *loc=_locs[i];
2617       if(loc)
2618         loc->simpleRepr(oss);
2619       else
2620         oss<< "EMPTY !\n";
2621     }
2622 }
2623
2624 void MEDFileFieldGlobs::setFileName(const char *fileName)
2625 {
2626   _file_name=fileName;
2627 }
2628
2629 void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2630 {
2631   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
2632     {
2633       DataArrayInt *elt(*it);
2634       if(elt)
2635         {
2636           std::string name(elt->getName());
2637           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2638             {
2639               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2640                 {
2641                   elt->setName((*it2).second.c_str());
2642                   return;
2643                 }
2644             }
2645         }
2646     }
2647 }
2648
2649 void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2650 {
2651   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
2652     {
2653       MEDFileFieldLoc *elt(*it);
2654       if(elt)
2655         {
2656           std::string name(elt->getName());
2657           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2658             {
2659               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2660                 {
2661                   elt->setName((*it2).second.c_str());
2662                   return;
2663                 }
2664             }
2665         }
2666     }
2667 }
2668
2669 int MEDFileFieldGlobs::getNbOfGaussPtPerCell(int locId) const throw(INTERP_KERNEL::Exception)
2670 {
2671   if(locId<0 || locId>=(int)_locs.size())
2672     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getNbOfGaussPtPerCell : Invalid localization id !");
2673   return _locs[locId]->getNbOfGaussPtPerCell();
2674 }
2675
2676 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName) const throw(INTERP_KERNEL::Exception)
2677 {
2678   return getLocalizationFromId(getLocalizationId(locName));
2679 }
2680
2681 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) const throw(INTERP_KERNEL::Exception)
2682 {
2683   if(locId<0 || locId>=(int)_locs.size())
2684     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2685   return *_locs[locId];
2686 }
2687
2688 namespace ParaMEDMEMImpl
2689 {
2690   class LocFinder
2691   {
2692   public:
2693     LocFinder(const char *loc):_loc(loc) { }
2694     bool operator() (const MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>& loc) { return loc->isName(_loc); }
2695   private:
2696     const char *_loc;
2697   };
2698
2699   class PflFinder
2700   {
2701   public:
2702     PflFinder(const std::string& pfl):_pfl(pfl) { }
2703     bool operator() (const MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& pfl) { return _pfl==pfl->getName(); }
2704   private:
2705     const std::string& _pfl;
2706   };
2707 }
2708
2709 int MEDFileFieldGlobs::getLocalizationId(const char *loc) const throw(INTERP_KERNEL::Exception)
2710 {
2711   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),ParaMEDMEMImpl::LocFinder(loc));
2712   if(it==_locs.end())
2713     {
2714       std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
2715       for(it=_locs.begin();it!=_locs.end();it++)
2716         oss << "\"" << (*it)->getName() << "\", ";
2717       throw INTERP_KERNEL::Exception(oss.str().c_str());
2718     }
2719   return std::distance(_locs.begin(),it);
2720 }
2721
2722 /*!
2723  * The returned value is never null.
2724  */
2725 const DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName) const throw(INTERP_KERNEL::Exception)
2726 {
2727   std::string pflNameCpp(pflName);
2728   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2729   if(it==_pfls.end())
2730     {
2731       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2732       for(it=_pfls.begin();it!=_pfls.end();it++)
2733         oss << "\"" << (*it)->getName() << "\", ";
2734       throw INTERP_KERNEL::Exception(oss.str().c_str());
2735     }
2736   return *it;
2737 }
2738
2739 const DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) const throw(INTERP_KERNEL::Exception)
2740 {
2741   if(pflId<0 || pflId>=(int)_pfls.size())
2742     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2743   return _pfls[pflId];
2744 }
2745
2746 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) throw(INTERP_KERNEL::Exception)
2747 {
2748   if(locId<0 || locId>=(int)_locs.size())
2749     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2750   return *_locs[locId];
2751 }
2752
2753 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName) throw(INTERP_KERNEL::Exception)
2754 {
2755   return getLocalizationFromId(getLocalizationId(locName));
2756 }
2757
2758 /*!
2759  * The returned value is never null.
2760  */
2761 DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName) throw(INTERP_KERNEL::Exception)
2762 {
2763   std::string pflNameCpp(pflName);
2764   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2765   if(it==_pfls.end())
2766     {
2767       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2768       for(it=_pfls.begin();it!=_pfls.end();it++)
2769         oss << "\"" << (*it)->getName() << "\", ";
2770       throw INTERP_KERNEL::Exception(oss.str().c_str());
2771     }
2772   return *it;
2773 }
2774
2775 DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) throw(INTERP_KERNEL::Exception)
2776 {
2777   if(pflId<0 || pflId>=(int)_pfls.size())
2778     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2779   return _pfls[pflId];
2780 }
2781
2782 void MEDFileFieldGlobs::killProfileIds(const std::vector<int>& pflIds) throw(INTERP_KERNEL::Exception)
2783 {
2784   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newPfls;
2785   int i=0;
2786   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2787     {
2788       if(std::find(pflIds.begin(),pflIds.end(),i)==pflIds.end())
2789         newPfls.push_back(*it);
2790     }
2791   _pfls=newPfls;
2792 }
2793
2794 void MEDFileFieldGlobs::killLocalizationIds(const std::vector<int>& locIds) throw(INTERP_KERNEL::Exception)
2795 {
2796   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> > newLocs;
2797   int i=0;
2798   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2799     {
2800       if(std::find(locIds.begin(),locIds.end(),i)==locIds.end())
2801         newLocs.push_back(*it);
2802     }
2803   _locs=newLocs;
2804 }
2805
2806 std::vector<std::string> MEDFileFieldGlobs::getPfls() const
2807 {
2808   int sz=_pfls.size();
2809   std::vector<std::string> ret(sz);
2810   for(int i=0;i<sz;i++)
2811     ret[i]=_pfls[i]->getName();
2812   return ret;
2813 }
2814
2815 std::vector<std::string> MEDFileFieldGlobs::getLocs() const
2816 {
2817   int sz=_locs.size();
2818   std::vector<std::string> ret(sz);
2819   for(int i=0;i<sz;i++)
2820     ret[i]=_locs[i]->getName();
2821   return ret;
2822 }
2823
2824 bool MEDFileFieldGlobs::existsPfl(const char *pflName) const
2825 {
2826   std::vector<std::string> v=getPfls();
2827   std::string s(pflName);
2828   return std::find(v.begin(),v.end(),s)!=v.end();
2829 }
2830
2831 bool MEDFileFieldGlobs::existsLoc(const char *locName) const
2832 {
2833   std::vector<std::string> v=getLocs();
2834   std::string s(locName);
2835   return std::find(v.begin(),v.end(),s)!=v.end();
2836 }
2837
2838 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualProfiles() const
2839 {
2840   std::map<int,std::vector<int> > m;
2841   int i=0;
2842   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2843     {
2844       const DataArrayInt *tmp=(*it);
2845       if(tmp)
2846         {
2847           m[tmp->getHashCode()].push_back(i);
2848         }
2849     }
2850   std::vector< std::vector<int> > ret;
2851   for(std::map<int,std::vector<int> >::const_iterator it2=m.begin();it2!=m.end();it2++)
2852     {
2853       if((*it2).second.size()>1)
2854         {
2855           std::vector<int> ret0;
2856           bool equalityOrNot=false;
2857           for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
2858             {
2859               std::vector<int>::const_iterator it4=it3; it4++;
2860               for(;it4!=(*it2).second.end();it4++)
2861                 {
2862                   if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
2863                     {
2864                       if(!equalityOrNot)
2865                         ret0.push_back(*it3);
2866                       ret0.push_back(*it4);
2867                       equalityOrNot=true;
2868                     }
2869                 }
2870             }
2871           if(!ret0.empty())
2872             ret.push_back(ret0);
2873         }
2874     }
2875   return ret;
2876 }
2877
2878 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
2879 {
2880   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
2881 }
2882
2883 void MEDFileFieldGlobs::appendProfile(DataArrayInt *pfl) throw(INTERP_KERNEL::Exception)
2884 {
2885   std::string name(pfl->getName());
2886   if(name.empty())
2887     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
2888   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2889     if(name==(*it)->getName())
2890       {
2891         if(!pfl->isEqual(*(*it)))
2892           {
2893             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
2894             throw INTERP_KERNEL::Exception(oss.str().c_str());
2895           }
2896       }
2897   pfl->incrRef();
2898   _pfls.push_back(pfl);
2899 }
2900
2901 void MEDFileFieldGlobs::appendLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w) throw(INTERP_KERNEL::Exception)
2902 {
2903   std::string name(locName);
2904   if(name.empty())
2905     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
2906   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
2907   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2908     if((*it)->isName(locName))
2909       {
2910         if(!(*it)->isEqual(*obj,1e-12))
2911           {
2912             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
2913             throw INTERP_KERNEL::Exception(oss.str().c_str());
2914           }
2915       }
2916   _locs.push_back(obj);
2917 }
2918
2919 std::string MEDFileFieldGlobs::createNewNameOfPfl() const throw(INTERP_KERNEL::Exception)
2920 {
2921   std::vector<std::string> names=getPfls();
2922   return CreateNewNameNotIn("NewPfl_",names);
2923 }
2924
2925 std::string MEDFileFieldGlobs::createNewNameOfLoc() const throw(INTERP_KERNEL::Exception)
2926 {
2927   std::vector<std::string> names=getLocs();
2928   return CreateNewNameNotIn("NewLoc_",names);
2929 }
2930
2931 std::string MEDFileFieldGlobs::CreateNewNameNotIn(const char *prefix, const std::vector<std::string>& namesToAvoid) throw(INTERP_KERNEL::Exception)
2932 {
2933   for(std::size_t sz=0;sz<100000;sz++)
2934     {
2935       std::ostringstream tryName;
2936       tryName << prefix << sz;
2937       if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tryName.str())==namesToAvoid.end())
2938         return tryName.str();
2939     }
2940   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::CreateNewNameNotIn : impossible to create an additional profile limit of 100000 profiles reached !");
2941 }
2942
2943 /*!
2944  * Creates a MEDFileFieldGlobsReal on a given file name. Nothing is read here.
2945  *  \param [in] fname - the file name.
2946  */
2947 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal(const char *fname):_globals(MEDFileFieldGlobs::New(fname))
2948 {
2949 }
2950
2951 /*!
2952  * Creates an empty MEDFileFieldGlobsReal.
2953  */
2954 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal():_globals(MEDFileFieldGlobs::New())
2955 {
2956 }
2957
2958 std::size_t MEDFileFieldGlobsReal::getHeapMemorySize() const
2959 {
2960   std::size_t ret=0;
2961   if((const MEDFileFieldGlobs *)_globals)
2962     ret+=_globals->getHeapMemorySize();
2963   return ret;
2964 }
2965
2966 /*!
2967  * Returns a string describing profiles and Gauss points held in \a this.
2968  *  \return std::string - the description string.
2969  */
2970 void MEDFileFieldGlobsReal::simpleReprGlobs(std::ostream& oss) const
2971 {
2972   const MEDFileFieldGlobs *glob=_globals;
2973   std::ostringstream oss2; oss2 << glob;
2974   std::string stars(oss2.str().length(),'*');
2975   oss << "Globals information on fields (at " << oss2.str() << "):" << "\n************************************" << stars  << "\n\n";
2976   if(glob)
2977     glob->simpleRepr(oss);
2978   else
2979     oss << "NO GLOBAL INFORMATION !\n";
2980 }
2981
2982 void MEDFileFieldGlobsReal::resetContent()
2983 {
2984   _globals=MEDFileFieldGlobs::New();
2985 }
2986
2987 MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
2988 {
2989 }
2990
2991 /*!
2992  * Copies references to profiles and Gauss points from another MEDFileFieldGlobsReal.
2993  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
2994  */
2995 void MEDFileFieldGlobsReal::shallowCpyGlobs(const MEDFileFieldGlobsReal& other)
2996 {
2997   _globals=other._globals;
2998 }
2999
3000 /*!
3001  * Copies references to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3002  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3003  */
3004 void MEDFileFieldGlobsReal::shallowCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other) throw(INTERP_KERNEL::Exception)
3005 {
3006   const MEDFileFieldGlobs *otherg(other._globals);
3007   if(!otherg)
3008     return ;
3009   _globals=otherg->shallowCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3010 }
3011
3012 /*!
3013  * Copies deeply to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3014  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3015  */
3016 void MEDFileFieldGlobsReal::deepCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other) throw(INTERP_KERNEL::Exception)
3017 {
3018   const MEDFileFieldGlobs *otherg(other._globals);
3019   if(!otherg)
3020     return ;
3021   _globals=otherg->deepCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3022 }
3023
3024 void MEDFileFieldGlobsReal::deepCpyGlobs(const MEDFileFieldGlobsReal& other)
3025 {
3026   _globals=other._globals;
3027   if((const MEDFileFieldGlobs *)_globals)
3028     _globals=other._globals->deepCpy();
3029 }
3030
3031 /*!
3032  * Adds profiles and Gauss points held by another MEDFileFieldGlobsReal to \a this one.
3033  *  \param [in] other - the MEDFileFieldGlobsReal to copy data from.
3034  *  \param [in] eps - a precision used to compare Gauss points with same name held by
3035  *         \a this and \a other MEDFileFieldGlobsReal.
3036  *  \throw If \a this and \a other hold profiles with equal names but different ids.
3037  *  \throw If  \a this and \a other hold different Gauss points with equal names.
3038  */
3039 void MEDFileFieldGlobsReal::appendGlobs(const MEDFileFieldGlobsReal& other, double eps) throw(INTERP_KERNEL::Exception)
3040 {
3041   const MEDFileFieldGlobs *thisGlobals(_globals),*otherGlobals(other._globals);
3042   if(thisGlobals==otherGlobals)
3043     return ;
3044   if(!thisGlobals)
3045     {
3046       _globals=other._globals;
3047       return ;
3048     }
3049   _globals->appendGlobs(*other._globals,eps);
3050 }
3051
3052 void MEDFileFieldGlobsReal::checkGlobsCoherency() const throw(INTERP_KERNEL::Exception)
3053 {
3054   checkGlobsPflsPartCoherency();
3055   checkGlobsLocsPartCoherency();
3056 }
3057
3058 void MEDFileFieldGlobsReal::checkGlobsPflsPartCoherency() const throw(INTERP_KERNEL::Exception)
3059 {
3060   contentNotNull()->checkGlobsPflsPartCoherency(getPflsReallyUsed());
3061 }
3062
3063 void MEDFileFieldGlobsReal::checkGlobsLocsPartCoherency() const throw(INTERP_KERNEL::Exception)
3064 {
3065   contentNotNull()->checkGlobsLocsPartCoherency(getLocsReallyUsed());
3066 }
3067
3068 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id, const char *pflName) throw(INTERP_KERNEL::Exception)
3069 {
3070   contentNotNull()->loadProfileInFile(fid,id,pflName);
3071 }
3072
3073 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id)
3074 {
3075   contentNotNull()->loadProfileInFile(fid,id);
3076 }
3077
3078 void MEDFileFieldGlobsReal::loadGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
3079 {
3080   contentNotNull()->loadGlobals(fid,*this);
3081 }
3082
3083 void MEDFileFieldGlobsReal::loadAllGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
3084 {
3085   contentNotNull()->loadAllGlobals(fid);
3086 }
3087
3088 void MEDFileFieldGlobsReal::writeGlobals(med_idt fid, const MEDFileWritable& opt) const throw(INTERP_KERNEL::Exception)
3089 {
3090   contentNotNull()->writeGlobals(fid,opt);
3091 }
3092
3093 /*!
3094  * Returns names of all profiles. To get only used profiles call getPflsReallyUsed()
3095  * or getPflsReallyUsedMulti().
3096  *  \return std::vector<std::string> - a sequence of names of all profiles.
3097  */
3098 std::vector<std::string> MEDFileFieldGlobsReal::getPfls() const
3099 {
3100   return contentNotNull()->getPfls();
3101 }
3102
3103 /*!
3104  * Returns names of all localizations. To get only used localizations call getLocsReallyUsed()
3105  * or getLocsReallyUsedMulti().
3106  *  \return std::vector<std::string> - a sequence of names of all localizations.
3107  */
3108 std::vector<std::string> MEDFileFieldGlobsReal::getLocs() const
3109 {
3110   return contentNotNull()->getLocs();
3111 }
3112
3113 /*!
3114  * Checks if the profile with a given name exists.
3115  *  \param [in] pflName - the profile name of interest.
3116  *  \return bool - \c true if the profile named \a pflName exists.
3117  */
3118 bool MEDFileFieldGlobsReal::existsPfl(const char *pflName) const
3119 {
3120   return contentNotNull()->existsPfl(pflName);
3121 }
3122
3123 /*!
3124  * Checks if the localization with a given name exists.
3125  *  \param [in] locName - the localization name of interest.
3126  *  \return bool - \c true if the localization named \a locName exists.
3127  */
3128 bool MEDFileFieldGlobsReal::existsLoc(const char *locName) const
3129 {
3130   return contentNotNull()->existsLoc(locName);
3131 }
3132
3133 std::string MEDFileFieldGlobsReal::createNewNameOfPfl() const throw(INTERP_KERNEL::Exception)
3134 {
3135   return contentNotNull()->createNewNameOfPfl();
3136 }
3137
3138 std::string MEDFileFieldGlobsReal::createNewNameOfLoc() const throw(INTERP_KERNEL::Exception)
3139 {
3140   return contentNotNull()->createNewNameOfLoc();
3141 }
3142
3143 /*!
3144  * Sets the name of a MED file.
3145  *  \param [inout] fileName - the file name.
3146  */
3147 void MEDFileFieldGlobsReal::setFileName(const char *fileName)
3148 {
3149   contentNotNull()->setFileName(fileName);
3150 }
3151
3152 /*!
3153  * Finds equal profiles. Two profiles are considered equal if they contain the same ids
3154  * in the same order.
3155  *  \return std::vector< std::vector<int> > - a sequence of groups of equal profiles.
3156  *          Each item of this sequence is a vector containing ids of equal profiles.
3157  */
3158 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualProfiles() const
3159 {
3160   return contentNotNull()->whichAreEqualProfiles();
3161 }
3162
3163 /*!
3164  * Finds equal localizations.
3165  *  \param [in] eps - a precision used to compare real values of the localizations.
3166  *  \return std::vector< std::vector<int> > - a sequence of groups of equal localizations.
3167  *          Each item of this sequence is a vector containing ids of equal localizations.
3168  */
3169 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualLocs(double eps) const
3170 {
3171   return contentNotNull()->whichAreEqualLocs(eps);
3172 }
3173
3174 /*!
3175  * Renames the profiles. References to profiles (a reference is a profile name) are not changed.
3176  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3177  *        this sequence is a pair whose
3178  *        - the first item is a vector of profile names to replace by the second item,
3179  *        - the second item is a profile name to replace every profile name of the first item.
3180  */
3181 void MEDFileFieldGlobsReal::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3182 {
3183   contentNotNull()->changePflsNamesInStruct(mapOfModif);
3184 }
3185
3186 /*!
3187  * Renames the localizations. References to localizations (a reference is a localization name) are not changed.
3188  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3189  *        this sequence is a pair whose
3190  *        - the first item is a vector of localization names to replace by the second item,
3191  *        - the second item is a localization name to replace every localization name of the first item.
3192  */
3193 void MEDFileFieldGlobsReal::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3194 {
3195   contentNotNull()->changeLocsNamesInStruct(mapOfModif);
3196 }
3197
3198 /*!
3199  * Replaces references to some profiles (a reference is a profile name) by references
3200  * to other profiles and, contrary to changePflsRefsNamesGen(), renames the profiles
3201  * them-selves accordingly. <br>
3202  * This method is a generalization of changePflName().
3203  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3204  *        this sequence is a pair whose
3205  *        - the first item is a vector of profile names to replace by the second item,
3206  *        - the second item is a profile name to replace every profile of the first item.
3207  * \sa changePflsRefsNamesGen()
3208  * \sa changePflName()
3209  */
3210 void MEDFileFieldGlobsReal::changePflsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3211 {
3212   changePflsRefsNamesGen(mapOfModif);
3213   changePflsNamesInStruct(mapOfModif);
3214 }
3215
3216 /*!
3217  * Replaces references to some localizations (a reference is a localization name) by references
3218  * to other localizations and, contrary to changeLocsRefsNamesGen(), renames the localizations
3219  * them-selves accordingly. <br>
3220  * This method is a generalization of changeLocName().
3221  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3222  *        this sequence is a pair whose
3223  *        - the first item is a vector of localization names to replace by the second item,
3224  *        - the second item is a localization name to replace every localization of the first item.
3225  * \sa changeLocsRefsNamesGen()
3226  * \sa changeLocName()
3227  */
3228 void MEDFileFieldGlobsReal::changeLocsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3229 {
3230   changeLocsRefsNamesGen(mapOfModif);
3231   changeLocsNamesInStruct(mapOfModif);
3232 }
3233
3234 /*!
3235  * Renames the profile having a given name and updates references to this profile.
3236  *  \param [in] oldName - the name of the profile to rename.
3237  *  \param [in] newName - a new name of the profile.
3238  * \sa changePflsNames().
3239  */
3240 void MEDFileFieldGlobsReal::changePflName(const char *oldName, const char *newName) throw(INTERP_KERNEL::Exception)
3241 {
3242   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3243   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3244   mapOfModif[0]=p;
3245   changePflsNames(mapOfModif);
3246 }
3247
3248 /*!
3249  * Renames the localization having a given name and updates references to this localization.
3250  *  \param [in] oldName - the name of the localization to rename.
3251  *  \param [in] newName - a new name of the localization.
3252  * \sa changeLocsNames().
3253  */
3254 void MEDFileFieldGlobsReal::changeLocName(const char *oldName, const char *newName) throw(INTERP_KERNEL::Exception)
3255 {
3256   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3257   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3258   mapOfModif[0]=p;
3259   changeLocsNames(mapOfModif);
3260 }
3261
3262 /*!
3263  * Removes duplicated profiles. Returns a map used to update references to removed
3264  * profiles via changePflsRefsNamesGen().
3265  * Equal profiles are found using whichAreEqualProfiles().
3266  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3267  *          a sequence describing the performed replacements of profiles. Each element of
3268  *          this sequence is a pair whose
3269  *          - the first item is a vector of profile names replaced by the second item,
3270  *          - the second item is a profile name replacing every profile of the first item.
3271  */
3272 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipPflsNames() throw(INTERP_KERNEL::Exception)
3273 {
3274   std::vector< std::vector<int> > pseudoRet=whichAreEqualProfiles();
3275   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3276   int i=0;
3277   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3278     {
3279       std::vector< std::string > tmp((*it).size());
3280       int j=0;
3281       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3282         tmp[j]=std::string(getProfileFromId(*it2)->getName());
3283       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3284       ret[i]=p;
3285       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3286       killProfileIds(tmp2);
3287     }
3288   changePflsRefsNamesGen(ret);
3289   return ret;
3290 }
3291
3292 /*!
3293  * Removes duplicated localizations. Returns a map used to update references to removed
3294  * localizations via changeLocsRefsNamesGen().
3295  * Equal localizations are found using whichAreEqualLocs().
3296  *  \param [in] eps - a precision used to compare real values of the localizations.
3297  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3298  *          a sequence describing the performed replacements of localizations. Each element of
3299  *          this sequence is a pair whose
3300  *          - the first item is a vector of localization names replaced by the second item,
3301  *          - the second item is a localization name replacing every localization of the first item.
3302  */
3303 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipLocsNames(double eps) throw(INTERP_KERNEL::Exception)
3304 {
3305   std::vector< std::vector<int> > pseudoRet=whichAreEqualLocs(eps);
3306   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3307   int i=0;
3308   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3309     {
3310       std::vector< std::string > tmp((*it).size());
3311       int j=0;
3312       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3313         tmp[j]=std::string(getLocalizationFromId(*it2).getName());
3314       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3315       ret[i]=p;
3316       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3317       killLocalizationIds(tmp2);
3318     }
3319   changeLocsRefsNamesGen(ret);
3320   return ret;
3321 }
3322
3323 /*!
3324  * Returns number of Gauss points per cell in a given localization.
3325  *  \param [in] locId - an id of the localization of interest.
3326  *  \return int - the number of the Gauss points per cell.
3327  */
3328 int MEDFileFieldGlobsReal::getNbOfGaussPtPerCell(int locId) const throw(INTERP_KERNEL::Exception)
3329 {
3330   return contentNotNull()->getNbOfGaussPtPerCell(locId);
3331 }
3332
3333 /*!
3334  * Returns an id of a localization by its name.
3335  *  \param [in] loc - the localization name of interest.
3336  *  \return int - the id of the localization.
3337  *  \throw If there is no a localization named \a loc.
3338  */
3339 int MEDFileFieldGlobsReal::getLocalizationId(const char *loc) const throw(INTERP_KERNEL::Exception)
3340 {
3341   return contentNotNull()->getLocalizationId(loc);
3342 }
3343
3344 /*!
3345  * Returns the name of the MED file.
3346  *  \return const char * - the MED file name.
3347  */
3348 const char *MEDFileFieldGlobsReal::getFileName() const
3349 {
3350   return contentNotNull()->getFileName();
3351 }
3352
3353 std::string MEDFileFieldGlobsReal::getFileName2() const
3354 {
3355   return contentNotNull()->getFileName2();
3356 }
3357
3358 /*!
3359  * Returns a localization object by its name.
3360  *  \param [in] locName - the name of the localization of interest.
3361  *  \return const MEDFileFieldLoc& - the localization object having the name \a locName.
3362  *  \throw If there is no a localization named \a locName.
3363  */
3364 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName) const throw(INTERP_KERNEL::Exception)
3365 {
3366   return contentNotNull()->getLocalization(locName);
3367 }
3368
3369 /*!
3370  * Returns a localization object by its id.
3371  *  \param [in] locId - the id of the localization of interest.
3372  *  \return const MEDFileFieldLoc& - the localization object having the id \a locId.
3373  *  \throw If there is no a localization with id \a locId.
3374  */
3375 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) const throw(INTERP_KERNEL::Exception)
3376 {
3377   return contentNotNull()->getLocalizationFromId(locId);
3378 }
3379
3380 /*!
3381  * Returns a profile array by its name.
3382  *  \param [in] pflName - the name of the profile of interest.
3383  *  \return const DataArrayInt * - the profile array having the name \a pflName.
3384  *  \throw If there is no a profile named \a pflName.
3385  */
3386 const DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName) const throw(INTERP_KERNEL::Exception)
3387 {
3388   return contentNotNull()->getProfile(pflName);
3389 }
3390
3391 /*!
3392  * Returns a profile array by its id.
3393  *  \param [in] pflId - the id of the profile of interest.
3394  *  \return const DataArrayInt * - the profile array having the id \a pflId.
3395  *  \throw If there is no a profile with id \a pflId.
3396  */
3397 const DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) const throw(INTERP_KERNEL::Exception)
3398 {
3399   return contentNotNull()->getProfileFromId(pflId);
3400 }
3401
3402 /*!
3403  * Returns a localization object, apt for modification, by its id.
3404  *  \param [in] locId - the id of the localization of interest.
3405  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3406  *          having the id \a locId.
3407  *  \throw If there is no a localization with id \a locId.
3408  */
3409 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) throw(INTERP_KERNEL::Exception)
3410 {
3411   return contentNotNull()->getLocalizationFromId(locId);
3412 }
3413
3414 /*!
3415  * Returns a localization object, apt for modification, by its name.
3416  *  \param [in] locName - the name of the localization of interest.
3417  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3418  *          having the name \a locName.
3419  *  \throw If there is no a localization named \a locName.
3420  */
3421 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName) throw(INTERP_KERNEL::Exception)
3422 {
3423   return contentNotNull()->getLocalization(locName);
3424 }
3425
3426 /*!
3427  * Returns a profile array, apt for modification, by its name.
3428  *  \param [in] pflName - the name of the profile of interest.
3429  *  \return DataArrayInt * - a non-const pointer to the profile array having the name \a pflName.
3430  *  \throw If there is no a profile named \a pflName.
3431  */
3432 DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName) throw(INTERP_KERNEL::Exception)
3433 {
3434   return contentNotNull()->getProfile(pflName);
3435 }
3436
3437 /*!
3438  * Returns a profile array, apt for modification, by its id.
3439  *  \param [in] pflId - the id of the profile of interest.
3440  *  \return DataArrayInt * - a non-const pointer to the profile array having the id \a pflId.
3441  *  \throw If there is no a profile with id \a pflId.
3442  */
3443 DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) throw(INTERP_KERNEL::Exception)
3444 {
3445   return contentNotNull()->getProfileFromId(pflId);
3446 }
3447
3448 /*!
3449  * Removes profiles given by their ids. No data is updated to track this removal.
3450  *  \param [in] pflIds - a sequence of ids of the profiles to remove.
3451  */
3452 void MEDFileFieldGlobsReal::killProfileIds(const std::vector<int>& pflIds) throw(INTERP_KERNEL::Exception)
3453 {
3454   contentNotNull()->killProfileIds(pflIds);
3455 }
3456
3457 /*!
3458  * Removes localizations given by their ids. No data is updated to track this removal.
3459  *  \param [in] locIds - a sequence of ids of the localizations to remove.
3460  */
3461 void MEDFileFieldGlobsReal::killLocalizationIds(const std::vector<int>& locIds) throw(INTERP_KERNEL::Exception)
3462 {
3463   contentNotNull()->killLocalizationIds(locIds);
3464 }
3465
3466 /*!
3467  * Stores a profile array.
3468  *  \param [in] pfl - the profile array to store.
3469  *  \throw If the name of \a pfl is empty.
3470  *  \throw If a profile with the same name as that of \a pfl already exists but contains
3471  *         different ids.
3472  */
3473 void MEDFileFieldGlobsReal::appendProfile(DataArrayInt *pfl) throw(INTERP_KERNEL::Exception)
3474 {
3475   contentNotNull()->appendProfile(pfl);
3476 }
3477
3478 /*!
3479  * Adds a new localization of Gauss points.
3480  *  \param [in] locName - the name of the new localization.
3481  *  \param [in] geoType - a geometrical type of the reference cell.
3482  *  \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
3483  *         must be \c nbOfNodesPerCell * \c dimOfType.
3484  *  \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
3485  *         must be  _wg_.size() * \c dimOfType.
3486  *  \param [in] w - the weights of Gauss points.
3487  *  \throw If \a locName is empty.
3488  *  \throw If a localization with the name \a locName already exists but is
3489  *         different form the new one.
3490  */
3491 void MEDFileFieldGlobsReal::appendLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w) throw(INTERP_KERNEL::Exception)
3492 {
3493   contentNotNull()->appendLoc(locName,geoType,refCoo,gsCoo,w);
3494 }
3495
3496 MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() throw(INTERP_KERNEL::Exception)
3497 {
3498   MEDFileFieldGlobs *g(_globals);
3499   if(!g)
3500     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in not const !");
3501   return g;
3502 }
3503
3504 const MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() const throw(INTERP_KERNEL::Exception)
3505 {
3506   const MEDFileFieldGlobs *g(_globals);
3507   if(!g)
3508     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in const !");
3509   return g;
3510 }
3511
3512 //= MEDFileFieldNameScope
3513
3514 MEDFileFieldNameScope::MEDFileFieldNameScope()
3515 {
3516 }
3517
3518 MEDFileFieldNameScope::MEDFileFieldNameScope(const char *fieldName):_name(fieldName)
3519 {
3520 }
3521
3522 /*!
3523  * Returns the name of \a this field.
3524  *  \return std::string - a string containing the field name.
3525  */
3526 std::string MEDFileFieldNameScope::getName() const throw(INTERP_KERNEL::Exception)
3527 {
3528   return _name;
3529 }
3530
3531 /*!
3532  * Sets name of \a this field
3533  *  \param [in] name - the new field name.
3534  */
3535 void MEDFileFieldNameScope::setName(const char *fieldName) throw(INTERP_KERNEL::Exception)
3536 {
3537   _name=fieldName;
3538 }
3539
3540 std::string MEDFileFieldNameScope::getDtUnit() const throw(INTERP_KERNEL::Exception)
3541 {
3542   return _dt_unit;
3543 }
3544
3545 void MEDFileFieldNameScope::setDtUnit(const char *dtUnit) throw(INTERP_KERNEL::Exception)
3546 {
3547   _dt_unit=dtUnit;
3548 }
3549
3550 void MEDFileFieldNameScope::copyNameScope(const MEDFileFieldNameScope& other)
3551 {
3552   _name=other._name;
3553   _dt_unit=other._dt_unit;
3554 }
3555
3556 //= MEDFileAnyTypeField1TSWithoutSDA
3557
3558 void MEDFileAnyTypeField1TSWithoutSDA::deepCpyLeavesFrom(const MEDFileAnyTypeField1TSWithoutSDA& other) throw(INTERP_KERNEL::Exception)
3559 {
3560   _field_per_mesh.resize(other._field_per_mesh.size());
3561   std::size_t i=0;
3562   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
3563     {
3564       if((const MEDFileFieldPerMesh *)*it)
3565         _field_per_mesh[i]=(*it)->deepCpy(this);
3566     }
3567 }
3568
3569 /*!
3570  * Prints a string describing \a this field into a stream. This string is outputted
3571  * by \c print Python command.
3572  *  \param [in] bkOffset - number of white spaces printed at the beginning of each line.
3573  *  \param [in,out] oss - the out stream.
3574  *  \param [in] f1tsId - the field index within a MED file. If \a f1tsId < 0, the tiny
3575  *          info id printed, else, not.
3576  */
3577 void MEDFileAnyTypeField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
3578 {
3579   std::string startOfLine(bkOffset,' ');
3580   oss << startOfLine << "Field ";
3581   if(bkOffset==0)
3582     oss << "[Type=" << getTypeStr() << "] with name \"" << getName() << "\" ";
3583   oss << "on one time Step ";
3584   if(f1tsId>=0)
3585     oss << "(" << f1tsId << ") ";
3586   oss << "on iteration=" << _iteration << " order=" << _order << "." << std::endl;
3587   oss << startOfLine << "Time attached is : " << _dt << " [" << _dt_unit << "]." << std::endl;
3588   const DataArray *arr=getUndergroundDataArray();
3589   if(arr)
3590     {
3591       const std::vector<std::string> &comps=arr->getInfoOnComponents();
3592       if(f1tsId<0)
3593         {
3594           oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
3595           for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
3596             oss << startOfLine << "  -  \"" << (*it) << "\"" << std::endl;
3597         }
3598       if(arr->isAllocated())
3599         {
3600           oss << startOfLine << "Whole field contains " << arr->getNumberOfTuples() << " tuples." << std::endl;
3601         }
3602       else
3603         oss << startOfLine << "The array of the current field has not allocated yet !" << std::endl;
3604     }
3605   else
3606     {
3607       oss << startOfLine << "Field infos are empty ! Not defined yet !" << std::endl;
3608     }
3609   oss << startOfLine << "----------------------" << std::endl;
3610   if(!_field_per_mesh.empty())
3611     {
3612       int i=0;
3613       for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
3614         {
3615           const MEDFileFieldPerMesh *cur=(*it2);
3616           if(cur)
3617             cur->simpleRepr(bkOffset,oss,i);
3618           else
3619             oss << startOfLine << "Field per mesh #" << i << " is not defined !" << std::endl;
3620         }
3621     }
3622   else
3623     {
3624       oss << startOfLine << "Field is not defined on any meshes !" << std::endl;
3625     }
3626   oss << startOfLine << "----------------------" << std::endl;
3627 }
3628
3629 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitComponents() const throw(INTERP_KERNEL::Exception)
3630 {
3631   const DataArray *arr(getUndergroundDataArray());
3632   if(!arr)
3633     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitComponents : no array defined !");
3634   int nbOfCompo=arr->getNumberOfComponents();
3635   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfCompo);
3636   for(int i=0;i<nbOfCompo;i++)
3637     {
3638       ret[i]=deepCpy();
3639       std::vector<int> v(1,i);
3640       MEDCouplingAutoRefCountObjectPtr<DataArray> arr2=arr->keepSelectedComponents(v);
3641       ret[i]->setArray(arr2);
3642     }
3643   return ret;
3644 }
3645
3646 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order):MEDFileFieldNameScope(fieldName),_iteration(iteration),_order(order),_csit(csit),_nb_of_tuples_to_be_allocated(-2)
3647 {
3648 }
3649
3650 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA():_iteration(-1),_order(-1),_dt(0.),_csit(-1),_nb_of_tuples_to_be_allocated(-1)
3651 {
3652 }
3653
3654 /*!
3655  * Returns the maximal dimension of supporting elements. Returns -2 if \a this is
3656  * empty. Returns -1 if this in on nodes.
3657  *  \return int - the dimension of \a this.
3658  */
3659 int MEDFileAnyTypeField1TSWithoutSDA::getDimension() const
3660 {
3661   int ret=-2;
3662   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3663     (*it)->getDimension(ret);
3664   return ret;
3665 }
3666
3667 /*!
3668  * Returns the mesh name.
3669  *  \return std::string - a string holding the mesh name.
3670  *  \throw If \c _field_per_mesh.empty()
3671  */
3672 std::string MEDFileAnyTypeField1TSWithoutSDA::getMeshName() const throw(INTERP_KERNEL::Exception)
3673 {
3674   if(_field_per_mesh.empty())
3675     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshName : No field set !");
3676   return _field_per_mesh[0]->getMeshName();
3677 }
3678
3679 void MEDFileAnyTypeField1TSWithoutSDA::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
3680 {
3681   std::string oldName(getMeshName());
3682   std::vector< std::pair<std::string,std::string> > v(1);
3683   v[0].first=oldName; v[0].second=newMeshName;
3684   changeMeshNames(v);
3685 }
3686
3687 bool MEDFileAnyTypeField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
3688 {
3689   bool ret=false;
3690   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3691     {
3692       MEDFileFieldPerMesh *cur(*it);
3693       if(cur)
3694         ret=cur->changeMeshNames(modifTab) || ret;
3695     }
3696   return ret;
3697 }
3698
3699 /*!
3700  * Returns the number of iteration of the state of underlying mesh.
3701  *  \return int - the iteration number.
3702  *  \throw If \c _field_per_mesh.empty()
3703  */
3704 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIteration() const throw(INTERP_KERNEL::Exception)
3705 {
3706   if(_field_per_mesh.empty())
3707     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshIteration : No field set !");
3708   return _field_per_mesh[0]->getMeshIteration();
3709 }
3710
3711 /*!
3712  * Returns the order number of iteration of the state of underlying mesh.
3713  *  \return int - the order number.
3714  *  \throw If \c _field_per_mesh.empty()
3715  */
3716 int MEDFileAnyTypeField1TSWithoutSDA::getMeshOrder() const throw(INTERP_KERNEL::Exception)
3717 {
3718   if(_field_per_mesh.empty())
3719     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshOrder : No field set !");
3720   return _field_per_mesh[0]->getMeshOrder();
3721 }
3722
3723 /*!
3724  * Checks if \a this field is tagged by a given iteration number and a given
3725  * iteration order number.
3726  *  \param [in] iteration - the iteration number of interest.
3727  *  \param [in] order - the iteration order number of interest.
3728  *  \return bool - \c true if \a this->getIteration() == \a iteration &&
3729  *          \a this->getOrder() == \a order.
3730  */
3731 bool MEDFileAnyTypeField1TSWithoutSDA::isDealingTS(int iteration, int order) const
3732 {
3733   return iteration==_iteration && order==_order;
3734 }
3735
3736 /*!
3737  * Returns number of iteration and order number of iteration when
3738  * \a this field has been calculated.
3739  *  \return std::pair<int,int> - a pair of the iteration number and the iteration
3740  *          order number.
3741  */
3742 std::pair<int,int> MEDFileAnyTypeField1TSWithoutSDA::getDtIt() const
3743 {
3744   std::pair<int,int> p;
3745   fillIteration(p);
3746   return p;
3747 }
3748
3749 /*!
3750  * Returns number of iteration and order number of iteration when
3751  * \a this field has been calculated.
3752  *  \param [in,out] p - a pair returning the iteration number and the iteration
3753  *          order number.
3754  */
3755 void MEDFileAnyTypeField1TSWithoutSDA::fillIteration(std::pair<int,int>& p) const
3756 {
3757   p.first=_iteration;
3758   p.second=_order;
3759 }
3760
3761 /*!
3762  * Returns all types of spatial discretization of \a this field.
3763  *  \param [in,out] types - a sequence of types of \a this field.
3764  */
3765 void MEDFileAnyTypeField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
3766 {
3767   std::set<TypeOfField> types2;
3768   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3769     {
3770       (*it)->fillTypesOfFieldAvailable(types2);
3771     }
3772   std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
3773   std::copy(types2.begin(),types2.end(),bi);
3774 }
3775
3776 /*!
3777  * Returns all types of spatial discretization of \a this field.
3778  *  \return std::vector<TypeOfField> - a sequence of types of spatial discretization
3779  *          of \a this field.
3780  */
3781 std::vector<TypeOfField> MEDFileAnyTypeField1TSWithoutSDA::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
3782 {
3783   std::vector<TypeOfField> ret;
3784   fillTypesOfFieldAvailable(ret);
3785   return ret;
3786 }
3787
3788 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsed2() const
3789 {
3790   std::vector<std::string> ret;
3791   std::set<std::string> ret2;
3792   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3793     {
3794       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
3795       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3796         if(ret2.find(*it2)==ret2.end())
3797           {
3798             ret.push_back(*it2);
3799             ret2.insert(*it2);
3800           }
3801     }
3802   return ret;
3803 }
3804
3805 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsed2() const
3806 {
3807   std::vector<std::string> ret;
3808   std::set<std::string> ret2;
3809   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3810     {
3811       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
3812       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3813         if(ret2.find(*it2)==ret2.end())
3814           {
3815             ret.push_back(*it2);
3816             ret2.insert(*it2);
3817           }
3818     }
3819   return ret;
3820 }
3821
3822 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsedMulti2() const
3823 {
3824   std::vector<std::string> ret;
3825   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3826     {
3827       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
3828       ret.insert(ret.end(),tmp.begin(),tmp.end());
3829     }
3830   return ret;
3831 }
3832
3833 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsedMulti2() const
3834 {
3835   std::vector<std::string> ret;
3836   std::set<std::string> ret2;
3837   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3838     {
3839       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
3840       ret.insert(ret.end(),tmp.begin(),tmp.end());
3841     }
3842   return ret;
3843 }
3844
3845 void MEDFileAnyTypeField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3846 {
3847   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3848     (*it)->changePflsRefsNamesGen(mapOfModif);
3849 }
3850
3851 void MEDFileAnyTypeField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3852 {
3853   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3854     (*it)->changeLocsRefsNamesGen(mapOfModif);
3855 }
3856
3857 /*!
3858  * Returns all attributes of parts of \a this field lying on a given mesh.
3859  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
3860  * item of every of returned sequences refers to the _i_-th part of \a this field.
3861  * Thus all sequences returned by this method are of the same length equal to number
3862  * of different types of supporting entities.<br>
3863  * A field part can include sub-parts with several different spatial discretizations,
3864  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
3865  * for example. Hence, some of the returned sequences contains nested sequences, and an item
3866  * of a nested sequence corresponds to a type of spatial discretization.<br>
3867  * This method allows for iteration over MEDFile DataStructure without any overhead.
3868  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3869  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3870  *          not checked if \a mname == \c NULL).
3871  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
3872  *          a field part is returned.
3873  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
3874  *          This sequence is of the same length as \a types.
3875  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
3876  *          discretization. A profile name can be empty.
3877  *          Length of this and of nested sequences is the same as that of \a typesF.
3878  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
3879  *          discretization. A localization name can be empty.
3880  *          Length of this and of nested sequences is the same as that of \a typesF.
3881  *  \return std::vector< std::vector< std::pair<int,int> > > - a sequence holding a range
3882  *          of ids of tuples within the data array, per each type of spatial
3883  *          discretization within one mesh entity type.
3884  *          Length of this and of nested sequences is the same as that of \a typesF.
3885  *  \throw If no field is lying on \a mname.
3886  */
3887 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeField1TSWithoutSDA::getFieldSplitedByType(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
3888 {
3889   int meshId=0;
3890   if(mname)
3891     meshId=getMeshIdFromMeshName(mname);
3892   else
3893     if(_field_per_mesh.empty())
3894       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
3895   return _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3896 }
3897
3898 /*!
3899  * Returns dimensions of mesh elements \a this field lies on. The returned value is a
3900  * maximal absolute dimension and values returned via the out parameter \a levs are
3901  * dimensions relative to the maximal absolute dimension. <br>
3902  * This method is designed for MEDFileField1TS instances that have a discretization
3903  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS",
3904  * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT",
3905  * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE".
3906  * Only these 3 discretizations will be taken into account here. If \a this is
3907  * \ref ParaMEDMEM::ON_NODES "ON_NODES", -1 is returned and \a levs are empty.<br>
3908  * This method is useful to make the link between the dimension of the underlying mesh
3909  * and the levels of \a this, because it is possible that the highest dimension of \a this
3910  * field is not equal to the dimension of the underlying mesh.
3911  *
3912  * Let's consider the following case:
3913  * - mesh \a m1 has a meshDimension 3 and has non empty levels [0,-1,-2] with elements
3914  * TETRA4, HEXA8, TRI3 and SEG2.
3915  * - field \a f1 lies on \a m1 and is defined on 3D and 1D elements TETRA4 and SEG2.
3916  * - field \a f2 lies on \a m1 and is defined on 2D and 1D elements TRI3 and SEG2.
3917  *
3918  * In this case \a f1->getNonEmptyLevels() returns (3,[0,-2]) and \a
3919  * f2->getNonEmptyLevels() returns (2,[0,-1]). <br>
3920  * The returned values can be used for example to retrieve a MEDCouplingFieldDouble lying
3921  * on elements of a certain relative level by calling getFieldAtLevel(). \a meshDimRelToMax
3922  * parameter of getFieldAtLevel() is computed basing on the returned values as this:
3923  * <em> meshDimRelToMax = absDim - meshDim + relativeLev </em>.
3924  * For example<br>
3925  * to retrieve the highest level of
3926  * \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+0 ); // absDim - meshDim + relativeLev</em><br>
3927  * to retrieve the lowest level of \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+(-2) );</em><br>
3928  * to retrieve the highest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+0 );</em><br>
3929  * to retrieve the lowest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+(-1) )</em>.
3930  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3931  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3932  *          not checked if \a mname == \c NULL).
3933  *  \param [in,out] levs - a sequence returning the dimensions relative to the maximal
3934  *          absolute one. They are in decreasing order. This sequence is cleared before
3935  *          filling it in.
3936  *  \return int - the maximal absolute dimension of elements \a this fields lies on.
3937  *  \throw If no field is lying on \a mname.
3938  */
3939 int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
3940 {
3941   levs.clear();
3942   int meshId=getMeshIdFromMeshName(mname);
3943   std::vector<INTERP_KERNEL::NormalizedCellType> types;
3944   std::vector< std::vector<TypeOfField> > typesF;
3945   std::vector< std::vector<std::string> > pfls, locs;
3946   _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3947   if(types.empty())
3948     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getNonEmptyLevels : 'this' is empty !");
3949   std::set<INTERP_KERNEL::NormalizedCellType> st(types.begin(),types.end());
3950   if(st.size()==1 && (*st.begin())==INTERP_KERNEL::NORM_ERROR)
3951     return -1;
3952   st.erase(INTERP_KERNEL::NORM_ERROR);
3953   std::set<int> ret1;
3954   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
3955     {
3956       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
3957       ret1.insert((int)cm.getDimension());
3958     }
3959   int ret=*std::max_element(ret1.begin(),ret1.end());
3960   std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
3961   std::transform(levs.begin(),levs.end(),levs.begin(),std::bind2nd(std::plus<int>(),-ret));
3962   return ret;
3963 }
3964
3965 /*!
3966  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
3967  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
3968  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
3969  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
3970  */
3971 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
3972 {
3973   int mid=getMeshIdFromMeshName(mName);
3974   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
3975 }
3976
3977 /*!
3978  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
3979  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
3980  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
3981  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
3982  */
3983 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
3984 {
3985   int mid=getMeshIdFromMeshName(mName);
3986   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
3987 }
3988
3989 /*!
3990  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
3991  */
3992 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIdFromMeshName(const char *mName) const throw(INTERP_KERNEL::Exception)
3993 {
3994   if(_field_per_mesh.empty())
3995     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
3996   if(mName==0)
3997     return 0;
3998   std::string mName2(mName);
3999   int ret=0;
4000   std::vector<std::string> msg;
4001   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
4002     if(mName2==(*it)->getMeshName())
4003       return ret;
4004     else
4005       msg.push_back((*it)->getMeshName());
4006   std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
4007   oss << "Possible meshes are : ";
4008   for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
4009     oss << "\"" << (*it2) << "\" ";
4010   throw INTERP_KERNEL::Exception(oss.str().c_str());
4011 }
4012
4013 int MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
4014 {
4015   if(!mesh)
4016     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary : input mesh is NULL !");
4017   std::string tmp(mesh->getName());
4018   if(tmp.empty())
4019     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
4020   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();
4021   int i=0;
4022   for(;it!=_field_per_mesh.end();it++,i++)
4023     {
4024       if((*it)->getMeshName()==tmp)
4025         return i;
4026     }
4027   int sz=_field_per_mesh.size();
4028   _field_per_mesh.resize(sz+1);
4029   _field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
4030   return sz;
4031 }
4032
4033 bool MEDFileAnyTypeField1TSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
4034                                                             MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
4035 {
4036   bool ret=false;
4037   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4038     {
4039       MEDFileFieldPerMesh *fpm(*it);
4040       if(fpm)
4041         ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
4042     }
4043   return ret;
4044 }
4045
4046 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
4047 {
4048   std::vector<INTERP_KERNEL::NormalizedCellType> types;
4049   std::vector< std::vector<TypeOfField> > typesF;
4050   std::vector< std::vector<std::string> > pfls,locs;
4051   std::vector< std::vector<std::pair<int,int> > > bgEnd=getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs);
4052   std::set<TypeOfField> allEnt;
4053   for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++)
4054     for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4055       allEnt.insert(*it2);
4056   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(allEnt.size());
4057   std::set<TypeOfField>::const_iterator it3(allEnt.begin());
4058   for(std::size_t i=0;i<allEnt.size();i++,it3++)
4059     {
4060       std::vector< std::pair<int,int> > its;
4061       ret[i]=shallowCpy();
4062       int newLgth=ret[i]->keepOnlySpatialDiscretization(*it3,its);
4063       ret[i]->updateData(newLgth,its);
4064     }
4065   return ret;
4066 }
4067
4068 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlySpatialDiscretization(TypeOfField tof, std::vector< std::pair<int,int> >& its) throw(INTERP_KERNEL::Exception)
4069 {
4070   int globalCounter=0;
4071   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4072     (*it)->keepOnlySpatialDiscretization(tof,globalCounter,its);
4073   return globalCounter;
4074 }
4075
4076 void MEDFileAnyTypeField1TSWithoutSDA::updateData(int newLgth, const std::vector< std::pair<int,int> >& oldStartStops) throw(INTERP_KERNEL::Exception)
4077 {
4078   if(_nb_of_tuples_to_be_allocated>=0)
4079     {
4080       _nb_of_tuples_to_be_allocated=newLgth;
4081       return ;
4082     }
4083   if(_nb_of_tuples_to_be_allocated==-1)
4084     return ;
4085   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4086     {
4087       const DataArray *oldArr=getUndergroundDataArray();
4088       if(!oldArr || !oldArr->isAllocated())
4089         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 1 !");
4090       MEDCouplingAutoRefCountObjectPtr<DataArray> newArr=createNewEmptyDataArrayInstance();
4091       newArr->alloc(newLgth,getNumberOfComponents());
4092       int pos=0;
4093       for(std::vector< std::pair<int,int> >::const_iterator it=oldStartStops.begin();it!=oldStartStops.end();it++)
4094         {
4095           if((*it).second<(*it).first)
4096             throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : the range in the leaves was invalid !");
4097           newArr->setContigPartOfSelectedValues2(pos,oldArr,(*it).first,(*it).second,1);
4098           pos+=(*it).second-(*it).first;
4099         }
4100       setArray(newArr);
4101       return ;
4102     }
4103   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 2 !");
4104 }
4105
4106 void MEDFileAnyTypeField1TSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4107 {
4108   if(_field_per_mesh.empty())
4109     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : empty field !");
4110   if(_field_per_mesh.size()>1)
4111     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : In MED3.0 mode in writting mode only ONE underlying mesh supported !");
4112   _field_per_mesh[0]->copyOptionsFrom(opts);
4113   _field_per_mesh[0]->writeLL(fid,nasc);
4114 }
4115
4116 /*!
4117  * This methods returns true is the allocation has been needed leading to a modification of state in \a this->_nb_of_tuples_to_be_allocated.
4118  * If false is returned the memory allocation is not required.
4119  */
4120 bool MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile() throw(INTERP_KERNEL::Exception)
4121 {
4122   if(_nb_of_tuples_to_be_allocated>=0)
4123     {
4124       getOrCreateAndGetArray()->alloc(_nb_of_tuples_to_be_allocated,getNumberOfComponents());
4125       _nb_of_tuples_to_be_allocated=-2;
4126       return true;
4127     }
4128   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4129     return false;
4130   if(_nb_of_tuples_to_be_allocated==-1)
4131     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : trying to read from a file an empty instance ! Need to prepare the structure before !");
4132   if(_nb_of_tuples_to_be_allocated<-3)
4133     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4134
4135 }
4136
4137 void MEDFileAnyTypeField1TSWithoutSDA::loadOnlyStructureOfDataRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4138 {
4139   med_int numdt,numit;
4140   med_float dt;
4141   med_int nmesh;
4142   med_bool localMesh;
4143   med_int meshnumdt,meshnumit;
4144   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
4145   MEDfieldComputingStepInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&_dt);
4146   MEDfield23ComputingStepMeshInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&dt,&nmesh,meshName,&localMesh,&meshnumdt,&meshnumit);
4147   if(_iteration!=numdt || _order!=numit)
4148     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively : unexpected exception internal error !");
4149   _field_per_mesh.resize(nmesh);
4150   for(int i=0;i<nmesh;i++)
4151     _field_per_mesh[i]=MEDFileFieldPerMesh::NewOnRead(fid,this,i+1,meshnumdt,meshnumit,nasc);//tony
4152   _nb_of_tuples_to_be_allocated=0;
4153   for(int i=0;i<nmesh;i++)
4154     _field_per_mesh[i]->loadOnlyStructureOfDataRecursively(fid,_nb_of_tuples_to_be_allocated,nasc);
4155 }
4156
4157 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4158 {
4159   allocIfNecessaryTheArrayToReceiveDataFromFile();
4160   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4161     (*it)->loadBigArraysRecursively(fid,nasc);
4162 }
4163
4164 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4165 {
4166   if(allocIfNecessaryTheArrayToReceiveDataFromFile())
4167     for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4168       (*it)->loadBigArraysRecursively(fid,nasc);
4169 }
4170
4171 void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4172 {
4173   loadOnlyStructureOfDataRecursively(fid,nasc);
4174   loadBigArraysRecursively(fid,nasc);
4175 }
4176
4177 void MEDFileAnyTypeField1TSWithoutSDA::releaseArrays() throw(INTERP_KERNEL::Exception)
4178 {
4179   DataArray *thisArr(getUndergroundDataArray());
4180   if(thisArr && thisArr->isAllocated())
4181     {
4182       _nb_of_tuples_to_be_allocated=thisArr->getNumberOfTuples();
4183       thisArr->desallocate();
4184     }
4185 }
4186
4187 std::size_t MEDFileAnyTypeField1TSWithoutSDA::getHeapMemorySize() const
4188 {
4189   std::size_t ret=_dt_unit.capacity()+_field_per_mesh.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh >);
4190   if(getUndergroundDataArray())
4191     ret+=getUndergroundDataArray()->getHeapMemorySize();
4192   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4193     ret+=(*it)->getHeapMemorySize();
4194   return ret;
4195 }
4196
4197 /*!
4198  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
4199  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
4200  * "Sort By Type"), if not, an exception is thrown.
4201  *  \param [in] field - the field to add to \a this. The array of field \a field is ignored
4202  *  \param [in] arr - the array of values.
4203  *  \param [in,out] glob - the global data where profiles and localization present in
4204  *          \a field, if any, are added.
4205  *  \throw If the name of \a field is empty.
4206  *  \throw If the data array of \a field is not set.
4207  *  \throw If \a this->_arr is already allocated but has different number of components
4208  *         than \a field.
4209  *  \throw If the underlying mesh of \a field has no name.
4210  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
4211  */
4212 void MEDFileAnyTypeField1TSWithoutSDA::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4213 {
4214   const MEDCouplingMesh *mesh=field->getMesh();
4215   //
4216   TypeOfField type=field->getTypeOfField();
4217   std::vector<DataArrayInt *> dummy;
4218   int start=copyTinyInfoFrom(field,arr);
4219   int pos=addNewEntryIfNecessary(mesh);
4220   if(type!=ON_NODES)
4221     {
4222       std::vector<int> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
4223       _field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,arr,glob,nasc);
4224     }
4225   else
4226     _field_per_mesh[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
4227 }
4228
4229 /*!
4230  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
4231  * of a given mesh are used as the support of the given field (a real support is not used).
4232  * Elements of the given mesh must be sorted suitable for writing to MED file.
4233  * Order of underlying mesh entities of the given field specified by \a profile parameter
4234  * is not prescribed; this method permutes field values to have them sorted by element
4235  * type as required for writing to MED file. A new profile is added only if no equal
4236  * profile is missing.
4237  *  \param [in] field - the field to add to \a this. The field double values are ignored.
4238  *  \param [in] arrOfVals - the values of the field \a field used.
4239  *  \param [in] mesh - the supporting mesh of \a field.
4240  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
4241  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
4242  *  \param [in,out] glob - the global data where profiles and localization present in
4243  *          \a field, if any, are added.
4244  *  \throw If either \a field or \a mesh or \a profile has an empty name.
4245  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4246  *  \throw If the data array of \a field is not set.
4247  *  \throw If \a this->_arr is already allocated but has different number of components
4248  *         than \a field.
4249  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4250  *  \sa setFieldNoProfileSBT()
4251  */
4252 void MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4253 {
4254   TypeOfField type=field->getTypeOfField();
4255   int start=copyTinyInfoFrom(field,arrOfVals);
4256   std::vector<DataArrayInt *> idsInPflPerType;
4257   std::vector<DataArrayInt *> idsPerType;
4258   std::vector<int> code,code2;
4259   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4260   if(type!=ON_NODES)
4261     {
4262       m->splitProfilePerType(profile,code,idsInPflPerType,idsPerType);
4263       code2=m->getDistributionOfTypes();
4264       //
4265       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsInPflPerType2(idsInPflPerType.size());
4266       for(std::size_t i=0;i<idsInPflPerType.size();i++)
4267         idsInPflPerType2[i]=idsInPflPerType[i];
4268       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsPerType2(idsPerType.size());
4269       for(std::size_t i=0;i<idsPerType.size();i++)
4270         idsPerType2[i]=idsPerType[i];
4271       //
4272       int pos=addNewEntryIfNecessary(m);
4273       _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
4274     }
4275   else
4276     {
4277       int pos=addNewEntryIfNecessary(m);
4278       _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
4279     }
4280 }
4281
4282 /*!
4283  * \param [in] newNbOfTuples - The new nb of tuples to be allocated.
4284  */
4285 void MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile(int newNbOfTuples) throw(INTERP_KERNEL::Exception)
4286 {
4287   if(_nb_of_tuples_to_be_allocated>=0)
4288     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile : the object is expected to be appended to a data coming from a file but not loaded ! Load before appending data !");
4289   DataArray *arr(getOrCreateAndGetArray());
4290   arr->alloc(newNbOfTuples,arr->getNumberOfComponents());
4291   _nb_of_tuples_to_be_allocated=-3;
4292 }
4293
4294 /*!
4295  * Copies tiny info and allocates \a this->_arr instance of DataArrayDouble to
4296  * append data of a given MEDCouplingFieldDouble. So that the size of \a this->_arr becomes
4297  * larger by the size of \a field. Returns an id of the first not filled
4298  * tuple of \a this->_arr.
4299  *  \param [in] field - the field to copy the info on components and the name from.
4300  *  \return int - the id of first not initialized tuple of \a this->_arr.
4301  *  \throw If the name of \a field is empty.
4302  *  \throw If the data array of \a field is not set.
4303  *  \throw If \a this->_arr is already allocated but has different number of components
4304  *         than \a field.
4305  */
4306 int MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr) throw(INTERP_KERNEL::Exception)
4307 {
4308   if(!field)
4309     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
4310   std::string name(field->getName());
4311   setName(name.c_str());
4312   setDtUnit(field->getTimeUnit());
4313   if(name.empty())
4314     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
4315   if(!arr)
4316     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
4317   if(!arr->isAllocated())
4318     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : array is not allocated !");
4319   _dt=field->getTime(_iteration,_order);
4320   int nbOfComponents=arr->getNumberOfComponents();
4321   getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
4322   if(!getOrCreateAndGetArray()->isAllocated())
4323     {
4324       allocNotFromFile(arr->getNumberOfTuples());
4325       return 0;
4326     }
4327   else
4328     {
4329       int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
4330       int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
4331       getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
4332       _nb_of_tuples_to_be_allocated=-3;
4333       return oldNbOfTuples;
4334     }
4335 }
4336
4337 /*!
4338  * Returns number of components in \a this field
4339  *  \return int - the number of components.
4340  */
4341 int MEDFileAnyTypeField1TSWithoutSDA::getNumberOfComponents() const
4342 {
4343   return getOrCreateAndGetArray()->getNumberOfComponents();
4344 }
4345
4346 /*!
4347  * Change info on components in \a this.
4348  * \throw If size of \a infos is not equal to the number of components already in \a this.
4349  */
4350 void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos) throw(INTERP_KERNEL::Exception)
4351 {
4352   DataArray *arr=getOrCreateAndGetArray();
4353   arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
4354 }
4355
4356 /*!
4357  * Returns info on components of \a this field.
4358  *  \return const std::vector<std::string>& - a sequence of strings each being an
4359  *          information on _i_-th component.
4360  */
4361 const std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo() const
4362 {
4363   const DataArray *arr=getOrCreateAndGetArray();
4364   return arr->getInfoOnComponents();
4365 }
4366
4367 /*!
4368  * Returns a mutable info on components of \a this field.
4369  *  \return std::vector<std::string>& - a sequence of strings each being an
4370  *          information on _i_-th component.
4371  */
4372 std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo()
4373 {
4374   DataArray *arr=getOrCreateAndGetArray();
4375   return arr->getInfoOnComponents();
4376 }
4377
4378 /*!
4379  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4380  *  \param [in] type - a spatial discretization of the new field.
4381  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4382  *  \param [in] mName - a name of the supporting mesh.
4383  *  \param [in] renumPol - specifies how to permute values of the result field according to
4384  *          the optional numbers of cells and nodes, if any. The valid values are
4385  *          - 0 - do not permute.
4386  *          - 1 - permute cells.
4387  *          - 2 - permute nodes.
4388  *          - 3 - permute cells and nodes.
4389  *
4390  *  \param [in] glob - the global data storing profiles and localization.
4391  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4392  *          caller is to delete this field using decrRef() as it is no more needed.
4393  *  \throw If the MED file is not readable.
4394  *  \throw If there is no mesh named \a mName in the MED file.
4395  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4396  *  \throw If no field of \a this is lying on the mesh \a mName.
4397  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4398  */
4399 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4400 {
4401   MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4402   if(mName==0)
4403     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4404   else
4405     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4406   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4407 }
4408
4409 /*!
4410  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4411  *  \param [in] type - a spatial discretization of the new field.
4412  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4413  *  \param [in] renumPol - specifies how to permute values of the result field according to
4414  *          the optional numbers of cells and nodes, if any. The valid values are
4415  *          - 0 - do not permute.
4416  *          - 1 - permute cells.
4417  *          - 2 - permute nodes.
4418  *          - 3 - permute cells and nodes.
4419  *
4420  *  \param [in] glob - the global data storing profiles and localization.
4421  *  \param [in] mesh - the supporting mesh.
4422  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4423  *          caller is to delete this field using decrRef() as it is no more needed.
4424  *  \throw If the MED file is not readable.
4425  *  \throw If no field of \a this is lying on \a mesh.
4426  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4427  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4428  */
4429 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4430 {
4431   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax,false);
4432   const DataArrayInt *d=mesh->getNumberFieldAtLevel(meshDimRelToMax);
4433   const DataArrayInt *e=mesh->getNumberFieldAtLevel(1);
4434   if(meshDimRelToMax==1)
4435     (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
4436   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e,arrOut,nasc);
4437 }
4438
4439 /*!
4440  * Returns a new MEDCouplingFieldDouble of a given type lying on the top level cells of a
4441  * given mesh.
4442  *  \param [in] type - a spatial discretization of the new field.
4443  *  \param [in] mName - a name of the supporting mesh.
4444  *  \param [in] renumPol - specifies how to permute values of the result field according to
4445  *          the optional numbers of cells and nodes, if any. The valid values are
4446  *          - 0 - do not permute.
4447  *          - 1 - permute cells.
4448  *          - 2 - permute nodes.
4449  *          - 3 - permute cells and nodes.
4450  *
4451  *  \param [in] glob - the global data storing profiles and localization.
4452  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4453  *          caller is to delete this field using decrRef() as it is no more needed.
4454  *  \throw If the MED file is not readable.
4455  *  \throw If there is no mesh named \a mName in the MED file.
4456  *  \throw If there are no mesh entities in the mesh.
4457  *  \throw If no field values of the given \a type are available.
4458  */
4459 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4460 {
4461    MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4462   if(mName==0)
4463     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4464   else
4465     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4466   int absDim=getDimension();
4467   int meshDimRelToMax=absDim-mm->getMeshDimension();
4468   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4469 }
4470
4471 /*!
4472  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4473  *  \param [in] type - a spatial discretization of the new field.
4474  *  \param [in] renumPol - specifies how to permute values of the result field according to
4475  *          the optional numbers of cells and nodes, if any. The valid values are
4476  *          - 0 - do not permute.
4477  *          - 1 - permute cells.
4478  *          - 2 - permute nodes.
4479  *          - 3 - permute cells and nodes.
4480  *
4481  *  \param [in] glob - the global data storing profiles and localization.
4482  *  \param [in] mesh - the supporting mesh.
4483  *  \param [in] cellRenum - the cell numbers array used for permutation of the result
4484  *         field according to \a renumPol.
4485  *  \param [in] nodeRenum - the node numbers array used for permutation of the result
4486  *         field according to \a renumPol.
4487  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4488  *          caller is to delete this field using decrRef() as it is no more needed.
4489  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4490  *  \throw If no field of \a this is lying on \a mesh.
4491  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4492  */
4493 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, const DataArrayInt *cellRenum, const DataArrayInt *nodeRenum, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4494 {
4495   static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
4496   int meshId=getMeshIdFromMeshName(mesh->getName());
4497   bool isPfl=false;
4498   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl,arrOut,nasc);
4499   switch(renumPol)
4500     {
4501     case 0:
4502       {
4503         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4504         return ret.retn();
4505       }
4506     case 3:
4507     case 1:
4508       {
4509         if(isPfl)
4510           throw INTERP_KERNEL::Exception(msg1);
4511         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4512         if(cellRenum)
4513           {
4514             if((int)cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
4515               {
4516                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4517                 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
4518                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4519               }
4520             MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
4521             if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
4522             std::vector<DataArray *> arrOut2(1,arrOut);
4523             // 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
4524             disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
4525             (const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
4526           }
4527         if(renumPol==1)
4528           return ret.retn();
4529       }
4530     case 2:
4531       {
4532         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4533         if(isPfl)
4534           throw INTERP_KERNEL::Exception(msg1);
4535         if(nodeRenum)
4536           {
4537             if((int)nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
4538               {
4539                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4540                 oss << "\"" << nasc.getName() << "\" not defined on all nodes !";
4541                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4542               }
4543             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
4544             if(!dynamic_cast<DataArrayDouble *>((DataArray *)arrOut))
4545               throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : node renumbering not implemented for not double DataArrays !");
4546             ret->renumberNodes(nodeRenumSafe->getConstPointer());
4547           }
4548         return ret.retn();
4549       }
4550     default:
4551       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
4552     }
4553 }
4554
4555 /*!
4556  * Returns values and a profile of the field of a given type lying on a given support.
4557  *  \param [in] type - a spatial discretization of the field.
4558  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4559  *  \param [in] mesh - the supporting mesh.
4560  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
4561  *          field of interest lies on. If the field lies on all entities of the given
4562  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
4563  *          using decrRef() as it is no more needed.
4564  *  \param [in] glob - the global data storing profiles and localization.
4565  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
4566  *          field. The caller is to delete this array using decrRef() as it is no more needed.
4567  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4568  *  \throw If no field of \a this is lying on \a mesh.
4569  *  \throw If no field values of the given \a type are available.
4570  */
4571 DataArray *MEDFileAnyTypeField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4572 {
4573   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4574   int meshId=getMeshIdFromMeshName(mesh->getName());
4575   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob,nasc);
4576   ret->setName(nasc.getName().c_str());
4577   return ret.retn();
4578 }
4579
4580 //= MEDFileField1TSWithoutSDA
4581
4582 /*!
4583  * Throws if a given value is not a valid (non-extended) relative dimension.
4584  *  \param [in] meshDimRelToMax - the relative dimension value.
4585  *  \throw If \a meshDimRelToMax > 0.
4586  */
4587 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax) throw(INTERP_KERNEL::Exception)
4588 {
4589   if(meshDimRelToMax>0)
4590     throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
4591 }
4592
4593 /*!
4594  * Checks if elements of a given mesh are in the order suitable for writing
4595  * to the MED file. If this is not so, an exception is thrown. In a case of success, returns a
4596  * vector describing types of elements and their number.
4597  *  \param [in] mesh - the mesh to check.
4598  *  \return std::vector<int> - a vector holding for each element type (1) item of
4599  *          INTERP_KERNEL::NormalizedCellType, (2) number of elements, (3) -1.
4600  *          These values are in full-interlace mode.
4601  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4602  */
4603 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
4604 {
4605   if(!mesh)
4606     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
4607   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
4608   int nbOfTypes=geoTypes.size();
4609   std::vector<int> code(3*nbOfTypes);
4610   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr1=DataArrayInt::New();
4611   arr1->alloc(nbOfTypes,1);
4612   int *arrPtr=arr1->getPointer();
4613   std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
4614   for(int i=0;i<nbOfTypes;i++,it++)
4615     arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
4616   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
4617   const int *arrPtr2=arr2->getConstPointer();
4618   int i=0;
4619   for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
4620     {
4621       int pos=arrPtr2[i];
4622       int nbCells=mesh->getNumberOfCellsWithType(*it);
4623       code[3*pos]=(int)(*it);
4624       code[3*pos+1]=nbCells;
4625       code[3*pos+2]=-1;//no profiles
4626     }
4627   std::vector<const DataArrayInt *> idsPerType;//no profiles
4628   DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
4629   if(da)
4630     {
4631       da->decrRef();
4632       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
4633     }
4634   return code;
4635 }
4636
4637 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos)
4638 {
4639   return new MEDFileField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4640 }
4641
4642 /*!
4643  * Returns all attributes and values of parts of \a this field lying on a given mesh.
4644  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
4645  * item of every of returned sequences refers to the _i_-th part of \a this field.
4646  * Thus all sequences returned by this method are of the same length equal to number
4647  * of different types of supporting entities.<br>
4648  * A field part can include sub-parts with several different spatial discretizations,
4649  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
4650  * for example. Hence, some of the returned sequences contains nested sequences, and an item
4651  * of a nested sequence corresponds to a type of spatial discretization.<br>
4652  * This method allows for iteration over MEDFile DataStructure with a reduced overhead.
4653  * The overhead is due to selecting values into new instances of DataArrayDouble.
4654  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4655  *          for the case with only one underlying mesh. (Actually, the number of meshes is
4656  *          not checked if \a mname == \c NULL).
4657  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
4658  *          a field part is returned.
4659  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
4660  *          A field part can include sub-parts with several different spatial discretizations,
4661  *          \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and
4662  *          \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT" for example.
4663  *          This sequence is of the same length as \a types.
4664  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
4665  *          discretization. A profile name can be empty.
4666  *          Length of this and of nested sequences is the same as that of \a typesF.
4667  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
4668  *          discretization. A localization name can be empty.
4669  *          Length of this and of nested sequences is the same as that of \a typesF.
4670  *  \return std::vector< std::vector<DataArrayDouble *> > - a sequence holding arrays of values
4671  *          per each type of spatial discretization within one mesh entity type.
4672  *          The caller is to delete each DataArrayDouble using decrRef() as it is no more needed.
4673  *          Length of this and of nested sequences is the same as that of \a typesF.
4674  *  \throw If no field is lying on \a mname.
4675  */
4676 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TSWithoutSDA::getFieldSplitedByType2(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
4677 {
4678   int meshId=0;
4679   if(mname)
4680     meshId=getMeshIdFromMeshName(mname);
4681   else
4682     if(_field_per_mesh.empty())
4683       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
4684   std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
4685   int nbOfRet=ret0.size();
4686   std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
4687   for(int i=0;i<nbOfRet;i++)
4688     {
4689       const std::vector< std::pair<int,int> >& p=ret0[i];
4690       int nbOfRet1=p.size();
4691       ret[i].resize(nbOfRet1);
4692       for(int j=0;j<nbOfRet1;j++)
4693         {
4694           DataArrayDouble *tmp=_arr->selectByTupleId2(p[j].first,p[j].second,1);
4695           ret[i][j]=tmp;
4696         }
4697     }
4698   return ret;
4699 }
4700
4701 /*!
4702  * Returns a pointer to the underground DataArrayDouble instance. So the
4703  * caller should not decrRef() it. This method allows for a direct access to the field
4704  * values. This method is quite unusable if there is more than a nodal field or a cell
4705  * field on single geometric cell type.
4706  *  \return DataArrayDouble * - the pointer to the field values array.
4707  */
4708 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDouble() const throw(INTERP_KERNEL::Exception)
4709 {
4710   const DataArrayDouble *ret=_arr;
4711   if(ret)
4712     return const_cast<DataArrayDouble *>(ret);
4713   else
4714     return 0;
4715 }
4716
4717 const char *MEDFileField1TSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
4718 {
4719   return TYPE_STR;
4720 }
4721
4722 MEDFileIntField1TSWithoutSDA *MEDFileField1TSWithoutSDA::convertToInt() const throw(INTERP_KERNEL::Exception)
4723 {
4724   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA);
4725   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4726   ret->deepCpyLeavesFrom(*this);
4727   const DataArrayDouble *arr(_arr);
4728   if(arr)
4729     {
4730       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr->convertToIntArr());
4731       ret->setArray(arr2);
4732     }
4733   return ret.retn();
4734 }
4735
4736 /*!
4737  * Returns a pointer to the underground DataArrayDouble instance. So the
4738  * caller should not decrRef() it. This method allows for a direct access to the field
4739  * values. This method is quite unusable if there is more than a nodal field or a cell
4740  * field on single geometric cell type.
4741  *  \return DataArrayDouble * - the pointer to the field values array.
4742  */
4743 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
4744 {
4745   return getUndergroundDataArrayDouble();
4746 }
4747
4748 /*!
4749  * Returns a pointer to the underground DataArrayDouble instance and a
4750  * sequence describing parameters of a support of each part of \a this field. The
4751  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4752  * direct access to the field values. This method is intended for the field lying on one
4753  * mesh only.
4754  *  \param [in,out] entries - the sequence describing parameters of a support of each
4755  *         part of \a this field. Each item of this sequence consists of two parts. The
4756  *         first part describes a type of mesh entity and an id of discretization of a
4757  *         current field part. The second part describes a range of values [begin,end)
4758  *         within the returned array relating to the current field part.
4759  *  \return DataArrayDouble * - the pointer to the field values array.
4760  *  \throw If the number of underlying meshes is not equal to 1.
4761  *  \throw If no field values are available.
4762  *  \sa getUndergroundDataArray()
4763  */
4764 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDoubleExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4765 {
4766   if(_field_per_mesh.size()!=1)
4767     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
4768   if(_field_per_mesh[0]==0)
4769     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
4770   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
4771   return getUndergroundDataArrayDouble();
4772 }
4773
4774 /*!
4775  * Returns a pointer to the underground DataArrayDouble instance and a
4776  * sequence describing parameters of a support of each part of \a this field. The
4777  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4778  * direct access to the field values. This method is intended for the field lying on one
4779  * mesh only.
4780  *  \param [in,out] entries - the sequence describing parameters of a support of each
4781  *         part of \a this field. Each item of this sequence consists of two parts. The
4782  *         first part describes a type of mesh entity and an id of discretization of a
4783  *         current field part. The second part describes a range of values [begin,end)
4784  *         within the returned array relating to the current field part.
4785  *  \return DataArrayDouble * - the pointer to the field values array.
4786  *  \throw If the number of underlying meshes is not equal to 1.
4787  *  \throw If no field values are available.
4788  *  \sa getUndergroundDataArray()
4789  */
4790 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4791 {
4792   return getUndergroundDataArrayDoubleExt(entries);
4793 }
4794
4795 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4796                                                      const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4797 {
4798   DataArrayDouble *arr=getOrCreateAndGetArrayDouble();
4799   arr->setInfoAndChangeNbOfCompo(infos);
4800 }
4801
4802 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4803 {
4804 }
4805
4806 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
4807 {
4808   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA(*this));
4809   ret->deepCpyLeavesFrom(*this);
4810   return ret.retn();
4811 }
4812
4813 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
4814 {
4815   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret=static_cast<MEDFileField1TSWithoutSDA *>(shallowCpy());
4816   if((const DataArrayDouble *)_arr)
4817     ret->_arr=_arr->deepCpy();
4818   return ret.retn();
4819 }
4820
4821 void MEDFileField1TSWithoutSDA::setArray(DataArray *arr) throw(INTERP_KERNEL::Exception)
4822 {
4823   if(!arr)
4824     {
4825       _nb_of_tuples_to_be_allocated=-1;
4826       _arr=0;
4827       return ;
4828     }
4829   DataArrayDouble *arrC=dynamic_cast<DataArrayDouble *>(arr);
4830   if(!arrC)
4831     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayDouble !");
4832   else
4833     _nb_of_tuples_to_be_allocated=-3;
4834   arrC->incrRef();
4835   _arr=arrC;
4836 }
4837
4838 DataArray *MEDFileField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
4839 {
4840   return DataArrayDouble::New();
4841 }
4842
4843 DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble()
4844 {
4845   DataArrayDouble *ret=_arr;
4846   if(ret)
4847     return ret;
4848   _arr=DataArrayDouble::New();
4849   return _arr;
4850 }
4851
4852 DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray()
4853 {
4854   return getOrCreateAndGetArrayDouble();
4855 }
4856
4857 const DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble() const
4858 {
4859   const DataArrayDouble *ret=_arr;
4860   if(ret)
4861     return ret;
4862   DataArrayDouble *ret2=DataArrayDouble::New();
4863   const_cast<MEDFileField1TSWithoutSDA *>(this)->_arr=DataArrayDouble::New();
4864   return ret2;
4865 }
4866
4867 const DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray() const
4868 {
4869   return getOrCreateAndGetArrayDouble();
4870 }
4871
4872 //= MEDFileIntField1TSWithoutSDA
4873
4874 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order,
4875                                                                 const std::vector<std::string>& infos)
4876 {
4877   return new MEDFileIntField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4878 }
4879
4880 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4881 {
4882 }
4883
4884 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4885                                                            const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4886 {
4887   DataArrayInt *arr=getOrCreateAndGetArrayInt();
4888   arr->setInfoAndChangeNbOfCompo(infos);
4889 }
4890
4891 const char *MEDFileIntField1TSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
4892 {
4893   return TYPE_STR;
4894 }
4895
4896 MEDFileField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::convertToDouble() const throw(INTERP_KERNEL::Exception)
4897 {
4898   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
4899   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4900   ret->deepCpyLeavesFrom(*this);
4901   const DataArrayInt *arr(_arr);
4902   if(arr)
4903     {
4904       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2(arr->convertToDblArr());
4905       ret->setArray(arr2);
4906     }
4907   return ret.retn();
4908 }
4909
4910 /*!
4911  * Returns a pointer to the underground DataArrayInt instance. So the
4912  * caller should not decrRef() it. This method allows for a direct access to the field
4913  * values. This method is quite unusable if there is more than a nodal field or a cell
4914  * field on single geometric cell type.
4915  *  \return DataArrayInt * - the pointer to the field values array.
4916  */
4917 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
4918 {
4919   return getUndergroundDataArrayInt();
4920 }
4921
4922 /*!
4923  * Returns a pointer to the underground DataArrayInt instance. So the
4924  * caller should not decrRef() it. This method allows for a direct access to the field
4925  * values. This method is quite unusable if there is more than a nodal field or a cell
4926  * field on single geometric cell type.
4927  *  \return DataArrayInt * - the pointer to the field values array.
4928  */
4929 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayInt() const throw(INTERP_KERNEL::Exception)
4930 {
4931   const DataArrayInt *ret=_arr;
4932   if(ret)
4933     return const_cast<DataArrayInt *>(ret);
4934   else
4935     return 0;
4936 }
4937
4938 /*!
4939  * Returns a pointer to the underground DataArrayInt instance and a
4940  * sequence describing parameters of a support of each part of \a this field. The
4941  * caller should not decrRef() the returned DataArrayInt. This method allows for a
4942  * direct access to the field values. This method is intended for the field lying on one
4943  * mesh only.
4944  *  \param [in,out] entries - the sequence describing parameters of a support of each
4945  *         part of \a this field. Each item of this sequence consists of two parts. The
4946  *         first part describes a type of mesh entity and an id of discretization of a
4947  *         current field part. The second part describes a range of values [begin,end)
4948  *         within the returned array relating to the current field part.
4949  *  \return DataArrayInt * - the pointer to the field values array.
4950  *  \throw If the number of underlying meshes is not equal to 1.
4951  *  \throw If no field values are available.
4952  *  \sa getUndergroundDataArray()
4953  */
4954 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4955 {
4956   return getUndergroundDataArrayIntExt(entries);
4957 }
4958
4959 /*!
4960  * Returns a pointer to the underground DataArrayInt instance and a
4961  * sequence describing parameters of a support of each part of \a this field. The
4962  * caller should not decrRef() the returned DataArrayInt. This method allows for a
4963  * direct access to the field values. This method is intended for the field lying on one
4964  * mesh only.
4965  *  \param [in,out] entries - the sequence describing parameters of a support of each
4966  *         part of \a this field. Each item of this sequence consists of two parts. The
4967  *         first part describes a type of mesh entity and an id of discretization of a
4968  *         current field part. The second part describes a range of values [begin,end)
4969  *         within the returned array relating to the current field part.
4970  *  \return DataArrayInt * - the pointer to the field values array.
4971  *  \throw If the number of underlying meshes is not equal to 1.
4972  *  \throw If no field values are available.
4973  *  \sa getUndergroundDataArray()
4974  */
4975 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4976 {
4977   if(_field_per_mesh.size()!=1)
4978     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
4979   if(_field_per_mesh[0]==0)
4980     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
4981   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
4982   return getUndergroundDataArrayInt();
4983 }
4984
4985 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
4986 {
4987   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA(*this));
4988   ret->deepCpyLeavesFrom(*this);
4989   return ret.retn();
4990 }
4991
4992 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
4993 {
4994   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret=static_cast<MEDFileIntField1TSWithoutSDA *>(shallowCpy());
4995   if((const DataArrayInt *)_arr)
4996     ret->_arr=_arr->deepCpy();
4997   return ret.retn();
4998 }
4999
5000 void MEDFileIntField1TSWithoutSDA::setArray(DataArray *arr) throw(INTERP_KERNEL::Exception)
5001 {
5002   if(!arr)
5003     {
5004       _nb_of_tuples_to_be_allocated=-1;
5005       _arr=0;
5006       return ;
5007     }
5008   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>(arr);
5009   if(!arrC)
5010     throw INTERP_KERNEL::Exception("MEDFileIntField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayInt !");
5011   else
5012     _nb_of_tuples_to_be_allocated=-3;
5013   arrC->incrRef();
5014   _arr=arrC;
5015 }
5016
5017 DataArray *MEDFileIntField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
5018 {
5019   return DataArrayInt::New();
5020 }
5021
5022 DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt()
5023 {
5024   DataArrayInt *ret=_arr;
5025   if(ret)
5026     return ret;
5027   _arr=DataArrayInt::New();
5028   return _arr;
5029 }
5030
5031 DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray()
5032 {
5033   return getOrCreateAndGetArrayInt();
5034 }
5035
5036 const DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt() const
5037 {
5038   const DataArrayInt *ret=_arr;
5039   if(ret)
5040     return ret;
5041   DataArrayInt *ret2=DataArrayInt::New();
5042   const_cast<MEDFileIntField1TSWithoutSDA *>(this)->_arr=DataArrayInt::New();
5043   return ret2;
5044 }
5045
5046 const DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray() const
5047 {
5048   return getOrCreateAndGetArrayInt();
5049 }
5050
5051 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
5052 {
5053 }
5054
5055 //= MEDFileAnyTypeField1TS
5056
5057 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5058 {
5059   med_field_type typcha;
5060   //
5061   std::vector<std::string> infos;
5062   std::string dtunit,fieldName;
5063   LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
5064   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5065   switch(typcha)
5066     {
5067     case MED_FLOAT64:
5068       {
5069         ret=MEDFileField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5070         break;
5071       }
5072     case MED_INT32:
5073       {
5074         ret=MEDFileIntField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5075         break;
5076       }
5077     default:
5078       {
5079         std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fileName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
5080         throw INTERP_KERNEL::Exception(oss.str().c_str());
5081       }
5082     }
5083   ret->setDtUnit(dtunit.c_str());
5084   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5085   //
5086   med_int numdt,numit;
5087   med_float dt;
5088   MEDfieldComputingStepInfo(fid,fieldName.c_str(),1,&numdt,&numit,&dt);
5089   ret->setTime(numdt,numit,dt);
5090   ret->_csit=1;
5091   if(loadAll)
5092     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5093   else
5094     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5095   return ret.retn();
5096 }
5097
5098 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5099 try:MEDFileFieldGlobsReal(fileName)
5100 {
5101   MEDFileUtilities::CheckFileForRead(fileName);
5102   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5103   _content=BuildContentFrom(fid,fileName,loadAll);
5104   loadGlobals(fid);
5105 }
5106 catch(INTERP_KERNEL::Exception& e)
5107   {
5108     throw e;
5109   }
5110
5111 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5112 {
5113   med_field_type typcha;
5114   std::vector<std::string> infos;
5115   std::string dtunit;
5116   int iii=-1;
5117   int nbSteps=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5118   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5119   switch(typcha)
5120     {
5121     case MED_FLOAT64:
5122       {
5123         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5124         break;
5125       }
5126     case MED_INT32:
5127       {
5128         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5129         break;
5130       }
5131     default:
5132       {
5133         std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
5134         throw INTERP_KERNEL::Exception(oss.str().c_str());
5135       }
5136     }
5137   ret->setDtUnit(dtunit.c_str());
5138   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5139   //
5140   if(nbSteps<1)
5141     {
5142       std::ostringstream oss; oss << "MEDFileField1TS(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but there is no time steps on it !";
5143       throw INTERP_KERNEL::Exception(oss.str().c_str());
5144     }
5145   //
5146   med_int numdt,numit;
5147   med_float dt;
5148   MEDfieldComputingStepInfo(fid,fieldName,1,&numdt,&numit,&dt);
5149   ret->setTime(numdt,numit,dt);
5150   ret->_csit=1;
5151   if(loadAll)
5152     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5153   else
5154     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5155   return ret.retn();
5156 }
5157
5158 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5159 try:MEDFileFieldGlobsReal(fileName)
5160 {
5161   MEDFileUtilities::CheckFileForRead(fileName);
5162   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5163   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
5164   loadGlobals(fid);
5165 }
5166 catch(INTERP_KERNEL::Exception& e)
5167   {
5168     throw e;
5169   }
5170
5171 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c, const char *fileName) throw(INTERP_KERNEL::Exception)
5172 {
5173   if(!c)
5174     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
5175   if(dynamic_cast<const MEDFileField1TSWithoutSDA *>(c))
5176     {
5177       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New();
5178       ret->setFileName(fileName);
5179       ret->_content=c; c->incrRef();
5180       return ret.retn();
5181     }
5182   if(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(c))
5183     {
5184       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New();
5185       ret->setFileName(fileName);
5186       ret->_content=c; c->incrRef();
5187       return ret.retn();
5188     }
5189   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
5190 }
5191
5192 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5193 {
5194   MEDFileUtilities::CheckFileForRead(fileName);
5195   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5196   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
5197   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5198   ret->loadGlobals(fid);
5199   return ret.retn();
5200 }
5201
5202 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5203 {
5204   MEDFileUtilities::CheckFileForRead(fileName);
5205   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5206   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
5207   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5208   ret->loadGlobals(fid);
5209   return ret.retn();
5210 }
5211
5212 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5213 {
5214   MEDFileUtilities::CheckFileForRead(fileName);
5215   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5216   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5217   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5218   ret->loadGlobals(fid);
5219   return ret.retn();
5220 }
5221
5222 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5223 {
5224   med_field_type typcha;
5225   std::vector<std::string> infos;
5226   std::string dtunit;
5227   int iii=-1;
5228   int nbOfStep2=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5229   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5230   switch(typcha)
5231     {
5232     case MED_FLOAT64:
5233       {
5234         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5235         break;
5236       }
5237     case MED_INT32:
5238       {
5239         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5240         break;
5241       }
5242     default:
5243       {
5244         std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fileName,fieldName,iteration,order) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
5245         throw INTERP_KERNEL::Exception(oss.str().c_str());
5246       }
5247     }
5248   ret->setDtUnit(dtunit.c_str());
5249   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5250   //
5251   bool found=false;
5252   std::vector< std::pair<int,int> > dtits(nbOfStep2);
5253   for(int i=0;i<nbOfStep2 && !found;i++)
5254     {
5255       med_int numdt,numit;
5256       med_float dt;
5257       MEDfieldComputingStepInfo(fid,fieldName,i+1,&numdt,&numit,&dt);
5258       if(numdt==iteration && numit==order)
5259         {
5260           found=true;
5261           ret->_csit=i+1;
5262         }
5263       else
5264         dtits[i]=std::pair<int,int>(numdt,numit);
5265     }
5266   if(!found)
5267     {
5268       std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << fileName << "' ! Available iterations are : ";
5269       for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
5270         oss << "(" << (*iter).first << "," << (*iter).second << "), ";
5271       throw INTERP_KERNEL::Exception(oss.str().c_str());
5272     }
5273   if(loadAll)
5274     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5275   else
5276     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5277   return ret.retn();
5278 }
5279
5280 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5281 try:MEDFileFieldGlobsReal(fileName)
5282 {
5283   MEDFileUtilities::CheckFileForRead(fileName);
5284   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5285   _content=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5286   loadGlobals(fid);
5287 }
5288 catch(INTERP_KERNEL::Exception& e)
5289   {
5290     throw e;
5291   }
5292
5293 /*!
5294  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5295  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5296  *
5297  * \warning this is a shallow copy constructor
5298  */
5299 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent)
5300 {
5301   if(!shallowCopyOfContent)
5302     {
5303       const MEDFileAnyTypeField1TSWithoutSDA *otherPtr(&other);
5304       otherPtr->incrRef();
5305       _content=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(otherPtr);
5306     }
5307   else
5308     {
5309       _content=other.shallowCpy();
5310     }
5311 }
5312
5313 int MEDFileAnyTypeField1TS::LocateField2(med_idt fid, const char *fileName, int fieldIdCFormat, bool checkFieldId, std::string& fieldName, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut) throw(INTERP_KERNEL::Exception)
5314 {
5315   if(checkFieldId)
5316     {
5317       int nbFields=MEDnField(fid);
5318       if(fieldIdCFormat>=nbFields)
5319         {
5320           std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << fileName << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
5321           throw INTERP_KERNEL::Exception(oss.str().c_str());
5322         }
5323     }
5324   int ncomp=MEDfieldnComponent(fid,fieldIdCFormat+1);
5325   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5326   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5327   INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5328   INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5329   INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5330   med_bool localMesh;
5331   int nbOfStep;
5332   MEDfieldInfo(fid,fieldIdCFormat+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
5333   fieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
5334   dtunitOut=MEDLoaderBase::buildStringFromFortran(dtunit,MED_LNAME_SIZE);
5335   infos.clear(); infos.resize(ncomp);
5336   for(int j=0;j<ncomp;j++)
5337     infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
5338   return nbOfStep;
5339 }
5340
5341 /*!
5342  * This method throws an INTERP_KERNEL::Exception if \a fieldName field is not in file pointed by \a fid and with name \a fileName.
5343  *
5344  * \param [out]
5345  * \return in case of success the number of time steps available for the field with name \a fieldName.
5346  */
5347 int MEDFileAnyTypeField1TS::LocateField(med_idt fid, const char *fileName, const char *fieldName, int& posCFormat, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut) throw(INTERP_KERNEL::Exception)
5348 {
5349   int nbFields=MEDnField(fid);
5350   bool found=false;
5351   std::vector<std::string> fns(nbFields);
5352   int nbOfStep2=-1;
5353   for(int i=0;i<nbFields && !found;i++)
5354     {
5355       std::string tmp;
5356       nbOfStep2=LocateField2(fid,fileName,i,false,tmp,typcha,infos,dtunitOut);
5357       fns[i]=tmp;
5358       found=(tmp==fieldName);
5359       if(found)
5360         posCFormat=i;
5361     }
5362   if(!found)
5363     {
5364       std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << fileName << "' ! Available fields are : ";
5365       for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
5366         oss << "\"" << *it << "\" ";
5367       throw INTERP_KERNEL::Exception(oss.str().c_str());
5368     }
5369   return nbOfStep2;
5370 }
5371
5372 /*!
5373  * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5374  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5375  * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5376  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5377  * to keep a valid instance.
5378  * If \b this do not have any leaf that correspond to the request of the input parameter (\b mName, \b typ, \b locId) an INTERP_KERNEL::Exception will be thrown.
5379  * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
5380  * If \b newPflName already exists and that \b forceRenameOnGlob is false (the default) an INTERP_KERNEL::Exception will be thrown to avoid big confusion. In this case the called should rename before the profile name with name \b newPflName.
5381  *
5382  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
5383  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
5384  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5385  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5386  * \param [in] newLocName is the new localization name.
5387  * \param [in] forceRenameOnGlob specifies the behaviour in case of profile \b newPflName already exists. If true, the renaming is done without check. It can lead to major bug.
5388  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
5389  */
5390 void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newPflName, bool forceRenameOnGlob) throw(INTERP_KERNEL::Exception)
5391 {
5392   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5393   std::string oldPflName=disc->getProfile();
5394   std::vector<std::string> vv=getPflsReallyUsedMulti();
5395   int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
5396   if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
5397     {
5398       disc->setProfile(newPflName);
5399       DataArrayInt *pfl=getProfile(oldPflName.c_str());
5400       pfl->setName(newPflName);
5401     }
5402   else
5403     {
5404       std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
5405       throw INTERP_KERNEL::Exception(oss.str().c_str());
5406     }
5407 }
5408
5409 /*!
5410  * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5411  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5412  * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5413  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5414  * to keep a valid instance.
5415  * If \b this do not have any leaf that correspond to the request of the input parameter (\b mName, \b typ, \b locId) an INTERP_KERNEL::Exception will be thrown.
5416  * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
5417  * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
5418  * If \b newLocName already exists an INTERP_KERNEL::Exception will be thrown to avoid big confusion. In this case the called should rename before the profile name with name \b newLocName.
5419  *
5420  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
5421  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
5422  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5423  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5424  * \param [in] newLocName is the new localization name.
5425  * \param [in] forceRenameOnGlob specifies the behaviour in case of profile \b newLocName already exists. If true, the renaming is done without check. It can lead to major bug.
5426  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
5427  */
5428 void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newLocName, bool forceRenameOnGlob) throw(INTERP_KERNEL::Exception)
5429 {
5430   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5431   std::string oldLocName=disc->getLocalization();
5432   std::vector<std::string> vv=getLocsReallyUsedMulti();
5433   int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
5434   if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
5435     {
5436       disc->setLocalization(newLocName);
5437       MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
5438       loc.setName(newLocName);
5439     }
5440   else
5441     {
5442       std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
5443       throw INTERP_KERNEL::Exception(oss.str().c_str());
5444     }
5445 }
5446
5447 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() throw(INTERP_KERNEL::Exception)
5448 {
5449   MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5450   if(!ret)
5451     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : content is expected to be not null !");
5452   return ret;
5453 }
5454
5455 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() const throw(INTERP_KERNEL::Exception)
5456 {
5457   const MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5458   if(!ret)
5459     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : const content is expected to be not null !");
5460   return ret;
5461 }
5462
5463 /*!
5464  * Writes \a this field into a MED file specified by its name.
5465  *  \param [in] fileName - the MED file name.
5466  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
5467  * - 2 - erase; an existing file is removed.
5468  * - 1 - append; same data should not be present in an existing file.
5469  * - 0 - overwrite; same data present in an existing file is overwritten.
5470  *  \throw If the field name is not set.
5471  *  \throw If no field data is set.
5472  *  \throw If \a mode == 1 and the same data is present in an existing file.
5473  */
5474 void MEDFileAnyTypeField1TS::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
5475 {
5476   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
5477   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
5478   writeLL(fid);
5479 }
5480
5481 /*!
5482  * This method alloc the arrays and load potentially huge arrays contained in this field.
5483  * This method should be called when a MEDFileAnyTypeField1TS::New constructor has been with false as the last parameter.
5484  * This method can be also called to refresh or reinit values from a file.
5485  *
5486  * \throw If the fileName is not set or points to a non readable MED file.
5487  * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5488  */
5489 void MEDFileAnyTypeField1TS::loadArrays() throw(INTERP_KERNEL::Exception)
5490 {
5491   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5492   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
5493 }
5494
5495 /*!
5496  * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
5497  * But once data loaded once, this method does nothing.
5498  *
5499  * \throw If the fileName is not set or points to a non readable MED file.
5500  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::releaseArrays
5501  */
5502 void MEDFileAnyTypeField1TS::loadArraysIfNecessary() throw(INTERP_KERNEL::Exception)
5503 {
5504   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5505   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
5506 }
5507
5508 /*!
5509  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
5510  * This method does not release arrays set outside the context of a MED file.
5511  *
5512  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary
5513  */
5514 void MEDFileAnyTypeField1TS::releaseArrays() throw(INTERP_KERNEL::Exception)
5515 {
5516   contentNotNullBase()->releaseArrays();
5517 }
5518
5519 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
5520 {
5521   int nbComp=getNumberOfComponents();
5522   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5523   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5524   for(int i=0;i<nbComp;i++)
5525     {
5526       std::string info=getInfo()[i];
5527       std::string c,u;
5528       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
5529       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
5530       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
5531     }
5532   if(getName().empty())
5533     throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
5534   MEDfieldCr(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
5535   writeGlobals(fid,*this);
5536   contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
5537 }
5538
5539 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySize() const
5540 {
5541   std::size_t ret=0;
5542   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5543     ret+=_content->getHeapMemorySize();
5544   return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
5545 }
5546
5547 /*!
5548  * Returns a string describing \a this field. This string is outputted
5549  * by \c print Python command.
5550  */
5551 std::string MEDFileAnyTypeField1TS::simpleRepr() const
5552 {
5553   std::ostringstream oss;
5554   contentNotNullBase()->simpleRepr(0,oss,-1);
5555   simpleReprGlobs(oss);
5556   return oss.str();
5557 }
5558
5559 /*!
5560  * This method returns all profiles whose name is non empty used.
5561  * \b WARNING If profile is used several times it will be reported \b only \b once.
5562  * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
5563  */
5564 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
5565 {
5566   return contentNotNullBase()->getPflsReallyUsed2();
5567 }
5568
5569 /*!
5570  * This method returns all localizations whose name is non empty used.
5571  * \b WARNING If localization is used several times it will be reported \b only \b once.
5572  */
5573 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
5574 {
5575   return contentNotNullBase()->getLocsReallyUsed2();
5576 }
5577
5578 /*!
5579  * This method returns all profiles whose name is non empty used.
5580  * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
5581  */
5582 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
5583 {
5584   return contentNotNullBase()->getPflsReallyUsedMulti2();
5585 }
5586
5587 /*!
5588  * This method returns all localizations whose name is non empty used.
5589  * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
5590  */
5591 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
5592 {
5593   return contentNotNullBase()->getLocsReallyUsedMulti2();
5594 }
5595
5596 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5597 {
5598   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
5599 }
5600
5601 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5602 {
5603   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
5604 }
5605
5606 int MEDFileAnyTypeField1TS::getDimension() const
5607 {
5608   return contentNotNullBase()->getDimension();
5609 }
5610
5611 int MEDFileAnyTypeField1TS::getIteration() const
5612 {
5613   return contentNotNullBase()->getIteration();
5614 }
5615
5616 int MEDFileAnyTypeField1TS::getOrder() const
5617 {
5618   return contentNotNullBase()->getOrder();
5619 }
5620
5621 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
5622 {
5623   return contentNotNullBase()->getTime(iteration,order);
5624 }
5625
5626 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
5627 {
5628   contentNotNullBase()->setTime(iteration,order,val);
5629 }
5630
5631 std::string MEDFileAnyTypeField1TS::getName() const
5632 {
5633   return contentNotNullBase()->getName();
5634 }
5635
5636 void MEDFileAnyTypeField1TS::setName(const char *name)
5637 {
5638   contentNotNullBase()->setName(name);
5639 }
5640
5641 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
5642 {
5643   contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
5644 }
5645
5646 std::string MEDFileAnyTypeField1TS::getDtUnit() const throw(INTERP_KERNEL::Exception)
5647 {
5648   return contentNotNullBase()->getDtUnit();
5649 }
5650
5651 void MEDFileAnyTypeField1TS::setDtUnit(const char *dtUnit) throw(INTERP_KERNEL::Exception)
5652 {
5653   contentNotNullBase()->setDtUnit(dtUnit);
5654 }
5655
5656 std::string MEDFileAnyTypeField1TS::getMeshName() const throw(INTERP_KERNEL::Exception)
5657 {
5658   return contentNotNullBase()->getMeshName();
5659 }
5660
5661 void MEDFileAnyTypeField1TS::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
5662 {
5663   contentNotNullBase()->setMeshName(newMeshName);
5664 }
5665
5666 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
5667 {
5668   return contentNotNullBase()->changeMeshNames(modifTab);
5669 }
5670
5671 int MEDFileAnyTypeField1TS::getMeshIteration() const throw(INTERP_KERNEL::Exception)
5672 {
5673   return contentNotNullBase()->getMeshIteration();
5674 }
5675
5676 int MEDFileAnyTypeField1TS::getMeshOrder() const throw(INTERP_KERNEL::Exception)
5677 {
5678   return contentNotNullBase()->getMeshOrder();
5679 }
5680
5681 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
5682 {
5683   return contentNotNullBase()->getNumberOfComponents();
5684 }
5685
5686 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
5687 {
5688   return contentNotNullBase()->isDealingTS(iteration,order);
5689 }
5690
5691 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
5692 {
5693   return contentNotNullBase()->getDtIt();
5694 }
5695
5696 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
5697 {
5698   contentNotNullBase()->fillIteration(p);
5699 }
5700
5701 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
5702 {
5703   contentNotNullBase()->fillTypesOfFieldAvailable(types);
5704 }
5705
5706 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos) throw(INTERP_KERNEL::Exception)
5707 {
5708   contentNotNullBase()->setInfo(infos);
5709 }
5710
5711 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
5712 {
5713   return contentNotNullBase()->getInfo();
5714 }
5715 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
5716 {
5717   return contentNotNullBase()->getInfo();
5718 }
5719
5720 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
5721 {
5722   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5723 }
5724
5725 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
5726 {
5727   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5728 }
5729
5730 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
5731 {
5732   return contentNotNullBase()->getNonEmptyLevels(mname,levs);
5733 }
5734
5735 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
5736 {
5737   return contentNotNullBase()->getTypesOfFieldAvailable();
5738 }
5739
5740 std::vector< std::vector<std::pair<int,int> > > MEDFileAnyTypeField1TS::getFieldSplitedByType(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
5741                                                                                        std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5742 {
5743   return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
5744 }
5745
5746 /*!
5747  * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
5748  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5749  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
5750  */
5751 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const throw(INTERP_KERNEL::Exception)
5752 {
5753   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5754   if(!content)
5755     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
5756   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
5757   std::size_t sz(contentsSplit.size());
5758   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5759   for(std::size_t i=0;i<sz;i++)
5760     {
5761       ret[i]=shallowCpy();
5762       ret[i]->_content=contentsSplit[i];
5763     }
5764   return ret;
5765 }
5766
5767 /*!
5768  * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
5769  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5770  */
5771 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
5772 {
5773   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5774   if(!content)
5775     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
5776   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitDiscretizations();
5777   std::size_t sz(contentsSplit.size());
5778   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5779   for(std::size_t i=0;i<sz;i++)
5780     {
5781       ret[i]=shallowCpy();
5782       ret[i]->_content=contentsSplit[i];
5783     }
5784   return ret;
5785 }
5786
5787 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCpy() const throw(INTERP_KERNEL::Exception)
5788 {
5789   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=shallowCpy();
5790   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5791     ret->_content=_content->deepCpy();
5792   ret->deepCpyGlobs(*this);
5793   return ret.retn();
5794 }
5795
5796 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr) throw(INTERP_KERNEL::Exception)
5797 {
5798   return contentNotNullBase()->copyTinyInfoFrom(field,arr);
5799 }
5800
5801 //= MEDFileField1TS
5802
5803 /*!
5804  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5805  * the first field that has been read from a specified MED file.
5806  *  \param [in] fileName - the name of the MED file to read.
5807  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5808  *          is to delete this field using decrRef() as it is no more needed.
5809  *  \throw If reading the file fails.
5810  */
5811 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5812 {
5813   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,loadAll);
5814   ret->contentNotNull();
5815   return ret.retn();
5816 }
5817
5818 /*!
5819  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5820  * a given field that has been read from a specified MED file.
5821  *  \param [in] fileName - the name of the MED file to read.
5822  *  \param [in] fieldName - the name of the field to read.
5823  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5824  *          is to delete this field using decrRef() as it is no more needed.
5825  *  \throw If reading the file fails.
5826  *  \throw If there is no field named \a fieldName in the file.
5827  */
5828 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5829 {
5830   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,loadAll);
5831   ret->contentNotNull();
5832   return ret.retn();
5833 }
5834
5835 /*!
5836  * Returns a new instance of MEDFileField1TS holding data of a given time step of
5837  * a given field that has been read from a specified MED file.
5838  *  \param [in] fileName - the name of the MED file to read.
5839  *  \param [in] fieldName - the name of the field to read.
5840  *  \param [in] iteration - the iteration number of a required time step.
5841  *  \param [in] order - the iteration order number of required time step.
5842  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5843  *          is to delete this field using decrRef() as it is no more needed.
5844  *  \throw If reading the file fails.
5845  *  \throw If there is no field named \a fieldName in the file.
5846  *  \throw If the required time step is missing from the file.
5847  */
5848 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5849 {
5850   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,iteration,order,loadAll);
5851   ret->contentNotNull();
5852   return ret.retn();
5853 }
5854
5855 /*!
5856  * Returns a new instance of MEDFileField1TS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5857  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5858  *
5859  * Returns a new instance of MEDFileField1TS holding either a shallow copy
5860  * of a given MEDFileField1TSWithoutSDA ( \a other ) or \a other itself.
5861  * \warning this is a shallow copy constructor
5862  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
5863  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
5864  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5865  *          is to delete this field using decrRef() as it is no more needed.
5866  */
5867 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5868 {
5869   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(other,shallowCopyOfContent);
5870   ret->contentNotNull();
5871   return ret.retn();
5872 }
5873
5874 /*!
5875  * Returns a new empty instance of MEDFileField1TS.
5876  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5877  *          is to delete this field using decrRef() as it is no more needed.
5878  */
5879 MEDFileField1TS *MEDFileField1TS::New()
5880 {
5881   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS;
5882   ret->contentNotNull();
5883   return ret.retn();
5884 }
5885
5886 /*!
5887  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
5888  * following the given input policy.
5889  *
5890  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
5891  *                            By default (true) the globals are deeply copied.
5892  * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
5893  */
5894 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
5895 {
5896   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret;
5897   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5898   if(content)
5899     {
5900       const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
5901       if(!contc)
5902         throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
5903       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
5904       ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc,getFileName()));
5905     }
5906   else
5907     ret=MEDFileIntField1TS::New();
5908   if(deepCpyGlobs)
5909     ret->deepCpyGlobs(*this);
5910   else
5911     ret->shallowCpyGlobs(*this);
5912   return ret.retn();
5913 }
5914
5915 const MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() const throw(INTERP_KERNEL::Exception)
5916 {
5917   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
5918   if(!pt)
5919     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is null !");
5920   const MEDFileField1TSWithoutSDA *ret=dynamic_cast<const MEDFileField1TSWithoutSDA *>(pt);
5921   if(!ret)
5922     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
5923   return ret;
5924 }
5925
5926 MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() throw(INTERP_KERNEL::Exception)
5927 {
5928   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
5929   if(!pt)
5930     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is null !");
5931   MEDFileField1TSWithoutSDA *ret=dynamic_cast<MEDFileField1TSWithoutSDA *>(pt);
5932   if(!ret)
5933     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
5934   return ret;
5935 }
5936
5937 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MEDCouplingAutoRefCountObjectPtr<DataArray>& arr) throw(INTERP_KERNEL::Exception)
5938 {
5939   if(!f)
5940     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
5941   if(!((DataArray*)arr))
5942     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
5943   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
5944   if(!arrOutC)
5945     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
5946   f->setArray(arrOutC);
5947 }
5948
5949 DataArrayDouble *MEDFileField1TS::ReturnSafelyDataArrayDouble(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr) throw(INTERP_KERNEL::Exception)
5950 {
5951   if(!((DataArray*)arr))
5952     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : no array !");
5953   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
5954   if(!arrOutC)
5955     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
5956   arrOutC->incrRef();
5957   return arrOutC;
5958 }
5959
5960 MEDFileField1TS::MEDFileField1TS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5961 try:MEDFileAnyTypeField1TS(fileName,loadAll)
5962 {
5963 }
5964 catch(INTERP_KERNEL::Exception& e)
5965   { throw e; }
5966
5967 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5968 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
5969 {
5970 }
5971 catch(INTERP_KERNEL::Exception& e)
5972   { throw e; }
5973
5974 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5975 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
5976 {
5977 }
5978 catch(INTERP_KERNEL::Exception& e)
5979   { throw e; }
5980
5981 /*!
5982  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5983  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5984  *
5985  * \warning this is a shallow copy constructor
5986  */
5987 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5988 try:MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
5989 {
5990 }
5991 catch(INTERP_KERNEL::Exception& e)
5992   { throw e; }
5993
5994 MEDFileField1TS::MEDFileField1TS()
5995 {
5996   _content=new MEDFileField1TSWithoutSDA;
5997 }
5998
5999 /*!
6000  * Returns a new MEDCouplingFieldDouble of a given type lying on
6001  * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6002  * has not been constructed via file reading, an exception is thrown.
6003  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6004  *  \param [in] type - a spatial discretization of interest.
6005  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6006  *  \param [in] renumPol - specifies how to permute values of the result field according to
6007  *          the optional numbers of cells and nodes, if any. The valid values are
6008  *          - 0 - do not permute.
6009  *          - 1 - permute cells.
6010  *          - 2 - permute nodes.
6011  *          - 3 - permute cells and nodes.
6012  *
6013  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6014  *          caller is to delete this field using decrRef() as it is no more needed.
6015  *  \throw If \a this field has not been constructed via file reading.
6016  *  \throw If the MED file is not readable.
6017  *  \throw If there is no mesh in the MED file.
6018  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6019  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6020  *  \sa getFieldOnMeshAtLevel()
6021  */
6022 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
6023 {
6024   if(getFileName2().empty())
6025     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6026   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6027   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNull());
6028   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6029   return ret.retn();
6030 }
6031
6032 /*!
6033  * Returns a new MEDCouplingFieldDouble of a given type lying on
6034  * the top level cells of the first mesh in MED file. If \a this field
6035  * has not been constructed via file reading, an exception is thrown.
6036  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6037  *  \param [in] type - a spatial discretization of interest.
6038  *  \param [in] renumPol - specifies how to permute values of the result field according to
6039  *          the optional numbers of cells and nodes, if any. The valid values are
6040  *          - 0 - do not permute.
6041  *          - 1 - permute cells.
6042  *          - 2 - permute nodes.
6043  *          - 3 - permute cells and nodes.
6044  *
6045  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6046  *          caller is to delete this field using decrRef() as it is no more needed.
6047  *  \throw If \a this field has not been constructed via file reading.
6048  *  \throw If the MED file is not readable.
6049  *  \throw If there is no mesh in the MED file.
6050  *  \throw If no field values of the given \a type.
6051  *  \throw If no field values lying on the top level support.
6052  *  \sa getFieldAtLevel()
6053  */
6054 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const throw(INTERP_KERNEL::Exception)
6055 {
6056   if(getFileName2().empty())
6057     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6058   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6059   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNull());
6060   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6061   return ret.retn();
6062 }
6063
6064 /*!
6065  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6066  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6067  *  \param [in] type - a spatial discretization of the new field.
6068  *  \param [in] mesh - the supporting mesh.
6069  *  \param [in] renumPol - specifies how to permute values of the result field according to
6070  *          the optional numbers of cells and nodes, if any. The valid values are
6071  *          - 0 - do not permute.
6072  *          - 1 - permute cells.
6073  *          - 2 - permute nodes.
6074  *          - 3 - permute cells and nodes.
6075  *
6076  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6077  *          caller is to delete this field using decrRef() as it is no more needed.
6078  *  \throw If no field of \a this is lying on \a mesh.
6079  *  \throw If the mesh is empty.
6080  *  \throw If no field values of the given \a type are available.
6081  *  \sa getFieldAtLevel()
6082  *  \sa getFieldOnMeshAtLevel()
6083  */
6084 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
6085 {
6086   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6087   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull());
6088   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6089   return ret.retn();
6090 }
6091
6092 /*!
6093  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6094  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6095  *  \param [in] type - a spatial discretization of interest.
6096  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6097  *  \param [in] mesh - the supporting mesh.
6098  *  \param [in] renumPol - specifies how to permute values of the result field according to
6099  *          the optional numbers of cells and nodes, if any. The valid values are
6100  *          - 0 - do not permute.
6101  *          - 1 - permute cells.
6102  *          - 2 - permute nodes.
6103  *          - 3 - permute cells and nodes.
6104  *
6105  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6106  *          caller is to delete this field using decrRef() as it is no more needed.
6107  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6108  *  \throw If no field of \a this is lying on \a mesh.
6109  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6110  *  \sa getFieldAtLevel()
6111  *  \sa getFieldOnMeshAtLevel()
6112  */
6113 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
6114 {
6115   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6116   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull());
6117   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6118   return ret.retn();
6119 }
6120
6121 /*!
6122  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6123  * This method is called "Old" because in MED3 norm a field has only one meshName
6124  * attached, so this method is for readers of MED2 files. If \a this field
6125  * has not been constructed via file reading, an exception is thrown.
6126  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6127  *  \param [in] type - a spatial discretization of interest.
6128  *  \param [in] mName - a name of the supporting mesh.
6129  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6130  *  \param [in] renumPol - specifies how to permute values of the result field according to
6131  *          the optional numbers of cells and nodes, if any. The valid values are
6132  *          - 0 - do not permute.
6133  *          - 1 - permute cells.
6134  *          - 2 - permute nodes.
6135  *          - 3 - permute cells and nodes.
6136  *
6137  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6138  *          caller is to delete this field using decrRef() as it is no more needed.
6139  *  \throw If the MED file is not readable.
6140  *  \throw If there is no mesh named \a mName in the MED file.
6141  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6142  *  \throw If \a this field has not been constructed via file reading.
6143  *  \throw If no field of \a this is lying on the mesh named \a mName.
6144  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6145  *  \sa getFieldAtLevel()
6146  */
6147 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
6148 {
6149   if(getFileName2().empty())
6150     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6151   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6152   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
6153   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6154   return ret.retn();
6155 }
6156
6157 /*!
6158  * Returns values and a profile of the field of a given type lying on a given support.
6159  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6160  *  \param [in] type - a spatial discretization of the field.
6161  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6162  *  \param [in] mesh - the supporting mesh.
6163  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6164  *          field of interest lies on. If the field lies on all entities of the given
6165  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6166  *          using decrRef() as it is no more needed.
6167  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
6168  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6169  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6170  *  \throw If no field of \a this is lying on \a mesh.
6171  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6172  */
6173 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
6174 {
6175   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6176   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
6177 }
6178
6179 /*!
6180  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6181  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6182  * "Sort By Type"), if not, an exception is thrown.
6183  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6184  *  \param [in] field - the field to add to \a this.
6185  *  \throw If the name of \a field is empty.
6186  *  \throw If the data array of \a field is not set.
6187  *  \throw If the data array is already allocated but has different number of components
6188  *         than \a field.
6189  *  \throw If the underlying mesh of \a field has no name.
6190  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6191  */
6192 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
6193 {
6194   setFileName("");
6195   contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
6196 }
6197
6198 /*!
6199  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
6200  * of a given mesh are used as the support of the given field (a real support is not used).
6201  * Elements of the given mesh must be sorted suitable for writing to MED file.
6202  * Order of underlying mesh entities of the given field specified by \a profile parameter
6203  * is not prescribed; this method permutes field values to have them sorted by element
6204  * type as required for writing to MED file. A new profile is added only if no equal
6205  * profile is missing.
6206  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6207  *  \param [in] field - the field to add to \a this.
6208  *  \param [in] mesh - the supporting mesh of \a field.
6209  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
6210  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6211  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6212  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6213  *  \throw If the data array of \a field is not set.
6214  *  \throw If the data array of \a this is already allocated but has different number of
6215  *         components than \a field.
6216  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6217  *  \sa setFieldNoProfileSBT()
6218  */
6219 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
6220 {
6221   setFileName("");
6222   contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6223 }
6224
6225 MEDFileAnyTypeField1TS *MEDFileField1TS::shallowCpy() const throw(INTERP_KERNEL::Exception)
6226 {
6227   return new MEDFileField1TS(*this);
6228 }
6229
6230 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
6231 {
6232   return contentNotNull()->getUndergroundDataArrayDouble();
6233 }
6234
6235 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
6236 {
6237   return contentNotNull()->getUndergroundDataArrayDoubleExt(entries);
6238 }
6239
6240 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6241                                                                                       std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
6242 {
6243   return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
6244 }
6245
6246 //= MEDFileIntField1TS
6247
6248 MEDFileIntField1TS *MEDFileIntField1TS::New()
6249 {
6250   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS;
6251   ret->contentNotNull();
6252   return ret.retn();
6253 }
6254
6255 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
6256 {
6257   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,loadAll);
6258   ret->contentNotNull();
6259   return ret.retn();
6260 }
6261
6262 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
6263 {
6264   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,loadAll);
6265   ret->contentNotNull();
6266   return ret.retn();
6267 }
6268
6269 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
6270 {
6271   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,iteration,order,loadAll);
6272   ret->contentNotNull();
6273   return ret.retn();
6274 }
6275
6276 MEDFileIntField1TS *MEDFileIntField1TS::New(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent)
6277 {
6278   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(other,shallowCopyOfContent);
6279   ret->contentNotNull();
6280   return ret.retn();
6281 }
6282
6283 MEDFileIntField1TS::MEDFileIntField1TS()
6284 {
6285   _content=new MEDFileIntField1TSWithoutSDA;
6286 }
6287
6288 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
6289 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6290 {
6291 }
6292 catch(INTERP_KERNEL::Exception& e)
6293   { throw e; }
6294
6295 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
6296 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6297 {
6298 }
6299 catch(INTERP_KERNEL::Exception& e)
6300   { throw e; }
6301
6302 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
6303 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6304 {
6305 }
6306 catch(INTERP_KERNEL::Exception& e)
6307   { throw e; }
6308
6309 /*!
6310  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6311  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6312  *
6313  * \warning this is a shallow copy constructor
6314  */
6315 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6316 {
6317 }
6318
6319 MEDFileAnyTypeField1TS *MEDFileIntField1TS::shallowCpy() const throw(INTERP_KERNEL::Exception)
6320 {
6321   return new MEDFileIntField1TS(*this);
6322 }
6323
6324 /*!
6325  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
6326  * following the given input policy.
6327  *
6328  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6329  *                            By default (true) the globals are deeply copied.
6330  * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
6331  */
6332 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
6333 {
6334   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret;
6335   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6336   if(content)
6337     {
6338       const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
6339       if(!contc)
6340         throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
6341       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
6342       ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc,getFileName()));
6343     }
6344   else
6345     ret=MEDFileField1TS::New();
6346   if(deepCpyGlobs)
6347     ret->deepCpyGlobs(*this);
6348   else
6349     ret->shallowCpyGlobs(*this);
6350   return ret.retn();
6351 }
6352
6353 /*!
6354  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6355  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6356  * "Sort By Type"), if not, an exception is thrown.
6357  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6358  *  \param [in] field - the field to add to \a this. The field double values are ignored.
6359  *  \param [in] arrOfVals - the values of the field \a field used.
6360  *  \throw If the name of \a field is empty.
6361  *  \throw If the data array of \a field is not set.
6362  *  \throw If the data array is already allocated but has different number of components
6363  *         than \a field.
6364  *  \throw If the underlying mesh of \a field has no name.
6365  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6366  */
6367 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals) throw(INTERP_KERNEL::Exception)
6368 {
6369   setFileName("");
6370   contentNotNull()->setFieldNoProfileSBT(field,arrOfVals,*this,*contentNotNull());
6371 }
6372
6373 /*!
6374  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
6375  * of a given mesh are used as the support of the given field (a real support is not used).
6376  * Elements of the given mesh must be sorted suitable for writing to MED file.
6377  * Order of underlying mesh entities of the given field specified by \a profile parameter
6378  * is not prescribed; this method permutes field values to have them sorted by element
6379  * type as required for writing to MED file. A new profile is added only if no equal
6380  * profile is missing.
6381  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6382  *  \param [in] field - the field to add to \a this. The field double values are ignored.
6383  *  \param [in] arrOfVals - the values of the field \a field used.
6384  *  \param [in] mesh - the supporting mesh of \a field.
6385  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
6386  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6387  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6388  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6389  *  \throw If the data array of \a field is not set.
6390  *  \throw If the data array of \a this is already allocated but has different number of
6391  *         components than \a field.
6392  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6393  *  \sa setFieldNoProfileSBT()
6394  */
6395 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
6396 {
6397   setFileName("");
6398   contentNotNull()->setFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6399 }
6400
6401 const MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() const throw(INTERP_KERNEL::Exception)
6402 {
6403   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6404   if(!pt)
6405     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is null !");
6406   const MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(pt);
6407   if(!ret)
6408     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is not null but it is not of type int32 ! Reason is maybe that the read field has not the type INT32 !");
6409   return ret;
6410 }
6411
6412 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6413 {
6414   if(getFileName2().empty())
6415     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6416   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut2;
6417   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut2,*contentNotNull());
6418   DataArrayInt *arrOutC=dynamic_cast<DataArrayInt *>((DataArray *)arrOut2);
6419   if(!arrOutC)
6420     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : mismatch between dataArrays type and MEDFileIntField1TS ! Expected int32 !");
6421   arrOut=arrOutC;
6422   return ret.retn();
6423 }
6424
6425 DataArrayInt *MEDFileIntField1TS::ReturnSafelyDataArrayInt(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr) throw(INTERP_KERNEL::Exception)
6426 {
6427   if(!((DataArray *)arr))
6428     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is NULL !");
6429   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>((DataArray *)arr);
6430   if(!arrC)
6431     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is not of type INT32 !");
6432   arrC->incrRef();
6433   return arrC;
6434 }
6435
6436 /*!
6437  * Returns a new MEDCouplingFieldDouble of a given type lying on
6438  * the top level cells of the first mesh in MED file. If \a this field
6439  * has not been constructed via file reading, an exception is thrown.
6440  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6441  *  \param [in] type - a spatial discretization of interest.
6442  *  \param [out] arrOut - the DataArrayInt containing values of field.
6443  *  \param [in] renumPol - specifies how to permute values of the result field according to
6444  *          the optional numbers of cells and nodes, if any. The valid values are
6445  *          - 0 - do not permute.
6446  *          - 1 - permute cells.
6447  *          - 2 - permute nodes.
6448  *          - 3 - permute cells and nodes.
6449  *
6450  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6451  *          caller is to delete this field using decrRef() as it is no more needed.
6452  *  \throw If \a this field has not been constructed via file reading.
6453  *  \throw If the MED file is not readable.
6454  *  \throw If there is no mesh in the MED file.
6455  *  \throw If no field values of the given \a type.
6456  *  \throw If no field values lying on the top level support.
6457  *  \sa getFieldAtLevel()
6458  */
6459 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6460 {
6461   if(getFileName2().empty())
6462     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6463   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6464   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNull());
6465   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6466   return ret.retn();
6467 }
6468
6469 /*!
6470  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6471  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6472  *  \param [in] type - a spatial discretization of the new field.
6473  *  \param [in] mesh - the supporting mesh.
6474  *  \param [out] arrOut - the DataArrayInt containing values of field.
6475  *  \param [in] renumPol - specifies how to permute values of the result field according to
6476  *          the optional numbers of cells and nodes, if any. The valid values are
6477  *          - 0 - do not permute.
6478  *          - 1 - permute cells.
6479  *          - 2 - permute nodes.
6480  *          - 3 - permute cells and nodes.
6481  *
6482  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6483  *          caller is to delete this field using decrRef() as it is no more needed.
6484  *  \throw If no field of \a this is lying on \a mesh.
6485  *  \throw If the mesh is empty.
6486  *  \throw If no field values of the given \a type are available.
6487  *  \sa getFieldAtLevel()
6488  *  \sa getFieldOnMeshAtLevel()
6489  */
6490 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6491 {
6492   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6493   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNull());
6494   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6495   return ret.retn();
6496 }
6497
6498 /*!
6499  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6500  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6501  *  \param [in] type - a spatial discretization of interest.
6502  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6503  *  \param [out] arrOut - the DataArrayInt containing values of field.
6504  *  \param [in] mesh - the supporting mesh.
6505  *  \param [in] renumPol - specifies how to permute values of the result field according to
6506  *          the optional numbers of cells and nodes, if any. The valid values are
6507  *          - 0 - do not permute.
6508  *          - 1 - permute cells.
6509  *          - 2 - permute nodes.
6510  *          - 3 - permute cells and nodes.
6511  *
6512  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6513  *          caller is to delete this field using decrRef() as it is no more needed.
6514  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6515  *  \throw If no field of \a this is lying on \a mesh.
6516  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6517  *  \sa getFieldAtLevel()
6518  *  \sa getFieldOnMeshAtLevel()
6519  */
6520 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6521 {
6522   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6523   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNull());
6524   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6525   return ret.retn();
6526 }
6527
6528 /*!
6529  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6530  * This method is called "Old" because in MED3 norm a field has only one meshName
6531  * attached, so this method is for readers of MED2 files. If \a this field
6532  * has not been constructed via file reading, an exception is thrown.
6533  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6534  *  \param [in] type - a spatial discretization of interest.
6535  *  \param [in] mName - a name of the supporting mesh.
6536  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6537  *  \param [out] arrOut - the DataArrayInt containing values of field.
6538  *  \param [in] renumPol - specifies how to permute values of the result field according to
6539  *          the optional numbers of cells and nodes, if any. The valid values are
6540  *          - 0 - do not permute.
6541  *          - 1 - permute cells.
6542  *          - 2 - permute nodes.
6543  *          - 3 - permute cells and nodes.
6544  *
6545  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6546  *          caller is to delete this field using decrRef() as it is no more needed.
6547  *  \throw If the MED file is not readable.
6548  *  \throw If there is no mesh named \a mName in the MED file.
6549  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6550  *  \throw If \a this field has not been constructed via file reading.
6551  *  \throw If no field of \a this is lying on the mesh named \a mName.
6552  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6553  *  \sa getFieldAtLevel()
6554  */
6555 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6556 {
6557   if(getFileName2().empty())
6558     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6559   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6560   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNull());
6561   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6562   return ret.retn();
6563 }
6564
6565 /*!
6566  * Returns values and a profile of the field of a given type lying on a given support.
6567  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6568  *  \param [in] type - a spatial discretization of the field.
6569  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6570  *  \param [in] mesh - the supporting mesh.
6571  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6572  *          field of interest lies on. If the field lies on all entities of the given
6573  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6574  *          using decrRef() as it is no more needed.
6575  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
6576  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6577  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6578  *  \throw If no field of \a this is lying on \a mesh.
6579  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6580  */
6581 DataArrayInt *MEDFileIntField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
6582 {
6583   MEDCouplingAutoRefCountObjectPtr<DataArray> arr=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6584   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6585 }
6586
6587 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() throw(INTERP_KERNEL::Exception)
6588 {
6589   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6590   if(!pt)
6591     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is null !");
6592   MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<MEDFileIntField1TSWithoutSDA *>(pt);
6593   if(!ret)
6594     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is not null but it is not of type int32 ! Reason is maybe that the read field has not the type INT32 !");
6595   return ret;
6596 }
6597
6598 DataArrayInt *MEDFileIntField1TS::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
6599 {
6600   return contentNotNull()->getUndergroundDataArrayInt();
6601 }
6602
6603 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
6604
6605 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
6606 {
6607 }
6608
6609 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const char *fieldName):MEDFileFieldNameScope(fieldName)
6610 {
6611 }
6612
6613 /*!
6614  * \param [in] fieldId field id in C mode
6615  */
6616 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll) throw(INTERP_KERNEL::Exception)
6617 {
6618   med_field_type typcha;
6619   std::string dtunitOut;
6620   int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,"",fieldId,false,_name,typcha,_infos,dtunitOut);
6621   setDtUnit(dtunitOut.c_str());
6622   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll);
6623 }
6624
6625 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
6626 try:MEDFileFieldNameScope(fieldName),_infos(infos)
6627 {
6628   setDtUnit(dtunit.c_str());
6629   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll);
6630 }
6631 catch(INTERP_KERNEL::Exception& e)
6632 {
6633   throw e;
6634 }
6635
6636 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySize() const
6637 {
6638   std::size_t ret=_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA>);
6639   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6640     ret+=(*it).capacity();
6641   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6642     if((const MEDFileAnyTypeField1TSWithoutSDA *)(*it))
6643       ret+=(*it)->getHeapMemorySize();
6644   return ret;
6645 }
6646
6647 /*!
6648  * If one of the id in [ \a startIds , \a endIds ) points to a null element, there is not throw. Simply, this empty element is added as if it were not
6649  * NULL.
6650  */
6651 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const throw(INTERP_KERNEL::Exception)
6652 {
6653   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6654   ret->setInfo(_infos);
6655   int sz=(int)_time_steps.size();
6656   for(const int *id=startIds;id!=endIds;id++)
6657     {
6658       if(*id>=0 && *id<sz)
6659         {
6660           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
6661           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6662           if(tse)
6663             {
6664               tse->incrRef();
6665               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6666             }
6667           ret->pushBackTimeStep(tse2);
6668         }
6669       else
6670         {
6671           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
6672           oss << " ! Should be in [0," << sz << ") !";
6673           throw INTERP_KERNEL::Exception(oss.str().c_str());
6674         }
6675     }
6676   if(ret->getNumberOfTS()>0)
6677     ret->synchronizeNameScope();
6678   ret->copyNameScope(*this);
6679   return ret.retn();
6680 }
6681
6682 /*!
6683  * If one of the id in the input range points to a null element, there is not throw. Simply, this empty element is added as if it were not
6684  * NULL.
6685  */
6686 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
6687 {
6688   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
6689   int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
6690   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6691   ret->setInfo(_infos);
6692   int sz=(int)_time_steps.size();
6693   int j=bg;
6694   for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
6695     {
6696       if(j>=0 && j<sz)
6697         {
6698           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
6699           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6700           if(tse)
6701             {
6702               tse->incrRef();
6703               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6704             }
6705           ret->pushBackTimeStep(tse2);
6706         }
6707       else
6708         {
6709           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
6710           oss << " ! Should be in [0," << sz << ") !";
6711           throw INTERP_KERNEL::Exception(oss.str().c_str());
6712         }
6713     }
6714   if(ret->getNumberOfTS()>0)
6715     ret->synchronizeNameScope();
6716   ret->copyNameScope(*this);
6717   return ret.retn();
6718 }
6719
6720 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
6721 {
6722   int id=0;
6723   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6724   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6725     {
6726       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6727       if(!cur)
6728         continue;
6729       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6730       if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
6731         ids->pushBackSilent(id);
6732     }
6733   return buildFromTimeStepIds(ids->begin(),ids->end());
6734 }
6735
6736 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
6737 {
6738   int id=0;
6739   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6740   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6741     {
6742       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6743       if(!cur)
6744         continue;
6745       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6746       if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
6747         ids->pushBackSilent(id);
6748     }
6749   return buildFromTimeStepIds(ids->begin(),ids->end());
6750 }
6751
6752 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const throw(INTERP_KERNEL::Exception)
6753 {
6754   return _infos;
6755 }
6756
6757 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
6758 {
6759   _infos=info;
6760 }
6761
6762 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const throw(INTERP_KERNEL::Exception)
6763 {
6764   int ret=0;
6765   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
6766     {
6767       const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
6768       if(pt->isDealingTS(iteration,order))
6769         return ret;
6770     }
6771   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
6772   std::vector< std::pair<int,int> > vp=getIterations();
6773   for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
6774     oss << "(" << (*it2).first << "," << (*it2).second << ") ";
6775   throw INTERP_KERNEL::Exception(oss.str().c_str());
6776 }
6777
6778 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const throw(INTERP_KERNEL::Exception)
6779 {
6780   return *_time_steps[getTimeStepPos(iteration,order)];
6781 }
6782
6783 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) throw(INTERP_KERNEL::Exception)
6784 {
6785   return *_time_steps[getTimeStepPos(iteration,order)];
6786 }
6787
6788 std::string MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshName() const throw(INTERP_KERNEL::Exception)
6789 {
6790   if(_time_steps.empty())
6791     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
6792   return _time_steps[0]->getMeshName();
6793 }
6794
6795 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
6796 {
6797   std::string oldName(getMeshName());
6798   std::vector< std::pair<std::string,std::string> > v(1);
6799   v[0].first=oldName; v[0].second=newMeshName;
6800   changeMeshNames(v);
6801 }
6802
6803 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
6804 {
6805   bool ret=false;
6806   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6807     {
6808       MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6809       if(cur)
6810         ret=cur->changeMeshNames(modifTab) || ret;
6811     }
6812   return ret;
6813 }
6814
6815 /*!
6816  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
6817  */
6818 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
6819 {
6820   return getTimeStepEntry(iteration,order).getUndergroundDataArray();
6821 }
6822
6823 /*!
6824  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
6825  */
6826 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
6827 {
6828   return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
6829 }
6830
6831 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
6832                                                                 MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
6833 {
6834   bool ret=false;
6835   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6836     {
6837       MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
6838       if(f1ts)
6839         ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
6840     }
6841   return ret;
6842 }
6843
6844 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
6845 {
6846   std::string startLine(bkOffset,' ');
6847   oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
6848   if(fmtsId>=0)
6849     oss << " (" << fmtsId << ")";
6850   oss << " has the following name: \"" << _name << "\"." << std::endl;
6851   oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
6852   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6853     {
6854       oss << startLine << "  -  \"" << *it << "\"" << std::endl;
6855     }
6856   int i=0;
6857   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
6858     {
6859       std::string chapter(17,'0'+i);
6860       oss << startLine << chapter << std::endl;
6861       const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6862       if(cur)
6863         cur->simpleRepr(bkOffset+2,oss,i);
6864       else
6865         oss << startLine << "  Field on one time step #" << i << " is not defined !" << std::endl;
6866       oss << startLine << chapter << std::endl;
6867     }
6868 }
6869
6870 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const throw(INTERP_KERNEL::Exception)
6871 {
6872   std::size_t sz=_time_steps.size();
6873   std::vector< std::pair<int,int> > ret(sz);
6874   ret1.resize(sz);
6875   for(std::size_t i=0;i<sz;i++)
6876     {
6877       const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
6878       if(f1ts)
6879         {
6880           ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
6881         }
6882       else
6883         {
6884           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
6885           throw INTERP_KERNEL::Exception(oss.str().c_str());
6886         }
6887     }
6888   return ret;
6889 }
6890
6891 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>& tse) throw(INTERP_KERNEL::Exception)
6892 {
6893   MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
6894   if(!tse2)
6895     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
6896   checkCoherencyOfType(tse2);
6897   if(_time_steps.empty())
6898     {
6899       setName(tse2->getName().c_str());
6900       setInfo(tse2->getInfo());
6901     }
6902   checkThatComponentsMatch(tse2->getInfo());
6903   _time_steps.push_back(tse);
6904 }
6905
6906 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope() throw(INTERP_KERNEL::Exception)
6907 {
6908   std::size_t nbOfCompo=_infos.size();
6909   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6910     {
6911       MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6912       if(cur)
6913         {
6914           if((cur->getInfo()).size()!=nbOfCompo)
6915             {
6916               std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
6917               oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
6918               throw INTERP_KERNEL::Exception(oss.str().c_str());
6919             }
6920           cur->copyNameScope(*this);
6921         }
6922     }
6923 }
6924
6925 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll) throw(INTERP_KERNEL::Exception)
6926 {
6927   _time_steps.resize(nbPdt);
6928   for(int i=0;i<nbPdt;i++)
6929     {
6930       std::vector< std::pair<int,int> > ts;
6931       med_int numdt=0,numo=0;
6932       med_int meshIt=0,meshOrder=0;
6933       med_float dt=0.0;
6934       MEDfieldComputingStepMeshInfo(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder);
6935       switch(fieldTyp)
6936         {
6937         case MED_FLOAT64:
6938           {
6939             _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
6940             break;
6941           }
6942         case MED_INT32:
6943           {
6944             _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
6945             break;
6946           }
6947         default:
6948           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
6949         }
6950       if(loadAll)
6951         _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this);
6952       else
6953         _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this);
6954     }
6955 }
6956
6957 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const throw(INTERP_KERNEL::Exception)
6958 {
6959   if(_time_steps.empty())
6960     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
6961   checkThatNbOfCompoOfTSMatchThis();
6962   std::vector<std::string> infos(getInfo());
6963   int nbComp=infos.size();
6964   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
6965   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
6966   for(int i=0;i<nbComp;i++)
6967     {
6968       std::string info=infos[i];
6969       std::string c,u;
6970       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
6971       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
6972       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
6973     }
6974   if(_name.empty())
6975     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
6976   MEDfieldCr(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
6977   int nbOfTS=_time_steps.size();
6978   for(int i=0;i<nbOfTS;i++)
6979     _time_steps[i]->writeLL(fid,opts,*this);
6980 }
6981
6982 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
6983 {
6984   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6985     {
6986       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
6987       if(elt)
6988         elt->loadBigArraysRecursively(fid,nasc);
6989     }
6990 }
6991
6992 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
6993 {
6994   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6995     {
6996       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
6997       if(elt)
6998         elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
6999     }
7000 }
7001
7002 void MEDFileAnyTypeFieldMultiTSWithoutSDA::releaseArrays() throw(INTERP_KERNEL::Exception)
7003 {
7004   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7005     {
7006       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7007       if(elt)
7008         elt->releaseArrays();
7009     }
7010 }
7011
7012 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
7013 {
7014   return _time_steps.size();
7015 }
7016
7017 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS() throw(INTERP_KERNEL::Exception)
7018 {
7019   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  > newTS;
7020   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7021     {
7022       const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
7023       if(tmp)
7024         newTS.push_back(*it);
7025     }
7026   _time_steps=newTS;
7027 }
7028
7029 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
7030 {
7031   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7032   int maxId=(int)_time_steps.size();
7033   int ii=0;
7034   std::set<int> idsToDel;
7035   for(const int *id=startIds;id!=endIds;id++,ii++)
7036     {
7037       if(*id>=0 && *id<maxId)
7038         {
7039           idsToDel.insert(*id);
7040         }
7041       else
7042         {
7043           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
7044           throw INTERP_KERNEL::Exception(oss.str().c_str());
7045         }
7046     }
7047   for(int iii=0;iii<maxId;iii++)
7048     if(idsToDel.find(iii)==idsToDel.end())
7049       newTS.push_back(_time_steps[iii]);
7050   _time_steps=newTS;
7051 }
7052
7053 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step) throw(INTERP_KERNEL::Exception)
7054 {
7055   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
7056   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7057   if(nbOfEntriesToKill==0)
7058     return ;
7059   std::size_t sz=_time_steps.size();
7060   std::vector<bool> b(sz,true);
7061   int j=bg;
7062   for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
7063     b[j]=false;
7064   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7065   for(std::size_t i=0;i<sz;i++)
7066     if(b[i])
7067       newTS.push_back(_time_steps[i]);
7068   _time_steps=newTS;
7069 }
7070
7071 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
7072 {
7073   int ret=0;
7074   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
7075   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7076     {
7077       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7078       if(tmp)
7079         {
7080           int it2,ord;
7081           tmp->getTime(it2,ord);
7082           if(it2==iteration && order==ord)
7083             return ret;
7084           else
7085             oss << "(" << it2 << ","  << ord << "), ";
7086         }
7087     }
7088   throw INTERP_KERNEL::Exception(oss.str().c_str());
7089 }
7090
7091 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
7092 {
7093   int ret=0;
7094   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
7095   oss.precision(15);
7096   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7097     {
7098       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7099       if(tmp)
7100         {
7101           int it2,ord;
7102           double ti=tmp->getTime(it2,ord);
7103           if(fabs(time-ti)<eps)
7104             return ret;
7105           else
7106             oss << ti << ", ";
7107         }
7108     }
7109   throw INTERP_KERNEL::Exception(oss.str().c_str());
7110 }
7111
7112 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
7113 {
7114   int lgth=_time_steps.size();
7115   std::vector< std::pair<int,int> > ret(lgth);
7116   for(int i=0;i<lgth;i++)
7117     _time_steps[i]->fillIteration(ret[i]);
7118   return ret;
7119 }
7120
7121 /*!
7122  * This method has 3 inputs 'iteration' 'order' 'mname'. 'mname' can be null if the user is the general case where there is only one meshName lying on 'this'
7123  * This method returns two things.
7124  * - The absolute dimension of 'this' in first parameter.
7125  * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
7126  *   to the first output parameter. The values in 'levs' will be returned in decreasing order.
7127  *
7128  * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
7129  * Only these 3 discretizations will be taken into account here.
7130  *
7131  * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
7132  * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
7133  * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
7134  *
7135  * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
7136  * It is possible (even if it is not common) that the highest level in 'this' were not equal to the meshDimension of the underlying mesh in 'this'.
7137  *
7138  * Let's consider the typical following case :
7139  * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
7140  * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
7141  * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
7142  *   TETRA4 and SEG2
7143  * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
7144  *
7145  * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
7146  *
7147  * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
7148  * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
7149  * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
7150  * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
7151  */
7152 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
7153 {
7154   return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
7155 }
7156
7157 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const throw(INTERP_KERNEL::Exception)
7158 {
7159   if(pos<0 || pos>=(int)_time_steps.size())
7160     {
7161       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7162       throw INTERP_KERNEL::Exception(oss.str().c_str());
7163     }
7164   const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7165   if(item==0)
7166     {
7167       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7168       oss << "\nTry to use following method eraseEmptyTS !";
7169       throw INTERP_KERNEL::Exception(oss.str().c_str());
7170     }
7171   return item;
7172 }
7173
7174 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) throw(INTERP_KERNEL::Exception)
7175 {
7176   if(pos<0 || pos>=(int)_time_steps.size())
7177     {
7178       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7179       throw INTERP_KERNEL::Exception(oss.str().c_str());
7180     }
7181   MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7182   if(item==0)
7183     {
7184       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7185       oss << "\nTry to use following method eraseEmptyTS !";
7186       throw INTERP_KERNEL::Exception(oss.str().c_str());
7187     }
7188   return item;
7189 }
7190
7191 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
7192 {
7193   std::vector<std::string> ret;
7194   std::set<std::string> ret2;
7195   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7196     {
7197       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
7198       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7199         if(ret2.find(*it2)==ret2.end())
7200           {
7201             ret.push_back(*it2);
7202             ret2.insert(*it2);
7203           }
7204     }
7205   return ret;
7206 }
7207
7208 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
7209 {
7210   std::vector<std::string> ret;
7211   std::set<std::string> ret2;
7212   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7213     {
7214       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
7215       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7216         if(ret2.find(*it2)==ret2.end())
7217           {
7218             ret.push_back(*it2);
7219             ret2.insert(*it2);
7220           }
7221     }
7222   return ret;
7223 }
7224
7225 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
7226 {
7227   std::vector<std::string> ret;
7228   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7229     {
7230       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
7231       ret.insert(ret.end(),tmp.begin(),tmp.end());
7232     }
7233   return ret;
7234 }
7235
7236 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
7237 {
7238   std::vector<std::string> ret;
7239   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7240     {
7241       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
7242       ret.insert(ret.end(),tmp.begin(),tmp.end());
7243     }
7244   return ret;
7245 }
7246
7247 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7248 {
7249   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7250     (*it)->changePflsRefsNamesGen2(mapOfModif);
7251 }
7252
7253 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7254 {
7255   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7256     (*it)->changeLocsRefsNamesGen2(mapOfModif);
7257 }
7258
7259 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
7260 {
7261   int lgth=_time_steps.size();
7262   std::vector< std::vector<TypeOfField> > ret(lgth);
7263   for(int i=0;i<lgth;i++)
7264     _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
7265   return ret;
7266 }
7267
7268 /*!
7269  * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
7270  */
7271 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeFieldMultiTSWithoutSDA::getFieldSplitedByType(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
7272 {
7273   return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
7274 }
7275
7276 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
7277 {
7278   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
7279   std::size_t i=0;
7280   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7281     {
7282       if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
7283         ret->_time_steps[i]=(*it)->deepCpy();
7284     }
7285   return ret.retn();
7286 }
7287
7288 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const throw(INTERP_KERNEL::Exception)
7289 {
7290   std::size_t sz(_infos.size()),sz2(_time_steps.size());
7291   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
7292   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
7293   for(std::size_t i=0;i<sz;i++)
7294     {
7295       ret[i]=shallowCpy();
7296       ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
7297     }
7298   for(std::size_t i=0;i<sz2;i++)
7299     {
7300       std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
7301       if(ret1.size()!=sz)
7302         {
7303           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
7304           throw INTERP_KERNEL::Exception(oss.str().c_str());
7305         }
7306       ts[i]=ret1;
7307     }
7308   for(std::size_t i=0;i<sz;i++)
7309     for(std::size_t j=0;j<sz2;j++)
7310       ret[i]->_time_steps[j]=ts[j][i];
7311   return ret;
7312 }
7313
7314 /*!
7315  * This method splits into discretization each time steps in \a this.
7316  * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
7317  */
7318 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
7319 {
7320   std::size_t sz(_time_steps.size());
7321   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7322   for(std::size_t i=0;i<sz;i++)
7323     {
7324       const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7325       if(!timeStep)
7326         {
7327           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
7328           throw INTERP_KERNEL::Exception(oss.str().c_str());
7329         }
7330       items[i]=timeStep->splitDiscretizations();
7331     }
7332   //
7333   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
7334   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
7335   std::vector< TypeOfField > types;
7336   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7337     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7338       {
7339         std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
7340         if(ts.size()!=1)
7341           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
7342         std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
7343         if(it2==types.end())
7344           types.push_back(ts[0]);
7345       }
7346   ret.resize(types.size()); ret2.resize(types.size());
7347   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7348     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7349       {
7350         TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
7351         std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
7352         ret2[pos].push_back(*it1);
7353       }
7354   for(std::size_t i=0;i<types.size();i++)
7355     {
7356       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=createNew();
7357       for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
7358         elt->pushBackTimeStep(*it1);//also updates infos in elt
7359       ret[i]=elt;
7360       elt->MEDFileFieldNameScope::operator=(*this);
7361     }
7362   return ret;
7363 }
7364
7365 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr) throw(INTERP_KERNEL::Exception)
7366 {
7367   _name=field->getName();
7368   if(_name.empty())
7369     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
7370   if(!arr)
7371     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
7372   _infos=arr->getInfoOnComponents();
7373 }
7374
7375 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const throw(INTERP_KERNEL::Exception)
7376 {
7377   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
7378   if(_name!=field->getName())
7379     {
7380       std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
7381       oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
7382       throw INTERP_KERNEL::Exception(oss.str().c_str());
7383     }
7384   if(!arr)
7385     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
7386   checkThatComponentsMatch(arr->getInfoOnComponents());
7387 }
7388
7389 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const throw(INTERP_KERNEL::Exception)
7390 {
7391   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
7392   if(getInfo().size()!=compos.size())
7393     {
7394       std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
7395       oss << " number of components of element to append (" << compos.size() << ") !";
7396       throw INTERP_KERNEL::Exception(oss.str().c_str());
7397     }
7398   if(_infos!=compos)
7399     {
7400       std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
7401       std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
7402       oss << " But compo in input fields are : ";
7403       std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
7404       oss << " !";
7405       throw INTERP_KERNEL::Exception(oss.str().c_str());
7406     }
7407 }
7408
7409 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const throw(INTERP_KERNEL::Exception)
7410 {
7411   std::size_t sz=_infos.size();
7412   int j=0;
7413   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
7414     {
7415       const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7416       if(elt)
7417         if(elt->getInfo().size()!=sz)
7418           {
7419             std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
7420             oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
7421             throw INTERP_KERNEL::Exception(oss.str().c_str());
7422           }
7423     }
7424 }
7425
7426 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
7427 {
7428   if(!field)
7429     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7430   if(!_time_steps.empty())
7431     checkCoherencyOfTinyInfo(field,arr);
7432   MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
7433   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7434   objC->setFieldNoProfileSBT(field,arr,glob,*this);
7435   copyTinyInfoFrom(field,arr);
7436   _time_steps.push_back(obj);
7437 }
7438
7439 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
7440 {
7441   if(!field)
7442     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7443   if(!_time_steps.empty())
7444     checkCoherencyOfTinyInfo(field,arr);
7445   MEDFileField1TSWithoutSDA *objC=new MEDFileField1TSWithoutSDA;
7446   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7447   objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
7448   copyTinyInfoFrom(field,arr);
7449   _time_steps.push_back(obj);
7450 }
7451
7452 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ts) throw(INTERP_KERNEL::Exception)
7453 {
7454   int sz=(int)_time_steps.size();
7455   if(i<0 || i>=sz)
7456     {
7457       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
7458       throw INTERP_KERNEL::Exception(oss.str().c_str());
7459     }
7460   const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
7461   if(tsPtr)
7462     {
7463       if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
7464         {
7465           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() <<  " !";
7466           throw INTERP_KERNEL::Exception(oss.str().c_str());
7467         }
7468     }
7469   _time_steps[i]=ts;
7470 }
7471
7472 //= MEDFileFieldMultiTSWithoutSDA
7473
7474 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::New(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
7475 {
7476   return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7477 }
7478
7479 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
7480 {
7481 }
7482
7483 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7484 {
7485 }
7486
7487 /*!
7488  * \param [in] fieldId field id in C mode
7489  */
7490 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll) throw(INTERP_KERNEL::Exception)
7491 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7492 {
7493 }
7494 catch(INTERP_KERNEL::Exception& e)
7495   { throw e; }
7496
7497 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
7498 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7499 {
7500 }
7501 catch(INTERP_KERNEL::Exception& e)
7502 { throw e; }
7503
7504 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const throw(INTERP_KERNEL::Exception)
7505 {
7506   return new MEDFileField1TSWithoutSDA;
7507 }
7508
7509 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const throw(INTERP_KERNEL::Exception)
7510 {
7511   if(!f1ts)
7512     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7513   const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
7514   if(!f1tsC)
7515     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
7516 }
7517
7518 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
7519 {
7520   return MEDFileField1TSWithoutSDA::TYPE_STR;
7521 }
7522
7523 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
7524 {
7525   return new MEDFileFieldMultiTSWithoutSDA(*this);
7526 }
7527
7528 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const throw(INTERP_KERNEL::Exception)
7529 {
7530   return new MEDFileFieldMultiTSWithoutSDA;
7531 }
7532
7533 /*!
7534  * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
7535  * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
7536  */
7537 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
7538 {
7539   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
7540   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
7541   if(!myF1TSC)
7542     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
7543   return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
7544 }
7545
7546 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const throw(INTERP_KERNEL::Exception)
7547 {
7548   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
7549   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7550   int i=0;
7551   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7552     {
7553       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7554       if(eltToConv)
7555         {
7556           const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
7557           if(!eltToConvC)
7558             throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
7559           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
7560           ret->setIteration(i,elt);
7561         }
7562     }
7563   return ret.retn();
7564 }
7565
7566 //= MEDFileAnyTypeFieldMultiTS
7567
7568 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
7569 {
7570 }
7571
7572 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
7573 try:MEDFileFieldGlobsReal(fileName)
7574 {
7575   MEDFileUtilities::CheckFileForRead(fileName);
7576   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7577   _content=BuildContentFrom(fid,fileName,loadAll);
7578   loadGlobals(fid);
7579 }
7580 catch(INTERP_KERNEL::Exception& e)
7581   {
7582     throw e;
7583   }
7584
7585 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
7586 {
7587   med_field_type typcha;
7588   std::vector<std::string> infos;
7589   std::string dtunit;
7590   int i=-1;
7591   MEDFileAnyTypeField1TS::LocateField(fid,fileName,fieldName,i,typcha,infos,dtunit);
7592   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7593   switch(typcha)
7594     {
7595     case MED_FLOAT64:
7596       {
7597         ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll);
7598         break;
7599       }
7600     case MED_INT32:
7601       {
7602         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll);
7603         break;
7604       }
7605     default:
7606       {
7607         std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
7608         throw INTERP_KERNEL::Exception(oss.str().c_str());
7609       }
7610     }
7611   ret->setDtUnit(dtunit.c_str());
7612   return ret.retn();
7613 }
7614
7615 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
7616 {
7617   med_field_type typcha;
7618   //
7619   std::vector<std::string> infos;
7620   std::string dtunit,fieldName;
7621   MEDFileAnyTypeField1TS::LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
7622   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7623   switch(typcha)
7624     {
7625     case MED_FLOAT64:
7626       {
7627         ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll);
7628         break;
7629       }
7630     case MED_INT32:
7631       {
7632         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll);
7633         break;
7634       }
7635     default:
7636       {
7637         std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fileName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
7638         throw INTERP_KERNEL::Exception(oss.str().c_str());
7639       }
7640     }
7641   ret->setDtUnit(dtunit.c_str());
7642   return ret.retn();
7643 }
7644
7645 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, const char *fileName) throw(INTERP_KERNEL::Exception)
7646 {
7647   if(!c)
7648     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
7649   if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
7650     {
7651       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=MEDFileFieldMultiTS::New();
7652       ret->setFileName(fileName);
7653       ret->_content=c;  c->incrRef();
7654       return ret.retn();
7655     }
7656   if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
7657     {
7658       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=MEDFileIntFieldMultiTS::New();
7659       ret->setFileName(fileName);
7660       ret->_content=c;  c->incrRef();
7661       return ret.retn();
7662     }
7663   throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
7664 }
7665
7666 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
7667 try:MEDFileFieldGlobsReal(fileName)
7668 {
7669   MEDFileUtilities::CheckFileForRead(fileName);
7670   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7671   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
7672   loadGlobals(fid);
7673 }
7674 catch(INTERP_KERNEL::Exception& e)
7675   {
7676     throw e;
7677   }
7678
7679 //= MEDFileIntFieldMultiTSWithoutSDA
7680
7681 MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::New(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
7682 {
7683   return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7684 }
7685
7686 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
7687 {
7688 }
7689
7690 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7691 {
7692 }
7693
7694 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, const char *fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll) throw(INTERP_KERNEL::Exception)
7695 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7696 {
7697 }
7698 catch(INTERP_KERNEL::Exception& e)
7699 { throw e; }
7700
7701 /*!
7702  * \param [in] fieldId field id in C mode
7703  */
7704 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll) throw(INTERP_KERNEL::Exception)
7705 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7706 {
7707 }
7708 catch(INTERP_KERNEL::Exception& e)
7709   { throw e; }
7710
7711 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const throw(INTERP_KERNEL::Exception)
7712 {
7713   return new MEDFileIntField1TSWithoutSDA;
7714 }
7715
7716 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const throw(INTERP_KERNEL::Exception)
7717 {
7718   if(!f1ts)
7719     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7720   const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
7721   if(!f1tsC)
7722     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
7723 }
7724
7725 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
7726 {
7727   return MEDFileIntField1TSWithoutSDA::TYPE_STR;
7728 }
7729
7730 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
7731 {
7732   return new MEDFileIntFieldMultiTSWithoutSDA(*this);
7733 }
7734
7735 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const throw(INTERP_KERNEL::Exception)
7736 {
7737   return new MEDFileIntFieldMultiTSWithoutSDA;
7738 }
7739
7740 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const throw(INTERP_KERNEL::Exception)
7741 {
7742   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
7743   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7744   int i=0;
7745   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7746     {
7747       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7748       if(eltToConv)
7749         {
7750           const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
7751           if(!eltToConvC)
7752             throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
7753           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
7754           ret->setIteration(i,elt);
7755         }
7756     }
7757   return ret.retn();
7758 }
7759
7760 //= MEDFileAnyTypeFieldMultiTS
7761
7762 /*!
7763  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
7764  * that has been read from a specified MED file.
7765  *  \param [in] fileName - the name of the MED file to read.
7766  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7767  *          is to delete this field using decrRef() as it is no more needed.
7768  *  \throw If reading the file fails.
7769  */
7770 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
7771 {
7772   MEDFileUtilities::CheckFileForRead(fileName);
7773   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7774   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
7775   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7776   ret->loadGlobals(fid);
7777   return ret.retn();
7778 }
7779
7780 /*!
7781  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
7782  * that has been read from a specified MED file.
7783  *  \param [in] fileName - the name of the MED file to read.
7784  *  \param [in] fieldName - the name of the field to read.
7785  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7786  *          is to delete this field using decrRef() as it is no more needed.
7787  *  \throw If reading the file fails.
7788  *  \throw If there is no field named \a fieldName in the file.
7789  */
7790 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
7791 {
7792   MEDFileUtilities::CheckFileForRead(fileName);
7793   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7794   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
7795   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7796   ret->loadGlobals(fid);
7797   return ret.retn();
7798 }
7799
7800 /*!
7801  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
7802  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
7803  *
7804  * \warning this is a shallow copy constructor
7805  */
7806 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
7807 {
7808   if(!shallowCopyOfContent)
7809     {
7810       const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
7811       otherPtr->incrRef();
7812       _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
7813     }
7814   else
7815     {
7816       _content=other.shallowCpy();
7817     }
7818 }
7819
7820 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() throw(INTERP_KERNEL::Exception)
7821 {
7822   MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7823   if(!ret)
7824     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
7825   return ret;
7826 }
7827
7828 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const throw(INTERP_KERNEL::Exception)
7829 {
7830   const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7831   if(!ret)
7832     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
7833   return ret;
7834 }
7835
7836 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
7837 {
7838   return contentNotNullBase()->getPflsReallyUsed2();
7839 }
7840
7841 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
7842 {
7843   return contentNotNullBase()->getLocsReallyUsed2();
7844 }
7845
7846 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
7847 {
7848   return contentNotNullBase()->getPflsReallyUsedMulti2();
7849 }
7850
7851 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
7852 {
7853   return contentNotNullBase()->getLocsReallyUsedMulti2();
7854 }
7855
7856 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7857 {
7858   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
7859 }
7860
7861 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7862 {
7863   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
7864 }
7865
7866 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
7867 {
7868   return contentNotNullBase()->getNumberOfTS();
7869 }
7870
7871 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS() throw(INTERP_KERNEL::Exception)
7872 {
7873   contentNotNullBase()->eraseEmptyTS();
7874 }
7875
7876 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
7877 {
7878   contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
7879 }
7880
7881 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step) throw(INTERP_KERNEL::Exception)
7882 {
7883   contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
7884 }
7885
7886 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const throw(INTERP_KERNEL::Exception)
7887 {
7888   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
7889   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7890   ret->_content=c;
7891   return ret.retn();
7892 }
7893
7894 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
7895 {
7896   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
7897   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7898   ret->_content=c;
7899   return ret.retn();
7900 }
7901
7902 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
7903 {
7904   return contentNotNullBase()->getIterations();
7905 }
7906
7907 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts) throw(INTERP_KERNEL::Exception)
7908 {
7909   for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
7910     pushBackTimeStep(*it);
7911 }
7912
7913 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts) throw(INTERP_KERNEL::Exception)
7914 {
7915   if(!f1ts)
7916     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
7917   checkCoherencyOfType(f1ts);
7918   f1ts->incrRef();
7919   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
7920   MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
7921   c->incrRef();
7922   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
7923   if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
7924     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
7925   _content->pushBackTimeStep(cSafe);
7926   appendGlobs(*f1ts,1e-12);
7927 }
7928
7929 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope() throw(INTERP_KERNEL::Exception)
7930 {
7931   contentNotNullBase()->synchronizeNameScope();
7932 }
7933
7934 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
7935 {
7936   return contentNotNullBase()->getPosOfTimeStep(iteration,order);
7937 }
7938
7939 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
7940 {
7941   return contentNotNullBase()->getPosGivenTime(time,eps);
7942 }
7943
7944 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
7945 {
7946   return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
7947 }
7948
7949 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
7950 {
7951   return contentNotNullBase()->getTypesOfFieldAvailable();
7952 }
7953
7954 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeFieldMultiTS::getFieldSplitedByType(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
7955 {
7956   return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
7957 }
7958
7959 std::string MEDFileAnyTypeFieldMultiTS::getName() const
7960 {
7961   return contentNotNullBase()->getName();
7962 }
7963
7964 void MEDFileAnyTypeFieldMultiTS::setName(const char *name)
7965 {
7966   contentNotNullBase()->setName(name);
7967 }
7968
7969 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const throw(INTERP_KERNEL::Exception)
7970 {
7971   return contentNotNullBase()->getDtUnit();
7972 }
7973
7974 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const char *dtUnit) throw(INTERP_KERNEL::Exception)
7975 {
7976   contentNotNullBase()->setDtUnit(dtUnit);
7977 }
7978
7979 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
7980 {
7981   contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
7982 }
7983
7984 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const throw(INTERP_KERNEL::Exception)
7985 {
7986   return contentNotNullBase()->getTimeSteps(ret1);
7987 }
7988
7989 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const throw(INTERP_KERNEL::Exception)
7990 {
7991   return contentNotNullBase()->getMeshName();
7992 }
7993
7994 void MEDFileAnyTypeFieldMultiTS::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
7995 {
7996   contentNotNullBase()->setMeshName(newMeshName);
7997 }
7998
7999 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
8000 {
8001   return contentNotNullBase()->changeMeshNames(modifTab);
8002 }
8003
8004 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const throw(INTERP_KERNEL::Exception)
8005 {
8006   return contentNotNullBase()->getInfo();
8007 }
8008
8009 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
8010 {
8011   return contentNotNullBase()->setInfo(info);
8012 }
8013
8014 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const throw(INTERP_KERNEL::Exception)
8015 {
8016   const std::vector<std::string> ret=getInfo();
8017   return (int)ret.size();
8018 }
8019
8020 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
8021 {
8022   writeGlobals(fid,*this);
8023   contentNotNullBase()->writeLL(fid,*this);
8024 }
8025
8026 /*!
8027  * Writes \a this field into a MED file specified by its name.
8028  *  \param [in] fileName - the MED file name.
8029  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
8030  * - 2 - erase; an existing file is removed.
8031  * - 1 - append; same data should not be present in an existing file.
8032  * - 0 - overwrite; same data present in an existing file is overwritten.
8033  *  \throw If the field name is not set.
8034  *  \throw If no field data is set.
8035  *  \throw If \a mode == 1 and the same data is present in an existing file.
8036  */
8037 void MEDFileAnyTypeFieldMultiTS::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
8038 {
8039   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
8040   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
8041   writeLL(fid);
8042 }
8043
8044 /*!
8045  * This method alloc the arrays and load potentially huge arrays contained in this field.
8046  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
8047  * This method can be also called to refresh or reinit values from a file.
8048  *
8049  * \throw If the fileName is not set or points to a non readable MED file.
8050  */
8051 void MEDFileAnyTypeFieldMultiTS::loadArrays() throw(INTERP_KERNEL::Exception)
8052 {
8053   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8054   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
8055 }
8056
8057 /*!
8058  * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
8059  * But once data loaded once, this method does nothing.
8060  *
8061  * \throw If the fileName is not set or points to a non readable MED file.
8062  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::releaseArrays
8063  */
8064 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary() throw(INTERP_KERNEL::Exception)
8065 {
8066   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8067   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
8068 }
8069
8070 /*!
8071  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
8072  * This method does not release arrays set outside the context of a MED file.
8073  *
8074  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
8075  */
8076 void MEDFileAnyTypeFieldMultiTS::releaseArrays() throw(INTERP_KERNEL::Exception)
8077 {
8078   contentNotNullBase()->releaseArrays();
8079 }
8080
8081 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
8082 {
8083   std::ostringstream oss;
8084   contentNotNullBase()->simpleRepr(0,oss,-1);
8085   simpleReprGlobs(oss);
8086   return oss.str();
8087 }
8088
8089 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySize() const
8090 {
8091   std::size_t ret=0;
8092   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)_content)
8093     ret+=_content->getHeapMemorySize();
8094   return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
8095 }
8096
8097 /*!
8098  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
8099  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8100  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
8101  */
8102 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const throw(INTERP_KERNEL::Exception)
8103 {
8104   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8105   if(!content)
8106     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
8107   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
8108   std::size_t sz(contentsSplit.size());
8109   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8110   for(std::size_t i=0;i<sz;i++)
8111     {
8112       ret[i]=shallowCpy();
8113       ret[i]->_content=contentsSplit[i];
8114     }
8115   return ret;
8116 }
8117
8118 /*!
8119  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
8120  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8121  */
8122 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
8123 {
8124   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8125   if(!content)
8126     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
8127   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitDiscretizations();
8128   std::size_t sz(contentsSplit.size());
8129   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8130   for(std::size_t i=0;i<sz;i++)
8131     {
8132       ret[i]=shallowCpy();
8133       ret[i]->_content=contentsSplit[i];
8134     }
8135   return ret;
8136 }
8137
8138 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCpy() const throw(INTERP_KERNEL::Exception)
8139 {
8140   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8141   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8142     ret->_content=_content->deepCpy();
8143   ret->deepCpyGlobs(*this);
8144   return ret.retn();
8145 }
8146
8147 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
8148 {
8149   return _content;
8150 }
8151
8152 /*!
8153  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8154  *  \param [in] iteration - the iteration number of a required time step.
8155  *  \param [in] order - the iteration order number of required time step.
8156  *  \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
8157  *          delete this field using decrRef() as it is no more needed.
8158  *  \throw If there is no required time step in \a this field.
8159  */
8160 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
8161 {
8162   int pos=getPosOfTimeStep(iteration,order);
8163   return getTimeStepAtPos(pos);
8164 }
8165
8166 /*!
8167  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8168  *  \param [in] time - the time of the time step of interest.
8169  *  \param [in] eps - a precision used to compare time values.
8170  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8171  *          delete this field using decrRef() as it is no more needed.
8172  *  \throw If there is no required time step in \a this field.
8173  */
8174 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
8175 {
8176   int pos=getPosGivenTime(time,eps);
8177   return getTimeStepAtPos(pos);
8178 }
8179
8180 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator() throw(INTERP_KERNEL::Exception)
8181 {
8182   return new MEDFileAnyTypeFieldMultiTSIterator(this);
8183 }
8184
8185 //= MEDFileFieldMultiTS
8186
8187 /*!
8188  * Returns a new empty instance of MEDFileFieldMultiTS.
8189  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8190  *          is to delete this field using decrRef() as it is no more needed.
8191  */
8192 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
8193 {
8194   return new MEDFileFieldMultiTS;
8195 }
8196
8197 /*!
8198  * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
8199  * that has been read from a specified MED file.
8200  *  \param [in] fileName - the name of the MED file to read.
8201  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8202  *          is to delete this field using decrRef() as it is no more needed.
8203  *  \throw If reading the file fails.
8204  */
8205 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
8206 {
8207   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,loadAll);
8208   ret->contentNotNull();//to check that content type matches with \a this type.
8209   return ret.retn();
8210 }
8211
8212 /*!
8213  * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
8214  * that has been read from a specified MED file.
8215  *  \param [in] fileName - the name of the MED file to read.
8216  *  \param [in] fieldName - the name of the field to read.
8217  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8218  *          is to delete this field using decrRef() as it is no more needed.
8219  *  \throw If reading the file fails.
8220  *  \throw If there is no field named \a fieldName in the file.
8221  */
8222 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
8223 {
8224   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,fieldName,loadAll);
8225   ret->contentNotNull();//to check that content type matches with \a this type.
8226   return ret.retn();
8227 }
8228
8229 /*!
8230  * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8231  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8232  *
8233  * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
8234  * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8235  * \warning this is a shallow copy constructor
8236  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
8237  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8238  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8239  *          is to delete this field using decrRef() as it is no more needed.
8240  */
8241 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8242 {
8243   return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
8244 }
8245
8246 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const throw(INTERP_KERNEL::Exception)
8247 {
8248   return new MEDFileFieldMultiTS(*this);
8249 }
8250
8251 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const throw(INTERP_KERNEL::Exception)
8252 {
8253   if(!f1ts)
8254     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8255   const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
8256   if(!f1tsC)
8257     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8258 }
8259
8260 /*!
8261  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
8262  * following the given input policy.
8263  *
8264  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8265  *                            By default (true) the globals are deeply copied.
8266  * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
8267  */
8268 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
8269 {
8270   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret;
8271   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8272   if(content)
8273     {
8274       const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
8275       if(!contc)
8276         throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
8277       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
8278       ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc,getFileName()));
8279     }
8280   else
8281     ret=MEDFileIntFieldMultiTS::New();
8282   if(deepCpyGlobs)
8283     ret->deepCpyGlobs(*this);
8284   else
8285     ret->shallowCpyGlobs(*this);
8286   return ret.retn();
8287 }
8288
8289 /*!
8290  * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
8291  *  \param [in] pos - a time step id.
8292  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8293  *          delete this field using decrRef() as it is no more needed.
8294  *  \throw If \a pos is not a valid time step id.
8295  */
8296 MEDFileAnyTypeField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const throw(INTERP_KERNEL::Exception)
8297 {
8298   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8299   if(!item)
8300     {
8301       std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8302       throw INTERP_KERNEL::Exception(oss.str().c_str());
8303     }
8304   const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
8305   if(itemC)
8306     {
8307       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
8308       ret->shallowCpyGlobs(*this);
8309       return ret.retn();
8310     }
8311   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
8312   throw INTERP_KERNEL::Exception(oss.str().c_str());
8313 }
8314
8315 /*!
8316  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8317  * mesh entities of a given dimension of the first mesh in MED file.
8318  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8319  *  \param [in] type - a spatial discretization of interest.
8320  *  \param [in] iteration - the iteration number of a required time step.
8321  *  \param [in] order - the iteration order number of required time step.
8322  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8323  *  \param [in] renumPol - specifies how to permute values of the result field according to
8324  *          the optional numbers of cells and nodes, if any. The valid values are
8325  *          - 0 - do not permute.
8326  *          - 1 - permute cells.
8327  *          - 2 - permute nodes.
8328  *          - 3 - permute cells and nodes.
8329  *
8330  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8331  *          caller is to delete this field using decrRef() as it is no more needed.
8332  *  \throw If the MED file is not readable.
8333  *  \throw If there is no mesh in the MED file.
8334  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8335  *  \throw If no field values of the required parameters are available.
8336  */
8337 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
8338 {
8339   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8340   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8341   if(!myF1TSC)
8342     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
8343   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8344   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNullBase());
8345   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8346   return ret.retn();
8347 }
8348
8349 /*!
8350  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8351  * the top level cells of the first mesh in MED file.
8352  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8353  *  \param [in] type - a spatial discretization of interest.
8354  *  \param [in] iteration - the iteration number of a required time step.
8355  *  \param [in] order - the iteration order number of required time step.
8356  *  \param [in] renumPol - specifies how to permute values of the result field according to
8357  *          the optional numbers of cells and nodes, if any. The valid values are
8358  *          - 0 - do not permute.
8359  *          - 1 - permute cells.
8360  *          - 2 - permute nodes.
8361  *          - 3 - permute cells and nodes.
8362  *
8363  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8364  *          caller is to delete this field using decrRef() as it is no more needed.
8365  *  \throw If the MED file is not readable.
8366  *  \throw If there is no mesh in the MED file.
8367  *  \throw If no field values of the required parameters are available.
8368  */
8369 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const throw(INTERP_KERNEL::Exception)
8370 {
8371   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8372   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8373   if(!myF1TSC)
8374     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
8375   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8376   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNullBase());
8377   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8378   return ret.retn();
8379 }
8380
8381 /*!
8382  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8383  * a given support.
8384  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8385  *  \param [in] type - a spatial discretization of interest.
8386  *  \param [in] iteration - the iteration number of a required time step.
8387  *  \param [in] order - the iteration order number of required time step.
8388  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8389  *  \param [in] mesh - the supporting mesh.
8390  *  \param [in] renumPol - specifies how to permute values of the result field according to
8391  *          the optional numbers of cells and nodes, if any. The valid values are
8392  *          - 0 - do not permute.
8393  *          - 1 - permute cells.
8394  *          - 2 - permute nodes.
8395  *          - 3 - permute cells and nodes.
8396  *
8397  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8398  *          caller is to delete this field using decrRef() as it is no more needed.
8399  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8400  *  \throw If no field of \a this is lying on \a mesh.
8401  *  \throw If no field values of the required parameters are available.
8402  */
8403 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
8404 {
8405   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8406   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8407   if(!myF1TSC)
8408     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8409   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8410   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
8411   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8412   return ret.retn();
8413 }
8414
8415 /*!
8416  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8417  * given support.
8418  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8419  *  \param [in] type - a spatial discretization of the new field.
8420  *  \param [in] iteration - the iteration number of a required time step.
8421  *  \param [in] order - the iteration order number of required time step.
8422  *  \param [in] mesh - the supporting mesh.
8423  *  \param [in] renumPol - specifies how to permute values of the result field according to
8424  *          the optional numbers of cells and nodes, if any. The valid values are
8425  *          - 0 - do not permute.
8426  *          - 1 - permute cells.
8427  *          - 2 - permute nodes.
8428  *          - 3 - permute cells and nodes.
8429  *
8430  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8431  *          caller is to delete this field using decrRef() as it is no more needed.
8432  *  \throw If no field of \a this is lying on \a mesh.
8433  *  \throw If no field values of the required parameters are available.
8434  */
8435 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
8436 {
8437   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8438   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8439   if(!myF1TSC)
8440     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8441   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8442   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
8443   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8444   return ret.retn();
8445 }
8446
8447 /*!
8448  * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
8449  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8450  * This method is useful for MED2 file format when field on different mesh was autorized.
8451  */
8452 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const char *mname, int iteration, int order, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
8453 {
8454   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8455   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8456   if(!myF1TSC)
8457     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
8458   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8459   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
8460   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8461   return ret.retn();
8462 }
8463
8464 /*!
8465  * Returns values and a profile of the field of a given type, of a given time step,
8466  * lying on a given support.
8467  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8468  *  \param [in] type - a spatial discretization of the field.
8469  *  \param [in] iteration - the iteration number of a required time step.
8470  *  \param [in] order - the iteration order number of required time step.
8471  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8472  *  \param [in] mesh - the supporting mesh.
8473  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8474  *          field of interest lies on. If the field lies on all entities of the given
8475  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8476  *          using decrRef() as it is no more needed.
8477  *  \param [in] glob - the global data storing profiles and localization.
8478  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
8479  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8480  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8481  *  \throw If no field of \a this is lying on \a mesh.
8482  *  \throw If no field values of the required parameters are available.
8483  */
8484 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
8485 {
8486   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8487   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8488   if(!myF1TSC)
8489     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
8490   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8491   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
8492 }
8493
8494 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const throw(INTERP_KERNEL::Exception)
8495 {
8496   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8497   if(!pt)
8498     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
8499   const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
8500   if(!ret)
8501     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 !");
8502   return ret;
8503 }
8504
8505  MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() throw(INTERP_KERNEL::Exception)
8506 {
8507   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8508   if(!pt)
8509     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
8510   MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
8511   if(!ret)
8512     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 !");
8513   return ret;
8514 }
8515
8516 /*!
8517  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8518  * the given field is checked if its elements are sorted suitable for writing to MED file
8519  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8520  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8521  *  \param [in] field - the field to add to \a this.
8522  *  \throw If the name of \a field is empty.
8523  *  \throw If the data array of \a field is not set.
8524  *  \throw If existing time steps have different name or number of components than \a field.
8525  *  \throw If the underlying mesh of \a field has no name.
8526  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8527  */
8528 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
8529 {
8530   const DataArrayDouble *arr=0;
8531   if(field)
8532     arr=field->getArray();
8533   contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
8534 }
8535
8536 /*!
8537  * Adds a MEDCouplingFieldDouble to \a this as another time step. Specified entities of
8538  * a given dimension of a given mesh are used as the support of the given field.
8539  * Elements of the given mesh must be sorted suitable for writing to MED file.
8540  * Order of underlying mesh entities of the given field specified by \a profile parameter
8541  * is not prescribed; this method permutes field values to have them sorted by element
8542  * type as required for writing to MED file.
8543  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8544  *  \param [in] field - the field to add to \a this.
8545  *  \param [in] mesh - the supporting mesh of \a field.
8546  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
8547  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
8548  *  \throw If either \a field or \a mesh or \a profile has an empty name.
8549  *  \throw If existing time steps have different name or number of components than \a field.
8550  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8551  *  \throw If the data array of \a field is not set.
8552  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
8553  */
8554 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
8555 {
8556   const DataArrayDouble *arr=0;
8557   if(field)
8558     arr=field->getArray();
8559   contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
8560 }
8561
8562 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
8563 {
8564   _content=new MEDFileFieldMultiTSWithoutSDA;
8565 }
8566
8567 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
8568 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
8569 {
8570 }
8571 catch(INTERP_KERNEL::Exception& e)
8572   { throw e; }
8573
8574 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
8575 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
8576 {
8577 }
8578 catch(INTERP_KERNEL::Exception& e)
8579   { throw e; }
8580
8581 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
8582 {
8583 }
8584
8585 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTS::getFieldSplitedByType2(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
8586 {
8587   return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
8588 }
8589
8590 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
8591 {
8592   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
8593 }
8594
8595 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
8596 {
8597   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
8598 }
8599
8600 //= MEDFileAnyTypeFieldMultiTSIterator
8601
8602 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
8603 {
8604   if(fmts)
8605     {
8606       fmts->incrRef();
8607       _nb_iter=fmts->getNumberOfTS();
8608     }
8609 }
8610
8611 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
8612 {
8613 }
8614
8615 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt() throw(INTERP_KERNEL::Exception)
8616 {
8617   if(_iter_id<_nb_iter)
8618     {
8619       MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
8620       if(fmts)
8621         return fmts->getTimeStepAtPos(_iter_id++);
8622       else
8623         return 0;
8624     }
8625   else
8626     return 0;
8627 }
8628
8629 //= MEDFileIntFieldMultiTS
8630
8631 /*!
8632  * Returns a new empty instance of MEDFileFieldMultiTS.
8633  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8634  *          is to delete this field using decrRef() as it is no more needed.
8635  */
8636 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
8637 {
8638   return new MEDFileIntFieldMultiTS;
8639 }
8640
8641 /*!
8642  * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
8643  * that has been read from a specified MED file.
8644  *  \param [in] fileName - the name of the MED file to read.
8645  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8646  *          is to delete this field using decrRef() as it is no more needed.
8647  *  \throw If reading the file fails.
8648  */
8649 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
8650 {
8651   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,loadAll);
8652   ret->contentNotNull();//to check that content type matches with \a this type.
8653   return ret.retn();
8654 }
8655
8656 /*!
8657  * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
8658  * that has been read from a specified MED file.
8659  *  \param [in] fileName - the name of the MED file to read.
8660  *  \param [in] fieldName - the name of the field to read.
8661  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8662  *          is to delete this field using decrRef() as it is no more needed.
8663  *  \throw If reading the file fails.
8664  *  \throw If there is no field named \a fieldName in the file.
8665  */
8666 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
8667 {
8668   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,fieldName,loadAll);
8669   ret->contentNotNull();//to check that content type matches with \a this type.
8670   return ret.retn();
8671 }
8672
8673 /*!
8674  * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8675  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8676  *
8677  * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
8678  * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8679  * \warning this is a shallow copy constructor
8680  *  \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
8681  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8682  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8683  *          is to delete this field using decrRef() as it is no more needed.
8684  */
8685 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8686 {
8687   return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
8688 }
8689
8690 /*!
8691  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
8692  * following the given input policy.
8693  *
8694  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8695  *                            By default (true) the globals are deeply copied.
8696  * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
8697  */
8698 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
8699 {
8700   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret;
8701   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8702   if(content)
8703     {
8704       const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
8705       if(!contc)
8706         throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
8707       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
8708       ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc,getFileName()));
8709     }
8710   else
8711     ret=MEDFileFieldMultiTS::New();
8712   if(deepCpyGlobs)
8713     ret->deepCpyGlobs(*this);
8714   else
8715     ret->shallowCpyGlobs(*this);
8716   return ret.retn();
8717 }
8718
8719 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const throw(INTERP_KERNEL::Exception)
8720 {
8721   return new MEDFileIntFieldMultiTS(*this);
8722 }
8723
8724 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const throw(INTERP_KERNEL::Exception)
8725 {
8726   if(!f1ts)
8727     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8728   const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
8729   if(!f1tsC)
8730     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
8731 }
8732
8733 /*!
8734  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8735  * mesh entities of a given dimension of the first mesh in MED file.
8736  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8737  *  \param [in] type - a spatial discretization of interest.
8738  *  \param [in] iteration - the iteration number of a required time step.
8739  *  \param [in] order - the iteration order number of required time step.
8740  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8741  *  \param [out] arrOut - the DataArrayInt containing values of field.
8742  *  \param [in] renumPol - specifies how to permute values of the result field according to
8743  *          the optional numbers of cells and nodes, if any. The valid values are
8744  *          - 0 - do not permute.
8745  *          - 1 - permute cells.
8746  *          - 2 - permute nodes.
8747  *          - 3 - permute cells and nodes.
8748  *
8749  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8750  *          caller is to delete this field using decrRef() as it is no more needed.
8751  *  \throw If the MED file is not readable.
8752  *  \throw If there is no mesh in the MED file.
8753  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8754  *  \throw If no field values of the required parameters are available.
8755  */
8756 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8757 {
8758   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8759   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8760   if(!myF1TSC)
8761     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
8762   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8763   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arr,*contentNotNullBase());
8764   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8765   return ret.retn();
8766 }
8767
8768 /*!
8769  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8770  * the top level cells of the first mesh in MED file.
8771  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8772  *  \param [in] type - a spatial discretization of interest.
8773  *  \param [in] iteration - the iteration number of a required time step.
8774  *  \param [in] order - the iteration order number of required time step.
8775  *  \param [out] arrOut - the DataArrayInt containing values of field.
8776  *  \param [in] renumPol - specifies how to permute values of the result field according to
8777  *          the optional numbers of cells and nodes, if any. The valid values are
8778  *          - 0 - do not permute.
8779  *          - 1 - permute cells.
8780  *          - 2 - permute nodes.
8781  *          - 3 - permute cells and nodes.
8782  *
8783  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8784  *          caller is to delete this field using decrRef() as it is no more needed.
8785  *  \throw If the MED file is not readable.
8786  *  \throw If there is no mesh in the MED file.
8787  *  \throw If no field values of the required parameters are available.
8788  */
8789 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8790 {
8791   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8792   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8793   if(!myF1TSC)
8794     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
8795   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8796   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNullBase());
8797   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8798   return ret.retn();
8799 }
8800
8801 /*!
8802  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8803  * a given support.
8804  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8805  *  \param [in] type - a spatial discretization of interest.
8806  *  \param [in] iteration - the iteration number of a required time step.
8807  *  \param [in] order - the iteration order number of required time step.
8808  *  \param [out] arrOut - the DataArrayInt containing values of field.
8809  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8810  *  \param [in] mesh - the supporting mesh.
8811  *  \param [in] renumPol - specifies how to permute values of the result field according to
8812  *          the optional numbers of cells and nodes, if any. The valid values are
8813  *          - 0 - do not permute.
8814  *          - 1 - permute cells.
8815  *          - 2 - permute nodes.
8816  *          - 3 - permute cells and nodes.
8817  *
8818  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8819  *          caller is to delete this field using decrRef() as it is no more needed.
8820  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8821  *  \throw If no field of \a this is lying on \a mesh.
8822  *  \throw If no field values of the required parameters are available.
8823  */
8824 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8825 {
8826   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8827   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8828   if(!myF1TSC)
8829     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
8830   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8831   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase());
8832   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8833   return ret.retn();
8834 }
8835
8836 /*!
8837  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8838  * given support.
8839  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8840  *  \param [in] type - a spatial discretization of the new field.
8841  *  \param [in] iteration - the iteration number of a required time step.
8842  *  \param [in] order - the iteration order number of required time step.
8843  *  \param [in] mesh - the supporting mesh.
8844  *  \param [out] arrOut - the DataArrayInt containing values of field.
8845  *  \param [in] renumPol - specifies how to permute values of the result field according to
8846  *          the optional numbers of cells and nodes, if any. The valid values are
8847  *          - 0 - do not permute.
8848  *          - 1 - permute cells.
8849  *          - 2 - permute nodes.
8850  *          - 3 - permute cells and nodes.
8851  *
8852  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8853  *          caller is to delete this field using decrRef() as it is no more needed.
8854  *  \throw If no field of \a this is lying on \a mesh.
8855  *  \throw If no field values of the required parameters are available.
8856  */
8857 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8858 {
8859   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8860   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8861   if(!myF1TSC)
8862     throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
8863   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8864   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase());
8865   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8866   return ret.retn();
8867 }
8868
8869 /*!
8870  * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
8871  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8872  * This method is useful for MED2 file format when field on different mesh was autorized.
8873  */
8874 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8875 {
8876   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8877   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8878   if(!myF1TSC)
8879     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
8880   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8881   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase());
8882   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8883   return ret.retn();
8884 }
8885
8886 /*!
8887  * Returns values and a profile of the field of a given type, of a given time step,
8888  * lying on a given support.
8889  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8890  *  \param [in] type - a spatial discretization of the field.
8891  *  \param [in] iteration - the iteration number of a required time step.
8892  *  \param [in] order - the iteration order number of required time step.
8893  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8894  *  \param [in] mesh - the supporting mesh.
8895  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8896  *          field of interest lies on. If the field lies on all entities of the given
8897  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8898  *          using decrRef() as it is no more needed.
8899  *  \param [in] glob - the global data storing profiles and localization.
8900  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
8901  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8902  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8903  *  \throw If no field of \a this is lying on \a mesh.
8904  *  \throw If no field values of the required parameters are available.
8905  */
8906 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
8907 {
8908   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8909   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8910   if(!myF1TSC)
8911     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
8912   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8913   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(ret);
8914 }
8915
8916 /*!
8917  * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
8918  *  \param [in] pos - a time step id.
8919  *  \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
8920  *          delete this field using decrRef() as it is no more needed.
8921  *  \throw If \a pos is not a valid time step id.
8922  */
8923 MEDFileAnyTypeField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const throw(INTERP_KERNEL::Exception)
8924 {
8925   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8926   if(!item)
8927     {
8928       std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8929       throw INTERP_KERNEL::Exception(oss.str().c_str());
8930     }
8931   const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
8932   if(itemC)
8933     {
8934       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
8935       ret->shallowCpyGlobs(*this);
8936       return ret.retn();
8937     }
8938   std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
8939   throw INTERP_KERNEL::Exception(oss.str().c_str());
8940 }
8941
8942 /*!
8943  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8944  * the given field is checked if its elements are sorted suitable for writing to MED file
8945  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8946  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8947  *  \param [in] field - the field to add to \a this.
8948  *  \throw If the name of \a field is empty.
8949  *  \throw If the data array of \a field is not set.
8950  *  \throw If existing time steps have different name or number of components than \a field.
8951  *  \throw If the underlying mesh of \a field has no name.
8952  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8953  */
8954 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals) throw(INTERP_KERNEL::Exception)
8955 {
8956   contentNotNull()->appendFieldNoProfileSBT(field,arrOfVals,*this);
8957 }
8958
8959 /*!
8960  * Adds a MEDCouplingFieldDouble to \a this as another time step. Specified entities of
8961  * a given dimension of a given mesh are used as the support of the given field.
8962  * Elements of the given mesh must be sorted suitable for writing to MED file.
8963  * Order of underlying mesh entities of the given field specified by \a profile parameter
8964  * is not prescribed; this method permutes field values to have them sorted by element
8965  * type as required for writing to MED file.
8966  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8967  *  \param [in] field - the field to add to \a this.
8968  *  \param [in] mesh - the supporting mesh of \a field.
8969  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
8970  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
8971  *  \throw If either \a field or \a mesh or \a profile has an empty name.
8972  *  \throw If existing time steps have different name or number of components than \a field.
8973  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8974  *  \throw If the data array of \a field is not set.
8975  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
8976  */
8977 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
8978 {
8979   contentNotNull()->appendFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this);
8980 }
8981
8982 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const throw(INTERP_KERNEL::Exception)
8983 {
8984   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8985   if(!pt)
8986     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
8987   const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
8988   if(!ret)
8989     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 !");
8990   return ret;
8991 }
8992
8993  MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() throw(INTERP_KERNEL::Exception)
8994 {
8995   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8996   if(!pt)
8997     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
8998   MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
8999   if(!ret)
9000     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 !");
9001   return ret;
9002 }
9003
9004 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
9005 {
9006   _content=new MEDFileIntFieldMultiTSWithoutSDA;
9007 }
9008
9009 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
9010 {
9011 }
9012
9013 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
9014 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
9015 {
9016 }
9017 catch(INTERP_KERNEL::Exception& e)
9018   { throw e; }
9019
9020 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
9021 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
9022 {
9023 }
9024 catch(INTERP_KERNEL::Exception& e)
9025   { throw e; }
9026
9027 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
9028 {
9029   return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
9030 }
9031
9032 //= MEDFileFields
9033
9034 MEDFileFields *MEDFileFields::New()
9035 {
9036   return new MEDFileFields;
9037 }
9038
9039 MEDFileFields *MEDFileFields::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
9040 {
9041   return new MEDFileFields(fileName,loadAll);
9042 }
9043
9044 std::size_t MEDFileFields::getHeapMemorySize() const
9045 {
9046   std::size_t ret=_fields.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
9047   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9048     if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)*it)
9049       ret+=(*it)->getHeapMemorySize();
9050   return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
9051 }
9052
9053 MEDFileFields *MEDFileFields::deepCpy() const throw(INTERP_KERNEL::Exception)
9054 {
9055   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9056   std::size_t i=0;
9057   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9058     {
9059       if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9060         ret->_fields[i]=(*it)->deepCpy();
9061     }
9062   ret->deepCpyGlobs(*this);
9063   return ret.retn();
9064 }
9065
9066 MEDFileFields *MEDFileFields::shallowCpy() const throw(INTERP_KERNEL::Exception)
9067 {
9068   return new MEDFileFields(*this);
9069 }
9070
9071 /*!
9072  * 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
9073  * 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.
9074  * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
9075  *
9076  * \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.
9077  * \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.
9078  *
9079  * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9080  */
9081 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const throw(INTERP_KERNEL::Exception)
9082 {
9083   std::set< std::pair<int,int> > s;
9084   bool firstShot=true;
9085   areThereSomeForgottenTS=false;
9086   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9087     {
9088       if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9089         continue;
9090       std::vector< std::pair<int,int> > v=(*it)->getIterations();
9091       std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
9092       if(firstShot)
9093         { s=s1; firstShot=false; }
9094       else
9095         {
9096           std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
9097           if(s!=s2)
9098             areThereSomeForgottenTS=true;
9099           s=s2;
9100         }
9101     }
9102   std::vector< std::pair<int,int> > ret;
9103   std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
9104   return ret;
9105 }
9106
9107 int MEDFileFields::getNumberOfFields() const
9108 {
9109   return _fields.size();
9110 }
9111
9112 std::vector<std::string> MEDFileFields::getFieldsNames() const throw(INTERP_KERNEL::Exception)
9113 {
9114   std::vector<std::string> ret(_fields.size());
9115   int i=0;
9116   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9117     {
9118       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
9119       if(f)
9120         {
9121           ret[i]=f->getName();
9122         }
9123       else
9124         {
9125           std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
9126           throw INTERP_KERNEL::Exception(oss.str().c_str());
9127         }
9128     }
9129   return ret;
9130 }
9131
9132 std::vector<std::string> MEDFileFields::getMeshesNames() const throw(INTERP_KERNEL::Exception)
9133 {
9134   std::vector<std::string> ret;
9135   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9136     {
9137       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9138       if(cur)
9139         ret.push_back(cur->getMeshName());
9140     }
9141   return ret;
9142 }
9143
9144 std::string MEDFileFields::simpleRepr() const
9145 {
9146   std::ostringstream oss;
9147   oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
9148   simpleRepr(0,oss);
9149   return oss.str();
9150 }
9151
9152 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
9153 {
9154   int nbOfFields=getNumberOfFields();
9155   std::string startLine(bkOffset,' ');
9156   oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
9157   int i=0;
9158   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9159     {
9160       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9161       if(cur)
9162         {
9163           oss << startLine << "  - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
9164         }
9165       else
9166         {
9167           oss << startLine << "  - not defined !" << std::endl;
9168         }
9169     }
9170   i=0;
9171   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9172     {
9173       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9174       std::string chapter(17,'0'+i);
9175       oss << startLine << chapter << std::endl;
9176       if(cur)
9177         {
9178           cur->simpleRepr(bkOffset+2,oss,i);
9179         }
9180       else
9181         {
9182           oss << startLine << "  - not defined !" << std::endl;
9183         }
9184       oss << startLine << chapter << std::endl;
9185     }
9186   simpleReprGlobs(oss);
9187 }
9188
9189 MEDFileFields::MEDFileFields()
9190 {
9191 }
9192
9193 MEDFileFields::MEDFileFields(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
9194 try:MEDFileFieldGlobsReal(fileName)
9195   {
9196     MEDFileUtilities::CheckFileForRead(fileName);
9197     MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
9198     int nbFields=MEDnField(fid);
9199     _fields.resize(nbFields);
9200     med_field_type typcha;
9201     for(int i=0;i<nbFields;i++)
9202       {
9203         std::vector<std::string> infos;
9204         std::string fieldName,dtunit;
9205         int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,fileName,i,false,fieldName,typcha,infos,dtunit);
9206         switch(typcha)
9207           {
9208           case MED_FLOAT64:
9209             {
9210               _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9211               break;
9212             }
9213           case MED_INT32:
9214             {
9215               _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9216               break;
9217             }
9218           default:
9219             {
9220               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] !";
9221               throw INTERP_KERNEL::Exception(oss.str().c_str());
9222             }
9223           }
9224       }
9225     loadAllGlobals(fid);
9226   }
9227 catch(INTERP_KERNEL::Exception& e)
9228   {
9229     throw e;
9230   }
9231
9232 void MEDFileFields::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
9233 {
9234   int i=0;
9235   writeGlobals(fid,*this);
9236   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9237     {
9238       const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
9239       if(!elt)
9240         {
9241           std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
9242           throw INTERP_KERNEL::Exception(oss.str().c_str());
9243         }
9244       elt->writeLL(fid,*this);
9245     }
9246 }
9247
9248 void MEDFileFields::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
9249 {
9250   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
9251   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
9252   writeLL(fid);
9253 }
9254
9255 /*!
9256  * This method alloc the arrays and load potentially huge arrays contained in this field.
9257  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
9258  * This method can be also called to refresh or reinit values from a file.
9259  *
9260  * \throw If the fileName is not set or points to a non readable MED file.
9261  */
9262 void MEDFileFields::loadArrays() throw(INTERP_KERNEL::Exception)
9263 {
9264   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9265   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9266     {
9267       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9268       if(elt)
9269         elt->loadBigArraysRecursively(fid,*elt);
9270     }
9271 }
9272
9273 /*!
9274  * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
9275  * But once data loaded once, this method does nothing.
9276  *
9277  * \throw If the fileName is not set or points to a non readable MED file.
9278  * \sa MEDFileFields::loadArrays, MEDFileFields::releaseArrays
9279  */
9280 void MEDFileFields::loadArraysIfNecessary() throw(INTERP_KERNEL::Exception)
9281 {
9282   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9283   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9284     {
9285       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9286       if(elt)
9287         elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
9288     }
9289 }
9290
9291 /*!
9292  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
9293  * This method does not release arrays set outside the context of a MED file.
9294  *
9295  * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary
9296  */
9297 void MEDFileFields::releaseArrays() throw(INTERP_KERNEL::Exception)
9298 {
9299   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9300   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9301     {
9302       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9303       if(elt)
9304         elt->releaseArrays();
9305     }
9306 }
9307
9308 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
9309 {
9310   std::vector<std::string> ret;
9311   std::set<std::string> ret2;
9312   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9313     {
9314       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
9315       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9316         if(ret2.find(*it2)==ret2.end())
9317           {
9318             ret.push_back(*it2);
9319             ret2.insert(*it2);
9320           }
9321     }
9322   return ret;
9323 }
9324
9325 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
9326 {
9327   std::vector<std::string> ret;
9328   std::set<std::string> ret2;
9329   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9330     {
9331       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9332       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9333         if(ret2.find(*it2)==ret2.end())
9334           {
9335             ret.push_back(*it2);
9336             ret2.insert(*it2);
9337           }
9338     }
9339   return ret;
9340 }
9341
9342 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
9343 {
9344   std::vector<std::string> ret;
9345   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9346     {
9347       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
9348       ret.insert(ret.end(),tmp.begin(),tmp.end());
9349     }
9350   return ret;
9351 }
9352
9353 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
9354 {
9355   std::vector<std::string> ret;
9356   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9357     {
9358       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9359       ret.insert(ret.end(),tmp.begin(),tmp.end());
9360     }
9361   return ret;
9362 }
9363
9364 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
9365 {
9366   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9367     (*it)->changePflsRefsNamesGen2(mapOfModif);
9368 }
9369
9370 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
9371 {
9372   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9373     (*it)->changeLocsRefsNamesGen2(mapOfModif);
9374 }
9375
9376 void MEDFileFields::resize(int newSize) throw(INTERP_KERNEL::Exception)
9377 {
9378   _fields.resize(newSize);
9379 }
9380
9381 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields) throw(INTERP_KERNEL::Exception)
9382 {
9383   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
9384     pushField(*it);
9385 }
9386
9387 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field) throw(INTERP_KERNEL::Exception)
9388 {
9389   if(!field)
9390     throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
9391   _fields.push_back(field->getContent());
9392   appendGlobs(*field,1e-12);
9393 }
9394
9395 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field) throw(INTERP_KERNEL::Exception)
9396 {
9397   if(!field)
9398     throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
9399   if(i>=(int)_fields.size())
9400     _fields.resize(i+1);
9401   _fields[i]=field->getContent();
9402   appendGlobs(*field,1e-12);
9403 }
9404
9405 void MEDFileFields::destroyFieldAtPos(int i) throw(INTERP_KERNEL::Exception)
9406 {
9407   destroyFieldsAtPos(&i,&i+1);
9408 }
9409
9410 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
9411 {
9412   std::vector<bool> b(_fields.size(),true);
9413   for(const int *i=startIds;i!=endIds;i++)
9414     {
9415       if(*i<0 || *i>=(int)_fields.size())
9416         {
9417           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9418           throw INTERP_KERNEL::Exception(oss.str().c_str());
9419         }
9420       b[*i]=false;
9421     }
9422   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9423   std::size_t j=0;
9424   for(std::size_t i=0;i<_fields.size();i++)
9425     if(b[i])
9426       fields[j++]=_fields[i];
9427   _fields=fields;
9428 }
9429
9430 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step) throw(INTERP_KERNEL::Exception)
9431 {
9432   static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
9433   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
9434   std::vector<bool> b(_fields.size(),true);
9435   int k=bg;
9436   for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
9437     {
9438       if(k<0 || k>=(int)_fields.size())
9439         {
9440           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
9441           throw INTERP_KERNEL::Exception(oss.str().c_str());
9442         }
9443       b[k]=false;
9444     }
9445   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9446   std::size_t j=0;
9447   for(std::size_t i=0;i<_fields.size();i++)
9448     if(b[i])
9449       fields[j++]=_fields[i];
9450   _fields=fields;
9451 }
9452
9453 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
9454 {
9455   bool ret=false;
9456   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9457     {
9458       MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9459       if(cur)
9460         ret=cur->changeMeshNames(modifTab) || ret;
9461     }
9462   return ret;
9463 }
9464
9465 /*!
9466  * \param [in] meshName the name of the mesh that will be renumbered.
9467  * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
9468  *             This code corresponds to the distribution of types in the corresponding mesh.
9469  * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
9470  * \param [in] renumO2N the old to new renumber array.
9471  * \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
9472  *         field in \a this.
9473  */
9474 bool MEDFileFields::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N) throw(INTERP_KERNEL::Exception)
9475 {
9476   bool ret=false;
9477   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9478     {
9479       MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
9480       if(fmts)
9481         {
9482           ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
9483         }
9484     }
9485   return ret;
9486 }
9487
9488 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const throw(INTERP_KERNEL::Exception)
9489 {
9490   if(i<0 || i>=(int)_fields.size())
9491     {
9492       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
9493       throw INTERP_KERNEL::Exception(oss.str().c_str());
9494     }
9495   const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
9496   if(!fmts)
9497     return 0;
9498   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret;
9499   const MEDFileFieldMultiTSWithoutSDA *fmtsC=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts);
9500   const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts);
9501   if(fmtsC)
9502     ret=MEDFileFieldMultiTS::New(*fmtsC,false);
9503   else if(fmtsC2)
9504     ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
9505   else
9506     {
9507       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
9508       throw INTERP_KERNEL::Exception(oss.str().c_str());
9509     }
9510   ret->shallowCpyGlobs(*this);
9511   return ret.retn();
9512 }
9513
9514 /*!
9515  * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
9516  * This method is accessible in python using __getitem__ with a list in input.
9517  * \return a new object that the caller should deal with.
9518  */
9519 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const throw(INTERP_KERNEL::Exception)
9520 {
9521   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9522   std::size_t sz=std::distance(startIds,endIds);
9523   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
9524   int j=0;
9525   for(const int *i=startIds;i!=endIds;i++,j++)
9526     {
9527       if(*i<0 || *i>=(int)_fields.size())
9528         {
9529           std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9530           throw INTERP_KERNEL::Exception(oss.str().c_str());
9531         }
9532       fields[j]=_fields[*i];
9533     }
9534   ret->_fields=fields;
9535   return ret.retn();
9536 }
9537
9538 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const char *fieldName) const throw(INTERP_KERNEL::Exception)
9539 {
9540   return getFieldAtPos(getPosFromFieldName(fieldName));
9541 }
9542
9543 /*!
9544  * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
9545  * This method can be seen as a filter applied on \a this, that returns an object containing
9546  * 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
9547  * shallow copied from \a this.
9548  *
9549  * \param [in] meshName - the name of the mesh on w
9550  * \return a new object that the caller should deal with.
9551  */
9552 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const char *meshName) const throw(INTERP_KERNEL::Exception)
9553 {
9554   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9555   ret->shallowCpyOnlyUsedGlobs(*this);
9556   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9557     {
9558       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9559       if(!cur)
9560         continue;
9561       if(cur->getMeshName()==meshName)
9562         {
9563           cur->incrRef();
9564           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
9565           ret->_fields.push_back(cur2);
9566         }
9567     }
9568   return ret.retn();
9569 }
9570
9571 /*!
9572  * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
9573  * Input time steps are specified using a pair of integer (iteration, order).
9574  * 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,
9575  * but for each multitimestep only the time steps in \a timeSteps are kept.
9576  * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
9577  *
9578  * The returned object points to shallow copy of elements in \a this.
9579  *
9580  * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
9581  * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
9582  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9583  */
9584 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
9585 {
9586   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9587   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9588     {
9589       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9590       if(!cur)
9591         continue;
9592       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
9593       ret->_fields.push_back(elt);
9594     }
9595   ret->shallowCpyOnlyUsedGlobs(*this);
9596   return ret.retn();
9597 }
9598
9599 /*!
9600  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
9601  */
9602 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
9603 {
9604   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9605   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9606     {
9607       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9608       if(!cur)
9609         continue;
9610       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
9611       if(elt->getNumberOfTS()!=0)
9612         ret->_fields.push_back(elt);
9613     }
9614   ret->shallowCpyOnlyUsedGlobs(*this);
9615   return ret.retn();
9616 }
9617
9618 MEDFileFieldsIterator *MEDFileFields::iterator() throw(INTERP_KERNEL::Exception)
9619 {
9620   return new MEDFileFieldsIterator(this);
9621 }
9622
9623 int MEDFileFields::getPosFromFieldName(const char *fieldName) const throw(INTERP_KERNEL::Exception)
9624 {
9625   std::string tmp(fieldName);
9626   std::vector<std::string> poss;
9627   for(std::size_t i=0;i<_fields.size();i++)
9628     {
9629       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=_fields[i];
9630       if(f)
9631         {
9632           std::string fname(f->getName());
9633           if(tmp==fname)
9634             return i;
9635           else
9636             poss.push_back(fname);
9637         }
9638     }
9639   std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
9640   std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
9641   oss << " !";
9642   throw INTERP_KERNEL::Exception(oss.str().c_str());
9643 }
9644
9645 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
9646 {
9647   if(fs)
9648     {
9649       fs->incrRef();
9650       _nb_iter=fs->getNumberOfFields();
9651     }
9652 }
9653
9654 MEDFileFieldsIterator::~MEDFileFieldsIterator()
9655 {
9656 }
9657
9658 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
9659 {
9660   if(_iter_id<_nb_iter)
9661     {
9662       MEDFileFields *fs(_fs);
9663       if(fs)
9664         return fs->getFieldAtPos(_iter_id++);
9665       else
9666         return 0;
9667     }
9668   else
9669     return 0;
9670 }