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   if(!arr || !arr->isAllocated())
1025     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::assignNodeFieldProfile : input array is null, or not allocated !");
1026   _field_pm_pt_pd.resize(1);
1027   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1028   _field_pm_pt_pd[0]->assignFieldProfile(start,pfl,pfl2,pfl2,-1,field,arr,0,glob,nasc);//mesh is not requested so 0 is send.
1029 }
1030
1031 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, int offset, int nbOfCells) throw(INTERP_KERNEL::Exception)
1032 {
1033   TypeOfField type=field->getTypeOfField();
1034   if(type!=ON_GAUSS_PT)
1035     {
1036       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1037       int sz=_field_pm_pt_pd.size();
1038       bool found=false;
1039       for(int j=0;j<sz && !found;j++)
1040         {
1041           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1042             {
1043               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1044               found=true;
1045             }
1046         }
1047       if(!found)
1048         {
1049           _field_pm_pt_pd.resize(sz+1);
1050           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1051         }
1052       std::vector<int> ret(1,(int)sz);
1053       return ret;
1054     }
1055   else
1056     {
1057       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
1058       int sz2=ret2.size();
1059       std::vector<int> ret3(sz2);
1060       int k=0;
1061       for(int i=0;i<sz2;i++)
1062         {
1063           int sz=_field_pm_pt_pd.size();
1064           int locIdToFind=ret2[i];
1065           bool found=false;
1066           for(int j=0;j<sz && !found;j++)
1067             {
1068               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1069                 {
1070                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1071                   ret3[k++]=j;
1072                   found=true;
1073                 }
1074             }
1075           if(!found)
1076             {
1077               _field_pm_pt_pd.resize(sz+1);
1078               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1079               ret3[k++]=sz;
1080             }
1081         }
1082       return ret3;
1083     }
1084 }
1085
1086 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, int offset, int nbOfCells) throw(INTERP_KERNEL::Exception)
1087 {
1088   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1089   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1090   if(!disc2)
1091     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1092   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1093   if(!da)
1094     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss (no profile) : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1095   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleId2(offset,offset+nbOfCells,1);
1096   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1097   if(retTmp->presenceOfValue(-1))
1098     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1099   std::vector<int> ret(retTmp->begin(),retTmp->end());
1100   return ret;
1101 }
1102
1103 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells) throw(INTERP_KERNEL::Exception)
1104 {
1105   TypeOfField type=field->getTypeOfField();
1106   if(type!=ON_GAUSS_PT)
1107     {
1108       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1109       int sz=_field_pm_pt_pd.size();
1110       bool found=false;
1111       for(int j=0;j<sz && !found;j++)
1112         {
1113           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1114             {
1115               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1116               found=true;
1117             }
1118         }
1119       if(!found)
1120         {
1121           _field_pm_pt_pd.resize(sz+1);
1122           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1123         }
1124       std::vector<int> ret(1,0);
1125       return ret;
1126     }
1127   else
1128     {
1129       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,subCells);
1130       int sz2=ret2.size();
1131       std::vector<int> ret3(sz2);
1132       int k=0;
1133       for(int i=0;i<sz2;i++)
1134         {
1135           int sz=_field_pm_pt_pd.size();
1136           int locIdToFind=ret2[i];
1137           bool found=false;
1138           for(int j=0;j<sz && !found;j++)
1139             {
1140               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1141                 {
1142                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1143                   ret3[k++]=j;
1144                   found=true;
1145                 }
1146             }
1147           if(!found)
1148             {
1149               _field_pm_pt_pd.resize(sz+1);
1150               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1151               ret3[k++]=sz;
1152             }
1153         }
1154       return ret3;
1155     }
1156 }
1157
1158 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells) throw(INTERP_KERNEL::Exception)
1159 {
1160   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1161   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1162   if(!disc2)
1163     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1164   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1165   if(!da)
1166     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1167   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleIdSafe(subCells->getConstPointer(),subCells->getConstPointer()+subCells->getNumberOfTuples());
1168   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1169   if(retTmp->presenceOfValue(-1))
1170     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1171   std::vector<int> ret(retTmp->begin(),retTmp->end());
1172   return ret;
1173 }
1174
1175 const MEDFileFieldPerMesh *MEDFileFieldPerMeshPerType::getFather() const
1176 {
1177   return _father;
1178 }
1179
1180 void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
1181 {
1182   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1183   int curDim=(int)cm.getDimension();
1184   dim=std::max(dim,curDim);
1185 }
1186
1187 void MEDFileFieldPerMeshPerType::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
1188 {
1189   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1190     {
1191       (*it)->fillTypesOfFieldAvailable(types);
1192     }
1193 }
1194
1195 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)
1196 {
1197   int sz=_field_pm_pt_pd.size();
1198   dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
1199   for(int i=0;i<sz;i++)
1200     {
1201       _field_pm_pt_pd[i]->getCoarseData(types[i],dads[i],pfls[i],locs[i]);
1202     }
1203 }
1204
1205 int MEDFileFieldPerMeshPerType::getIteration() const
1206 {
1207   return _father->getIteration();
1208 }
1209
1210 int MEDFileFieldPerMeshPerType::getOrder() const
1211 {
1212   return _father->getOrder();
1213 }
1214
1215 double MEDFileFieldPerMeshPerType::getTime() const
1216 {
1217   return _father->getTime();
1218 }
1219
1220 std::string MEDFileFieldPerMeshPerType::getMeshName() const
1221 {
1222   return _father->getMeshName();
1223 }
1224
1225 void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1226 {
1227   const char startLine[]="  ## ";
1228   std::string startLine2(bkOffset,' ');
1229   std::string startLine3(startLine2);
1230   startLine3+=startLine;
1231   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1232     {
1233       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1234       oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry types " << cm.getRepr() << "." << std::endl;
1235     }
1236   else
1237     oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
1238   oss << startLine3 << "Entry is defined on " <<  _field_pm_pt_pd.size() << " localizations." << std::endl;
1239   int i=0;
1240   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1241     {
1242       const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
1243       if(cur)
1244         cur->simpleRepr(bkOffset,oss,i);
1245       else
1246         {
1247           oss << startLine2 << "    ## " << "Localization #" << i << " is empty !" << std::endl;
1248         }
1249     }
1250 }
1251
1252 void MEDFileFieldPerMeshPerType::getSizes(int& globalSz, int& nbOfEntries) const
1253 {
1254   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1255     {
1256       globalSz+=(*it)->getNumberOfTuples();
1257     }
1258   nbOfEntries+=(int)_field_pm_pt_pd.size();
1259 }
1260
1261 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
1262 {
1263   return _geo_type;
1264 }
1265
1266
1267 int MEDFileFieldPerMeshPerType::getNumberOfComponents() const
1268 {
1269   return _father->getNumberOfComponents();
1270 }
1271
1272 DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray()
1273 {
1274   return _father->getOrCreateAndGetArray();
1275 }
1276
1277 const DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray() const
1278 {
1279   const MEDFileFieldPerMesh *fath=_father;
1280   return fath->getOrCreateAndGetArray();
1281 }
1282
1283 const std::vector<std::string>& MEDFileFieldPerMeshPerType::getInfo() const
1284 {
1285   return _father->getInfo();
1286 }
1287
1288 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsed() const
1289 {
1290   std::vector<std::string> ret;
1291   std::set<std::string> ret2;
1292   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1293     {
1294       std::string tmp=(*it1)->getProfile();
1295       if(!tmp.empty())
1296         if(ret2.find(tmp)==ret2.end())
1297           {
1298             ret.push_back(tmp);
1299             ret2.insert(tmp);
1300           }
1301     }
1302   return ret;
1303 }
1304
1305 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsed() const
1306 {
1307   std::vector<std::string> ret;
1308   std::set<std::string> ret2;
1309   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1310     {
1311       std::string tmp=(*it1)->getLocalization();
1312       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1313         if(ret2.find(tmp)==ret2.end())
1314           {
1315             ret.push_back(tmp);
1316             ret2.insert(tmp);
1317           }
1318     }
1319   return ret;
1320 }
1321
1322 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsedMulti() const
1323 {
1324   std::vector<std::string> ret;
1325   std::set<std::string> ret2;
1326   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1327     {
1328       std::string tmp=(*it1)->getProfile();
1329       if(!tmp.empty())
1330         ret.push_back(tmp);
1331     }
1332   return ret;
1333 }
1334
1335 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsedMulti() const
1336 {
1337   std::vector<std::string> ret;
1338   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1339     {
1340       std::string tmp=(*it1)->getLocalization();
1341       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1342         ret.push_back(tmp);
1343     }
1344   return ret;
1345 }
1346
1347 void MEDFileFieldPerMeshPerType::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1348 {
1349   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1350     (*it1)->changePflsRefsNamesGen(mapOfModif);
1351 }
1352
1353 void MEDFileFieldPerMeshPerType::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1354 {
1355   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1356     (*it1)->changeLocsRefsNamesGen(mapOfModif);
1357 }
1358
1359 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) throw(INTERP_KERNEL::Exception)
1360 {
1361   if(_field_pm_pt_pd.empty())
1362     {
1363       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1364       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1365       throw INTERP_KERNEL::Exception(oss.str().c_str());
1366     }
1367   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1368     return _field_pm_pt_pd[locId];
1369   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1370   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1371   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1372   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1373   return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
1374 }
1375
1376 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) const throw(INTERP_KERNEL::Exception)
1377 {
1378   if(_field_pm_pt_pd.empty())
1379     {
1380       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1381       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1382       throw INTERP_KERNEL::Exception(oss.str().c_str());
1383     }
1384   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1385     return _field_pm_pt_pd[locId];
1386   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1387   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1388   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1389   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1390   return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
1391 }
1392
1393 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
1394 {
1395   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1396     {
1397       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1398       if(meshDim!=(int)cm.getDimension())
1399         return ;
1400     }
1401   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1402     (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
1403 }
1404
1405 void MEDFileFieldPerMeshPerType::fillValues(int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
1406 {
1407   int i=0;
1408   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1409     {
1410       (*it)->fillValues(i,startEntryId,entries);
1411     }
1412 }
1413
1414 void MEDFileFieldPerMeshPerType::setLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves) throw(INTERP_KERNEL::Exception)
1415 {
1416   _field_pm_pt_pd=leaves;
1417   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1418     (*it)->setFather(this);
1419 }
1420
1421 /*!
1422  *  \param [in,out] globalNum a global numbering counter for the renumbering.
1423  *  \param [out] its - list of pair (start,stop) kept
1424  *  \return bool - false if the type of field \a tof is not contained in \a this.
1425  */
1426 bool MEDFileFieldPerMeshPerType::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its) throw(INTERP_KERNEL::Exception)
1427 {
1428   bool ret=false;
1429   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd;
1430   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1431     if((*it)->getType()==tof)
1432       {
1433         newPmPtPd.push_back(*it);
1434         std::pair<int,int> bgEnd; bgEnd.first=(*it)->getStart(); bgEnd.second=(*it)->getEnd();
1435         (*it)->setNewStart(globalNum);
1436         globalNum=(*it)->getEnd();
1437         its.push_back(bgEnd);
1438         ret=true;
1439       }
1440   if(ret)
1441     _field_pm_pt_pd=newPmPtPd;
1442   return ret;
1443 }
1444
1445 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType) throw(INTERP_KERNEL::Exception):_father(fath),_geo_type(geoType)
1446 {
1447 }
1448
1449 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)
1450 {
1451   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1452   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1453   med_geometry_type mgeoti;
1454   med_entity_type menti=ConvertIntoMEDFileType(type,geoType,mgeoti);
1455   int nbProfiles=MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),menti,mgeoti,pflName,locName);
1456   _field_pm_pt_pd.resize(nbProfiles);
1457   for(int i=0;i<nbProfiles;i++)
1458     {
1459       _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,type,i+1);
1460     }
1461 }
1462
1463 void MEDFileFieldPerMeshPerType::loadOnlyStructureOfDataRecursively(med_idt fid, int &start, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1464 {
1465   int pflId=0;
1466   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,pflId++)
1467     {
1468       (*it)->loadOnlyStructureOfDataRecursively(fid,pflId+1,start,nasc);//tony
1469     }
1470 }
1471
1472 void MEDFileFieldPerMeshPerType::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1473 {
1474   int pflId=0;
1475   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,pflId++)
1476     {
1477       (*it)->loadBigArray(fid,pflId+1,nasc);//tony
1478     }
1479 }
1480
1481 void MEDFileFieldPerMeshPerType::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
1482 {
1483   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1484     {
1485       (*it)->copyOptionsFrom(*this);
1486       (*it)->writeLL(fid,nasc);
1487     }
1488 }
1489
1490 med_entity_type MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(TypeOfField ikType, INTERP_KERNEL::NormalizedCellType ikGeoType, med_geometry_type& medfGeoType)
1491 {
1492   switch(ikType)
1493     {
1494     case ON_CELLS:
1495       medfGeoType=typmai3[(int)ikGeoType];
1496       return MED_CELL;
1497     case ON_NODES:
1498       medfGeoType=MED_NONE;
1499       return MED_NODE;
1500     case ON_GAUSS_NE:
1501       medfGeoType=typmai3[(int)ikGeoType];
1502       return MED_NODE_ELEMENT;
1503     case ON_GAUSS_PT:
1504       medfGeoType=typmai3[(int)ikGeoType];
1505       return MED_CELL;
1506     default:
1507       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType : unexpected entity type ! internal error");
1508     }
1509   return MED_UNDEF_ENTITY_TYPE;
1510 }
1511
1512 MEDFileFieldPerMesh *MEDFileFieldPerMesh::NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1513 {
1514   return new MEDFileFieldPerMesh(fid,fath,meshCsit,meshIteration,meshOrder,nasc);
1515 }
1516
1517 MEDFileFieldPerMesh *MEDFileFieldPerMesh::New(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh)
1518 {
1519   return new MEDFileFieldPerMesh(fath,mesh);
1520 }
1521
1522 std::size_t MEDFileFieldPerMesh::getHeapMemorySize() const
1523 {
1524   std::size_t ret=_mesh_name.capacity()+_field_pm_pt.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType >);
1525   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1526     if((const MEDFileFieldPerMeshPerType *)*it)
1527       ret+=(*it)->getHeapMemorySize();
1528   return ret;
1529 }
1530
1531 MEDFileFieldPerMesh *MEDFileFieldPerMesh::deepCpy(MEDFileAnyTypeField1TSWithoutSDA *father) const throw(INTERP_KERNEL::Exception)
1532 {
1533   MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
1534   ret->_father=father;
1535   std::size_t i=0;
1536   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1537     {
1538       if((const MEDFileFieldPerMeshPerType *)*it)
1539         ret->_field_pm_pt[i]=(*it)->deepCpy((MEDFileFieldPerMesh *)(ret));
1540     }
1541   return ret.retn();
1542 }
1543
1544 void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1545 {
1546   std::string startLine(bkOffset,' ');
1547   oss << startLine << "## Field part (" << id << ") lying on mesh \"" << _mesh_name << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
1548   oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
1549   int i=0;
1550   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1551     {
1552       const MEDFileFieldPerMeshPerType *cur=*it;
1553       if(cur)
1554         cur->simpleRepr(bkOffset,oss,i);
1555       else
1556         {
1557           oss << startLine << "  ## Entry geometry type #" << i << " is empty !" << std::endl;
1558         }
1559     }
1560 }
1561
1562 void MEDFileFieldPerMesh::copyTinyInfoFrom(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
1563 {
1564   _mesh_name=mesh->getName();
1565   mesh->getTime(_mesh_iteration,_mesh_order);
1566 }
1567
1568 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)
1569 {
1570   int nbOfTypes=code.size()/3;
1571   int offset=0;
1572   for(int i=0;i<nbOfTypes;i++)
1573     {
1574       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1575       int nbOfCells=code[3*i+1];
1576       int pos=addNewEntryIfNecessary(type);
1577       _field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1578       offset+=nbOfCells;
1579     }
1580 }
1581
1582 /*!
1583  * This method is the most general one. No optimization is done here.
1584  * \param [in] multiTypePfl is the end user profile specified in high level API
1585  * \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].
1586  * \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.
1587  * \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.
1588  * \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.
1589  * \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.
1590  */
1591 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)
1592 {
1593   int nbOfTypes=code.size()/3;
1594   for(int i=0;i<nbOfTypes;i++)
1595     {
1596       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1597       int pos=addNewEntryIfNecessary(type);
1598       DataArrayInt *pfl=0;
1599       if(code[3*i+2]!=-1)
1600         pfl=idsPerType[code[3*i+2]];
1601       int nbOfTupes2=code2.size()/3;
1602       int found=0;
1603       for(;found<nbOfTupes2;found++)
1604         if(code[3*i]==code2[3*found])
1605           break;
1606       if(found==nbOfTupes2)
1607         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::assignFieldProfile : internal problem ! Should never happen ! Please report bug to anthony.geay@cea.fr !");
1608       _field_pm_pt[pos]->assignFieldProfile(start,multiTypePfl,idsInPflPerType[i],pfl,code2[3*found+1],field,arr,mesh,glob,nasc);
1609     }
1610 }
1611
1612 void MEDFileFieldPerMesh::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1613 {
1614   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1615   _field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
1616 }
1617
1618 void MEDFileFieldPerMesh::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1619 {
1620   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1621   _field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,arr,glob,nasc);
1622 }
1623
1624 void MEDFileFieldPerMesh::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1625 {
1626   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1627     (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1628 }
1629
1630 void MEDFileFieldPerMesh::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
1631 {
1632   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1633     (*it)->loadBigArraysRecursively(fid,nasc);
1634 }
1635
1636 void MEDFileFieldPerMesh::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
1637 {
1638   int nbOfTypes=_field_pm_pt.size();
1639   for(int i=0;i<nbOfTypes;i++)
1640     {
1641       _field_pm_pt[i]->copyOptionsFrom(*this);
1642       _field_pm_pt[i]->writeLL(fid,nasc);
1643     }
1644 }
1645
1646 void MEDFileFieldPerMesh::getDimension(int& dim) const
1647 {
1648   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1649     (*it)->getDimension(dim);
1650 }
1651
1652 void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
1653 {
1654   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1655     (*it)->fillTypesOfFieldAvailable(types);
1656 }
1657
1658 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)
1659 {
1660   int sz=_field_pm_pt.size();
1661   std::vector< std::vector<std::pair<int,int> > > ret(sz);
1662   types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
1663   for(int i=0;i<sz;i++)
1664     {
1665       types[i]=_field_pm_pt[i]->getGeoType();
1666       _field_pm_pt[i]->fillFieldSplitedByType(ret[i],typesF[i],pfls[i],locs[i]);
1667     }
1668   return ret;
1669 }
1670
1671 double MEDFileFieldPerMesh::getTime() const
1672 {
1673   int tmp1,tmp2;
1674   return _father->getTime(tmp1,tmp2);
1675 }
1676
1677 int MEDFileFieldPerMesh::getIteration() const
1678 {
1679   return _father->getIteration();
1680 }
1681
1682 int MEDFileFieldPerMesh::getOrder() const
1683 {
1684   return _father->getOrder();
1685 }
1686
1687 int MEDFileFieldPerMesh::getNumberOfComponents() const
1688 {
1689   return _father->getNumberOfComponents();
1690 }
1691
1692 DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray()
1693 {
1694   if(!_father)
1695     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1696   return _father->getOrCreateAndGetArray();
1697 }
1698
1699 const DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray() const
1700 {
1701   if(!_father)
1702     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1703   return _father->getOrCreateAndGetArray();
1704 }
1705
1706 const std::vector<std::string>& MEDFileFieldPerMesh::getInfo() const
1707 {
1708   return _father->getInfo();
1709 }
1710
1711 /*!
1712  * type,geoTypes,dads,pfls,locs are input parameters. They should have the same size.
1713  * 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.
1714  * It returns 2 output vectors :
1715  * - 'code' of size 3*sz where sz is the number of different values into 'geoTypes'
1716  * - 'notNullPfls' contains sz2 values that are extracted from 'pfls' in which null profiles have been removed.
1717  * 'code' and 'notNullPfls' are in MEDCouplingUMesh::checkTypeConsistencyAndContig format.
1718  */
1719 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)
1720 {
1721   int notNullPflsSz=0;
1722   int nbOfArrs=geoTypes.size();
1723   for(int i=0;i<nbOfArrs;i++)
1724     if(pfls[i])
1725       notNullPflsSz++;
1726   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
1727   int nbOfDiffGeoTypes=geoTypes3.size();
1728   code.resize(3*nbOfDiffGeoTypes);
1729   notNullPfls.resize(notNullPflsSz);
1730   notNullPflsSz=0;
1731   int j=0;
1732   for(int i=0;i<nbOfDiffGeoTypes;i++)
1733     {
1734       int startZone=j;
1735       INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
1736       std::vector<const DataArrayInt *> notNullTmp;
1737       if(pfls[j])
1738         notNullTmp.push_back(pfls[j]);
1739       j++;
1740       for(;j<nbOfArrs;j++)
1741         if(geoTypes[j]==refType)
1742           {
1743             if(pfls[j])
1744               notNullTmp.push_back(pfls[j]);
1745           }
1746         else
1747           break;
1748       std::vector< std::pair<int,int> > tmpDads(dads.begin()+startZone,dads.begin()+j);
1749       std::vector<const DataArrayInt *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
1750       std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
1751       code[3*i]=(int)refType;
1752       std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
1753       code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
1754       if(notNullTmp.empty())
1755         code[3*i+2]=-1;
1756       else
1757         {
1758           notNullPfls[notNullPflsSz]=DataArrayInt::Aggregate(notNullTmp);
1759           code[3*i+2]=notNullPflsSz++;
1760         }
1761     }
1762 }
1763
1764 /*!
1765  * 'dads' 'geoTypes' and 'locs' are input parameters that should have same size sz. sz should be >=1.
1766  */
1767 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)
1768 {
1769   int sz=dads.size();
1770   int ret=0;
1771   for(int i=0;i<sz;i++)
1772     {
1773       if(locs[i]==-1)
1774         {
1775           if(type!=ON_GAUSS_NE)
1776             ret+=dads[i].second-dads[i].first;
1777           else
1778             {
1779               const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(geoTypes[i]);
1780               ret+=(dads[i].second-dads[i].first)/cm.getNumberOfNodes();
1781             }
1782         }
1783       else
1784         {
1785           int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
1786           ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
1787         }
1788     }
1789   return ret;
1790 }
1791
1792 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsed() const
1793 {
1794   std::vector<std::string> ret;
1795   std::set<std::string> ret2;
1796   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1797     {
1798       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
1799       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1800         if(ret2.find(*it2)==ret2.end())
1801           {
1802             ret.push_back(*it2);
1803             ret2.insert(*it2);
1804           }
1805     }
1806   return ret;
1807 }
1808
1809 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
1810 {
1811   std::vector<std::string> ret;
1812   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1813     {
1814       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
1815       ret.insert(ret.end(),tmp.begin(),tmp.end());
1816     }
1817   return ret;
1818 }
1819
1820 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsed() const
1821 {
1822   std::vector<std::string> ret;
1823   std::set<std::string> ret2;
1824   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1825     {
1826       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
1827       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1828         if(ret2.find(*it2)==ret2.end())
1829           {
1830             ret.push_back(*it2);
1831             ret2.insert(*it2);
1832           }
1833     }
1834   return ret;
1835 }
1836
1837 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
1838 {
1839   std::vector<std::string> ret;
1840   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1841     {
1842       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
1843       ret.insert(ret.end(),tmp.begin(),tmp.end());
1844     }
1845   return ret;
1846 }
1847
1848 bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
1849 {
1850   for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
1851     {
1852       if((*it).first==_mesh_name)
1853         {
1854           _mesh_name=(*it).second;
1855           return true;
1856         }
1857     }
1858   return false;
1859 }
1860
1861 bool MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
1862                                                       MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1863 {
1864   if(_mesh_name!=meshName)
1865     return false;
1866   std::set<INTERP_KERNEL::NormalizedCellType> typesToKeep;
1867   for(std::size_t i=0;i<oldCode.size()/3;i++) typesToKeep.insert((INTERP_KERNEL::NormalizedCellType)oldCode[3*i]);
1868   std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > > entries;
1869   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKept;
1870   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> otherEntries;
1871   getUndergroundDataArrayExt(entries);
1872   DataArray *arr0=getOrCreateAndGetArray();//tony
1873   if(!arr0)
1874     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values of field is null !");
1875   DataArrayDouble *arr=dynamic_cast<DataArrayDouble *>(arr0);//tony
1876   if(!arr0)
1877     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values is double ! Not managed for the moment !");
1878   int sz=0;
1879   if(!arr)
1880     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
1881   for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >::const_iterator it=entries.begin();it!=entries.end();it++)
1882     {
1883       if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
1884         {
1885           entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1886           sz+=(*it).second.second-(*it).second.first;
1887         }
1888       else
1889         otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1890     }
1891   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumDefrag=DataArrayInt::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
1892   ////////////////////
1893   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInMesh=DataArrayInt::New(); explicitIdsOldInMesh->alloc(sz,1);//sz is a majorant of the real size. A realloc will be done after
1894   int *workI2=explicitIdsOldInMesh->getPointer();
1895   int sz1=0,sz2=0,sid=1;
1896   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptML=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKept);
1897   // std::vector<int> tupleIdOfStartOfNewChuncksV(entriesKeptML.size());
1898   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator itL1=entriesKeptML.begin();itL1!=entriesKeptML.end();itL1++,sid++)
1899     {
1900       //  tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
1901       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInArr=DataArrayInt::New(); explicitIdsOldInArr->alloc(sz,1);
1902       int *workI=explicitIdsOldInArr->getPointer();
1903       for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
1904         {
1905           int delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
1906           (*itL2)->setLocId(sz2);
1907           (*itL2)->_tmp_work1=(*itL2)->getStart();
1908           int delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
1909         }
1910       renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
1911     }
1912   explicitIdsOldInMesh->reAlloc(sz2);
1913   int tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
1914   ////////////////////
1915   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
1916   // perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
1917   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
1918   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
1919     {
1920       otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
1921       otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
1922       otherEntriesNew.back()->setLocId((*it)->getGeoType());
1923     }
1924   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
1925   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
1926   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
1927     {
1928       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
1929       int newStart=elt->getLocId();
1930       elt->setLocId((*it)->getGeoType());
1931       elt->setNewStart(newStart);
1932       elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
1933       entriesKeptNew.push_back(elt);
1934       entriesKeptNew2.push_back(elt);
1935     }
1936   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
1937   // perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
1938   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
1939   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
1940   bool ret=false;
1941   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
1942     {
1943       sid=0;
1944       /*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
1945         {
1946           MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
1947           curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
1948           }*/
1949       ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
1950                                                             glob,arr2,otherEntriesNew) || ret;
1951     }
1952   if(!ret)
1953     return false;
1954   // Assign new dispatching
1955   assignNewLeaves(otherEntriesNew);
1956   arr->cpyFrom(*arr2);
1957   return true;
1958 }
1959
1960 /*!
1961  * \param [in,out] globalNum a global numbering counter for the renumbering.
1962  * \param [out] its - list of pair (start,stop) kept
1963  */
1964 void MEDFileFieldPerMesh::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its) throw(INTERP_KERNEL::Exception)
1965 {
1966   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > ret;
1967   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1968     {
1969       std::vector< std::pair<int,int> > its2;
1970       if((*it)->keepOnlySpatialDiscretization(tof,globalNum,its2))
1971         {
1972           ret.push_back(*it);
1973           its.insert(its.end(),its2.begin(),its2.end());
1974         }
1975     }
1976   _field_pm_pt=ret;
1977 }
1978
1979 void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves) throw(INTERP_KERNEL::Exception)
1980 {
1981   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > > types;
1982   for( std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
1983     types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
1984   //
1985   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > fieldPmPt(types.size());
1986   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
1987   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=fieldPmPt.begin();
1988   for(;it1!=types.end();it1++,it2++)
1989     {
1990       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
1991       elt->setLeaves((*it1).second);
1992       *it2=elt;
1993     }
1994   _field_pm_pt=fieldPmPt;
1995 }
1996
1997 void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1998 {
1999   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2000     (*it)->changePflsRefsNamesGen(mapOfModif);
2001 }
2002
2003 void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2004 {
2005   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2006     (*it)->changeLocsRefsNamesGen(mapOfModif);
2007 }
2008
2009 /*!
2010  * \param [in] mesh is the whole mesh
2011  */
2012 MEDCouplingFieldDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2013 {
2014   if(_field_pm_pt.empty())
2015     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2016   //
2017   std::vector< std::pair<int,int> > dads;
2018   std::vector<const DataArrayInt *> pfls;
2019   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2020   std::vector<int> locs,code;
2021   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2022   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2023     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2024   // Sort by types
2025   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2026   if(code.empty())
2027     {
2028       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2029       throw INTERP_KERNEL::Exception(oss.str().c_str());
2030     }
2031   //
2032   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2033   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2034   if(type!=ON_NODES)
2035     {
2036       DataArrayInt *arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2037       if(!arr)
2038         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2039       else
2040         {
2041           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr);
2042           return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl,arrOut,nasc);
2043         }
2044     }
2045   else
2046     {
2047       if(code.size()!=3)
2048         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2049       int nb=code[1];
2050       if(code[2]==-1)
2051         {
2052           if(nb!=mesh->getNumberOfNodes())
2053             {
2054               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2055               oss << " nodes in mesh !";
2056               throw INTERP_KERNEL::Exception(oss.str().c_str());
2057             }
2058           return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2059         }
2060       else
2061         return finishFieldNode2(glob,dads,locs,mesh,notNullPflsPerGeoType3[0],isPfl,arrOut,nasc);
2062     }
2063 }
2064
2065 DataArray *MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2066 {
2067   if(_field_pm_pt.empty())
2068     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2069   //
2070   std::vector<std::pair<int,int> > dads;
2071   std::vector<const DataArrayInt *> pfls;
2072   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2073   std::vector<int> locs,code;
2074   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2075   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2076     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2077   // Sort by types
2078   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2079   if(code.empty())
2080     {
2081       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2082       throw INTERP_KERNEL::Exception(oss.str().c_str());
2083     }
2084   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2085   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2086   if(type!=ON_NODES)
2087     {
2088       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2089       return finishField4(dads,arr,mesh->getNumberOfCells(),pfl);
2090     }
2091   else
2092     {
2093       if(code.size()!=3)
2094         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2095       int nb=code[1];
2096       if(code[2]==-1)
2097         {
2098           if(nb!=mesh->getNumberOfNodes())
2099             {
2100               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2101               oss << " nodes in mesh !";
2102               throw INTERP_KERNEL::Exception(oss.str().c_str());
2103             }
2104         }
2105       return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
2106     }
2107   //
2108   return 0;
2109 }
2110
2111 void MEDFileFieldPerMesh::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
2112 {
2113   int globalSz=0;
2114   int nbOfEntries=0;
2115   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2116     {
2117       (*it)->getSizes(globalSz,nbOfEntries);
2118     }
2119   entries.resize(nbOfEntries);
2120   nbOfEntries=0;
2121   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2122     {
2123       (*it)->fillValues(nbOfEntries,entries);
2124     }
2125 }
2126
2127 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
2128 {
2129   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2130     {
2131       if((*it)->getGeoType()==typ)
2132         return (*it)->getLeafGivenLocId(locId);
2133     }
2134   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2135   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2136   oss << "Possiblities are : ";
2137   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2138     {
2139       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2140       oss << "\"" << cm2.getRepr() << "\", ";
2141     }
2142   throw INTERP_KERNEL::Exception(oss.str().c_str());
2143 }
2144
2145 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
2146 {
2147   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2148     {
2149       if((*it)->getGeoType()==typ)
2150         return (*it)->getLeafGivenLocId(locId);
2151     }
2152   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2153   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2154   oss << "Possiblities are : ";
2155   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2156     {
2157       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2158       oss << "\"" << cm2.getRepr() << "\", ";
2159     }
2160   throw INTERP_KERNEL::Exception(oss.str().c_str());
2161 }
2162
2163 int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
2164 {
2165   int i=0;
2166   int pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
2167   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=_field_pm_pt.begin();
2168   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
2169     {
2170       INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
2171       if(type==curType)
2172         return i;
2173       else
2174         {
2175           int pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
2176           if(pos>pos2)
2177             it2=it+1;
2178         }
2179     }
2180   int ret=std::distance(_field_pm_pt.begin(),it2);
2181   _field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
2182   return ret;
2183 }
2184
2185 /*!
2186  * 'dads' and 'locs' input parameters have the same number of elements
2187  * \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
2188  */
2189 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2190                                                          const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs,
2191                                                          const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2192 {
2193   isPfl=false;
2194   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(type,ONE_TIME);
2195   ret->setMesh(mesh); ret->setName(nasc.getName().c_str()); ret->setTime(getTime(),getIteration(),getOrder()); ret->setTimeUnit(nasc.getDtUnit().c_str());
2196   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2197   const std::vector<std::string>& infos=getInfo();
2198   da->setInfoOnComponents(infos);
2199   da->setName("");
2200   if(type==ON_GAUSS_PT)
2201     {
2202       int offset=0;
2203       int nbOfArrs=dads.size();
2204       for(int i=0;i<nbOfArrs;i++)
2205         {
2206           std::vector<std::pair<int,int> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
2207           const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
2208           int nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
2209           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> di=DataArrayInt::New();
2210           di->alloc(nbOfElems,1);
2211           di->iota(offset);
2212           const MEDFileFieldLoc& fl=glob->getLocalizationFromId(locs[i]);
2213           ret->setGaussLocalizationOnCells(di->getConstPointer(),di->getConstPointer()+nbOfElems,fl.getRefCoords(),fl.getGaussCoords(),fl.getGaussWeights());
2214           offset+=nbOfElems;
2215         }
2216     }
2217   arrOut=da;
2218   return ret.retn();
2219 }
2220
2221 /*!
2222  * 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.
2223  * 'dads', 'locs' and 'geoTypes' input parameters have the same number of elements.
2224  * No check of this is performed. 'da' array contains an array in old2New style to be applyied to mesh to obtain the right support.
2225  * The order of cells in the returned field is those imposed by the profile.
2226  * \param [in] mesh is the global mesh.
2227  */
2228 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2229                                                           const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2230                                                           const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
2231                                                           const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2232 {
2233   if(da->isIdentity())
2234     {
2235       int nbOfTuples=da->getNumberOfTuples();
2236       if(nbOfTuples==mesh->getNumberOfCells())
2237         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2238     }
2239   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m2=mesh->buildPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2240   m2->setName(mesh->getName());
2241   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(type,glob,dads,locs,m2,isPfl,arrOut,nasc);
2242   isPfl=true;
2243   return ret.retn();
2244 }
2245
2246 /*!
2247  * This method is the complement of MEDFileFieldPerMesh::finishField2 method except that this method works for node profiles.
2248  */
2249 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishFieldNode2(const MEDFileFieldGlobsReal *glob,
2250                                                               const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2251                                                               const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2252 {
2253   if(da->isIdentity())
2254     {
2255       int nbOfTuples=da->getNumberOfTuples();
2256       if(nbOfTuples==mesh->getNumberOfNodes())//No problem for NORM_ERROR because it is in context of node
2257         return finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2258     }
2259   // Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
2260   const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
2261   if(meshu)
2262     {
2263       if(meshu->getNodalConnectivity()==0)
2264         {
2265           MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2266           int nb=da->getNbOfElems();
2267           const int *ptr=da->getConstPointer();
2268           MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
2269           meshuc->allocateCells(nb);
2270           for(int i=0;i<nb;i++)
2271             meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
2272           meshuc->finishInsertingCells();
2273           ret->setMesh(meshuc);
2274           const MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
2275           if(!disc) throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::finishFieldNode2 : internal error, no discretization on field !");
2276           disc->checkCoherencyBetween(meshuc,arrOut);
2277           return ret.retn();
2278         }
2279     }
2280   //
2281   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2282   isPfl=true;
2283   DataArrayInt *arr2=0;
2284   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2285   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
2286   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3(arr2);
2287   int nnodes=mesh2->getNumberOfNodes();
2288   if(nnodes==(int)da->getNbOfElems())
2289     {
2290       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
2291       arrOut->renumberInPlace(da3->getConstPointer());
2292       mesh2->setName(mesh->getName());
2293       ret->setMesh(mesh2);
2294       return ret.retn();
2295     }
2296   else
2297     {
2298       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 !!!";
2299       oss << "So it is impossible to return a well definied MEDCouplingFieldDouble instance on specified mesh on a specified meshDim !" << std::endl;
2300       oss << "To retrieve correctly such a field you have 3 possibilities :" << std::endl;
2301       oss << " - use an another meshDim compatible with the field on nodes (MED file does not have such information)" << std::endl;
2302       oss << " - use an another a meshDimRelToMax equal to 1 -> it will return a mesh with artificial cell POINT1 containing the profile !" << std::endl;
2303       oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
2304       throw INTERP_KERNEL::Exception(oss.str().c_str());
2305     }
2306   return 0;
2307 }
2308
2309 /*!
2310  * This method is the most light method of field retrieving.
2311  */
2312 DataArray *MEDFileFieldPerMesh::finishField4(const std::vector<std::pair<int,int> >& dads, const DataArrayInt *pflIn, int nbOfElems, DataArrayInt *&pflOut) const throw(INTERP_KERNEL::Exception)
2313 {
2314   if(!pflIn)
2315     {
2316       pflOut=DataArrayInt::New();
2317       pflOut->alloc(nbOfElems,1);
2318       pflOut->iota(0);
2319     }
2320   else
2321     {
2322       pflOut=const_cast<DataArrayInt*>(pflIn);
2323       pflOut->incrRef();
2324     }
2325   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> safePfl(pflOut);
2326   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2327   const std::vector<std::string>& infos=getInfo();
2328   int nbOfComp=infos.size();
2329   for(int i=0;i<nbOfComp;i++)
2330     da->setInfoOnComponent(i,infos[i].c_str());
2331   safePfl->incrRef();
2332   return da.retn();
2333 }
2334
2335 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),
2336                                                                                                                                                                                                                  _mesh_csit(meshCsit),_father(fath)
2337 {
2338   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2339   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2340   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2341   for(int i=0;i<MED_N_CELL_FIXED_GEO;i++)
2342     {
2343       int nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL,typmai[i],_mesh_csit,meshName,pflName,locName);
2344       if(nbProfile>0)
2345         {
2346           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[i],nasc));
2347           _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2348         }
2349       nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[i],_mesh_csit,meshName,pflName,locName);
2350       if(nbProfile>0)
2351         {
2352           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_GAUSS_NE,typmai2[i],nasc));
2353           _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2354         }
2355     }
2356   int nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,_mesh_csit,meshName,pflName,locName);
2357   if(nbProfile>0)
2358     {
2359       _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc));
2360       _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2361     }
2362 }
2363
2364 MEDFileFieldPerMesh::MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh):_father(fath)
2365 {
2366   copyTinyInfoFrom(mesh);
2367 }
2368
2369 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int id, const char *pflName) throw(INTERP_KERNEL::Exception)
2370 {
2371   if(id>=(int)_pfls.size())
2372     _pfls.resize(id+1);
2373   _pfls[id]=DataArrayInt::New();
2374   int lgth=MEDprofileSizeByName(fid,pflName);
2375   _pfls[id]->setName(pflName);
2376   _pfls[id]->alloc(lgth,1);
2377   MEDprofileRd(fid,pflName,_pfls[id]->getPointer());
2378   _pfls[id]->applyLin(1,-1,0);//Converting into C format
2379 }
2380
2381 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int i)
2382 {
2383   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2384   int sz;
2385   MEDprofileInfo(fid,i+1,pflName,&sz);
2386   std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
2387   if(i>=(int)_pfls.size())
2388     _pfls.resize(i+1);
2389   _pfls[i]=DataArrayInt::New();
2390   _pfls[i]->alloc(sz,1);
2391   _pfls[i]->setName(pflCpp.c_str());
2392   MEDprofileRd(fid,pflName,_pfls[i]->getPointer());
2393   _pfls[i]->applyLin(1,-1,0);//Converting into C format
2394 }
2395
2396 void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const throw(INTERP_KERNEL::Exception)
2397 {
2398   int nbOfPfls=_pfls.size();
2399   for(int i=0;i<nbOfPfls;i++)
2400     {
2401       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cpy=_pfls[i]->deepCpy();
2402       cpy->applyLin(1,1,0);
2403       INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2404       MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
2405       MEDprofileWr(fid,pflName,_pfls[i]->getNumberOfTuples(),cpy->getConstPointer());
2406     }
2407   //
2408   int nbOfLocs=_locs.size();
2409   for(int i=0;i<nbOfLocs;i++)
2410     _locs[i]->writeLL(fid);
2411 }
2412
2413 void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps) throw(INTERP_KERNEL::Exception)
2414 {
2415   std::vector<std::string> pfls=getPfls();
2416   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
2417     {
2418       std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
2419       if(it2==pfls.end())
2420         {
2421           _pfls.push_back(*it);
2422         }
2423       else
2424         {
2425           int id=std::distance(pfls.begin(),it2);
2426           if(!(*it)->isEqual(*_pfls[id]))
2427             {
2428               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2429               throw INTERP_KERNEL::Exception(oss.str().c_str());
2430             }
2431         }
2432     }
2433   std::vector<std::string> locs=getLocs();
2434   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=other._locs.begin();it!=other._locs.end();it++)
2435     {
2436       std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
2437       if(it2==locs.end())
2438         {
2439           _locs.push_back(*it);
2440         }
2441       else
2442         {
2443           int id=std::distance(locs.begin(),it2);
2444           if(!(*it)->isEqual(*_locs[id],eps))
2445             {
2446               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2447               throw INTERP_KERNEL::Exception(oss.str().c_str());
2448             }
2449         }
2450     }
2451 }
2452
2453 void MEDFileFieldGlobs::checkGlobsPflsPartCoherency(const std::vector<std::string>& pflsUsed) const throw(INTERP_KERNEL::Exception)
2454 {
2455   for(std::vector<std::string>::const_iterator it=pflsUsed.begin();it!=pflsUsed.end();it++)
2456     getProfile((*it).c_str());
2457 }
2458
2459 void MEDFileFieldGlobs::checkGlobsLocsPartCoherency(const std::vector<std::string>& locsUsed) const throw(INTERP_KERNEL::Exception)
2460 {
2461   for(std::vector<std::string>::const_iterator it=locsUsed.begin();it!=locsUsed.end();it++)
2462     getLocalization((*it).c_str());
2463 }
2464
2465 void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real) throw(INTERP_KERNEL::Exception)
2466 {
2467   std::vector<std::string> profiles=real.getPflsReallyUsed();
2468   int sz=profiles.size();
2469   _pfls.resize(sz);
2470   for(int i=0;i<sz;i++)
2471     loadProfileInFile(fid,i,profiles[i].c_str());
2472   //
2473   std::vector<std::string> locs=real.getLocsReallyUsed();
2474   sz=locs.size();
2475   _locs.resize(sz);
2476   for(int i=0;i<sz;i++)
2477     _locs[i]=MEDFileFieldLoc::New(fid,locs[i].c_str());
2478 }
2479
2480 void MEDFileFieldGlobs::loadAllGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
2481 {
2482   int nProfil=MEDnProfile(fid);
2483   for(int i=0;i<nProfil;i++)
2484     loadProfileInFile(fid,i);
2485   int sz=MEDnLocalization(fid);
2486   _locs.resize(sz);
2487   for(int i=0;i<sz;i++)
2488     {
2489       _locs[i]=MEDFileFieldLoc::New(fid,i);
2490     }
2491 }
2492
2493 MEDFileFieldGlobs *MEDFileFieldGlobs::New(const char *fname)
2494 {
2495   return new MEDFileFieldGlobs(fname);
2496 }
2497
2498 MEDFileFieldGlobs *MEDFileFieldGlobs::New()
2499 {
2500   return new MEDFileFieldGlobs;
2501 }
2502
2503 std::size_t MEDFileFieldGlobs::getHeapMemorySize() const
2504 {
2505   std::size_t ret=_file_name.capacity()+_pfls.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<DataArrayInt>)+_locs.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>);
2506   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2507     ret+=(*it)->getHeapMemorySize();
2508   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2509     ret+=(*it)->getHeapMemorySize();
2510   return ret;
2511 }
2512
2513 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpy() const throw(INTERP_KERNEL::Exception)
2514 {
2515   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
2516   std::size_t i=0;
2517   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2518     {
2519       if((const DataArrayInt *)*it)
2520         ret->_pfls[i]=(*it)->deepCpy();
2521     }
2522   i=0;
2523   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2524     {
2525       if((const MEDFileFieldLoc*)*it)
2526         ret->_locs[i]=(*it)->deepCpy();
2527     }
2528   return ret.retn();
2529 }
2530
2531 /*!
2532  * \throw if a profile in \a pfls in not in \a this.
2533  * \throw if a localization in \a locs in not in \a this.
2534  * \sa MEDFileFieldGlobs::deepCpyPart
2535  */
2536 MEDFileFieldGlobs *MEDFileFieldGlobs::shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const throw(INTERP_KERNEL::Exception)
2537 {
2538   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2539   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2540     {
2541       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2542       if(!pfl)
2543         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! pfl null !");
2544       pfl->incrRef();
2545       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2(pfl);
2546       ret->_pfls.push_back(pfl2);
2547     }
2548   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2549     {
2550       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2551       if(!loc)
2552         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! loc null !");
2553       loc->incrRef();
2554       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> loc2(loc);
2555       ret->_locs.push_back(loc2);
2556     }
2557   ret->setFileName(getFileName());
2558   return ret.retn();
2559 }
2560
2561 /*!
2562  * \throw if a profile in \a pfls in not in \a this.
2563  * \throw if a localization in \a locs in not in \a this.
2564  * \sa MEDFileFieldGlobs::shallowCpyPart
2565  */
2566 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const throw(INTERP_KERNEL::Exception)
2567 {
2568   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2569   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2570     {
2571       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2572       if(!pfl)
2573         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! pfl null !");
2574       ret->_pfls.push_back(pfl->deepCpy());
2575     }
2576   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2577     {
2578       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2579       if(!loc)
2580         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! loc null !");
2581       ret->_locs.push_back(loc->deepCpy());
2582     }
2583   ret->setFileName(getFileName());
2584   return ret.retn();
2585 }
2586
2587 MEDFileFieldGlobs::MEDFileFieldGlobs(const char *fname):_file_name(fname)
2588 {
2589 }
2590
2591 MEDFileFieldGlobs::MEDFileFieldGlobs()
2592 {
2593 }
2594
2595 MEDFileFieldGlobs::~MEDFileFieldGlobs()
2596 {
2597 }
2598
2599 void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
2600 {
2601   oss << "Profiles :\n";
2602   std::size_t n=_pfls.size();
2603   for(std::size_t i=0;i<n;i++)
2604     {
2605       oss << "  - #" << i << " ";
2606       const DataArrayInt *pfl=_pfls[i];
2607       if(pfl)
2608         oss << "\"" << pfl->getName() << "\"\n";
2609       else
2610         oss << "EMPTY !\n";
2611     }
2612   n=_locs.size();
2613   oss << "Localizations :\n";
2614   for(std::size_t i=0;i<n;i++)
2615     {
2616       oss << "  - #" << i << " ";
2617       const MEDFileFieldLoc *loc=_locs[i];
2618       if(loc)
2619         loc->simpleRepr(oss);
2620       else
2621         oss<< "EMPTY !\n";
2622     }
2623 }
2624
2625 void MEDFileFieldGlobs::setFileName(const char *fileName)
2626 {
2627   _file_name=fileName;
2628 }
2629
2630 void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2631 {
2632   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
2633     {
2634       DataArrayInt *elt(*it);
2635       if(elt)
2636         {
2637           std::string name(elt->getName());
2638           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2639             {
2640               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2641                 {
2642                   elt->setName((*it2).second.c_str());
2643                   return;
2644                 }
2645             }
2646         }
2647     }
2648 }
2649
2650 void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2651 {
2652   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
2653     {
2654       MEDFileFieldLoc *elt(*it);
2655       if(elt)
2656         {
2657           std::string name(elt->getName());
2658           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2659             {
2660               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2661                 {
2662                   elt->setName((*it2).second.c_str());
2663                   return;
2664                 }
2665             }
2666         }
2667     }
2668 }
2669
2670 int MEDFileFieldGlobs::getNbOfGaussPtPerCell(int locId) const throw(INTERP_KERNEL::Exception)
2671 {
2672   if(locId<0 || locId>=(int)_locs.size())
2673     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getNbOfGaussPtPerCell : Invalid localization id !");
2674   return _locs[locId]->getNbOfGaussPtPerCell();
2675 }
2676
2677 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName) const throw(INTERP_KERNEL::Exception)
2678 {
2679   return getLocalizationFromId(getLocalizationId(locName));
2680 }
2681
2682 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) const throw(INTERP_KERNEL::Exception)
2683 {
2684   if(locId<0 || locId>=(int)_locs.size())
2685     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2686   return *_locs[locId];
2687 }
2688
2689 namespace ParaMEDMEMImpl
2690 {
2691   class LocFinder
2692   {
2693   public:
2694     LocFinder(const char *loc):_loc(loc) { }
2695     bool operator() (const MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>& loc) { return loc->isName(_loc); }
2696   private:
2697     const char *_loc;
2698   };
2699
2700   class PflFinder
2701   {
2702   public:
2703     PflFinder(const std::string& pfl):_pfl(pfl) { }
2704     bool operator() (const MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& pfl) { return _pfl==pfl->getName(); }
2705   private:
2706     const std::string& _pfl;
2707   };
2708 }
2709
2710 int MEDFileFieldGlobs::getLocalizationId(const char *loc) const throw(INTERP_KERNEL::Exception)
2711 {
2712   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),ParaMEDMEMImpl::LocFinder(loc));
2713   if(it==_locs.end())
2714     {
2715       std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
2716       for(it=_locs.begin();it!=_locs.end();it++)
2717         oss << "\"" << (*it)->getName() << "\", ";
2718       throw INTERP_KERNEL::Exception(oss.str().c_str());
2719     }
2720   return std::distance(_locs.begin(),it);
2721 }
2722
2723 /*!
2724  * The returned value is never null.
2725  */
2726 const DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName) const throw(INTERP_KERNEL::Exception)
2727 {
2728   std::string pflNameCpp(pflName);
2729   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2730   if(it==_pfls.end())
2731     {
2732       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2733       for(it=_pfls.begin();it!=_pfls.end();it++)
2734         oss << "\"" << (*it)->getName() << "\", ";
2735       throw INTERP_KERNEL::Exception(oss.str().c_str());
2736     }
2737   return *it;
2738 }
2739
2740 const DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) const throw(INTERP_KERNEL::Exception)
2741 {
2742   if(pflId<0 || pflId>=(int)_pfls.size())
2743     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2744   return _pfls[pflId];
2745 }
2746
2747 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) throw(INTERP_KERNEL::Exception)
2748 {
2749   if(locId<0 || locId>=(int)_locs.size())
2750     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2751   return *_locs[locId];
2752 }
2753
2754 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName) throw(INTERP_KERNEL::Exception)
2755 {
2756   return getLocalizationFromId(getLocalizationId(locName));
2757 }
2758
2759 /*!
2760  * The returned value is never null.
2761  */
2762 DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName) throw(INTERP_KERNEL::Exception)
2763 {
2764   std::string pflNameCpp(pflName);
2765   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2766   if(it==_pfls.end())
2767     {
2768       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2769       for(it=_pfls.begin();it!=_pfls.end();it++)
2770         oss << "\"" << (*it)->getName() << "\", ";
2771       throw INTERP_KERNEL::Exception(oss.str().c_str());
2772     }
2773   return *it;
2774 }
2775
2776 DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) throw(INTERP_KERNEL::Exception)
2777 {
2778   if(pflId<0 || pflId>=(int)_pfls.size())
2779     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2780   return _pfls[pflId];
2781 }
2782
2783 void MEDFileFieldGlobs::killProfileIds(const std::vector<int>& pflIds) throw(INTERP_KERNEL::Exception)
2784 {
2785   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newPfls;
2786   int i=0;
2787   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2788     {
2789       if(std::find(pflIds.begin(),pflIds.end(),i)==pflIds.end())
2790         newPfls.push_back(*it);
2791     }
2792   _pfls=newPfls;
2793 }
2794
2795 void MEDFileFieldGlobs::killLocalizationIds(const std::vector<int>& locIds) throw(INTERP_KERNEL::Exception)
2796 {
2797   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> > newLocs;
2798   int i=0;
2799   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2800     {
2801       if(std::find(locIds.begin(),locIds.end(),i)==locIds.end())
2802         newLocs.push_back(*it);
2803     }
2804   _locs=newLocs;
2805 }
2806
2807 std::vector<std::string> MEDFileFieldGlobs::getPfls() const
2808 {
2809   int sz=_pfls.size();
2810   std::vector<std::string> ret(sz);
2811   for(int i=0;i<sz;i++)
2812     ret[i]=_pfls[i]->getName();
2813   return ret;
2814 }
2815
2816 std::vector<std::string> MEDFileFieldGlobs::getLocs() const
2817 {
2818   int sz=_locs.size();
2819   std::vector<std::string> ret(sz);
2820   for(int i=0;i<sz;i++)
2821     ret[i]=_locs[i]->getName();
2822   return ret;
2823 }
2824
2825 bool MEDFileFieldGlobs::existsPfl(const char *pflName) const
2826 {
2827   std::vector<std::string> v=getPfls();
2828   std::string s(pflName);
2829   return std::find(v.begin(),v.end(),s)!=v.end();
2830 }
2831
2832 bool MEDFileFieldGlobs::existsLoc(const char *locName) const
2833 {
2834   std::vector<std::string> v=getLocs();
2835   std::string s(locName);
2836   return std::find(v.begin(),v.end(),s)!=v.end();
2837 }
2838
2839 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualProfiles() const
2840 {
2841   std::map<int,std::vector<int> > m;
2842   int i=0;
2843   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2844     {
2845       const DataArrayInt *tmp=(*it);
2846       if(tmp)
2847         {
2848           m[tmp->getHashCode()].push_back(i);
2849         }
2850     }
2851   std::vector< std::vector<int> > ret;
2852   for(std::map<int,std::vector<int> >::const_iterator it2=m.begin();it2!=m.end();it2++)
2853     {
2854       if((*it2).second.size()>1)
2855         {
2856           std::vector<int> ret0;
2857           bool equalityOrNot=false;
2858           for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
2859             {
2860               std::vector<int>::const_iterator it4=it3; it4++;
2861               for(;it4!=(*it2).second.end();it4++)
2862                 {
2863                   if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
2864                     {
2865                       if(!equalityOrNot)
2866                         ret0.push_back(*it3);
2867                       ret0.push_back(*it4);
2868                       equalityOrNot=true;
2869                     }
2870                 }
2871             }
2872           if(!ret0.empty())
2873             ret.push_back(ret0);
2874         }
2875     }
2876   return ret;
2877 }
2878
2879 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
2880 {
2881   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
2882 }
2883
2884 void MEDFileFieldGlobs::appendProfile(DataArrayInt *pfl) throw(INTERP_KERNEL::Exception)
2885 {
2886   std::string name(pfl->getName());
2887   if(name.empty())
2888     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
2889   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2890     if(name==(*it)->getName())
2891       {
2892         if(!pfl->isEqual(*(*it)))
2893           {
2894             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
2895             throw INTERP_KERNEL::Exception(oss.str().c_str());
2896           }
2897       }
2898   pfl->incrRef();
2899   _pfls.push_back(pfl);
2900 }
2901
2902 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)
2903 {
2904   std::string name(locName);
2905   if(name.empty())
2906     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
2907   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
2908   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2909     if((*it)->isName(locName))
2910       {
2911         if(!(*it)->isEqual(*obj,1e-12))
2912           {
2913             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
2914             throw INTERP_KERNEL::Exception(oss.str().c_str());
2915           }
2916       }
2917   _locs.push_back(obj);
2918 }
2919
2920 std::string MEDFileFieldGlobs::createNewNameOfPfl() const throw(INTERP_KERNEL::Exception)
2921 {
2922   std::vector<std::string> names=getPfls();
2923   return CreateNewNameNotIn("NewPfl_",names);
2924 }
2925
2926 std::string MEDFileFieldGlobs::createNewNameOfLoc() const throw(INTERP_KERNEL::Exception)
2927 {
2928   std::vector<std::string> names=getLocs();
2929   return CreateNewNameNotIn("NewLoc_",names);
2930 }
2931
2932 std::string MEDFileFieldGlobs::CreateNewNameNotIn(const char *prefix, const std::vector<std::string>& namesToAvoid) throw(INTERP_KERNEL::Exception)
2933 {
2934   for(std::size_t sz=0;sz<100000;sz++)
2935     {
2936       std::ostringstream tryName;
2937       tryName << prefix << sz;
2938       if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tryName.str())==namesToAvoid.end())
2939         return tryName.str();
2940     }
2941   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::CreateNewNameNotIn : impossible to create an additional profile limit of 100000 profiles reached !");
2942 }
2943
2944 /*!
2945  * Creates a MEDFileFieldGlobsReal on a given file name. Nothing is read here.
2946  *  \param [in] fname - the file name.
2947  */
2948 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal(const char *fname):_globals(MEDFileFieldGlobs::New(fname))
2949 {
2950 }
2951
2952 /*!
2953  * Creates an empty MEDFileFieldGlobsReal.
2954  */
2955 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal():_globals(MEDFileFieldGlobs::New())
2956 {
2957 }
2958
2959 std::size_t MEDFileFieldGlobsReal::getHeapMemorySize() const
2960 {
2961   std::size_t ret=0;
2962   if((const MEDFileFieldGlobs *)_globals)
2963     ret+=_globals->getHeapMemorySize();
2964   return ret;
2965 }
2966
2967 /*!
2968  * Returns a string describing profiles and Gauss points held in \a this.
2969  *  \return std::string - the description string.
2970  */
2971 void MEDFileFieldGlobsReal::simpleReprGlobs(std::ostream& oss) const
2972 {
2973   const MEDFileFieldGlobs *glob=_globals;
2974   std::ostringstream oss2; oss2 << glob;
2975   std::string stars(oss2.str().length(),'*');
2976   oss << "Globals information on fields (at " << oss2.str() << "):" << "\n************************************" << stars  << "\n\n";
2977   if(glob)
2978     glob->simpleRepr(oss);
2979   else
2980     oss << "NO GLOBAL INFORMATION !\n";
2981 }
2982
2983 void MEDFileFieldGlobsReal::resetContent()
2984 {
2985   _globals=MEDFileFieldGlobs::New();
2986 }
2987
2988 MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
2989 {
2990 }
2991
2992 /*!
2993  * Copies references to profiles and Gauss points from another MEDFileFieldGlobsReal.
2994  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
2995  */
2996 void MEDFileFieldGlobsReal::shallowCpyGlobs(const MEDFileFieldGlobsReal& other)
2997 {
2998   _globals=other._globals;
2999 }
3000
3001 /*!
3002  * Copies references to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3003  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3004  */
3005 void MEDFileFieldGlobsReal::shallowCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other) throw(INTERP_KERNEL::Exception)
3006 {
3007   const MEDFileFieldGlobs *otherg(other._globals);
3008   if(!otherg)
3009     return ;
3010   _globals=otherg->shallowCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3011 }
3012
3013 /*!
3014  * Copies deeply to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3015  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3016  */
3017 void MEDFileFieldGlobsReal::deepCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other) throw(INTERP_KERNEL::Exception)
3018 {
3019   const MEDFileFieldGlobs *otherg(other._globals);
3020   if(!otherg)
3021     return ;
3022   _globals=otherg->deepCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3023 }
3024
3025 void MEDFileFieldGlobsReal::deepCpyGlobs(const MEDFileFieldGlobsReal& other)
3026 {
3027   _globals=other._globals;
3028   if((const MEDFileFieldGlobs *)_globals)
3029     _globals=other._globals->deepCpy();
3030 }
3031
3032 /*!
3033  * Adds profiles and Gauss points held by another MEDFileFieldGlobsReal to \a this one.
3034  *  \param [in] other - the MEDFileFieldGlobsReal to copy data from.
3035  *  \param [in] eps - a precision used to compare Gauss points with same name held by
3036  *         \a this and \a other MEDFileFieldGlobsReal.
3037  *  \throw If \a this and \a other hold profiles with equal names but different ids.
3038  *  \throw If  \a this and \a other hold different Gauss points with equal names.
3039  */
3040 void MEDFileFieldGlobsReal::appendGlobs(const MEDFileFieldGlobsReal& other, double eps) throw(INTERP_KERNEL::Exception)
3041 {
3042   const MEDFileFieldGlobs *thisGlobals(_globals),*otherGlobals(other._globals);
3043   if(thisGlobals==otherGlobals)
3044     return ;
3045   if(!thisGlobals)
3046     {
3047       _globals=other._globals;
3048       return ;
3049     }
3050   _globals->appendGlobs(*other._globals,eps);
3051 }
3052
3053 void MEDFileFieldGlobsReal::checkGlobsCoherency() const throw(INTERP_KERNEL::Exception)
3054 {
3055   checkGlobsPflsPartCoherency();
3056   checkGlobsLocsPartCoherency();
3057 }
3058
3059 void MEDFileFieldGlobsReal::checkGlobsPflsPartCoherency() const throw(INTERP_KERNEL::Exception)
3060 {
3061   contentNotNull()->checkGlobsPflsPartCoherency(getPflsReallyUsed());
3062 }
3063
3064 void MEDFileFieldGlobsReal::checkGlobsLocsPartCoherency() const throw(INTERP_KERNEL::Exception)
3065 {
3066   contentNotNull()->checkGlobsLocsPartCoherency(getLocsReallyUsed());
3067 }
3068
3069 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id, const char *pflName) throw(INTERP_KERNEL::Exception)
3070 {
3071   contentNotNull()->loadProfileInFile(fid,id,pflName);
3072 }
3073
3074 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id)
3075 {
3076   contentNotNull()->loadProfileInFile(fid,id);
3077 }
3078
3079 void MEDFileFieldGlobsReal::loadGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
3080 {
3081   contentNotNull()->loadGlobals(fid,*this);
3082 }
3083
3084 void MEDFileFieldGlobsReal::loadAllGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
3085 {
3086   contentNotNull()->loadAllGlobals(fid);
3087 }
3088
3089 void MEDFileFieldGlobsReal::writeGlobals(med_idt fid, const MEDFileWritable& opt) const throw(INTERP_KERNEL::Exception)
3090 {
3091   contentNotNull()->writeGlobals(fid,opt);
3092 }
3093
3094 /*!
3095  * Returns names of all profiles. To get only used profiles call getPflsReallyUsed()
3096  * or getPflsReallyUsedMulti().
3097  *  \return std::vector<std::string> - a sequence of names of all profiles.
3098  */
3099 std::vector<std::string> MEDFileFieldGlobsReal::getPfls() const
3100 {
3101   return contentNotNull()->getPfls();
3102 }
3103
3104 /*!
3105  * Returns names of all localizations. To get only used localizations call getLocsReallyUsed()
3106  * or getLocsReallyUsedMulti().
3107  *  \return std::vector<std::string> - a sequence of names of all localizations.
3108  */
3109 std::vector<std::string> MEDFileFieldGlobsReal::getLocs() const
3110 {
3111   return contentNotNull()->getLocs();
3112 }
3113
3114 /*!
3115  * Checks if the profile with a given name exists.
3116  *  \param [in] pflName - the profile name of interest.
3117  *  \return bool - \c true if the profile named \a pflName exists.
3118  */
3119 bool MEDFileFieldGlobsReal::existsPfl(const char *pflName) const
3120 {
3121   return contentNotNull()->existsPfl(pflName);
3122 }
3123
3124 /*!
3125  * Checks if the localization with a given name exists.
3126  *  \param [in] locName - the localization name of interest.
3127  *  \return bool - \c true if the localization named \a locName exists.
3128  */
3129 bool MEDFileFieldGlobsReal::existsLoc(const char *locName) const
3130 {
3131   return contentNotNull()->existsLoc(locName);
3132 }
3133
3134 std::string MEDFileFieldGlobsReal::createNewNameOfPfl() const throw(INTERP_KERNEL::Exception)
3135 {
3136   return contentNotNull()->createNewNameOfPfl();
3137 }
3138
3139 std::string MEDFileFieldGlobsReal::createNewNameOfLoc() const throw(INTERP_KERNEL::Exception)
3140 {
3141   return contentNotNull()->createNewNameOfLoc();
3142 }
3143
3144 /*!
3145  * Sets the name of a MED file.
3146  *  \param [inout] fileName - the file name.
3147  */
3148 void MEDFileFieldGlobsReal::setFileName(const char *fileName)
3149 {
3150   contentNotNull()->setFileName(fileName);
3151 }
3152
3153 /*!
3154  * Finds equal profiles. Two profiles are considered equal if they contain the same ids
3155  * in the same order.
3156  *  \return std::vector< std::vector<int> > - a sequence of groups of equal profiles.
3157  *          Each item of this sequence is a vector containing ids of equal profiles.
3158  */
3159 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualProfiles() const
3160 {
3161   return contentNotNull()->whichAreEqualProfiles();
3162 }
3163
3164 /*!
3165  * Finds equal localizations.
3166  *  \param [in] eps - a precision used to compare real values of the localizations.
3167  *  \return std::vector< std::vector<int> > - a sequence of groups of equal localizations.
3168  *          Each item of this sequence is a vector containing ids of equal localizations.
3169  */
3170 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualLocs(double eps) const
3171 {
3172   return contentNotNull()->whichAreEqualLocs(eps);
3173 }
3174
3175 /*!
3176  * Renames the profiles. References to profiles (a reference is a profile name) are not changed.
3177  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3178  *        this sequence is a pair whose
3179  *        - the first item is a vector of profile names to replace by the second item,
3180  *        - the second item is a profile name to replace every profile name of the first item.
3181  */
3182 void MEDFileFieldGlobsReal::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3183 {
3184   contentNotNull()->changePflsNamesInStruct(mapOfModif);
3185 }
3186
3187 /*!
3188  * Renames the localizations. References to localizations (a reference is a localization name) are not changed.
3189  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3190  *        this sequence is a pair whose
3191  *        - the first item is a vector of localization names to replace by the second item,
3192  *        - the second item is a localization name to replace every localization name of the first item.
3193  */
3194 void MEDFileFieldGlobsReal::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3195 {
3196   contentNotNull()->changeLocsNamesInStruct(mapOfModif);
3197 }
3198
3199 /*!
3200  * Replaces references to some profiles (a reference is a profile name) by references
3201  * to other profiles and, contrary to changePflsRefsNamesGen(), renames the profiles
3202  * them-selves accordingly. <br>
3203  * This method is a generalization of changePflName().
3204  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3205  *        this sequence is a pair whose
3206  *        - the first item is a vector of profile names to replace by the second item,
3207  *        - the second item is a profile name to replace every profile of the first item.
3208  * \sa changePflsRefsNamesGen()
3209  * \sa changePflName()
3210  */
3211 void MEDFileFieldGlobsReal::changePflsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3212 {
3213   changePflsRefsNamesGen(mapOfModif);
3214   changePflsNamesInStruct(mapOfModif);
3215 }
3216
3217 /*!
3218  * Replaces references to some localizations (a reference is a localization name) by references
3219  * to other localizations and, contrary to changeLocsRefsNamesGen(), renames the localizations
3220  * them-selves accordingly. <br>
3221  * This method is a generalization of changeLocName().
3222  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3223  *        this sequence is a pair whose
3224  *        - the first item is a vector of localization names to replace by the second item,
3225  *        - the second item is a localization name to replace every localization of the first item.
3226  * \sa changeLocsRefsNamesGen()
3227  * \sa changeLocName()
3228  */
3229 void MEDFileFieldGlobsReal::changeLocsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3230 {
3231   changeLocsRefsNamesGen(mapOfModif);
3232   changeLocsNamesInStruct(mapOfModif);
3233 }
3234
3235 /*!
3236  * Renames the profile having a given name and updates references to this profile.
3237  *  \param [in] oldName - the name of the profile to rename.
3238  *  \param [in] newName - a new name of the profile.
3239  * \sa changePflsNames().
3240  */
3241 void MEDFileFieldGlobsReal::changePflName(const char *oldName, const char *newName) throw(INTERP_KERNEL::Exception)
3242 {
3243   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3244   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3245   mapOfModif[0]=p;
3246   changePflsNames(mapOfModif);
3247 }
3248
3249 /*!
3250  * Renames the localization having a given name and updates references to this localization.
3251  *  \param [in] oldName - the name of the localization to rename.
3252  *  \param [in] newName - a new name of the localization.
3253  * \sa changeLocsNames().
3254  */
3255 void MEDFileFieldGlobsReal::changeLocName(const char *oldName, const char *newName) throw(INTERP_KERNEL::Exception)
3256 {
3257   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3258   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3259   mapOfModif[0]=p;
3260   changeLocsNames(mapOfModif);
3261 }
3262
3263 /*!
3264  * Removes duplicated profiles. Returns a map used to update references to removed
3265  * profiles via changePflsRefsNamesGen().
3266  * Equal profiles are found using whichAreEqualProfiles().
3267  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3268  *          a sequence describing the performed replacements of profiles. Each element of
3269  *          this sequence is a pair whose
3270  *          - the first item is a vector of profile names replaced by the second item,
3271  *          - the second item is a profile name replacing every profile of the first item.
3272  */
3273 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipPflsNames() throw(INTERP_KERNEL::Exception)
3274 {
3275   std::vector< std::vector<int> > pseudoRet=whichAreEqualProfiles();
3276   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3277   int i=0;
3278   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3279     {
3280       std::vector< std::string > tmp((*it).size());
3281       int j=0;
3282       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3283         tmp[j]=std::string(getProfileFromId(*it2)->getName());
3284       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3285       ret[i]=p;
3286       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3287       killProfileIds(tmp2);
3288     }
3289   changePflsRefsNamesGen(ret);
3290   return ret;
3291 }
3292
3293 /*!
3294  * Removes duplicated localizations. Returns a map used to update references to removed
3295  * localizations via changeLocsRefsNamesGen().
3296  * Equal localizations are found using whichAreEqualLocs().
3297  *  \param [in] eps - a precision used to compare real values of the localizations.
3298  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3299  *          a sequence describing the performed replacements of localizations. Each element of
3300  *          this sequence is a pair whose
3301  *          - the first item is a vector of localization names replaced by the second item,
3302  *          - the second item is a localization name replacing every localization of the first item.
3303  */
3304 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipLocsNames(double eps) throw(INTERP_KERNEL::Exception)
3305 {
3306   std::vector< std::vector<int> > pseudoRet=whichAreEqualLocs(eps);
3307   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3308   int i=0;
3309   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3310     {
3311       std::vector< std::string > tmp((*it).size());
3312       int j=0;
3313       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3314         tmp[j]=std::string(getLocalizationFromId(*it2).getName());
3315       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3316       ret[i]=p;
3317       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3318       killLocalizationIds(tmp2);
3319     }
3320   changeLocsRefsNamesGen(ret);
3321   return ret;
3322 }
3323
3324 /*!
3325  * Returns number of Gauss points per cell in a given localization.
3326  *  \param [in] locId - an id of the localization of interest.
3327  *  \return int - the number of the Gauss points per cell.
3328  */
3329 int MEDFileFieldGlobsReal::getNbOfGaussPtPerCell(int locId) const throw(INTERP_KERNEL::Exception)
3330 {
3331   return contentNotNull()->getNbOfGaussPtPerCell(locId);
3332 }
3333
3334 /*!
3335  * Returns an id of a localization by its name.
3336  *  \param [in] loc - the localization name of interest.
3337  *  \return int - the id of the localization.
3338  *  \throw If there is no a localization named \a loc.
3339  */
3340 int MEDFileFieldGlobsReal::getLocalizationId(const char *loc) const throw(INTERP_KERNEL::Exception)
3341 {
3342   return contentNotNull()->getLocalizationId(loc);
3343 }
3344
3345 /*!
3346  * Returns the name of the MED file.
3347  *  \return const char * - the MED file name.
3348  */
3349 const char *MEDFileFieldGlobsReal::getFileName() const
3350 {
3351   return contentNotNull()->getFileName();
3352 }
3353
3354 std::string MEDFileFieldGlobsReal::getFileName2() const
3355 {
3356   return contentNotNull()->getFileName2();
3357 }
3358
3359 /*!
3360  * Returns a localization object by its name.
3361  *  \param [in] locName - the name of the localization of interest.
3362  *  \return const MEDFileFieldLoc& - the localization object having the name \a locName.
3363  *  \throw If there is no a localization named \a locName.
3364  */
3365 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName) const throw(INTERP_KERNEL::Exception)
3366 {
3367   return contentNotNull()->getLocalization(locName);
3368 }
3369
3370 /*!
3371  * Returns a localization object by its id.
3372  *  \param [in] locId - the id of the localization of interest.
3373  *  \return const MEDFileFieldLoc& - the localization object having the id \a locId.
3374  *  \throw If there is no a localization with id \a locId.
3375  */
3376 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) const throw(INTERP_KERNEL::Exception)
3377 {
3378   return contentNotNull()->getLocalizationFromId(locId);
3379 }
3380
3381 /*!
3382  * Returns a profile array by its name.
3383  *  \param [in] pflName - the name of the profile of interest.
3384  *  \return const DataArrayInt * - the profile array having the name \a pflName.
3385  *  \throw If there is no a profile named \a pflName.
3386  */
3387 const DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName) const throw(INTERP_KERNEL::Exception)
3388 {
3389   return contentNotNull()->getProfile(pflName);
3390 }
3391
3392 /*!
3393  * Returns a profile array by its id.
3394  *  \param [in] pflId - the id of the profile of interest.
3395  *  \return const DataArrayInt * - the profile array having the id \a pflId.
3396  *  \throw If there is no a profile with id \a pflId.
3397  */
3398 const DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) const throw(INTERP_KERNEL::Exception)
3399 {
3400   return contentNotNull()->getProfileFromId(pflId);
3401 }
3402
3403 /*!
3404  * Returns a localization object, apt for modification, by its id.
3405  *  \param [in] locId - the id of the localization of interest.
3406  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3407  *          having the id \a locId.
3408  *  \throw If there is no a localization with id \a locId.
3409  */
3410 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) throw(INTERP_KERNEL::Exception)
3411 {
3412   return contentNotNull()->getLocalizationFromId(locId);
3413 }
3414
3415 /*!
3416  * Returns a localization object, apt for modification, by its name.
3417  *  \param [in] locName - the name of the localization of interest.
3418  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3419  *          having the name \a locName.
3420  *  \throw If there is no a localization named \a locName.
3421  */
3422 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName) throw(INTERP_KERNEL::Exception)
3423 {
3424   return contentNotNull()->getLocalization(locName);
3425 }
3426
3427 /*!
3428  * Returns a profile array, apt for modification, by its name.
3429  *  \param [in] pflName - the name of the profile of interest.
3430  *  \return DataArrayInt * - a non-const pointer to the profile array having the name \a pflName.
3431  *  \throw If there is no a profile named \a pflName.
3432  */
3433 DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName) throw(INTERP_KERNEL::Exception)
3434 {
3435   return contentNotNull()->getProfile(pflName);
3436 }
3437
3438 /*!
3439  * Returns a profile array, apt for modification, by its id.
3440  *  \param [in] pflId - the id of the profile of interest.
3441  *  \return DataArrayInt * - a non-const pointer to the profile array having the id \a pflId.
3442  *  \throw If there is no a profile with id \a pflId.
3443  */
3444 DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) throw(INTERP_KERNEL::Exception)
3445 {
3446   return contentNotNull()->getProfileFromId(pflId);
3447 }
3448
3449 /*!
3450  * Removes profiles given by their ids. No data is updated to track this removal.
3451  *  \param [in] pflIds - a sequence of ids of the profiles to remove.
3452  */
3453 void MEDFileFieldGlobsReal::killProfileIds(const std::vector<int>& pflIds) throw(INTERP_KERNEL::Exception)
3454 {
3455   contentNotNull()->killProfileIds(pflIds);
3456 }
3457
3458 /*!
3459  * Removes localizations given by their ids. No data is updated to track this removal.
3460  *  \param [in] locIds - a sequence of ids of the localizations to remove.
3461  */
3462 void MEDFileFieldGlobsReal::killLocalizationIds(const std::vector<int>& locIds) throw(INTERP_KERNEL::Exception)
3463 {
3464   contentNotNull()->killLocalizationIds(locIds);
3465 }
3466
3467 /*!
3468  * Stores a profile array.
3469  *  \param [in] pfl - the profile array to store.
3470  *  \throw If the name of \a pfl is empty.
3471  *  \throw If a profile with the same name as that of \a pfl already exists but contains
3472  *         different ids.
3473  */
3474 void MEDFileFieldGlobsReal::appendProfile(DataArrayInt *pfl) throw(INTERP_KERNEL::Exception)
3475 {
3476   contentNotNull()->appendProfile(pfl);
3477 }
3478
3479 /*!
3480  * Adds a new localization of Gauss points.
3481  *  \param [in] locName - the name of the new localization.
3482  *  \param [in] geoType - a geometrical type of the reference cell.
3483  *  \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
3484  *         must be \c nbOfNodesPerCell * \c dimOfType.
3485  *  \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
3486  *         must be  _wg_.size() * \c dimOfType.
3487  *  \param [in] w - the weights of Gauss points.
3488  *  \throw If \a locName is empty.
3489  *  \throw If a localization with the name \a locName already exists but is
3490  *         different form the new one.
3491  */
3492 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)
3493 {
3494   contentNotNull()->appendLoc(locName,geoType,refCoo,gsCoo,w);
3495 }
3496
3497 MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() throw(INTERP_KERNEL::Exception)
3498 {
3499   MEDFileFieldGlobs *g(_globals);
3500   if(!g)
3501     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in not const !");
3502   return g;
3503 }
3504
3505 const MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() const throw(INTERP_KERNEL::Exception)
3506 {
3507   const MEDFileFieldGlobs *g(_globals);
3508   if(!g)
3509     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in const !");
3510   return g;
3511 }
3512
3513 //= MEDFileFieldNameScope
3514
3515 MEDFileFieldNameScope::MEDFileFieldNameScope()
3516 {
3517 }
3518
3519 MEDFileFieldNameScope::MEDFileFieldNameScope(const char *fieldName):_name(fieldName)
3520 {
3521 }
3522
3523 /*!
3524  * Returns the name of \a this field.
3525  *  \return std::string - a string containing the field name.
3526  */
3527 std::string MEDFileFieldNameScope::getName() const throw(INTERP_KERNEL::Exception)
3528 {
3529   return _name;
3530 }
3531
3532 /*!
3533  * Sets name of \a this field
3534  *  \param [in] name - the new field name.
3535  */
3536 void MEDFileFieldNameScope::setName(const char *fieldName) throw(INTERP_KERNEL::Exception)
3537 {
3538   _name=fieldName;
3539 }
3540
3541 std::string MEDFileFieldNameScope::getDtUnit() const throw(INTERP_KERNEL::Exception)
3542 {
3543   return _dt_unit;
3544 }
3545
3546 void MEDFileFieldNameScope::setDtUnit(const char *dtUnit) throw(INTERP_KERNEL::Exception)
3547 {
3548   _dt_unit=dtUnit;
3549 }
3550
3551 void MEDFileFieldNameScope::copyNameScope(const MEDFileFieldNameScope& other)
3552 {
3553   _name=other._name;
3554   _dt_unit=other._dt_unit;
3555 }
3556
3557 //= MEDFileAnyTypeField1TSWithoutSDA
3558
3559 void MEDFileAnyTypeField1TSWithoutSDA::deepCpyLeavesFrom(const MEDFileAnyTypeField1TSWithoutSDA& other) throw(INTERP_KERNEL::Exception)
3560 {
3561   _field_per_mesh.resize(other._field_per_mesh.size());
3562   std::size_t i=0;
3563   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
3564     {
3565       if((const MEDFileFieldPerMesh *)*it)
3566         _field_per_mesh[i]=(*it)->deepCpy(this);
3567     }
3568 }
3569
3570 /*!
3571  * Prints a string describing \a this field into a stream. This string is outputted
3572  * by \c print Python command.
3573  *  \param [in] bkOffset - number of white spaces printed at the beginning of each line.
3574  *  \param [in,out] oss - the out stream.
3575  *  \param [in] f1tsId - the field index within a MED file. If \a f1tsId < 0, the tiny
3576  *          info id printed, else, not.
3577  */
3578 void MEDFileAnyTypeField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
3579 {
3580   std::string startOfLine(bkOffset,' ');
3581   oss << startOfLine << "Field ";
3582   if(bkOffset==0)
3583     oss << "[Type=" << getTypeStr() << "] with name \"" << getName() << "\" ";
3584   oss << "on one time Step ";
3585   if(f1tsId>=0)
3586     oss << "(" << f1tsId << ") ";
3587   oss << "on iteration=" << _iteration << " order=" << _order << "." << std::endl;
3588   oss << startOfLine << "Time attached is : " << _dt << " [" << _dt_unit << "]." << std::endl;
3589   const DataArray *arr=getUndergroundDataArray();
3590   if(arr)
3591     {
3592       const std::vector<std::string> &comps=arr->getInfoOnComponents();
3593       if(f1tsId<0)
3594         {
3595           oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
3596           for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
3597             oss << startOfLine << "  -  \"" << (*it) << "\"" << std::endl;
3598         }
3599       if(arr->isAllocated())
3600         {
3601           oss << startOfLine << "Whole field contains " << arr->getNumberOfTuples() << " tuples." << std::endl;
3602         }
3603       else
3604         oss << startOfLine << "The array of the current field has not allocated yet !" << std::endl;
3605     }
3606   else
3607     {
3608       oss << startOfLine << "Field infos are empty ! Not defined yet !" << std::endl;
3609     }
3610   oss << startOfLine << "----------------------" << std::endl;
3611   if(!_field_per_mesh.empty())
3612     {
3613       int i=0;
3614       for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
3615         {
3616           const MEDFileFieldPerMesh *cur=(*it2);
3617           if(cur)
3618             cur->simpleRepr(bkOffset,oss,i);
3619           else
3620             oss << startOfLine << "Field per mesh #" << i << " is not defined !" << std::endl;
3621         }
3622     }
3623   else
3624     {
3625       oss << startOfLine << "Field is not defined on any meshes !" << std::endl;
3626     }
3627   oss << startOfLine << "----------------------" << std::endl;
3628 }
3629
3630 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitComponents() const throw(INTERP_KERNEL::Exception)
3631 {
3632   const DataArray *arr(getUndergroundDataArray());
3633   if(!arr)
3634     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitComponents : no array defined !");
3635   int nbOfCompo=arr->getNumberOfComponents();
3636   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfCompo);
3637   for(int i=0;i<nbOfCompo;i++)
3638     {
3639       ret[i]=deepCpy();
3640       std::vector<int> v(1,i);
3641       MEDCouplingAutoRefCountObjectPtr<DataArray> arr2=arr->keepSelectedComponents(v);
3642       ret[i]->setArray(arr2);
3643     }
3644   return ret;
3645 }
3646
3647 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)
3648 {
3649 }
3650
3651 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA():_iteration(-1),_order(-1),_dt(0.),_csit(-1),_nb_of_tuples_to_be_allocated(-1)
3652 {
3653 }
3654
3655 /*!
3656  * Returns the maximal dimension of supporting elements. Returns -2 if \a this is
3657  * empty. Returns -1 if this in on nodes.
3658  *  \return int - the dimension of \a this.
3659  */
3660 int MEDFileAnyTypeField1TSWithoutSDA::getDimension() const
3661 {
3662   int ret=-2;
3663   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3664     (*it)->getDimension(ret);
3665   return ret;
3666 }
3667
3668 /*!
3669  * Returns the mesh name.
3670  *  \return std::string - a string holding the mesh name.
3671  *  \throw If \c _field_per_mesh.empty()
3672  */
3673 std::string MEDFileAnyTypeField1TSWithoutSDA::getMeshName() const throw(INTERP_KERNEL::Exception)
3674 {
3675   if(_field_per_mesh.empty())
3676     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshName : No field set !");
3677   return _field_per_mesh[0]->getMeshName();
3678 }
3679
3680 void MEDFileAnyTypeField1TSWithoutSDA::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
3681 {
3682   std::string oldName(getMeshName());
3683   std::vector< std::pair<std::string,std::string> > v(1);
3684   v[0].first=oldName; v[0].second=newMeshName;
3685   changeMeshNames(v);
3686 }
3687
3688 bool MEDFileAnyTypeField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
3689 {
3690   bool ret=false;
3691   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3692     {
3693       MEDFileFieldPerMesh *cur(*it);
3694       if(cur)
3695         ret=cur->changeMeshNames(modifTab) || ret;
3696     }
3697   return ret;
3698 }
3699
3700 /*!
3701  * Returns the number of iteration of the state of underlying mesh.
3702  *  \return int - the iteration number.
3703  *  \throw If \c _field_per_mesh.empty()
3704  */
3705 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIteration() const throw(INTERP_KERNEL::Exception)
3706 {
3707   if(_field_per_mesh.empty())
3708     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshIteration : No field set !");
3709   return _field_per_mesh[0]->getMeshIteration();
3710 }
3711
3712 /*!
3713  * Returns the order number of iteration of the state of underlying mesh.
3714  *  \return int - the order number.
3715  *  \throw If \c _field_per_mesh.empty()
3716  */
3717 int MEDFileAnyTypeField1TSWithoutSDA::getMeshOrder() const throw(INTERP_KERNEL::Exception)
3718 {
3719   if(_field_per_mesh.empty())
3720     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshOrder : No field set !");
3721   return _field_per_mesh[0]->getMeshOrder();
3722 }
3723
3724 /*!
3725  * Checks if \a this field is tagged by a given iteration number and a given
3726  * iteration order number.
3727  *  \param [in] iteration - the iteration number of interest.
3728  *  \param [in] order - the iteration order number of interest.
3729  *  \return bool - \c true if \a this->getIteration() == \a iteration &&
3730  *          \a this->getOrder() == \a order.
3731  */
3732 bool MEDFileAnyTypeField1TSWithoutSDA::isDealingTS(int iteration, int order) const
3733 {
3734   return iteration==_iteration && order==_order;
3735 }
3736
3737 /*!
3738  * Returns number of iteration and order number of iteration when
3739  * \a this field has been calculated.
3740  *  \return std::pair<int,int> - a pair of the iteration number and the iteration
3741  *          order number.
3742  */
3743 std::pair<int,int> MEDFileAnyTypeField1TSWithoutSDA::getDtIt() const
3744 {
3745   std::pair<int,int> p;
3746   fillIteration(p);
3747   return p;
3748 }
3749
3750 /*!
3751  * Returns number of iteration and order number of iteration when
3752  * \a this field has been calculated.
3753  *  \param [in,out] p - a pair returning the iteration number and the iteration
3754  *          order number.
3755  */
3756 void MEDFileAnyTypeField1TSWithoutSDA::fillIteration(std::pair<int,int>& p) const
3757 {
3758   p.first=_iteration;
3759   p.second=_order;
3760 }
3761
3762 /*!
3763  * Returns all types of spatial discretization of \a this field.
3764  *  \param [in,out] types - a sequence of types of \a this field.
3765  */
3766 void MEDFileAnyTypeField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
3767 {
3768   std::set<TypeOfField> types2;
3769   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3770     {
3771       (*it)->fillTypesOfFieldAvailable(types2);
3772     }
3773   std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
3774   std::copy(types2.begin(),types2.end(),bi);
3775 }
3776
3777 /*!
3778  * Returns all types of spatial discretization of \a this field.
3779  *  \return std::vector<TypeOfField> - a sequence of types of spatial discretization
3780  *          of \a this field.
3781  */
3782 std::vector<TypeOfField> MEDFileAnyTypeField1TSWithoutSDA::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
3783 {
3784   std::vector<TypeOfField> ret;
3785   fillTypesOfFieldAvailable(ret);
3786   return ret;
3787 }
3788
3789 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsed2() const
3790 {
3791   std::vector<std::string> ret;
3792   std::set<std::string> ret2;
3793   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3794     {
3795       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
3796       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3797         if(ret2.find(*it2)==ret2.end())
3798           {
3799             ret.push_back(*it2);
3800             ret2.insert(*it2);
3801           }
3802     }
3803   return ret;
3804 }
3805
3806 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsed2() const
3807 {
3808   std::vector<std::string> ret;
3809   std::set<std::string> ret2;
3810   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3811     {
3812       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
3813       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3814         if(ret2.find(*it2)==ret2.end())
3815           {
3816             ret.push_back(*it2);
3817             ret2.insert(*it2);
3818           }
3819     }
3820   return ret;
3821 }
3822
3823 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsedMulti2() const
3824 {
3825   std::vector<std::string> ret;
3826   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3827     {
3828       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
3829       ret.insert(ret.end(),tmp.begin(),tmp.end());
3830     }
3831   return ret;
3832 }
3833
3834 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsedMulti2() const
3835 {
3836   std::vector<std::string> ret;
3837   std::set<std::string> ret2;
3838   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3839     {
3840       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
3841       ret.insert(ret.end(),tmp.begin(),tmp.end());
3842     }
3843   return ret;
3844 }
3845
3846 void MEDFileAnyTypeField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3847 {
3848   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3849     (*it)->changePflsRefsNamesGen(mapOfModif);
3850 }
3851
3852 void MEDFileAnyTypeField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3853 {
3854   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3855     (*it)->changeLocsRefsNamesGen(mapOfModif);
3856 }
3857
3858 /*!
3859  * Returns all attributes of parts of \a this field lying on a given mesh.
3860  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
3861  * item of every of returned sequences refers to the _i_-th part of \a this field.
3862  * Thus all sequences returned by this method are of the same length equal to number
3863  * of different types of supporting entities.<br>
3864  * A field part can include sub-parts with several different spatial discretizations,
3865  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
3866  * for example. Hence, some of the returned sequences contains nested sequences, and an item
3867  * of a nested sequence corresponds to a type of spatial discretization.<br>
3868  * This method allows for iteration over MEDFile DataStructure without any overhead.
3869  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3870  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3871  *          not checked if \a mname == \c NULL).
3872  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
3873  *          a field part is returned.
3874  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
3875  *          This sequence is of the same length as \a types.
3876  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
3877  *          discretization. A profile name can be empty.
3878  *          Length of this and of nested sequences is the same as that of \a typesF.
3879  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
3880  *          discretization. A localization name can be empty.
3881  *          Length of this and of nested sequences is the same as that of \a typesF.
3882  *  \return std::vector< std::vector< std::pair<int,int> > > - a sequence holding a range
3883  *          of ids of tuples within the data array, per each type of spatial
3884  *          discretization within one mesh entity type.
3885  *          Length of this and of nested sequences is the same as that of \a typesF.
3886  *  \throw If no field is lying on \a mname.
3887  */
3888 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)
3889 {
3890   int meshId=0;
3891   if(mname)
3892     meshId=getMeshIdFromMeshName(mname);
3893   else
3894     if(_field_per_mesh.empty())
3895       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
3896   return _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3897 }
3898
3899 /*!
3900  * Returns dimensions of mesh elements \a this field lies on. The returned value is a
3901  * maximal absolute dimension and values returned via the out parameter \a levs are
3902  * dimensions relative to the maximal absolute dimension. <br>
3903  * This method is designed for MEDFileField1TS instances that have a discretization
3904  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS",
3905  * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT",
3906  * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE".
3907  * Only these 3 discretizations will be taken into account here. If \a this is
3908  * \ref ParaMEDMEM::ON_NODES "ON_NODES", -1 is returned and \a levs are empty.<br>
3909  * This method is useful to make the link between the dimension of the underlying mesh
3910  * and the levels of \a this, because it is possible that the highest dimension of \a this
3911  * field is not equal to the dimension of the underlying mesh.
3912  *
3913  * Let's consider the following case:
3914  * - mesh \a m1 has a meshDimension 3 and has non empty levels [0,-1,-2] with elements
3915  * TETRA4, HEXA8, TRI3 and SEG2.
3916  * - field \a f1 lies on \a m1 and is defined on 3D and 1D elements TETRA4 and SEG2.
3917  * - field \a f2 lies on \a m1 and is defined on 2D and 1D elements TRI3 and SEG2.
3918  *
3919  * In this case \a f1->getNonEmptyLevels() returns (3,[0,-2]) and \a
3920  * f2->getNonEmptyLevels() returns (2,[0,-1]). <br>
3921  * The returned values can be used for example to retrieve a MEDCouplingFieldDouble lying
3922  * on elements of a certain relative level by calling getFieldAtLevel(). \a meshDimRelToMax
3923  * parameter of getFieldAtLevel() is computed basing on the returned values as this:
3924  * <em> meshDimRelToMax = absDim - meshDim + relativeLev </em>.
3925  * For example<br>
3926  * to retrieve the highest level of
3927  * \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+0 ); // absDim - meshDim + relativeLev</em><br>
3928  * to retrieve the lowest level of \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+(-2) );</em><br>
3929  * to retrieve the highest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+0 );</em><br>
3930  * to retrieve the lowest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+(-1) )</em>.
3931  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3932  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3933  *          not checked if \a mname == \c NULL).
3934  *  \param [in,out] levs - a sequence returning the dimensions relative to the maximal
3935  *          absolute one. They are in decreasing order. This sequence is cleared before
3936  *          filling it in.
3937  *  \return int - the maximal absolute dimension of elements \a this fields lies on.
3938  *  \throw If no field is lying on \a mname.
3939  */
3940 int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
3941 {
3942   levs.clear();
3943   int meshId=getMeshIdFromMeshName(mname);
3944   std::vector<INTERP_KERNEL::NormalizedCellType> types;
3945   std::vector< std::vector<TypeOfField> > typesF;
3946   std::vector< std::vector<std::string> > pfls, locs;
3947   _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3948   if(types.empty())
3949     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getNonEmptyLevels : 'this' is empty !");
3950   std::set<INTERP_KERNEL::NormalizedCellType> st(types.begin(),types.end());
3951   if(st.size()==1 && (*st.begin())==INTERP_KERNEL::NORM_ERROR)
3952     return -1;
3953   st.erase(INTERP_KERNEL::NORM_ERROR);
3954   std::set<int> ret1;
3955   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
3956     {
3957       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
3958       ret1.insert((int)cm.getDimension());
3959     }
3960   int ret=*std::max_element(ret1.begin(),ret1.end());
3961   std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
3962   std::transform(levs.begin(),levs.end(),levs.begin(),std::bind2nd(std::plus<int>(),-ret));
3963   return ret;
3964 }
3965
3966 /*!
3967  * \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.
3968  * \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.
3969  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
3970  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
3971  */
3972 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
3973 {
3974   int mid=getMeshIdFromMeshName(mName);
3975   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
3976 }
3977
3978 /*!
3979  * \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.
3980  * \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.
3981  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
3982  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
3983  */
3984 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
3985 {
3986   int mid=getMeshIdFromMeshName(mName);
3987   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
3988 }
3989
3990 /*!
3991  * \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.
3992  */
3993 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIdFromMeshName(const char *mName) const throw(INTERP_KERNEL::Exception)
3994 {
3995   if(_field_per_mesh.empty())
3996     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
3997   if(mName==0)
3998     return 0;
3999   std::string mName2(mName);
4000   int ret=0;
4001   std::vector<std::string> msg;
4002   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
4003     if(mName2==(*it)->getMeshName())
4004       return ret;
4005     else
4006       msg.push_back((*it)->getMeshName());
4007   std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
4008   oss << "Possible meshes are : ";
4009   for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
4010     oss << "\"" << (*it2) << "\" ";
4011   throw INTERP_KERNEL::Exception(oss.str().c_str());
4012 }
4013
4014 int MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
4015 {
4016   if(!mesh)
4017     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary : input mesh is NULL !");
4018   std::string tmp(mesh->getName());
4019   if(tmp.empty())
4020     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
4021   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();
4022   int i=0;
4023   for(;it!=_field_per_mesh.end();it++,i++)
4024     {
4025       if((*it)->getMeshName()==tmp)
4026         return i;
4027     }
4028   int sz=_field_per_mesh.size();
4029   _field_per_mesh.resize(sz+1);
4030   _field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
4031   return sz;
4032 }
4033
4034 bool MEDFileAnyTypeField1TSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
4035                                                             MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
4036 {
4037   bool ret=false;
4038   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4039     {
4040       MEDFileFieldPerMesh *fpm(*it);
4041       if(fpm)
4042         ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
4043     }
4044   return ret;
4045 }
4046
4047 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
4048 {
4049   std::vector<INTERP_KERNEL::NormalizedCellType> types;
4050   std::vector< std::vector<TypeOfField> > typesF;
4051   std::vector< std::vector<std::string> > pfls,locs;
4052   std::vector< std::vector<std::pair<int,int> > > bgEnd=getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs);
4053   std::set<TypeOfField> allEnt;
4054   for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++)
4055     for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4056       allEnt.insert(*it2);
4057   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(allEnt.size());
4058   std::set<TypeOfField>::const_iterator it3(allEnt.begin());
4059   for(std::size_t i=0;i<allEnt.size();i++,it3++)
4060     {
4061       std::vector< std::pair<int,int> > its;
4062       ret[i]=shallowCpy();
4063       int newLgth=ret[i]->keepOnlySpatialDiscretization(*it3,its);
4064       ret[i]->updateData(newLgth,its);
4065     }
4066   return ret;
4067 }
4068
4069 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlySpatialDiscretization(TypeOfField tof, std::vector< std::pair<int,int> >& its) throw(INTERP_KERNEL::Exception)
4070 {
4071   int globalCounter=0;
4072   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4073     (*it)->keepOnlySpatialDiscretization(tof,globalCounter,its);
4074   return globalCounter;
4075 }
4076
4077 void MEDFileAnyTypeField1TSWithoutSDA::updateData(int newLgth, const std::vector< std::pair<int,int> >& oldStartStops) throw(INTERP_KERNEL::Exception)
4078 {
4079   if(_nb_of_tuples_to_be_allocated>=0)
4080     {
4081       _nb_of_tuples_to_be_allocated=newLgth;
4082       return ;
4083     }
4084   if(_nb_of_tuples_to_be_allocated==-1)
4085     return ;
4086   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4087     {
4088       const DataArray *oldArr=getUndergroundDataArray();
4089       if(!oldArr || !oldArr->isAllocated())
4090         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 1 !");
4091       MEDCouplingAutoRefCountObjectPtr<DataArray> newArr=createNewEmptyDataArrayInstance();
4092       newArr->alloc(newLgth,getNumberOfComponents());
4093       int pos=0;
4094       for(std::vector< std::pair<int,int> >::const_iterator it=oldStartStops.begin();it!=oldStartStops.end();it++)
4095         {
4096           if((*it).second<(*it).first)
4097             throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : the range in the leaves was invalid !");
4098           newArr->setContigPartOfSelectedValues2(pos,oldArr,(*it).first,(*it).second,1);
4099           pos+=(*it).second-(*it).first;
4100         }
4101       setArray(newArr);
4102       return ;
4103     }
4104   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 2 !");
4105 }
4106
4107 void MEDFileAnyTypeField1TSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4108 {
4109   if(_field_per_mesh.empty())
4110     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : empty field !");
4111   if(_field_per_mesh.size()>1)
4112     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : In MED3.0 mode in writting mode only ONE underlying mesh supported !");
4113   _field_per_mesh[0]->copyOptionsFrom(opts);
4114   _field_per_mesh[0]->writeLL(fid,nasc);
4115 }
4116
4117 /*!
4118  * 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.
4119  * If false is returned the memory allocation is not required.
4120  */
4121 bool MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile() throw(INTERP_KERNEL::Exception)
4122 {
4123   if(_nb_of_tuples_to_be_allocated>=0)
4124     {
4125       getOrCreateAndGetArray()->alloc(_nb_of_tuples_to_be_allocated,getNumberOfComponents());
4126       _nb_of_tuples_to_be_allocated=-2;
4127       return true;
4128     }
4129   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4130     return false;
4131   if(_nb_of_tuples_to_be_allocated==-1)
4132     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : trying to read from a file an empty instance ! Need to prepare the structure before !");
4133   if(_nb_of_tuples_to_be_allocated<-3)
4134     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4135
4136 }
4137
4138 void MEDFileAnyTypeField1TSWithoutSDA::loadOnlyStructureOfDataRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4139 {
4140   med_int numdt,numit;
4141   med_float dt;
4142   med_int nmesh;
4143   med_bool localMesh;
4144   med_int meshnumdt,meshnumit;
4145   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
4146   MEDfieldComputingStepInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&_dt);
4147   MEDfield23ComputingStepMeshInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&dt,&nmesh,meshName,&localMesh,&meshnumdt,&meshnumit);
4148   if(_iteration!=numdt || _order!=numit)
4149     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively : unexpected exception internal error !");
4150   _field_per_mesh.resize(nmesh);
4151   for(int i=0;i<nmesh;i++)
4152     _field_per_mesh[i]=MEDFileFieldPerMesh::NewOnRead(fid,this,i+1,meshnumdt,meshnumit,nasc);//tony
4153   _nb_of_tuples_to_be_allocated=0;
4154   for(int i=0;i<nmesh;i++)
4155     _field_per_mesh[i]->loadOnlyStructureOfDataRecursively(fid,_nb_of_tuples_to_be_allocated,nasc);
4156 }
4157
4158 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4159 {
4160   allocIfNecessaryTheArrayToReceiveDataFromFile();
4161   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4162     (*it)->loadBigArraysRecursively(fid,nasc);
4163 }
4164
4165 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4166 {
4167   if(allocIfNecessaryTheArrayToReceiveDataFromFile())
4168     for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4169       (*it)->loadBigArraysRecursively(fid,nasc);
4170 }
4171
4172 void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4173 {
4174   loadOnlyStructureOfDataRecursively(fid,nasc);
4175   loadBigArraysRecursively(fid,nasc);
4176 }
4177
4178 void MEDFileAnyTypeField1TSWithoutSDA::releaseArrays() throw(INTERP_KERNEL::Exception)
4179 {
4180   DataArray *thisArr(getUndergroundDataArray());
4181   if(thisArr && thisArr->isAllocated())
4182     {
4183       _nb_of_tuples_to_be_allocated=thisArr->getNumberOfTuples();
4184       thisArr->desallocate();
4185     }
4186 }
4187
4188 std::size_t MEDFileAnyTypeField1TSWithoutSDA::getHeapMemorySize() const
4189 {
4190   std::size_t ret=_dt_unit.capacity()+_field_per_mesh.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh >);
4191   if(getUndergroundDataArray())
4192     ret+=getUndergroundDataArray()->getHeapMemorySize();
4193   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4194     ret+=(*it)->getHeapMemorySize();
4195   return ret;
4196 }
4197
4198 /*!
4199  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
4200  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
4201  * "Sort By Type"), if not, an exception is thrown.
4202  *  \param [in] field - the field to add to \a this. The array of field \a field is ignored
4203  *  \param [in] arr - the array of values.
4204  *  \param [in,out] glob - the global data where profiles and localization present in
4205  *          \a field, if any, are added.
4206  *  \throw If the name of \a field is empty.
4207  *  \throw If the data array of \a field is not set.
4208  *  \throw If \a this->_arr is already allocated but has different number of components
4209  *         than \a field.
4210  *  \throw If the underlying mesh of \a field has no name.
4211  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
4212  */
4213 void MEDFileAnyTypeField1TSWithoutSDA::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
4214 {
4215   const MEDCouplingMesh *mesh=field->getMesh();
4216   //
4217   TypeOfField type=field->getTypeOfField();
4218   std::vector<DataArrayInt *> dummy;
4219   int start=copyTinyInfoFrom(field,arr);
4220   int pos=addNewEntryIfNecessary(mesh);
4221   if(type!=ON_NODES)
4222     {
4223       std::vector<int> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
4224       _field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,arr,glob,nasc);
4225     }
4226   else
4227     _field_per_mesh[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
4228 }
4229
4230 /*!
4231  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
4232  * of a given mesh are used as the support of the given field (a real support is not used).
4233  * Elements of the given mesh must be sorted suitable for writing to MED file.
4234  * Order of underlying mesh entities of the given field specified by \a profile parameter
4235  * is not prescribed; this method permutes field values to have them sorted by element
4236  * type as required for writing to MED file. A new profile is added only if no equal
4237  * profile is missing.
4238  *  \param [in] field - the field to add to \a this. The field double values are ignored.
4239  *  \param [in] arrOfVals - the values of the field \a field used.
4240  *  \param [in] mesh - the supporting mesh of \a field.
4241  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
4242  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
4243  *  \param [in,out] glob - the global data where profiles and localization present in
4244  *          \a field, if any, are added.
4245  *  \throw If either \a field or \a mesh or \a profile has an empty name.
4246  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4247  *  \throw If the data array of \a field is not set.
4248  *  \throw If \a this->_arr is already allocated but has different number of components
4249  *         than \a field.
4250  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4251  *  \sa setFieldNoProfileSBT()
4252  */
4253 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)
4254 {
4255   if(!field)
4256     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input field is null !");
4257   if(!arrOfVals || !arrOfVals->isAllocated())
4258     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input array is null or not allocated !");
4259   TypeOfField type=field->getTypeOfField();
4260   std::vector<DataArrayInt *> idsInPflPerType;
4261   std::vector<DataArrayInt *> idsPerType;
4262   std::vector<int> code,code2;
4263   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4264   if(type!=ON_NODES)
4265     {
4266       m->splitProfilePerType(profile,code,idsInPflPerType,idsPerType);
4267       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsInPflPerType2(idsInPflPerType.size()); std::copy(idsInPflPerType.begin(),idsInPflPerType.end(),idsInPflPerType2.begin());
4268       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsPerType2(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType2.begin());
4269       std::vector<const DataArrayInt *> idsPerType3(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType3.begin());
4270       // start of check
4271       MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field2=field->clone(false);
4272       if(type==ON_GAUSS_NE)
4273         {
4274           MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mPart=m->buildPart(profile->begin(),profile->end());
4275           field2->setMesh(mPart);
4276         }
4277       int nbOfTuplesExp=field2->getNumberOfTuplesExpectedRegardingCode(code,idsPerType3);
4278       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4279         {
4280           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : The array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4281           throw INTERP_KERNEL::Exception(oss.str().c_str());
4282         }
4283       // end of check
4284       int start=copyTinyInfoFrom(field,arrOfVals);
4285       code2=m->getDistributionOfTypes();
4286       //
4287       int pos=addNewEntryIfNecessary(m);
4288       _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
4289     }
4290   else
4291     {
4292       if(!profile || !profile->isAllocated() || profile->getNumberOfComponents()!=1)
4293         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input profile is null, not allocated or with number of components != 1 !");
4294       std::vector<int> v(3); v[0]=-1; v[1]=profile->getNumberOfTuples(); v[2]=0;
4295       std::vector<const DataArrayInt *> idsPerType3(1); idsPerType3[0]=profile;
4296       int nbOfTuplesExp=field->getNumberOfTuplesExpectedRegardingCode(v,idsPerType3);
4297       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4298         {
4299           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : For node field, the array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4300           throw INTERP_KERNEL::Exception(oss.str().c_str());
4301         }
4302       int start=copyTinyInfoFrom(field,arrOfVals);
4303       int pos=addNewEntryIfNecessary(m);
4304       _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
4305     }
4306 }
4307
4308 /*!
4309  * \param [in] newNbOfTuples - The new nb of tuples to be allocated.
4310  */
4311 void MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile(int newNbOfTuples) throw(INTERP_KERNEL::Exception)
4312 {
4313   if(_nb_of_tuples_to_be_allocated>=0)
4314     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 !");
4315   DataArray *arr(getOrCreateAndGetArray());
4316   arr->alloc(newNbOfTuples,arr->getNumberOfComponents());
4317   _nb_of_tuples_to_be_allocated=-3;
4318 }
4319
4320 /*!
4321  * Copies tiny info and allocates \a this->_arr instance of DataArrayDouble to
4322  * append data of a given MEDCouplingFieldDouble. So that the size of \a this->_arr becomes
4323  * larger by the size of \a field. Returns an id of the first not filled
4324  * tuple of \a this->_arr.
4325  *  \param [in] field - the field to copy the info on components and the name from.
4326  *  \return int - the id of first not initialized tuple of \a this->_arr.
4327  *  \throw If the name of \a field is empty.
4328  *  \throw If the data array of \a field is not set.
4329  *  \throw If \a this->_arr is already allocated but has different number of components
4330  *         than \a field.
4331  */
4332 int MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr) throw(INTERP_KERNEL::Exception)
4333 {
4334   if(!field)
4335     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
4336   std::string name(field->getName());
4337   setName(name.c_str());
4338   setDtUnit(field->getTimeUnit());
4339   if(name.empty())
4340     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
4341   if(!arr)
4342     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
4343   if(!arr->isAllocated())
4344     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : array is not allocated !");
4345   _dt=field->getTime(_iteration,_order);
4346   int nbOfComponents=arr->getNumberOfComponents();
4347   getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
4348   if(!getOrCreateAndGetArray()->isAllocated())
4349     {
4350       allocNotFromFile(arr->getNumberOfTuples());
4351       return 0;
4352     }
4353   else
4354     {
4355       int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
4356       int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
4357       getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
4358       _nb_of_tuples_to_be_allocated=-3;
4359       return oldNbOfTuples;
4360     }
4361 }
4362
4363 /*!
4364  * Returns number of components in \a this field
4365  *  \return int - the number of components.
4366  */
4367 int MEDFileAnyTypeField1TSWithoutSDA::getNumberOfComponents() const
4368 {
4369   return getOrCreateAndGetArray()->getNumberOfComponents();
4370 }
4371
4372 /*!
4373  * Change info on components in \a this.
4374  * \throw If size of \a infos is not equal to the number of components already in \a this.
4375  */
4376 void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos) throw(INTERP_KERNEL::Exception)
4377 {
4378   DataArray *arr=getOrCreateAndGetArray();
4379   arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
4380 }
4381
4382 /*!
4383  * Returns info on components of \a this field.
4384  *  \return const std::vector<std::string>& - a sequence of strings each being an
4385  *          information on _i_-th component.
4386  */
4387 const std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo() const
4388 {
4389   const DataArray *arr=getOrCreateAndGetArray();
4390   return arr->getInfoOnComponents();
4391 }
4392
4393 /*!
4394  * Returns a mutable info on components of \a this field.
4395  *  \return std::vector<std::string>& - a sequence of strings each being an
4396  *          information on _i_-th component.
4397  */
4398 std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo()
4399 {
4400   DataArray *arr=getOrCreateAndGetArray();
4401   return arr->getInfoOnComponents();
4402 }
4403
4404 /*!
4405  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4406  *  \param [in] type - a spatial discretization of the new field.
4407  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4408  *  \param [in] mName - a name of the supporting mesh.
4409  *  \param [in] renumPol - specifies how to permute values of the result field according to
4410  *          the optional numbers of cells and nodes, if any. The valid values are
4411  *          - 0 - do not permute.
4412  *          - 1 - permute cells.
4413  *          - 2 - permute nodes.
4414  *          - 3 - permute cells and nodes.
4415  *
4416  *  \param [in] glob - the global data storing profiles and localization.
4417  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4418  *          caller is to delete this field using decrRef() as it is no more needed.
4419  *  \throw If the MED file is not readable.
4420  *  \throw If there is no mesh named \a mName in the MED file.
4421  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4422  *  \throw If no field of \a this is lying on the mesh \a mName.
4423  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4424  */
4425 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)
4426 {
4427   MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4428   if(mName==0)
4429     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4430   else
4431     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4432   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4433 }
4434
4435 /*!
4436  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4437  *  \param [in] type - a spatial discretization of the new field.
4438  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4439  *  \param [in] renumPol - specifies how to permute values of the result field according to
4440  *          the optional numbers of cells and nodes, if any. The valid values are
4441  *          - 0 - do not permute.
4442  *          - 1 - permute cells.
4443  *          - 2 - permute nodes.
4444  *          - 3 - permute cells and nodes.
4445  *
4446  *  \param [in] glob - the global data storing profiles and localization.
4447  *  \param [in] mesh - the supporting mesh.
4448  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4449  *          caller is to delete this field using decrRef() as it is no more needed.
4450  *  \throw If the MED file is not readable.
4451  *  \throw If no field of \a this is lying on \a mesh.
4452  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4453  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4454  */
4455 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)
4456 {
4457   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax,false);
4458   const DataArrayInt *d=mesh->getNumberFieldAtLevel(meshDimRelToMax);
4459   const DataArrayInt *e=mesh->getNumberFieldAtLevel(1);
4460   if(meshDimRelToMax==1)
4461     (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
4462   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e,arrOut,nasc);
4463 }
4464
4465 /*!
4466  * Returns a new MEDCouplingFieldDouble of a given type lying on the top level cells of a
4467  * given mesh.
4468  *  \param [in] type - a spatial discretization of the new field.
4469  *  \param [in] mName - a name of the supporting mesh.
4470  *  \param [in] renumPol - specifies how to permute values of the result field according to
4471  *          the optional numbers of cells and nodes, if any. The valid values are
4472  *          - 0 - do not permute.
4473  *          - 1 - permute cells.
4474  *          - 2 - permute nodes.
4475  *          - 3 - permute cells and nodes.
4476  *
4477  *  \param [in] glob - the global data storing profiles and localization.
4478  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4479  *          caller is to delete this field using decrRef() as it is no more needed.
4480  *  \throw If the MED file is not readable.
4481  *  \throw If there is no mesh named \a mName in the MED file.
4482  *  \throw If there are no mesh entities in the mesh.
4483  *  \throw If no field values of the given \a type are available.
4484  */
4485 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4486 {
4487    MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4488   if(mName==0)
4489     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4490   else
4491     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4492   int absDim=getDimension();
4493   int meshDimRelToMax=absDim-mm->getMeshDimension();
4494   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4495 }
4496
4497 /*!
4498  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4499  *  \param [in] type - a spatial discretization of the new field.
4500  *  \param [in] renumPol - specifies how to permute values of the result field according to
4501  *          the optional numbers of cells and nodes, if any. The valid values are
4502  *          - 0 - do not permute.
4503  *          - 1 - permute cells.
4504  *          - 2 - permute nodes.
4505  *          - 3 - permute cells and nodes.
4506  *
4507  *  \param [in] glob - the global data storing profiles and localization.
4508  *  \param [in] mesh - the supporting mesh.
4509  *  \param [in] cellRenum - the cell numbers array used for permutation of the result
4510  *         field according to \a renumPol.
4511  *  \param [in] nodeRenum - the node numbers array used for permutation of the result
4512  *         field according to \a renumPol.
4513  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4514  *          caller is to delete this field using decrRef() as it is no more needed.
4515  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4516  *  \throw If no field of \a this is lying on \a mesh.
4517  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4518  */
4519 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)
4520 {
4521   static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
4522   int meshId=getMeshIdFromMeshName(mesh->getName());
4523   bool isPfl=false;
4524   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl,arrOut,nasc);
4525   switch(renumPol)
4526     {
4527     case 0:
4528       {
4529         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4530         return ret.retn();
4531       }
4532     case 3:
4533     case 1:
4534       {
4535         if(isPfl)
4536           throw INTERP_KERNEL::Exception(msg1);
4537         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4538         if(cellRenum)
4539           {
4540             if((int)cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
4541               {
4542                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4543                 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
4544                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4545               }
4546             MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
4547             if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
4548             std::vector<DataArray *> arrOut2(1,arrOut);
4549             // 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
4550             disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
4551             (const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
4552           }
4553         if(renumPol==1)
4554           return ret.retn();
4555       }
4556     case 2:
4557       {
4558         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4559         if(isPfl)
4560           throw INTERP_KERNEL::Exception(msg1);
4561         if(nodeRenum)
4562           {
4563             if((int)nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
4564               {
4565                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4566                 oss << "\"" << nasc.getName() << "\" not defined on all nodes !";
4567                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4568               }
4569             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
4570             if(!dynamic_cast<DataArrayDouble *>((DataArray *)arrOut))
4571               throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : node renumbering not implemented for not double DataArrays !");
4572             ret->renumberNodes(nodeRenumSafe->getConstPointer());
4573           }
4574         return ret.retn();
4575       }
4576     default:
4577       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
4578     }
4579 }
4580
4581 /*!
4582  * Returns values and a profile of the field of a given type lying on a given support.
4583  *  \param [in] type - a spatial discretization of the field.
4584  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4585  *  \param [in] mesh - the supporting mesh.
4586  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
4587  *          field of interest lies on. If the field lies on all entities of the given
4588  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
4589  *          using decrRef() as it is no more needed.
4590  *  \param [in] glob - the global data storing profiles and localization.
4591  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
4592  *          field. The caller is to delete this array using decrRef() as it is no more needed.
4593  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4594  *  \throw If no field of \a this is lying on \a mesh.
4595  *  \throw If no field values of the given \a type are available.
4596  */
4597 DataArray *MEDFileAnyTypeField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
4598 {
4599   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4600   int meshId=getMeshIdFromMeshName(mesh->getName());
4601   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob,nasc);
4602   ret->setName(nasc.getName().c_str());
4603   return ret.retn();
4604 }
4605
4606 //= MEDFileField1TSWithoutSDA
4607
4608 /*!
4609  * Throws if a given value is not a valid (non-extended) relative dimension.
4610  *  \param [in] meshDimRelToMax - the relative dimension value.
4611  *  \throw If \a meshDimRelToMax > 0.
4612  */
4613 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax) throw(INTERP_KERNEL::Exception)
4614 {
4615   if(meshDimRelToMax>0)
4616     throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
4617 }
4618
4619 /*!
4620  * Checks if elements of a given mesh are in the order suitable for writing
4621  * to the MED file. If this is not so, an exception is thrown. In a case of success, returns a
4622  * vector describing types of elements and their number.
4623  *  \param [in] mesh - the mesh to check.
4624  *  \return std::vector<int> - a vector holding for each element type (1) item of
4625  *          INTERP_KERNEL::NormalizedCellType, (2) number of elements, (3) -1.
4626  *          These values are in full-interlace mode.
4627  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4628  */
4629 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
4630 {
4631   if(!mesh)
4632     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
4633   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
4634   int nbOfTypes=geoTypes.size();
4635   std::vector<int> code(3*nbOfTypes);
4636   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr1=DataArrayInt::New();
4637   arr1->alloc(nbOfTypes,1);
4638   int *arrPtr=arr1->getPointer();
4639   std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
4640   for(int i=0;i<nbOfTypes;i++,it++)
4641     arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
4642   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
4643   const int *arrPtr2=arr2->getConstPointer();
4644   int i=0;
4645   for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
4646     {
4647       int pos=arrPtr2[i];
4648       int nbCells=mesh->getNumberOfCellsWithType(*it);
4649       code[3*pos]=(int)(*it);
4650       code[3*pos+1]=nbCells;
4651       code[3*pos+2]=-1;//no profiles
4652     }
4653   std::vector<const DataArrayInt *> idsPerType;//no profiles
4654   DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
4655   if(da)
4656     {
4657       da->decrRef();
4658       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
4659     }
4660   return code;
4661 }
4662
4663 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos)
4664 {
4665   return new MEDFileField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4666 }
4667
4668 /*!
4669  * Returns all attributes and values of parts of \a this field lying on a given mesh.
4670  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
4671  * item of every of returned sequences refers to the _i_-th part of \a this field.
4672  * Thus all sequences returned by this method are of the same length equal to number
4673  * of different types of supporting entities.<br>
4674  * A field part can include sub-parts with several different spatial discretizations,
4675  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
4676  * for example. Hence, some of the returned sequences contains nested sequences, and an item
4677  * of a nested sequence corresponds to a type of spatial discretization.<br>
4678  * This method allows for iteration over MEDFile DataStructure with a reduced overhead.
4679  * The overhead is due to selecting values into new instances of DataArrayDouble.
4680  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4681  *          for the case with only one underlying mesh. (Actually, the number of meshes is
4682  *          not checked if \a mname == \c NULL).
4683  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
4684  *          a field part is returned.
4685  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
4686  *          A field part can include sub-parts with several different spatial discretizations,
4687  *          \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and
4688  *          \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT" for example.
4689  *          This sequence is of the same length as \a types.
4690  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
4691  *          discretization. A profile name can be empty.
4692  *          Length of this and of nested sequences is the same as that of \a typesF.
4693  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
4694  *          discretization. A localization name can be empty.
4695  *          Length of this and of nested sequences is the same as that of \a typesF.
4696  *  \return std::vector< std::vector<DataArrayDouble *> > - a sequence holding arrays of values
4697  *          per each type of spatial discretization within one mesh entity type.
4698  *          The caller is to delete each DataArrayDouble using decrRef() as it is no more needed.
4699  *          Length of this and of nested sequences is the same as that of \a typesF.
4700  *  \throw If no field is lying on \a mname.
4701  */
4702 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)
4703 {
4704   int meshId=0;
4705   if(mname)
4706     meshId=getMeshIdFromMeshName(mname);
4707   else
4708     if(_field_per_mesh.empty())
4709       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
4710   std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
4711   int nbOfRet=ret0.size();
4712   std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
4713   for(int i=0;i<nbOfRet;i++)
4714     {
4715       const std::vector< std::pair<int,int> >& p=ret0[i];
4716       int nbOfRet1=p.size();
4717       ret[i].resize(nbOfRet1);
4718       for(int j=0;j<nbOfRet1;j++)
4719         {
4720           DataArrayDouble *tmp=_arr->selectByTupleId2(p[j].first,p[j].second,1);
4721           ret[i][j]=tmp;
4722         }
4723     }
4724   return ret;
4725 }
4726
4727 /*!
4728  * Returns a pointer to the underground DataArrayDouble instance. So the
4729  * caller should not decrRef() it. This method allows for a direct access to the field
4730  * values. This method is quite unusable if there is more than a nodal field or a cell
4731  * field on single geometric cell type.
4732  *  \return DataArrayDouble * - the pointer to the field values array.
4733  */
4734 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDouble() const throw(INTERP_KERNEL::Exception)
4735 {
4736   const DataArrayDouble *ret=_arr;
4737   if(ret)
4738     return const_cast<DataArrayDouble *>(ret);
4739   else
4740     return 0;
4741 }
4742
4743 const char *MEDFileField1TSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
4744 {
4745   return TYPE_STR;
4746 }
4747
4748 MEDFileIntField1TSWithoutSDA *MEDFileField1TSWithoutSDA::convertToInt() const throw(INTERP_KERNEL::Exception)
4749 {
4750   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA);
4751   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4752   ret->deepCpyLeavesFrom(*this);
4753   const DataArrayDouble *arr(_arr);
4754   if(arr)
4755     {
4756       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr->convertToIntArr());
4757       ret->setArray(arr2);
4758     }
4759   return ret.retn();
4760 }
4761
4762 /*!
4763  * Returns a pointer to the underground DataArrayDouble instance. So the
4764  * caller should not decrRef() it. This method allows for a direct access to the field
4765  * values. This method is quite unusable if there is more than a nodal field or a cell
4766  * field on single geometric cell type.
4767  *  \return DataArrayDouble * - the pointer to the field values array.
4768  */
4769 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
4770 {
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 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDoubleExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4791 {
4792   if(_field_per_mesh.size()!=1)
4793     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
4794   if(_field_per_mesh[0]==0)
4795     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
4796   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
4797   return getUndergroundDataArrayDouble();
4798 }
4799
4800 /*!
4801  * Returns a pointer to the underground DataArrayDouble instance and a
4802  * sequence describing parameters of a support of each part of \a this field. The
4803  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4804  * direct access to the field values. This method is intended for the field lying on one
4805  * mesh only.
4806  *  \param [in,out] entries - the sequence describing parameters of a support of each
4807  *         part of \a this field. Each item of this sequence consists of two parts. The
4808  *         first part describes a type of mesh entity and an id of discretization of a
4809  *         current field part. The second part describes a range of values [begin,end)
4810  *         within the returned array relating to the current field part.
4811  *  \return DataArrayDouble * - the pointer to the field values array.
4812  *  \throw If the number of underlying meshes is not equal to 1.
4813  *  \throw If no field values are available.
4814  *  \sa getUndergroundDataArray()
4815  */
4816 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4817 {
4818   return getUndergroundDataArrayDoubleExt(entries);
4819 }
4820
4821 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4822                                                      const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4823 {
4824   DataArrayDouble *arr=getOrCreateAndGetArrayDouble();
4825   arr->setInfoAndChangeNbOfCompo(infos);
4826 }
4827
4828 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4829 {
4830 }
4831
4832 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
4833 {
4834   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA(*this));
4835   ret->deepCpyLeavesFrom(*this);
4836   return ret.retn();
4837 }
4838
4839 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
4840 {
4841   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret=static_cast<MEDFileField1TSWithoutSDA *>(shallowCpy());
4842   if((const DataArrayDouble *)_arr)
4843     ret->_arr=_arr->deepCpy();
4844   return ret.retn();
4845 }
4846
4847 void MEDFileField1TSWithoutSDA::setArray(DataArray *arr) throw(INTERP_KERNEL::Exception)
4848 {
4849   if(!arr)
4850     {
4851       _nb_of_tuples_to_be_allocated=-1;
4852       _arr=0;
4853       return ;
4854     }
4855   DataArrayDouble *arrC=dynamic_cast<DataArrayDouble *>(arr);
4856   if(!arrC)
4857     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayDouble !");
4858   else
4859     _nb_of_tuples_to_be_allocated=-3;
4860   arrC->incrRef();
4861   _arr=arrC;
4862 }
4863
4864 DataArray *MEDFileField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
4865 {
4866   return DataArrayDouble::New();
4867 }
4868
4869 DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble()
4870 {
4871   DataArrayDouble *ret=_arr;
4872   if(ret)
4873     return ret;
4874   _arr=DataArrayDouble::New();
4875   return _arr;
4876 }
4877
4878 DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray()
4879 {
4880   return getOrCreateAndGetArrayDouble();
4881 }
4882
4883 const DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble() const
4884 {
4885   const DataArrayDouble *ret=_arr;
4886   if(ret)
4887     return ret;
4888   DataArrayDouble *ret2=DataArrayDouble::New();
4889   const_cast<MEDFileField1TSWithoutSDA *>(this)->_arr=DataArrayDouble::New();
4890   return ret2;
4891 }
4892
4893 const DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray() const
4894 {
4895   return getOrCreateAndGetArrayDouble();
4896 }
4897
4898 //= MEDFileIntField1TSWithoutSDA
4899
4900 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::New(const char *fieldName, int csit, int iteration, int order,
4901                                                                 const std::vector<std::string>& infos)
4902 {
4903   return new MEDFileIntField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4904 }
4905
4906 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4907 {
4908 }
4909
4910 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA(const char *fieldName, int csit, int iteration, int order,
4911                                                            const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4912 {
4913   DataArrayInt *arr=getOrCreateAndGetArrayInt();
4914   arr->setInfoAndChangeNbOfCompo(infos);
4915 }
4916
4917 const char *MEDFileIntField1TSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
4918 {
4919   return TYPE_STR;
4920 }
4921
4922 MEDFileField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::convertToDouble() const throw(INTERP_KERNEL::Exception)
4923 {
4924   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
4925   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4926   ret->deepCpyLeavesFrom(*this);
4927   const DataArrayInt *arr(_arr);
4928   if(arr)
4929     {
4930       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2(arr->convertToDblArr());
4931       ret->setArray(arr2);
4932     }
4933   return ret.retn();
4934 }
4935
4936 /*!
4937  * Returns a pointer to the underground DataArrayInt instance. So the
4938  * caller should not decrRef() it. This method allows for a direct access to the field
4939  * values. This method is quite unusable if there is more than a nodal field or a cell
4940  * field on single geometric cell type.
4941  *  \return DataArrayInt * - the pointer to the field values array.
4942  */
4943 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
4944 {
4945   return getUndergroundDataArrayInt();
4946 }
4947
4948 /*!
4949  * Returns a pointer to the underground DataArrayInt instance. So the
4950  * caller should not decrRef() it. This method allows for a direct access to the field
4951  * values. This method is quite unusable if there is more than a nodal field or a cell
4952  * field on single geometric cell type.
4953  *  \return DataArrayInt * - the pointer to the field values array.
4954  */
4955 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayInt() const throw(INTERP_KERNEL::Exception)
4956 {
4957   const DataArrayInt *ret=_arr;
4958   if(ret)
4959     return const_cast<DataArrayInt *>(ret);
4960   else
4961     return 0;
4962 }
4963
4964 /*!
4965  * Returns a pointer to the underground DataArrayInt instance and a
4966  * sequence describing parameters of a support of each part of \a this field. The
4967  * caller should not decrRef() the returned DataArrayInt. This method allows for a
4968  * direct access to the field values. This method is intended for the field lying on one
4969  * mesh only.
4970  *  \param [in,out] entries - the sequence describing parameters of a support of each
4971  *         part of \a this field. Each item of this sequence consists of two parts. The
4972  *         first part describes a type of mesh entity and an id of discretization of a
4973  *         current field part. The second part describes a range of values [begin,end)
4974  *         within the returned array relating to the current field part.
4975  *  \return DataArrayInt * - the pointer to the field values array.
4976  *  \throw If the number of underlying meshes is not equal to 1.
4977  *  \throw If no field values are available.
4978  *  \sa getUndergroundDataArray()
4979  */
4980 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4981 {
4982   return getUndergroundDataArrayIntExt(entries);
4983 }
4984
4985 /*!
4986  * Returns a pointer to the underground DataArrayInt instance and a
4987  * sequence describing parameters of a support of each part of \a this field. The
4988  * caller should not decrRef() the returned DataArrayInt. This method allows for a
4989  * direct access to the field values. This method is intended for the field lying on one
4990  * mesh only.
4991  *  \param [in,out] entries - the sequence describing parameters of a support of each
4992  *         part of \a this field. Each item of this sequence consists of two parts. The
4993  *         first part describes a type of mesh entity and an id of discretization of a
4994  *         current field part. The second part describes a range of values [begin,end)
4995  *         within the returned array relating to the current field part.
4996  *  \return DataArrayInt * - the pointer to the field values array.
4997  *  \throw If the number of underlying meshes is not equal to 1.
4998  *  \throw If no field values are available.
4999  *  \sa getUndergroundDataArray()
5000  */
5001 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
5002 {
5003   if(_field_per_mesh.size()!=1)
5004     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
5005   if(_field_per_mesh[0]==0)
5006     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
5007   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
5008   return getUndergroundDataArrayInt();
5009 }
5010
5011 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
5012 {
5013   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA(*this));
5014   ret->deepCpyLeavesFrom(*this);
5015   return ret.retn();
5016 }
5017
5018 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
5019 {
5020   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret=static_cast<MEDFileIntField1TSWithoutSDA *>(shallowCpy());
5021   if((const DataArrayInt *)_arr)
5022     ret->_arr=_arr->deepCpy();
5023   return ret.retn();
5024 }
5025
5026 void MEDFileIntField1TSWithoutSDA::setArray(DataArray *arr) throw(INTERP_KERNEL::Exception)
5027 {
5028   if(!arr)
5029     {
5030       _nb_of_tuples_to_be_allocated=-1;
5031       _arr=0;
5032       return ;
5033     }
5034   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>(arr);
5035   if(!arrC)
5036     throw INTERP_KERNEL::Exception("MEDFileIntField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayInt !");
5037   else
5038     _nb_of_tuples_to_be_allocated=-3;
5039   arrC->incrRef();
5040   _arr=arrC;
5041 }
5042
5043 DataArray *MEDFileIntField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
5044 {
5045   return DataArrayInt::New();
5046 }
5047
5048 DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt()
5049 {
5050   DataArrayInt *ret=_arr;
5051   if(ret)
5052     return ret;
5053   _arr=DataArrayInt::New();
5054   return _arr;
5055 }
5056
5057 DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray()
5058 {
5059   return getOrCreateAndGetArrayInt();
5060 }
5061
5062 const DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt() const
5063 {
5064   const DataArrayInt *ret=_arr;
5065   if(ret)
5066     return ret;
5067   DataArrayInt *ret2=DataArrayInt::New();
5068   const_cast<MEDFileIntField1TSWithoutSDA *>(this)->_arr=DataArrayInt::New();
5069   return ret2;
5070 }
5071
5072 const DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray() const
5073 {
5074   return getOrCreateAndGetArrayInt();
5075 }
5076
5077 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
5078 {
5079 }
5080
5081 //= MEDFileAnyTypeField1TS
5082
5083 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5084 {
5085   med_field_type typcha;
5086   //
5087   std::vector<std::string> infos;
5088   std::string dtunit,fieldName;
5089   LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
5090   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5091   switch(typcha)
5092     {
5093     case MED_FLOAT64:
5094       {
5095         ret=MEDFileField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5096         break;
5097       }
5098     case MED_INT32:
5099       {
5100         ret=MEDFileIntField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5101         break;
5102       }
5103     default:
5104       {
5105         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] !";
5106         throw INTERP_KERNEL::Exception(oss.str().c_str());
5107       }
5108     }
5109   ret->setDtUnit(dtunit.c_str());
5110   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5111   //
5112   med_int numdt,numit;
5113   med_float dt;
5114   MEDfieldComputingStepInfo(fid,fieldName.c_str(),1,&numdt,&numit,&dt);
5115   ret->setTime(numdt,numit,dt);
5116   ret->_csit=1;
5117   if(loadAll)
5118     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5119   else
5120     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5121   return ret.retn();
5122 }
5123
5124 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5125 try:MEDFileFieldGlobsReal(fileName)
5126 {
5127   MEDFileUtilities::CheckFileForRead(fileName);
5128   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5129   _content=BuildContentFrom(fid,fileName,loadAll);
5130   loadGlobals(fid);
5131 }
5132 catch(INTERP_KERNEL::Exception& e)
5133   {
5134     throw e;
5135   }
5136
5137 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5138 {
5139   med_field_type typcha;
5140   std::vector<std::string> infos;
5141   std::string dtunit;
5142   int iii=-1;
5143   int nbSteps=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5144   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5145   switch(typcha)
5146     {
5147     case MED_FLOAT64:
5148       {
5149         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5150         break;
5151       }
5152     case MED_INT32:
5153       {
5154         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5155         break;
5156       }
5157     default:
5158       {
5159         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] !";
5160         throw INTERP_KERNEL::Exception(oss.str().c_str());
5161       }
5162     }
5163   ret->setDtUnit(dtunit.c_str());
5164   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5165   //
5166   if(nbSteps<1)
5167     {
5168       std::ostringstream oss; oss << "MEDFileField1TS(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but there is no time steps on it !";
5169       throw INTERP_KERNEL::Exception(oss.str().c_str());
5170     }
5171   //
5172   med_int numdt,numit;
5173   med_float dt;
5174   MEDfieldComputingStepInfo(fid,fieldName,1,&numdt,&numit,&dt);
5175   ret->setTime(numdt,numit,dt);
5176   ret->_csit=1;
5177   if(loadAll)
5178     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5179   else
5180     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5181   return ret.retn();
5182 }
5183
5184 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5185 try:MEDFileFieldGlobsReal(fileName)
5186 {
5187   MEDFileUtilities::CheckFileForRead(fileName);
5188   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5189   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
5190   loadGlobals(fid);
5191 }
5192 catch(INTERP_KERNEL::Exception& e)
5193   {
5194     throw e;
5195   }
5196
5197 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c, const char *fileName) throw(INTERP_KERNEL::Exception)
5198 {
5199   if(!c)
5200     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
5201   if(dynamic_cast<const MEDFileField1TSWithoutSDA *>(c))
5202     {
5203       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New();
5204       ret->setFileName(fileName);
5205       ret->_content=c; c->incrRef();
5206       return ret.retn();
5207     }
5208   if(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(c))
5209     {
5210       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New();
5211       ret->setFileName(fileName);
5212       ret->_content=c; c->incrRef();
5213       return ret.retn();
5214     }
5215   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
5216 }
5217
5218 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5219 {
5220   MEDFileUtilities::CheckFileForRead(fileName);
5221   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5222   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
5223   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5224   ret->loadGlobals(fid);
5225   return ret.retn();
5226 }
5227
5228 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5229 {
5230   MEDFileUtilities::CheckFileForRead(fileName);
5231   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5232   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
5233   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5234   ret->loadGlobals(fid);
5235   return ret.retn();
5236 }
5237
5238 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5239 {
5240   MEDFileUtilities::CheckFileForRead(fileName);
5241   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5242   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5243   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5244   ret->loadGlobals(fid);
5245   return ret.retn();
5246 }
5247
5248 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5249 {
5250   med_field_type typcha;
5251   std::vector<std::string> infos;
5252   std::string dtunit;
5253   int iii=-1;
5254   int nbOfStep2=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5255   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5256   switch(typcha)
5257     {
5258     case MED_FLOAT64:
5259       {
5260         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5261         break;
5262       }
5263     case MED_INT32:
5264       {
5265         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5266         break;
5267       }
5268     default:
5269       {
5270         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] !";
5271         throw INTERP_KERNEL::Exception(oss.str().c_str());
5272       }
5273     }
5274   ret->setDtUnit(dtunit.c_str());
5275   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5276   //
5277   bool found=false;
5278   std::vector< std::pair<int,int> > dtits(nbOfStep2);
5279   for(int i=0;i<nbOfStep2 && !found;i++)
5280     {
5281       med_int numdt,numit;
5282       med_float dt;
5283       MEDfieldComputingStepInfo(fid,fieldName,i+1,&numdt,&numit,&dt);
5284       if(numdt==iteration && numit==order)
5285         {
5286           found=true;
5287           ret->_csit=i+1;
5288         }
5289       else
5290         dtits[i]=std::pair<int,int>(numdt,numit);
5291     }
5292   if(!found)
5293     {
5294       std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << fileName << "' ! Available iterations are : ";
5295       for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
5296         oss << "(" << (*iter).first << "," << (*iter).second << "), ";
5297       throw INTERP_KERNEL::Exception(oss.str().c_str());
5298     }
5299   if(loadAll)
5300     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5301   else
5302     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5303   return ret.retn();
5304 }
5305
5306 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5307 try:MEDFileFieldGlobsReal(fileName)
5308 {
5309   MEDFileUtilities::CheckFileForRead(fileName);
5310   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5311   _content=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5312   loadGlobals(fid);
5313 }
5314 catch(INTERP_KERNEL::Exception& e)
5315   {
5316     throw e;
5317   }
5318
5319 /*!
5320  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5321  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5322  *
5323  * \warning this is a shallow copy constructor
5324  */
5325 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent)
5326 {
5327   if(!shallowCopyOfContent)
5328     {
5329       const MEDFileAnyTypeField1TSWithoutSDA *otherPtr(&other);
5330       otherPtr->incrRef();
5331       _content=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(otherPtr);
5332     }
5333   else
5334     {
5335       _content=other.shallowCpy();
5336     }
5337 }
5338
5339 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)
5340 {
5341   if(checkFieldId)
5342     {
5343       int nbFields=MEDnField(fid);
5344       if(fieldIdCFormat>=nbFields)
5345         {
5346           std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << fileName << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
5347           throw INTERP_KERNEL::Exception(oss.str().c_str());
5348         }
5349     }
5350   int ncomp=MEDfieldnComponent(fid,fieldIdCFormat+1);
5351   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5352   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5353   INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5354   INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5355   INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5356   med_bool localMesh;
5357   int nbOfStep;
5358   MEDfieldInfo(fid,fieldIdCFormat+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
5359   fieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
5360   dtunitOut=MEDLoaderBase::buildStringFromFortran(dtunit,MED_LNAME_SIZE);
5361   infos.clear(); infos.resize(ncomp);
5362   for(int j=0;j<ncomp;j++)
5363     infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
5364   return nbOfStep;
5365 }
5366
5367 /*!
5368  * This method throws an INTERP_KERNEL::Exception if \a fieldName field is not in file pointed by \a fid and with name \a fileName.
5369  *
5370  * \param [out]
5371  * \return in case of success the number of time steps available for the field with name \a fieldName.
5372  */
5373 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)
5374 {
5375   int nbFields=MEDnField(fid);
5376   bool found=false;
5377   std::vector<std::string> fns(nbFields);
5378   int nbOfStep2=-1;
5379   for(int i=0;i<nbFields && !found;i++)
5380     {
5381       std::string tmp;
5382       nbOfStep2=LocateField2(fid,fileName,i,false,tmp,typcha,infos,dtunitOut);
5383       fns[i]=tmp;
5384       found=(tmp==fieldName);
5385       if(found)
5386         posCFormat=i;
5387     }
5388   if(!found)
5389     {
5390       std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << fileName << "' ! Available fields are : ";
5391       for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
5392         oss << "\"" << *it << "\" ";
5393       throw INTERP_KERNEL::Exception(oss.str().c_str());
5394     }
5395   return nbOfStep2;
5396 }
5397
5398 /*!
5399  * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5400  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5401  * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5402  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5403  * to keep a valid instance.
5404  * 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.
5405  * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
5406  * 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.
5407  *
5408  * \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.
5409  * \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.
5410  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5411  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5412  * \param [in] newLocName is the new localization name.
5413  * \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.
5414  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
5415  */
5416 void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newPflName, bool forceRenameOnGlob) throw(INTERP_KERNEL::Exception)
5417 {
5418   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5419   std::string oldPflName=disc->getProfile();
5420   std::vector<std::string> vv=getPflsReallyUsedMulti();
5421   int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
5422   if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
5423     {
5424       disc->setProfile(newPflName);
5425       DataArrayInt *pfl=getProfile(oldPflName.c_str());
5426       pfl->setName(newPflName);
5427     }
5428   else
5429     {
5430       std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
5431       throw INTERP_KERNEL::Exception(oss.str().c_str());
5432     }
5433 }
5434
5435 /*!
5436  * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5437  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5438  * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5439  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5440  * to keep a valid instance.
5441  * 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.
5442  * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
5443  * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
5444  * 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.
5445  *
5446  * \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.
5447  * \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.
5448  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5449  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5450  * \param [in] newLocName is the new localization name.
5451  * \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.
5452  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
5453  */
5454 void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newLocName, bool forceRenameOnGlob) throw(INTERP_KERNEL::Exception)
5455 {
5456   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5457   std::string oldLocName=disc->getLocalization();
5458   std::vector<std::string> vv=getLocsReallyUsedMulti();
5459   int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
5460   if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
5461     {
5462       disc->setLocalization(newLocName);
5463       MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
5464       loc.setName(newLocName);
5465     }
5466   else
5467     {
5468       std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
5469       throw INTERP_KERNEL::Exception(oss.str().c_str());
5470     }
5471 }
5472
5473 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() throw(INTERP_KERNEL::Exception)
5474 {
5475   MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5476   if(!ret)
5477     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : content is expected to be not null !");
5478   return ret;
5479 }
5480
5481 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() const throw(INTERP_KERNEL::Exception)
5482 {
5483   const MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5484   if(!ret)
5485     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : const content is expected to be not null !");
5486   return ret;
5487 }
5488
5489 /*!
5490  * Writes \a this field into a MED file specified by its name.
5491  *  \param [in] fileName - the MED file name.
5492  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
5493  * - 2 - erase; an existing file is removed.
5494  * - 1 - append; same data should not be present in an existing file.
5495  * - 0 - overwrite; same data present in an existing file is overwritten.
5496  *  \throw If the field name is not set.
5497  *  \throw If no field data is set.
5498  *  \throw If \a mode == 1 and the same data is present in an existing file.
5499  */
5500 void MEDFileAnyTypeField1TS::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
5501 {
5502   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
5503   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
5504   writeLL(fid);
5505 }
5506
5507 /*!
5508  * This method alloc the arrays and load potentially huge arrays contained in this field.
5509  * This method should be called when a MEDFileAnyTypeField1TS::New constructor has been with false as the last parameter.
5510  * This method can be also called to refresh or reinit values from a file.
5511  *
5512  * \throw If the fileName is not set or points to a non readable MED file.
5513  * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5514  */
5515 void MEDFileAnyTypeField1TS::loadArrays() throw(INTERP_KERNEL::Exception)
5516 {
5517   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5518   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
5519 }
5520
5521 /*!
5522  * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
5523  * But once data loaded once, this method does nothing.
5524  *
5525  * \throw If the fileName is not set or points to a non readable MED file.
5526  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::releaseArrays
5527  */
5528 void MEDFileAnyTypeField1TS::loadArraysIfNecessary() throw(INTERP_KERNEL::Exception)
5529 {
5530   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
5531   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
5532 }
5533
5534 /*!
5535  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
5536  * This method does not release arrays set outside the context of a MED file.
5537  *
5538  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary
5539  */
5540 void MEDFileAnyTypeField1TS::releaseArrays() throw(INTERP_KERNEL::Exception)
5541 {
5542   contentNotNullBase()->releaseArrays();
5543 }
5544
5545 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
5546 {
5547   int nbComp=getNumberOfComponents();
5548   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5549   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5550   for(int i=0;i<nbComp;i++)
5551     {
5552       std::string info=getInfo()[i];
5553       std::string c,u;
5554       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
5555       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
5556       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
5557     }
5558   if(getName().empty())
5559     throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
5560   MEDfieldCr(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
5561   writeGlobals(fid,*this);
5562   contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
5563 }
5564
5565 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySize() const
5566 {
5567   std::size_t ret=0;
5568   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5569     ret+=_content->getHeapMemorySize();
5570   return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
5571 }
5572
5573 /*!
5574  * Returns a string describing \a this field. This string is outputted
5575  * by \c print Python command.
5576  */
5577 std::string MEDFileAnyTypeField1TS::simpleRepr() const
5578 {
5579   std::ostringstream oss;
5580   contentNotNullBase()->simpleRepr(0,oss,-1);
5581   simpleReprGlobs(oss);
5582   return oss.str();
5583 }
5584
5585 /*!
5586  * This method returns all profiles whose name is non empty used.
5587  * \b WARNING If profile is used several times it will be reported \b only \b once.
5588  * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
5589  */
5590 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
5591 {
5592   return contentNotNullBase()->getPflsReallyUsed2();
5593 }
5594
5595 /*!
5596  * This method returns all localizations whose name is non empty used.
5597  * \b WARNING If localization is used several times it will be reported \b only \b once.
5598  */
5599 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
5600 {
5601   return contentNotNullBase()->getLocsReallyUsed2();
5602 }
5603
5604 /*!
5605  * This method returns all profiles whose name is non empty used.
5606  * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
5607  */
5608 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
5609 {
5610   return contentNotNullBase()->getPflsReallyUsedMulti2();
5611 }
5612
5613 /*!
5614  * This method returns all localizations whose name is non empty used.
5615  * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
5616  */
5617 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
5618 {
5619   return contentNotNullBase()->getLocsReallyUsedMulti2();
5620 }
5621
5622 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5623 {
5624   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
5625 }
5626
5627 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5628 {
5629   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
5630 }
5631
5632 int MEDFileAnyTypeField1TS::getDimension() const
5633 {
5634   return contentNotNullBase()->getDimension();
5635 }
5636
5637 int MEDFileAnyTypeField1TS::getIteration() const
5638 {
5639   return contentNotNullBase()->getIteration();
5640 }
5641
5642 int MEDFileAnyTypeField1TS::getOrder() const
5643 {
5644   return contentNotNullBase()->getOrder();
5645 }
5646
5647 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
5648 {
5649   return contentNotNullBase()->getTime(iteration,order);
5650 }
5651
5652 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
5653 {
5654   contentNotNullBase()->setTime(iteration,order,val);
5655 }
5656
5657 std::string MEDFileAnyTypeField1TS::getName() const
5658 {
5659   return contentNotNullBase()->getName();
5660 }
5661
5662 void MEDFileAnyTypeField1TS::setName(const char *name)
5663 {
5664   contentNotNullBase()->setName(name);
5665 }
5666
5667 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
5668 {
5669   contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
5670 }
5671
5672 std::string MEDFileAnyTypeField1TS::getDtUnit() const throw(INTERP_KERNEL::Exception)
5673 {
5674   return contentNotNullBase()->getDtUnit();
5675 }
5676
5677 void MEDFileAnyTypeField1TS::setDtUnit(const char *dtUnit) throw(INTERP_KERNEL::Exception)
5678 {
5679   contentNotNullBase()->setDtUnit(dtUnit);
5680 }
5681
5682 std::string MEDFileAnyTypeField1TS::getMeshName() const throw(INTERP_KERNEL::Exception)
5683 {
5684   return contentNotNullBase()->getMeshName();
5685 }
5686
5687 void MEDFileAnyTypeField1TS::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
5688 {
5689   contentNotNullBase()->setMeshName(newMeshName);
5690 }
5691
5692 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
5693 {
5694   return contentNotNullBase()->changeMeshNames(modifTab);
5695 }
5696
5697 int MEDFileAnyTypeField1TS::getMeshIteration() const throw(INTERP_KERNEL::Exception)
5698 {
5699   return contentNotNullBase()->getMeshIteration();
5700 }
5701
5702 int MEDFileAnyTypeField1TS::getMeshOrder() const throw(INTERP_KERNEL::Exception)
5703 {
5704   return contentNotNullBase()->getMeshOrder();
5705 }
5706
5707 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
5708 {
5709   return contentNotNullBase()->getNumberOfComponents();
5710 }
5711
5712 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
5713 {
5714   return contentNotNullBase()->isDealingTS(iteration,order);
5715 }
5716
5717 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
5718 {
5719   return contentNotNullBase()->getDtIt();
5720 }
5721
5722 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
5723 {
5724   contentNotNullBase()->fillIteration(p);
5725 }
5726
5727 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
5728 {
5729   contentNotNullBase()->fillTypesOfFieldAvailable(types);
5730 }
5731
5732 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos) throw(INTERP_KERNEL::Exception)
5733 {
5734   contentNotNullBase()->setInfo(infos);
5735 }
5736
5737 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
5738 {
5739   return contentNotNullBase()->getInfo();
5740 }
5741 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
5742 {
5743   return contentNotNullBase()->getInfo();
5744 }
5745
5746 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
5747 {
5748   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5749 }
5750
5751 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
5752 {
5753   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5754 }
5755
5756 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
5757 {
5758   return contentNotNullBase()->getNonEmptyLevels(mname,levs);
5759 }
5760
5761 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
5762 {
5763   return contentNotNullBase()->getTypesOfFieldAvailable();
5764 }
5765
5766 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,
5767                                                                                        std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5768 {
5769   return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
5770 }
5771
5772 /*!
5773  * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
5774  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5775  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
5776  */
5777 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const throw(INTERP_KERNEL::Exception)
5778 {
5779   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5780   if(!content)
5781     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
5782   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
5783   std::size_t sz(contentsSplit.size());
5784   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5785   for(std::size_t i=0;i<sz;i++)
5786     {
5787       ret[i]=shallowCpy();
5788       ret[i]->_content=contentsSplit[i];
5789     }
5790   return ret;
5791 }
5792
5793 /*!
5794  * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
5795  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5796  */
5797 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
5798 {
5799   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5800   if(!content)
5801     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
5802   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitDiscretizations();
5803   std::size_t sz(contentsSplit.size());
5804   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5805   for(std::size_t i=0;i<sz;i++)
5806     {
5807       ret[i]=shallowCpy();
5808       ret[i]->_content=contentsSplit[i];
5809     }
5810   return ret;
5811 }
5812
5813 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCpy() const throw(INTERP_KERNEL::Exception)
5814 {
5815   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=shallowCpy();
5816   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5817     ret->_content=_content->deepCpy();
5818   ret->deepCpyGlobs(*this);
5819   return ret.retn();
5820 }
5821
5822 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr) throw(INTERP_KERNEL::Exception)
5823 {
5824   return contentNotNullBase()->copyTinyInfoFrom(field,arr);
5825 }
5826
5827 //= MEDFileField1TS
5828
5829 /*!
5830  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5831  * the first field that has been read from a specified MED file.
5832  *  \param [in] fileName - the name of the MED file to read.
5833  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5834  *          is to delete this field using decrRef() as it is no more needed.
5835  *  \throw If reading the file fails.
5836  */
5837 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5838 {
5839   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,loadAll);
5840   ret->contentNotNull();
5841   return ret.retn();
5842 }
5843
5844 /*!
5845  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5846  * a given field that has been read from a specified MED file.
5847  *  \param [in] fileName - the name of the MED file to read.
5848  *  \param [in] fieldName - the name of the field to read.
5849  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5850  *          is to delete this field using decrRef() as it is no more needed.
5851  *  \throw If reading the file fails.
5852  *  \throw If there is no field named \a fieldName in the file.
5853  */
5854 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5855 {
5856   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,loadAll);
5857   ret->contentNotNull();
5858   return ret.retn();
5859 }
5860
5861 /*!
5862  * Returns a new instance of MEDFileField1TS holding data of a given time step of
5863  * a given field that has been read from a specified MED file.
5864  *  \param [in] fileName - the name of the MED file to read.
5865  *  \param [in] fieldName - the name of the field to read.
5866  *  \param [in] iteration - the iteration number of a required time step.
5867  *  \param [in] order - the iteration order number of required time step.
5868  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5869  *          is to delete this field using decrRef() as it is no more needed.
5870  *  \throw If reading the file fails.
5871  *  \throw If there is no field named \a fieldName in the file.
5872  *  \throw If the required time step is missing from the file.
5873  */
5874 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
5875 {
5876   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,iteration,order,loadAll);
5877   ret->contentNotNull();
5878   return ret.retn();
5879 }
5880
5881 /*!
5882  * Returns a new instance of MEDFileField1TS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5883  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5884  *
5885  * Returns a new instance of MEDFileField1TS holding either a shallow copy
5886  * of a given MEDFileField1TSWithoutSDA ( \a other ) or \a other itself.
5887  * \warning this is a shallow copy constructor
5888  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
5889  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
5890  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5891  *          is to delete this field using decrRef() as it is no more needed.
5892  */
5893 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5894 {
5895   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(other,shallowCopyOfContent);
5896   ret->contentNotNull();
5897   return ret.retn();
5898 }
5899
5900 /*!
5901  * Returns a new empty instance of MEDFileField1TS.
5902  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5903  *          is to delete this field using decrRef() as it is no more needed.
5904  */
5905 MEDFileField1TS *MEDFileField1TS::New()
5906 {
5907   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS;
5908   ret->contentNotNull();
5909   return ret.retn();
5910 }
5911
5912 /*!
5913  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
5914  * following the given input policy.
5915  *
5916  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
5917  *                            By default (true) the globals are deeply copied.
5918  * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
5919  */
5920 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
5921 {
5922   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret;
5923   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5924   if(content)
5925     {
5926       const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
5927       if(!contc)
5928         throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
5929       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
5930       ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc,getFileName()));
5931     }
5932   else
5933     ret=MEDFileIntField1TS::New();
5934   if(deepCpyGlobs)
5935     ret->deepCpyGlobs(*this);
5936   else
5937     ret->shallowCpyGlobs(*this);
5938   return ret.retn();
5939 }
5940
5941 const MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() const throw(INTERP_KERNEL::Exception)
5942 {
5943   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
5944   if(!pt)
5945     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is null !");
5946   const MEDFileField1TSWithoutSDA *ret=dynamic_cast<const MEDFileField1TSWithoutSDA *>(pt);
5947   if(!ret)
5948     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 !");
5949   return ret;
5950 }
5951
5952 MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() throw(INTERP_KERNEL::Exception)
5953 {
5954   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
5955   if(!pt)
5956     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is null !");
5957   MEDFileField1TSWithoutSDA *ret=dynamic_cast<MEDFileField1TSWithoutSDA *>(pt);
5958   if(!ret)
5959     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 !");
5960   return ret;
5961 }
5962
5963 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MEDCouplingAutoRefCountObjectPtr<DataArray>& arr) throw(INTERP_KERNEL::Exception)
5964 {
5965   if(!f)
5966     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
5967   if(!((DataArray*)arr))
5968     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
5969   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
5970   if(!arrOutC)
5971     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
5972   f->setArray(arrOutC);
5973 }
5974
5975 DataArrayDouble *MEDFileField1TS::ReturnSafelyDataArrayDouble(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr) throw(INTERP_KERNEL::Exception)
5976 {
5977   if(!((DataArray*)arr))
5978     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : no array !");
5979   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
5980   if(!arrOutC)
5981     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
5982   arrOutC->incrRef();
5983   return arrOutC;
5984 }
5985
5986 MEDFileField1TS::MEDFileField1TS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
5987 try:MEDFileAnyTypeField1TS(fileName,loadAll)
5988 {
5989 }
5990 catch(INTERP_KERNEL::Exception& e)
5991   { throw e; }
5992
5993 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
5994 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
5995 {
5996 }
5997 catch(INTERP_KERNEL::Exception& e)
5998   { throw e; }
5999
6000 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
6001 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6002 {
6003 }
6004 catch(INTERP_KERNEL::Exception& e)
6005   { throw e; }
6006
6007 /*!
6008  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6009  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6010  *
6011  * \warning this is a shallow copy constructor
6012  */
6013 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
6014 try:MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6015 {
6016 }
6017 catch(INTERP_KERNEL::Exception& e)
6018   { throw e; }
6019
6020 MEDFileField1TS::MEDFileField1TS()
6021 {
6022   _content=new MEDFileField1TSWithoutSDA;
6023 }
6024
6025 /*!
6026  * Returns a new MEDCouplingFieldDouble of a given type lying on
6027  * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6028  * has not been constructed via file reading, an exception is thrown.
6029  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6030  *  \param [in] type - a spatial discretization of interest.
6031  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6032  *  \param [in] renumPol - specifies how to permute values of the result field according to
6033  *          the optional numbers of cells and nodes, if any. The valid values are
6034  *          - 0 - do not permute.
6035  *          - 1 - permute cells.
6036  *          - 2 - permute nodes.
6037  *          - 3 - permute cells and nodes.
6038  *
6039  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6040  *          caller is to delete this field using decrRef() as it is no more needed.
6041  *  \throw If \a this field has not been constructed via file reading.
6042  *  \throw If the MED file is not readable.
6043  *  \throw If there is no mesh in the MED file.
6044  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6045  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6046  *  \sa getFieldOnMeshAtLevel()
6047  */
6048 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
6049 {
6050   if(getFileName2().empty())
6051     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6052   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6053   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNull());
6054   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6055   return ret.retn();
6056 }
6057
6058 /*!
6059  * Returns a new MEDCouplingFieldDouble of a given type lying on
6060  * the top level cells of the first mesh in MED file. If \a this field
6061  * has not been constructed via file reading, an exception is thrown.
6062  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6063  *  \param [in] type - a spatial discretization of interest.
6064  *  \param [in] renumPol - specifies how to permute values of the result field according to
6065  *          the optional numbers of cells and nodes, if any. The valid values are
6066  *          - 0 - do not permute.
6067  *          - 1 - permute cells.
6068  *          - 2 - permute nodes.
6069  *          - 3 - permute cells and nodes.
6070  *
6071  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6072  *          caller is to delete this field using decrRef() as it is no more needed.
6073  *  \throw If \a this field has not been constructed via file reading.
6074  *  \throw If the MED file is not readable.
6075  *  \throw If there is no mesh in the MED file.
6076  *  \throw If no field values of the given \a type.
6077  *  \throw If no field values lying on the top level support.
6078  *  \sa getFieldAtLevel()
6079  */
6080 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const throw(INTERP_KERNEL::Exception)
6081 {
6082   if(getFileName2().empty())
6083     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6084   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6085   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNull());
6086   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6087   return ret.retn();
6088 }
6089
6090 /*!
6091  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6092  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6093  *  \param [in] type - a spatial discretization of the new field.
6094  *  \param [in] mesh - the supporting mesh.
6095  *  \param [in] renumPol - specifies how to permute values of the result field according to
6096  *          the optional numbers of cells and nodes, if any. The valid values are
6097  *          - 0 - do not permute.
6098  *          - 1 - permute cells.
6099  *          - 2 - permute nodes.
6100  *          - 3 - permute cells and nodes.
6101  *
6102  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6103  *          caller is to delete this field using decrRef() as it is no more needed.
6104  *  \throw If no field of \a this is lying on \a mesh.
6105  *  \throw If the mesh is empty.
6106  *  \throw If no field values of the given \a type are available.
6107  *  \sa getFieldAtLevel()
6108  *  \sa getFieldOnMeshAtLevel()
6109  */
6110 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
6111 {
6112   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6113   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull());
6114   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6115   return ret.retn();
6116 }
6117
6118 /*!
6119  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6120  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6121  *  \param [in] type - a spatial discretization of interest.
6122  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6123  *  \param [in] mesh - the supporting mesh.
6124  *  \param [in] renumPol - specifies how to permute values of the result field according to
6125  *          the optional numbers of cells and nodes, if any. The valid values are
6126  *          - 0 - do not permute.
6127  *          - 1 - permute cells.
6128  *          - 2 - permute nodes.
6129  *          - 3 - permute cells and nodes.
6130  *
6131  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6132  *          caller is to delete this field using decrRef() as it is no more needed.
6133  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6134  *  \throw If no field of \a this is lying on \a mesh.
6135  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6136  *  \sa getFieldAtLevel()
6137  *  \sa getFieldOnMeshAtLevel()
6138  */
6139 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
6140 {
6141   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6142   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull());
6143   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6144   return ret.retn();
6145 }
6146
6147 /*!
6148  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6149  * This method is called "Old" because in MED3 norm a field has only one meshName
6150  * attached, so this method is for readers of MED2 files. If \a this field
6151  * has not been constructed via file reading, an exception is thrown.
6152  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6153  *  \param [in] type - a spatial discretization of interest.
6154  *  \param [in] mName - a name of the supporting mesh.
6155  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6156  *  \param [in] renumPol - specifies how to permute values of the result field according to
6157  *          the optional numbers of cells and nodes, if any. The valid values are
6158  *          - 0 - do not permute.
6159  *          - 1 - permute cells.
6160  *          - 2 - permute nodes.
6161  *          - 3 - permute cells and nodes.
6162  *
6163  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6164  *          caller is to delete this field using decrRef() as it is no more needed.
6165  *  \throw If the MED file is not readable.
6166  *  \throw If there is no mesh named \a mName in the MED file.
6167  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6168  *  \throw If \a this field has not been constructed via file reading.
6169  *  \throw If no field of \a this is lying on the mesh named \a mName.
6170  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6171  *  \sa getFieldAtLevel()
6172  */
6173 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
6174 {
6175   if(getFileName2().empty())
6176     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6177   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6178   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
6179   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6180   return ret.retn();
6181 }
6182
6183 /*!
6184  * Returns values and a profile of the field of a given type lying on a given support.
6185  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6186  *  \param [in] type - a spatial discretization of the field.
6187  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6188  *  \param [in] mesh - the supporting mesh.
6189  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6190  *          field of interest lies on. If the field lies on all entities of the given
6191  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6192  *          using decrRef() as it is no more needed.
6193  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
6194  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6195  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6196  *  \throw If no field of \a this is lying on \a mesh.
6197  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6198  */
6199 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
6200 {
6201   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6202   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
6203 }
6204
6205 /*!
6206  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6207  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6208  * "Sort By Type"), if not, an exception is thrown.
6209  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6210  *  \param [in] field - the field to add to \a this.
6211  *  \throw If the name of \a field is empty.
6212  *  \throw If the data array of \a field is not set.
6213  *  \throw If the data array is already allocated but has different number of components
6214  *         than \a field.
6215  *  \throw If the underlying mesh of \a field has no name.
6216  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6217  */
6218 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
6219 {
6220   setFileName("");
6221   contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
6222 }
6223
6224 /*!
6225  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6226  * can be an aggregation of several MEDCouplingFieldDouble instances.
6227  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6228  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6229  * and \a profile.
6230  *
6231  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6232  * A new profile is added only if no equal profile is missing.
6233  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6234  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
6235  *  \param [in] mesh - the supporting mesh of \a field.
6236  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6237  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6238  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6239  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6240  *  \throw If the data array of \a field is not set.
6241  *  \throw If the data array of \a this is already allocated but has different number of
6242  *         components than \a field.
6243  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6244  *  \sa setFieldNoProfileSBT()
6245  */
6246 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
6247 {
6248   setFileName("");
6249   contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6250 }
6251
6252 MEDFileAnyTypeField1TS *MEDFileField1TS::shallowCpy() const throw(INTERP_KERNEL::Exception)
6253 {
6254   return new MEDFileField1TS(*this);
6255 }
6256
6257 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
6258 {
6259   return contentNotNull()->getUndergroundDataArrayDouble();
6260 }
6261
6262 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
6263 {
6264   return contentNotNull()->getUndergroundDataArrayDoubleExt(entries);
6265 }
6266
6267 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6268                                                                                       std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
6269 {
6270   return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
6271 }
6272
6273 //= MEDFileIntField1TS
6274
6275 MEDFileIntField1TS *MEDFileIntField1TS::New()
6276 {
6277   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS;
6278   ret->contentNotNull();
6279   return ret.retn();
6280 }
6281
6282 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
6283 {
6284   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,loadAll);
6285   ret->contentNotNull();
6286   return ret.retn();
6287 }
6288
6289 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
6290 {
6291   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,loadAll);
6292   ret->contentNotNull();
6293   return ret.retn();
6294 }
6295
6296 MEDFileIntField1TS *MEDFileIntField1TS::New(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
6297 {
6298   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,iteration,order,loadAll);
6299   ret->contentNotNull();
6300   return ret.retn();
6301 }
6302
6303 MEDFileIntField1TS *MEDFileIntField1TS::New(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent)
6304 {
6305   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(other,shallowCopyOfContent);
6306   ret->contentNotNull();
6307   return ret.retn();
6308 }
6309
6310 MEDFileIntField1TS::MEDFileIntField1TS()
6311 {
6312   _content=new MEDFileIntField1TSWithoutSDA;
6313 }
6314
6315 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
6316 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6317 {
6318 }
6319 catch(INTERP_KERNEL::Exception& e)
6320   { throw e; }
6321
6322 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
6323 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6324 {
6325 }
6326 catch(INTERP_KERNEL::Exception& e)
6327   { throw e; }
6328
6329 MEDFileIntField1TS::MEDFileIntField1TS(const char *fileName, const char *fieldName, int iteration, int order, bool loadAll) throw(INTERP_KERNEL::Exception)
6330 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6331 {
6332 }
6333 catch(INTERP_KERNEL::Exception& e)
6334   { throw e; }
6335
6336 /*!
6337  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6338  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6339  *
6340  * \warning this is a shallow copy constructor
6341  */
6342 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6343 {
6344 }
6345
6346 MEDFileAnyTypeField1TS *MEDFileIntField1TS::shallowCpy() const throw(INTERP_KERNEL::Exception)
6347 {
6348   return new MEDFileIntField1TS(*this);
6349 }
6350
6351 /*!
6352  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
6353  * following the given input policy.
6354  *
6355  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6356  *                            By default (true) the globals are deeply copied.
6357  * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
6358  */
6359 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
6360 {
6361   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret;
6362   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6363   if(content)
6364     {
6365       const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
6366       if(!contc)
6367         throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
6368       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
6369       ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc,getFileName()));
6370     }
6371   else
6372     ret=MEDFileField1TS::New();
6373   if(deepCpyGlobs)
6374     ret->deepCpyGlobs(*this);
6375   else
6376     ret->shallowCpyGlobs(*this);
6377   return ret.retn();
6378 }
6379
6380 /*!
6381  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6382  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6383  * "Sort By Type"), if not, an exception is thrown.
6384  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6385  *  \param [in] field - the field to add to \a this. The field double values are ignored.
6386  *  \param [in] arrOfVals - the values of the field \a field used.
6387  *  \throw If the name of \a field is empty.
6388  *  \throw If the data array of \a field is not set.
6389  *  \throw If the data array is already allocated but has different number of components
6390  *         than \a field.
6391  *  \throw If the underlying mesh of \a field has no name.
6392  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6393  */
6394 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals) throw(INTERP_KERNEL::Exception)
6395 {
6396   setFileName("");
6397   contentNotNull()->setFieldNoProfileSBT(field,arrOfVals,*this,*contentNotNull());
6398 }
6399
6400 /*!
6401  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6402  * can be an aggregation of several MEDCouplingFieldDouble instances.
6403  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6404  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6405  * and \a profile.
6406  *
6407  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6408  * A new profile is added only if no equal profile is missing.
6409  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6410  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
6411  *  \param [in] arrOfVals - the values of the field \a field used.
6412  *  \param [in] mesh - the supporting mesh of \a field.
6413  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6414  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6415  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6416  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6417  *  \throw If the data array of \a field is not set.
6418  *  \throw If the data array of \a this is already allocated but has different number of
6419  *         components than \a field.
6420  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6421  *  \sa setFieldNoProfileSBT()
6422  */
6423 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
6424 {
6425   setFileName("");
6426   contentNotNull()->setFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6427 }
6428
6429 const MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() const throw(INTERP_KERNEL::Exception)
6430 {
6431   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6432   if(!pt)
6433     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is null !");
6434   const MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(pt);
6435   if(!ret)
6436     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 !");
6437   return ret;
6438 }
6439
6440 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6441 {
6442   if(getFileName2().empty())
6443     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6444   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut2;
6445   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut2,*contentNotNull());
6446   DataArrayInt *arrOutC=dynamic_cast<DataArrayInt *>((DataArray *)arrOut2);
6447   if(!arrOutC)
6448     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : mismatch between dataArrays type and MEDFileIntField1TS ! Expected int32 !");
6449   arrOut=arrOutC;
6450   return ret.retn();
6451 }
6452
6453 DataArrayInt *MEDFileIntField1TS::ReturnSafelyDataArrayInt(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr) throw(INTERP_KERNEL::Exception)
6454 {
6455   if(!((DataArray *)arr))
6456     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is NULL !");
6457   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>((DataArray *)arr);
6458   if(!arrC)
6459     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is not of type INT32 !");
6460   arrC->incrRef();
6461   return arrC;
6462 }
6463
6464 /*!
6465  * Returns a new MEDCouplingFieldDouble of a given type lying on
6466  * the top level cells of the first mesh in MED file. If \a this field
6467  * has not been constructed via file reading, an exception is thrown.
6468  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6469  *  \param [in] type - a spatial discretization of interest.
6470  *  \param [out] arrOut - the DataArrayInt containing values of field.
6471  *  \param [in] renumPol - specifies how to permute values of the result field according to
6472  *          the optional numbers of cells and nodes, if any. The valid values are
6473  *          - 0 - do not permute.
6474  *          - 1 - permute cells.
6475  *          - 2 - permute nodes.
6476  *          - 3 - permute cells and nodes.
6477  *
6478  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6479  *          caller is to delete this field using decrRef() as it is no more needed.
6480  *  \throw If \a this field has not been constructed via file reading.
6481  *  \throw If the MED file is not readable.
6482  *  \throw If there is no mesh in the MED file.
6483  *  \throw If no field values of the given \a type.
6484  *  \throw If no field values lying on the top level support.
6485  *  \sa getFieldAtLevel()
6486  */
6487 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6488 {
6489   if(getFileName2().empty())
6490     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6491   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6492   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNull());
6493   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6494   return ret.retn();
6495 }
6496
6497 /*!
6498  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6499  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6500  *  \param [in] type - a spatial discretization of the new field.
6501  *  \param [in] mesh - the supporting mesh.
6502  *  \param [out] arrOut - the DataArrayInt containing values of field.
6503  *  \param [in] renumPol - specifies how to permute values of the result field according to
6504  *          the optional numbers of cells and nodes, if any. The valid values are
6505  *          - 0 - do not permute.
6506  *          - 1 - permute cells.
6507  *          - 2 - permute nodes.
6508  *          - 3 - permute cells and nodes.
6509  *
6510  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6511  *          caller is to delete this field using decrRef() as it is no more needed.
6512  *  \throw If no field of \a this is lying on \a mesh.
6513  *  \throw If the mesh is empty.
6514  *  \throw If no field values of the given \a type are available.
6515  *  \sa getFieldAtLevel()
6516  *  \sa getFieldOnMeshAtLevel()
6517  */
6518 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6519 {
6520   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6521   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNull());
6522   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6523   return ret.retn();
6524 }
6525
6526 /*!
6527  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6528  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6529  *  \param [in] type - a spatial discretization of interest.
6530  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6531  *  \param [out] arrOut - the DataArrayInt containing values of field.
6532  *  \param [in] mesh - the supporting mesh.
6533  *  \param [in] renumPol - specifies how to permute values of the result field according to
6534  *          the optional numbers of cells and nodes, if any. The valid values are
6535  *          - 0 - do not permute.
6536  *          - 1 - permute cells.
6537  *          - 2 - permute nodes.
6538  *          - 3 - permute cells and nodes.
6539  *
6540  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6541  *          caller is to delete this field using decrRef() as it is no more needed.
6542  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6543  *  \throw If no field of \a this is lying on \a mesh.
6544  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6545  *  \sa getFieldAtLevel()
6546  *  \sa getFieldOnMeshAtLevel()
6547  */
6548 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6549 {
6550   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6551   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNull());
6552   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6553   return ret.retn();
6554 }
6555
6556 /*!
6557  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6558  * This method is called "Old" because in MED3 norm a field has only one meshName
6559  * attached, so this method is for readers of MED2 files. If \a this field
6560  * has not been constructed via file reading, an exception is thrown.
6561  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6562  *  \param [in] type - a spatial discretization of interest.
6563  *  \param [in] mName - a name of the supporting mesh.
6564  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6565  *  \param [out] arrOut - the DataArrayInt containing values of field.
6566  *  \param [in] renumPol - specifies how to permute values of the result field according to
6567  *          the optional numbers of cells and nodes, if any. The valid values are
6568  *          - 0 - do not permute.
6569  *          - 1 - permute cells.
6570  *          - 2 - permute nodes.
6571  *          - 3 - permute cells and nodes.
6572  *
6573  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6574  *          caller is to delete this field using decrRef() as it is no more needed.
6575  *  \throw If the MED file is not readable.
6576  *  \throw If there is no mesh named \a mName in the MED file.
6577  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6578  *  \throw If \a this field has not been constructed via file reading.
6579  *  \throw If no field of \a this is lying on the mesh named \a mName.
6580  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6581  *  \sa getFieldAtLevel()
6582  */
6583 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
6584 {
6585   if(getFileName2().empty())
6586     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6587   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6588   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNull());
6589   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6590   return ret.retn();
6591 }
6592
6593 /*!
6594  * Returns values and a profile of the field of a given type lying on a given support.
6595  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6596  *  \param [in] type - a spatial discretization of the field.
6597  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6598  *  \param [in] mesh - the supporting mesh.
6599  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6600  *          field of interest lies on. If the field lies on all entities of the given
6601  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6602  *          using decrRef() as it is no more needed.
6603  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
6604  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6605  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6606  *  \throw If no field of \a this is lying on \a mesh.
6607  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6608  */
6609 DataArrayInt *MEDFileIntField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
6610 {
6611   MEDCouplingAutoRefCountObjectPtr<DataArray> arr=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6612   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6613 }
6614
6615 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() throw(INTERP_KERNEL::Exception)
6616 {
6617   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6618   if(!pt)
6619     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is null !");
6620   MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<MEDFileIntField1TSWithoutSDA *>(pt);
6621   if(!ret)
6622     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 !");
6623   return ret;
6624 }
6625
6626 DataArrayInt *MEDFileIntField1TS::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
6627 {
6628   return contentNotNull()->getUndergroundDataArrayInt();
6629 }
6630
6631 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
6632
6633 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
6634 {
6635 }
6636
6637 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const char *fieldName):MEDFileFieldNameScope(fieldName)
6638 {
6639 }
6640
6641 /*!
6642  * \param [in] fieldId field id in C mode
6643  */
6644 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll) throw(INTERP_KERNEL::Exception)
6645 {
6646   med_field_type typcha;
6647   std::string dtunitOut;
6648   int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,"",fieldId,false,_name,typcha,_infos,dtunitOut);
6649   setDtUnit(dtunitOut.c_str());
6650   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll);
6651 }
6652
6653 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)
6654 try:MEDFileFieldNameScope(fieldName),_infos(infos)
6655 {
6656   setDtUnit(dtunit.c_str());
6657   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll);
6658 }
6659 catch(INTERP_KERNEL::Exception& e)
6660 {
6661   throw e;
6662 }
6663
6664 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySize() const
6665 {
6666   std::size_t ret=_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA>);
6667   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6668     ret+=(*it).capacity();
6669   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6670     if((const MEDFileAnyTypeField1TSWithoutSDA *)(*it))
6671       ret+=(*it)->getHeapMemorySize();
6672   return ret;
6673 }
6674
6675 /*!
6676  * 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
6677  * NULL.
6678  */
6679 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const throw(INTERP_KERNEL::Exception)
6680 {
6681   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6682   ret->setInfo(_infos);
6683   int sz=(int)_time_steps.size();
6684   for(const int *id=startIds;id!=endIds;id++)
6685     {
6686       if(*id>=0 && *id<sz)
6687         {
6688           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
6689           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6690           if(tse)
6691             {
6692               tse->incrRef();
6693               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6694             }
6695           ret->pushBackTimeStep(tse2);
6696         }
6697       else
6698         {
6699           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
6700           oss << " ! Should be in [0," << sz << ") !";
6701           throw INTERP_KERNEL::Exception(oss.str().c_str());
6702         }
6703     }
6704   if(ret->getNumberOfTS()>0)
6705     ret->synchronizeNameScope();
6706   ret->copyNameScope(*this);
6707   return ret.retn();
6708 }
6709
6710 /*!
6711  * 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
6712  * NULL.
6713  */
6714 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
6715 {
6716   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
6717   int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
6718   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6719   ret->setInfo(_infos);
6720   int sz=(int)_time_steps.size();
6721   int j=bg;
6722   for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
6723     {
6724       if(j>=0 && j<sz)
6725         {
6726           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
6727           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6728           if(tse)
6729             {
6730               tse->incrRef();
6731               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6732             }
6733           ret->pushBackTimeStep(tse2);
6734         }
6735       else
6736         {
6737           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
6738           oss << " ! Should be in [0," << sz << ") !";
6739           throw INTERP_KERNEL::Exception(oss.str().c_str());
6740         }
6741     }
6742   if(ret->getNumberOfTS()>0)
6743     ret->synchronizeNameScope();
6744   ret->copyNameScope(*this);
6745   return ret.retn();
6746 }
6747
6748 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
6749 {
6750   int id=0;
6751   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6752   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6753     {
6754       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6755       if(!cur)
6756         continue;
6757       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6758       if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
6759         ids->pushBackSilent(id);
6760     }
6761   return buildFromTimeStepIds(ids->begin(),ids->end());
6762 }
6763
6764 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
6765 {
6766   int id=0;
6767   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6768   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6769     {
6770       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6771       if(!cur)
6772         continue;
6773       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6774       if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
6775         ids->pushBackSilent(id);
6776     }
6777   return buildFromTimeStepIds(ids->begin(),ids->end());
6778 }
6779
6780 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const throw(INTERP_KERNEL::Exception)
6781 {
6782   return _infos;
6783 }
6784
6785 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
6786 {
6787   _infos=info;
6788 }
6789
6790 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const throw(INTERP_KERNEL::Exception)
6791 {
6792   int ret=0;
6793   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
6794     {
6795       const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
6796       if(pt->isDealingTS(iteration,order))
6797         return ret;
6798     }
6799   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
6800   std::vector< std::pair<int,int> > vp=getIterations();
6801   for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
6802     oss << "(" << (*it2).first << "," << (*it2).second << ") ";
6803   throw INTERP_KERNEL::Exception(oss.str().c_str());
6804 }
6805
6806 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const throw(INTERP_KERNEL::Exception)
6807 {
6808   return *_time_steps[getTimeStepPos(iteration,order)];
6809 }
6810
6811 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) throw(INTERP_KERNEL::Exception)
6812 {
6813   return *_time_steps[getTimeStepPos(iteration,order)];
6814 }
6815
6816 std::string MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshName() const throw(INTERP_KERNEL::Exception)
6817 {
6818   if(_time_steps.empty())
6819     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
6820   return _time_steps[0]->getMeshName();
6821 }
6822
6823 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
6824 {
6825   std::string oldName(getMeshName());
6826   std::vector< std::pair<std::string,std::string> > v(1);
6827   v[0].first=oldName; v[0].second=newMeshName;
6828   changeMeshNames(v);
6829 }
6830
6831 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
6832 {
6833   bool ret=false;
6834   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6835     {
6836       MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6837       if(cur)
6838         ret=cur->changeMeshNames(modifTab) || ret;
6839     }
6840   return ret;
6841 }
6842
6843 /*!
6844  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
6845  */
6846 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
6847 {
6848   return getTimeStepEntry(iteration,order).getUndergroundDataArray();
6849 }
6850
6851 /*!
6852  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
6853  */
6854 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)
6855 {
6856   return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
6857 }
6858
6859 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
6860                                                                 MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
6861 {
6862   bool ret=false;
6863   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6864     {
6865       MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
6866       if(f1ts)
6867         ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
6868     }
6869   return ret;
6870 }
6871
6872 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
6873 {
6874   std::string startLine(bkOffset,' ');
6875   oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
6876   if(fmtsId>=0)
6877     oss << " (" << fmtsId << ")";
6878   oss << " has the following name: \"" << _name << "\"." << std::endl;
6879   oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
6880   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6881     {
6882       oss << startLine << "  -  \"" << *it << "\"" << std::endl;
6883     }
6884   int i=0;
6885   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
6886     {
6887       std::string chapter(17,'0'+i);
6888       oss << startLine << chapter << std::endl;
6889       const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6890       if(cur)
6891         cur->simpleRepr(bkOffset+2,oss,i);
6892       else
6893         oss << startLine << "  Field on one time step #" << i << " is not defined !" << std::endl;
6894       oss << startLine << chapter << std::endl;
6895     }
6896 }
6897
6898 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const throw(INTERP_KERNEL::Exception)
6899 {
6900   std::size_t sz=_time_steps.size();
6901   std::vector< std::pair<int,int> > ret(sz);
6902   ret1.resize(sz);
6903   for(std::size_t i=0;i<sz;i++)
6904     {
6905       const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
6906       if(f1ts)
6907         {
6908           ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
6909         }
6910       else
6911         {
6912           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
6913           throw INTERP_KERNEL::Exception(oss.str().c_str());
6914         }
6915     }
6916   return ret;
6917 }
6918
6919 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>& tse) throw(INTERP_KERNEL::Exception)
6920 {
6921   MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
6922   if(!tse2)
6923     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
6924   checkCoherencyOfType(tse2);
6925   if(_time_steps.empty())
6926     {
6927       setName(tse2->getName().c_str());
6928       setInfo(tse2->getInfo());
6929     }
6930   checkThatComponentsMatch(tse2->getInfo());
6931   _time_steps.push_back(tse);
6932 }
6933
6934 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope() throw(INTERP_KERNEL::Exception)
6935 {
6936   std::size_t nbOfCompo=_infos.size();
6937   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6938     {
6939       MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6940       if(cur)
6941         {
6942           if((cur->getInfo()).size()!=nbOfCompo)
6943             {
6944               std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
6945               oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
6946               throw INTERP_KERNEL::Exception(oss.str().c_str());
6947             }
6948           cur->copyNameScope(*this);
6949         }
6950     }
6951 }
6952
6953 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll) throw(INTERP_KERNEL::Exception)
6954 {
6955   _time_steps.resize(nbPdt);
6956   for(int i=0;i<nbPdt;i++)
6957     {
6958       std::vector< std::pair<int,int> > ts;
6959       med_int numdt=0,numo=0;
6960       med_int meshIt=0,meshOrder=0;
6961       med_float dt=0.0;
6962       MEDfieldComputingStepMeshInfo(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder);
6963       switch(fieldTyp)
6964         {
6965         case MED_FLOAT64:
6966           {
6967             _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
6968             break;
6969           }
6970         case MED_INT32:
6971           {
6972             _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
6973             break;
6974           }
6975         default:
6976           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
6977         }
6978       if(loadAll)
6979         _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this);
6980       else
6981         _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this);
6982     }
6983 }
6984
6985 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const throw(INTERP_KERNEL::Exception)
6986 {
6987   if(_time_steps.empty())
6988     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
6989   checkThatNbOfCompoOfTSMatchThis();
6990   std::vector<std::string> infos(getInfo());
6991   int nbComp=infos.size();
6992   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
6993   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
6994   for(int i=0;i<nbComp;i++)
6995     {
6996       std::string info=infos[i];
6997       std::string c,u;
6998       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
6999       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7000       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7001     }
7002   if(_name.empty())
7003     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
7004   MEDfieldCr(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
7005   int nbOfTS=_time_steps.size();
7006   for(int i=0;i<nbOfTS;i++)
7007     _time_steps[i]->writeLL(fid,opts,*this);
7008 }
7009
7010 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
7011 {
7012   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7013     {
7014       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7015       if(elt)
7016         elt->loadBigArraysRecursively(fid,nasc);
7017     }
7018 }
7019
7020 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc) throw(INTERP_KERNEL::Exception)
7021 {
7022   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7023     {
7024       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7025       if(elt)
7026         elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
7027     }
7028 }
7029
7030 void MEDFileAnyTypeFieldMultiTSWithoutSDA::releaseArrays() throw(INTERP_KERNEL::Exception)
7031 {
7032   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7033     {
7034       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7035       if(elt)
7036         elt->releaseArrays();
7037     }
7038 }
7039
7040 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
7041 {
7042   return _time_steps.size();
7043 }
7044
7045 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS() throw(INTERP_KERNEL::Exception)
7046 {
7047   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  > newTS;
7048   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7049     {
7050       const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
7051       if(tmp)
7052         newTS.push_back(*it);
7053     }
7054   _time_steps=newTS;
7055 }
7056
7057 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
7058 {
7059   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7060   int maxId=(int)_time_steps.size();
7061   int ii=0;
7062   std::set<int> idsToDel;
7063   for(const int *id=startIds;id!=endIds;id++,ii++)
7064     {
7065       if(*id>=0 && *id<maxId)
7066         {
7067           idsToDel.insert(*id);
7068         }
7069       else
7070         {
7071           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
7072           throw INTERP_KERNEL::Exception(oss.str().c_str());
7073         }
7074     }
7075   for(int iii=0;iii<maxId;iii++)
7076     if(idsToDel.find(iii)==idsToDel.end())
7077       newTS.push_back(_time_steps[iii]);
7078   _time_steps=newTS;
7079 }
7080
7081 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step) throw(INTERP_KERNEL::Exception)
7082 {
7083   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
7084   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7085   if(nbOfEntriesToKill==0)
7086     return ;
7087   std::size_t sz=_time_steps.size();
7088   std::vector<bool> b(sz,true);
7089   int j=bg;
7090   for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
7091     b[j]=false;
7092   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7093   for(std::size_t i=0;i<sz;i++)
7094     if(b[i])
7095       newTS.push_back(_time_steps[i]);
7096   _time_steps=newTS;
7097 }
7098
7099 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
7100 {
7101   int ret=0;
7102   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
7103   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7104     {
7105       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7106       if(tmp)
7107         {
7108           int it2,ord;
7109           tmp->getTime(it2,ord);
7110           if(it2==iteration && order==ord)
7111             return ret;
7112           else
7113             oss << "(" << it2 << ","  << ord << "), ";
7114         }
7115     }
7116   throw INTERP_KERNEL::Exception(oss.str().c_str());
7117 }
7118
7119 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
7120 {
7121   int ret=0;
7122   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
7123   oss.precision(15);
7124   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7125     {
7126       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7127       if(tmp)
7128         {
7129           int it2,ord;
7130           double ti=tmp->getTime(it2,ord);
7131           if(fabs(time-ti)<eps)
7132             return ret;
7133           else
7134             oss << ti << ", ";
7135         }
7136     }
7137   throw INTERP_KERNEL::Exception(oss.str().c_str());
7138 }
7139
7140 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
7141 {
7142   int lgth=_time_steps.size();
7143   std::vector< std::pair<int,int> > ret(lgth);
7144   for(int i=0;i<lgth;i++)
7145     _time_steps[i]->fillIteration(ret[i]);
7146   return ret;
7147 }
7148
7149 /*!
7150  * 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'
7151  * This method returns two things.
7152  * - The absolute dimension of 'this' in first parameter.
7153  * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
7154  *   to the first output parameter. The values in 'levs' will be returned in decreasing order.
7155  *
7156  * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
7157  * Only these 3 discretizations will be taken into account here.
7158  *
7159  * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
7160  * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
7161  * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
7162  *
7163  * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
7164  * 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'.
7165  *
7166  * Let's consider the typical following case :
7167  * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
7168  * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
7169  * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
7170  *   TETRA4 and SEG2
7171  * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
7172  *
7173  * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
7174  *
7175  * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
7176  * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
7177  * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
7178  * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
7179  */
7180 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
7181 {
7182   return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
7183 }
7184
7185 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const throw(INTERP_KERNEL::Exception)
7186 {
7187   if(pos<0 || pos>=(int)_time_steps.size())
7188     {
7189       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7190       throw INTERP_KERNEL::Exception(oss.str().c_str());
7191     }
7192   const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7193   if(item==0)
7194     {
7195       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7196       oss << "\nTry to use following method eraseEmptyTS !";
7197       throw INTERP_KERNEL::Exception(oss.str().c_str());
7198     }
7199   return item;
7200 }
7201
7202 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) throw(INTERP_KERNEL::Exception)
7203 {
7204   if(pos<0 || pos>=(int)_time_steps.size())
7205     {
7206       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7207       throw INTERP_KERNEL::Exception(oss.str().c_str());
7208     }
7209   MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7210   if(item==0)
7211     {
7212       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7213       oss << "\nTry to use following method eraseEmptyTS !";
7214       throw INTERP_KERNEL::Exception(oss.str().c_str());
7215     }
7216   return item;
7217 }
7218
7219 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
7220 {
7221   std::vector<std::string> ret;
7222   std::set<std::string> ret2;
7223   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7224     {
7225       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
7226       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7227         if(ret2.find(*it2)==ret2.end())
7228           {
7229             ret.push_back(*it2);
7230             ret2.insert(*it2);
7231           }
7232     }
7233   return ret;
7234 }
7235
7236 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
7237 {
7238   std::vector<std::string> ret;
7239   std::set<std::string> ret2;
7240   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7241     {
7242       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
7243       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7244         if(ret2.find(*it2)==ret2.end())
7245           {
7246             ret.push_back(*it2);
7247             ret2.insert(*it2);
7248           }
7249     }
7250   return ret;
7251 }
7252
7253 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
7254 {
7255   std::vector<std::string> ret;
7256   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7257     {
7258       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
7259       ret.insert(ret.end(),tmp.begin(),tmp.end());
7260     }
7261   return ret;
7262 }
7263
7264 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
7265 {
7266   std::vector<std::string> ret;
7267   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7268     {
7269       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
7270       ret.insert(ret.end(),tmp.begin(),tmp.end());
7271     }
7272   return ret;
7273 }
7274
7275 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7276 {
7277   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7278     (*it)->changePflsRefsNamesGen2(mapOfModif);
7279 }
7280
7281 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7282 {
7283   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7284     (*it)->changeLocsRefsNamesGen2(mapOfModif);
7285 }
7286
7287 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
7288 {
7289   int lgth=_time_steps.size();
7290   std::vector< std::vector<TypeOfField> > ret(lgth);
7291   for(int i=0;i<lgth;i++)
7292     _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
7293   return ret;
7294 }
7295
7296 /*!
7297  * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
7298  */
7299 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)
7300 {
7301   return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
7302 }
7303
7304 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
7305 {
7306   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
7307   std::size_t i=0;
7308   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7309     {
7310       if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
7311         ret->_time_steps[i]=(*it)->deepCpy();
7312     }
7313   return ret.retn();
7314 }
7315
7316 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const throw(INTERP_KERNEL::Exception)
7317 {
7318   std::size_t sz(_infos.size()),sz2(_time_steps.size());
7319   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
7320   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
7321   for(std::size_t i=0;i<sz;i++)
7322     {
7323       ret[i]=shallowCpy();
7324       ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
7325     }
7326   for(std::size_t i=0;i<sz2;i++)
7327     {
7328       std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
7329       if(ret1.size()!=sz)
7330         {
7331           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
7332           throw INTERP_KERNEL::Exception(oss.str().c_str());
7333         }
7334       ts[i]=ret1;
7335     }
7336   for(std::size_t i=0;i<sz;i++)
7337     for(std::size_t j=0;j<sz2;j++)
7338       ret[i]->_time_steps[j]=ts[j][i];
7339   return ret;
7340 }
7341
7342 /*!
7343  * This method splits into discretization each time steps in \a this.
7344  * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
7345  */
7346 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
7347 {
7348   std::size_t sz(_time_steps.size());
7349   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7350   for(std::size_t i=0;i<sz;i++)
7351     {
7352       const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7353       if(!timeStep)
7354         {
7355           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
7356           throw INTERP_KERNEL::Exception(oss.str().c_str());
7357         }
7358       items[i]=timeStep->splitDiscretizations();
7359     }
7360   //
7361   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
7362   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
7363   std::vector< TypeOfField > types;
7364   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7365     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7366       {
7367         std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
7368         if(ts.size()!=1)
7369           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
7370         std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
7371         if(it2==types.end())
7372           types.push_back(ts[0]);
7373       }
7374   ret.resize(types.size()); ret2.resize(types.size());
7375   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7376     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7377       {
7378         TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
7379         std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
7380         ret2[pos].push_back(*it1);
7381       }
7382   for(std::size_t i=0;i<types.size();i++)
7383     {
7384       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=createNew();
7385       for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
7386         elt->pushBackTimeStep(*it1);//also updates infos in elt
7387       ret[i]=elt;
7388       elt->MEDFileFieldNameScope::operator=(*this);
7389     }
7390   return ret;
7391 }
7392
7393 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr) throw(INTERP_KERNEL::Exception)
7394 {
7395   _name=field->getName();
7396   if(_name.empty())
7397     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
7398   if(!arr)
7399     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
7400   _infos=arr->getInfoOnComponents();
7401 }
7402
7403 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const throw(INTERP_KERNEL::Exception)
7404 {
7405   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
7406   if(_name!=field->getName())
7407     {
7408       std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
7409       oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
7410       throw INTERP_KERNEL::Exception(oss.str().c_str());
7411     }
7412   if(!arr)
7413     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
7414   checkThatComponentsMatch(arr->getInfoOnComponents());
7415 }
7416
7417 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const throw(INTERP_KERNEL::Exception)
7418 {
7419   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
7420   if(getInfo().size()!=compos.size())
7421     {
7422       std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
7423       oss << " number of components of element to append (" << compos.size() << ") !";
7424       throw INTERP_KERNEL::Exception(oss.str().c_str());
7425     }
7426   if(_infos!=compos)
7427     {
7428       std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
7429       std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
7430       oss << " But compo in input fields are : ";
7431       std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
7432       oss << " !";
7433       throw INTERP_KERNEL::Exception(oss.str().c_str());
7434     }
7435 }
7436
7437 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const throw(INTERP_KERNEL::Exception)
7438 {
7439   std::size_t sz=_infos.size();
7440   int j=0;
7441   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
7442     {
7443       const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7444       if(elt)
7445         if(elt->getInfo().size()!=sz)
7446           {
7447             std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
7448             oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
7449             throw INTERP_KERNEL::Exception(oss.str().c_str());
7450           }
7451     }
7452 }
7453
7454 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
7455 {
7456   if(!field)
7457     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7458   if(!_time_steps.empty())
7459     checkCoherencyOfTinyInfo(field,arr);
7460   MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
7461   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7462   objC->setFieldNoProfileSBT(field,arr,glob,*this);
7463   copyTinyInfoFrom(field,arr);
7464   _time_steps.push_back(obj);
7465 }
7466
7467 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
7468 {
7469   if(!field)
7470     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7471   if(!_time_steps.empty())
7472     checkCoherencyOfTinyInfo(field,arr);
7473   MEDFileField1TSWithoutSDA *objC=new MEDFileField1TSWithoutSDA;
7474   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7475   objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
7476   copyTinyInfoFrom(field,arr);
7477   _time_steps.push_back(obj);
7478 }
7479
7480 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ts) throw(INTERP_KERNEL::Exception)
7481 {
7482   int sz=(int)_time_steps.size();
7483   if(i<0 || i>=sz)
7484     {
7485       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
7486       throw INTERP_KERNEL::Exception(oss.str().c_str());
7487     }
7488   const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
7489   if(tsPtr)
7490     {
7491       if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
7492         {
7493           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() <<  " !";
7494           throw INTERP_KERNEL::Exception(oss.str().c_str());
7495         }
7496     }
7497   _time_steps[i]=ts;
7498 }
7499
7500 //= MEDFileFieldMultiTSWithoutSDA
7501
7502 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)
7503 {
7504   return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7505 }
7506
7507 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
7508 {
7509 }
7510
7511 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7512 {
7513 }
7514
7515 /*!
7516  * \param [in] fieldId field id in C mode
7517  */
7518 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll) throw(INTERP_KERNEL::Exception)
7519 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7520 {
7521 }
7522 catch(INTERP_KERNEL::Exception& e)
7523   { throw e; }
7524
7525 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)
7526 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7527 {
7528 }
7529 catch(INTERP_KERNEL::Exception& e)
7530 { throw e; }
7531
7532 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const throw(INTERP_KERNEL::Exception)
7533 {
7534   return new MEDFileField1TSWithoutSDA;
7535 }
7536
7537 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const throw(INTERP_KERNEL::Exception)
7538 {
7539   if(!f1ts)
7540     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7541   const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
7542   if(!f1tsC)
7543     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
7544 }
7545
7546 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
7547 {
7548   return MEDFileField1TSWithoutSDA::TYPE_STR;
7549 }
7550
7551 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
7552 {
7553   return new MEDFileFieldMultiTSWithoutSDA(*this);
7554 }
7555
7556 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const throw(INTERP_KERNEL::Exception)
7557 {
7558   return new MEDFileFieldMultiTSWithoutSDA;
7559 }
7560
7561 /*!
7562  * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
7563  * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
7564  */
7565 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)
7566 {
7567   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
7568   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
7569   if(!myF1TSC)
7570     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
7571   return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
7572 }
7573
7574 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const throw(INTERP_KERNEL::Exception)
7575 {
7576   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
7577   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7578   int i=0;
7579   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7580     {
7581       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7582       if(eltToConv)
7583         {
7584           const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
7585           if(!eltToConvC)
7586             throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
7587           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
7588           ret->setIteration(i,elt);
7589         }
7590     }
7591   return ret.retn();
7592 }
7593
7594 //= MEDFileAnyTypeFieldMultiTS
7595
7596 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
7597 {
7598 }
7599
7600 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
7601 try:MEDFileFieldGlobsReal(fileName)
7602 {
7603   MEDFileUtilities::CheckFileForRead(fileName);
7604   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7605   _content=BuildContentFrom(fid,fileName,loadAll);
7606   loadGlobals(fid);
7607 }
7608 catch(INTERP_KERNEL::Exception& e)
7609   {
7610     throw e;
7611   }
7612
7613 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
7614 {
7615   med_field_type typcha;
7616   std::vector<std::string> infos;
7617   std::string dtunit;
7618   int i=-1;
7619   MEDFileAnyTypeField1TS::LocateField(fid,fileName,fieldName,i,typcha,infos,dtunit);
7620   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7621   switch(typcha)
7622     {
7623     case MED_FLOAT64:
7624       {
7625         ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll);
7626         break;
7627       }
7628     case MED_INT32:
7629       {
7630         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll);
7631         break;
7632       }
7633     default:
7634       {
7635         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] !";
7636         throw INTERP_KERNEL::Exception(oss.str().c_str());
7637       }
7638     }
7639   ret->setDtUnit(dtunit.c_str());
7640   return ret.retn();
7641 }
7642
7643 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
7644 {
7645   med_field_type typcha;
7646   //
7647   std::vector<std::string> infos;
7648   std::string dtunit,fieldName;
7649   MEDFileAnyTypeField1TS::LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
7650   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7651   switch(typcha)
7652     {
7653     case MED_FLOAT64:
7654       {
7655         ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll);
7656         break;
7657       }
7658     case MED_INT32:
7659       {
7660         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll);
7661         break;
7662       }
7663     default:
7664       {
7665         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] !";
7666         throw INTERP_KERNEL::Exception(oss.str().c_str());
7667       }
7668     }
7669   ret->setDtUnit(dtunit.c_str());
7670   return ret.retn();
7671 }
7672
7673 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, const char *fileName) throw(INTERP_KERNEL::Exception)
7674 {
7675   if(!c)
7676     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
7677   if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
7678     {
7679       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=MEDFileFieldMultiTS::New();
7680       ret->setFileName(fileName);
7681       ret->_content=c;  c->incrRef();
7682       return ret.retn();
7683     }
7684   if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
7685     {
7686       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=MEDFileIntFieldMultiTS::New();
7687       ret->setFileName(fileName);
7688       ret->_content=c;  c->incrRef();
7689       return ret.retn();
7690     }
7691   throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
7692 }
7693
7694 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
7695 try:MEDFileFieldGlobsReal(fileName)
7696 {
7697   MEDFileUtilities::CheckFileForRead(fileName);
7698   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7699   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
7700   loadGlobals(fid);
7701 }
7702 catch(INTERP_KERNEL::Exception& e)
7703   {
7704     throw e;
7705   }
7706
7707 //= MEDFileIntFieldMultiTSWithoutSDA
7708
7709 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)
7710 {
7711   return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7712 }
7713
7714 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
7715 {
7716 }
7717
7718 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const char *fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7719 {
7720 }
7721
7722 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)
7723 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7724 {
7725 }
7726 catch(INTERP_KERNEL::Exception& e)
7727 { throw e; }
7728
7729 /*!
7730  * \param [in] fieldId field id in C mode
7731  */
7732 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll) throw(INTERP_KERNEL::Exception)
7733 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7734 {
7735 }
7736 catch(INTERP_KERNEL::Exception& e)
7737   { throw e; }
7738
7739 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const throw(INTERP_KERNEL::Exception)
7740 {
7741   return new MEDFileIntField1TSWithoutSDA;
7742 }
7743
7744 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const throw(INTERP_KERNEL::Exception)
7745 {
7746   if(!f1ts)
7747     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7748   const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
7749   if(!f1tsC)
7750     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
7751 }
7752
7753 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const throw(INTERP_KERNEL::Exception)
7754 {
7755   return MEDFileIntField1TSWithoutSDA::TYPE_STR;
7756 }
7757
7758 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const throw(INTERP_KERNEL::Exception)
7759 {
7760   return new MEDFileIntFieldMultiTSWithoutSDA(*this);
7761 }
7762
7763 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const throw(INTERP_KERNEL::Exception)
7764 {
7765   return new MEDFileIntFieldMultiTSWithoutSDA;
7766 }
7767
7768 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const throw(INTERP_KERNEL::Exception)
7769 {
7770   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
7771   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7772   int i=0;
7773   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7774     {
7775       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7776       if(eltToConv)
7777         {
7778           const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
7779           if(!eltToConvC)
7780             throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
7781           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
7782           ret->setIteration(i,elt);
7783         }
7784     }
7785   return ret.retn();
7786 }
7787
7788 //= MEDFileAnyTypeFieldMultiTS
7789
7790 /*!
7791  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
7792  * that has been read from a specified MED file.
7793  *  \param [in] fileName - the name of the MED file to read.
7794  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7795  *          is to delete this field using decrRef() as it is no more needed.
7796  *  \throw If reading the file fails.
7797  */
7798 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
7799 {
7800   MEDFileUtilities::CheckFileForRead(fileName);
7801   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7802   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
7803   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7804   ret->loadGlobals(fid);
7805   return ret.retn();
7806 }
7807
7808 /*!
7809  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
7810  * that has been read from a specified MED file.
7811  *  \param [in] fileName - the name of the MED file to read.
7812  *  \param [in] fieldName - the name of the field to read.
7813  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7814  *          is to delete this field using decrRef() as it is no more needed.
7815  *  \throw If reading the file fails.
7816  *  \throw If there is no field named \a fieldName in the file.
7817  */
7818 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
7819 {
7820   MEDFileUtilities::CheckFileForRead(fileName);
7821   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
7822   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
7823   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7824   ret->loadGlobals(fid);
7825   return ret.retn();
7826 }
7827
7828 /*!
7829  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
7830  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
7831  *
7832  * \warning this is a shallow copy constructor
7833  */
7834 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
7835 {
7836   if(!shallowCopyOfContent)
7837     {
7838       const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
7839       otherPtr->incrRef();
7840       _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
7841     }
7842   else
7843     {
7844       _content=other.shallowCpy();
7845     }
7846 }
7847
7848 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() throw(INTERP_KERNEL::Exception)
7849 {
7850   MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7851   if(!ret)
7852     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
7853   return ret;
7854 }
7855
7856 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const throw(INTERP_KERNEL::Exception)
7857 {
7858   const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7859   if(!ret)
7860     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
7861   return ret;
7862 }
7863
7864 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
7865 {
7866   return contentNotNullBase()->getPflsReallyUsed2();
7867 }
7868
7869 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
7870 {
7871   return contentNotNullBase()->getLocsReallyUsed2();
7872 }
7873
7874 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
7875 {
7876   return contentNotNullBase()->getPflsReallyUsedMulti2();
7877 }
7878
7879 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
7880 {
7881   return contentNotNullBase()->getLocsReallyUsedMulti2();
7882 }
7883
7884 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7885 {
7886   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
7887 }
7888
7889 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
7890 {
7891   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
7892 }
7893
7894 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
7895 {
7896   return contentNotNullBase()->getNumberOfTS();
7897 }
7898
7899 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS() throw(INTERP_KERNEL::Exception)
7900 {
7901   contentNotNullBase()->eraseEmptyTS();
7902 }
7903
7904 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
7905 {
7906   contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
7907 }
7908
7909 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step) throw(INTERP_KERNEL::Exception)
7910 {
7911   contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
7912 }
7913
7914 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const throw(INTERP_KERNEL::Exception)
7915 {
7916   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
7917   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7918   ret->_content=c;
7919   return ret.retn();
7920 }
7921
7922 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
7923 {
7924   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
7925   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7926   ret->_content=c;
7927   return ret.retn();
7928 }
7929
7930 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
7931 {
7932   return contentNotNullBase()->getIterations();
7933 }
7934
7935 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts) throw(INTERP_KERNEL::Exception)
7936 {
7937   for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
7938     pushBackTimeStep(*it);
7939 }
7940
7941 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts) throw(INTERP_KERNEL::Exception)
7942 {
7943   if(!f1ts)
7944     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
7945   checkCoherencyOfType(f1ts);
7946   f1ts->incrRef();
7947   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
7948   MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
7949   c->incrRef();
7950   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
7951   if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
7952     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
7953   _content->pushBackTimeStep(cSafe);
7954   appendGlobs(*f1ts,1e-12);
7955 }
7956
7957 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope() throw(INTERP_KERNEL::Exception)
7958 {
7959   contentNotNullBase()->synchronizeNameScope();
7960 }
7961
7962 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
7963 {
7964   return contentNotNullBase()->getPosOfTimeStep(iteration,order);
7965 }
7966
7967 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
7968 {
7969   return contentNotNullBase()->getPosGivenTime(time,eps);
7970 }
7971
7972 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
7973 {
7974   return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
7975 }
7976
7977 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
7978 {
7979   return contentNotNullBase()->getTypesOfFieldAvailable();
7980 }
7981
7982 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)
7983 {
7984   return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
7985 }
7986
7987 std::string MEDFileAnyTypeFieldMultiTS::getName() const
7988 {
7989   return contentNotNullBase()->getName();
7990 }
7991
7992 void MEDFileAnyTypeFieldMultiTS::setName(const char *name)
7993 {
7994   contentNotNullBase()->setName(name);
7995 }
7996
7997 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const throw(INTERP_KERNEL::Exception)
7998 {
7999   return contentNotNullBase()->getDtUnit();
8000 }
8001
8002 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const char *dtUnit) throw(INTERP_KERNEL::Exception)
8003 {
8004   contentNotNullBase()->setDtUnit(dtUnit);
8005 }
8006
8007 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
8008 {
8009   contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
8010 }
8011
8012 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const throw(INTERP_KERNEL::Exception)
8013 {
8014   return contentNotNullBase()->getTimeSteps(ret1);
8015 }
8016
8017 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const throw(INTERP_KERNEL::Exception)
8018 {
8019   return contentNotNullBase()->getMeshName();
8020 }
8021
8022 void MEDFileAnyTypeFieldMultiTS::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
8023 {
8024   contentNotNullBase()->setMeshName(newMeshName);
8025 }
8026
8027 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
8028 {
8029   return contentNotNullBase()->changeMeshNames(modifTab);
8030 }
8031
8032 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const throw(INTERP_KERNEL::Exception)
8033 {
8034   return contentNotNullBase()->getInfo();
8035 }
8036
8037 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
8038 {
8039   return contentNotNullBase()->setInfo(info);
8040 }
8041
8042 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const throw(INTERP_KERNEL::Exception)
8043 {
8044   const std::vector<std::string> ret=getInfo();
8045   return (int)ret.size();
8046 }
8047
8048 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
8049 {
8050   writeGlobals(fid,*this);
8051   contentNotNullBase()->writeLL(fid,*this);
8052 }
8053
8054 /*!
8055  * Writes \a this field into a MED file specified by its name.
8056  *  \param [in] fileName - the MED file name.
8057  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
8058  * - 2 - erase; an existing file is removed.
8059  * - 1 - append; same data should not be present in an existing file.
8060  * - 0 - overwrite; same data present in an existing file is overwritten.
8061  *  \throw If the field name is not set.
8062  *  \throw If no field data is set.
8063  *  \throw If \a mode == 1 and the same data is present in an existing file.
8064  */
8065 void MEDFileAnyTypeFieldMultiTS::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
8066 {
8067   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
8068   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
8069   writeLL(fid);
8070 }
8071
8072 /*!
8073  * This method alloc the arrays and load potentially huge arrays contained in this field.
8074  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
8075  * This method can be also called to refresh or reinit values from a file.
8076  *
8077  * \throw If the fileName is not set or points to a non readable MED file.
8078  */
8079 void MEDFileAnyTypeFieldMultiTS::loadArrays() throw(INTERP_KERNEL::Exception)
8080 {
8081   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8082   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
8083 }
8084
8085 /*!
8086  * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
8087  * But once data loaded once, this method does nothing.
8088  *
8089  * \throw If the fileName is not set or points to a non readable MED file.
8090  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::releaseArrays
8091  */
8092 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary() throw(INTERP_KERNEL::Exception)
8093 {
8094   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
8095   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
8096 }
8097
8098 /*!
8099  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
8100  * This method does not release arrays set outside the context of a MED file.
8101  *
8102  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
8103  */
8104 void MEDFileAnyTypeFieldMultiTS::releaseArrays() throw(INTERP_KERNEL::Exception)
8105 {
8106   contentNotNullBase()->releaseArrays();
8107 }
8108
8109 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
8110 {
8111   std::ostringstream oss;
8112   contentNotNullBase()->simpleRepr(0,oss,-1);
8113   simpleReprGlobs(oss);
8114   return oss.str();
8115 }
8116
8117 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySize() const
8118 {
8119   std::size_t ret=0;
8120   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)_content)
8121     ret+=_content->getHeapMemorySize();
8122   return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
8123 }
8124
8125 /*!
8126  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
8127  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8128  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
8129  */
8130 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const throw(INTERP_KERNEL::Exception)
8131 {
8132   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8133   if(!content)
8134     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
8135   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
8136   std::size_t sz(contentsSplit.size());
8137   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8138   for(std::size_t i=0;i<sz;i++)
8139     {
8140       ret[i]=shallowCpy();
8141       ret[i]->_content=contentsSplit[i];
8142     }
8143   return ret;
8144 }
8145
8146 /*!
8147  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
8148  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8149  */
8150 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const throw(INTERP_KERNEL::Exception)
8151 {
8152   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8153   if(!content)
8154     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
8155   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitDiscretizations();
8156   std::size_t sz(contentsSplit.size());
8157   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8158   for(std::size_t i=0;i<sz;i++)
8159     {
8160       ret[i]=shallowCpy();
8161       ret[i]->_content=contentsSplit[i];
8162     }
8163   return ret;
8164 }
8165
8166 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCpy() const throw(INTERP_KERNEL::Exception)
8167 {
8168   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8169   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8170     ret->_content=_content->deepCpy();
8171   ret->deepCpyGlobs(*this);
8172   return ret.retn();
8173 }
8174
8175 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
8176 {
8177   return _content;
8178 }
8179
8180 /*!
8181  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8182  *  \param [in] iteration - the iteration number of a required time step.
8183  *  \param [in] order - the iteration order number of required time step.
8184  *  \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
8185  *          delete this field using decrRef() as it is no more needed.
8186  *  \throw If there is no required time step in \a this field.
8187  */
8188 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
8189 {
8190   int pos=getPosOfTimeStep(iteration,order);
8191   return getTimeStepAtPos(pos);
8192 }
8193
8194 /*!
8195  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8196  *  \param [in] time - the time of the time step of interest.
8197  *  \param [in] eps - a precision used to compare time values.
8198  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8199  *          delete this field using decrRef() as it is no more needed.
8200  *  \throw If there is no required time step in \a this field.
8201  */
8202 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
8203 {
8204   int pos=getPosGivenTime(time,eps);
8205   return getTimeStepAtPos(pos);
8206 }
8207
8208 /*!
8209  * This method groups not null items in \a vectFMTS per time step series. Two time series are considered equal if the list of their pair of integers iteration,order are equal.
8210  * The float64 value of time attached to the pair of integers are not considered here.
8211  *
8212  * \param [in] vectFMTS - vector of not null fields defined on a same global data pointer.
8213  * \throw If there is a null pointer in \a vectFMTS.
8214  */
8215 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS) throw(INTERP_KERNEL::Exception)
8216 {
8217   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries : presence of null instance in input vector !";
8218   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8219   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8220   while(!lstFMTS.empty())
8221     {
8222       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8223       MEDFileAnyTypeFieldMultiTS *curIt(*it);
8224       if(!curIt)
8225         throw INTERP_KERNEL::Exception(msg);
8226       std::vector< std::pair<int,int> > refIts=curIt->getIterations();
8227       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8228       elt.push_back(curIt); it=lstFMTS.erase(it);
8229       while(it!=lstFMTS.end())
8230         {
8231           curIt=*it;
8232           if(!curIt)
8233             throw INTERP_KERNEL::Exception(msg);
8234           std::vector< std::pair<int,int> > curIts=curIt->getIterations();
8235           if(refIts==curIts)
8236             { elt.push_back(curIt); it=lstFMTS.erase(it);}
8237           else
8238             it++;
8239         }
8240       ret.push_back(elt);
8241     }
8242   return ret;
8243 }
8244
8245 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator() throw(INTERP_KERNEL::Exception)
8246 {
8247   return new MEDFileAnyTypeFieldMultiTSIterator(this);
8248 }
8249
8250 //= MEDFileFieldMultiTS
8251
8252 /*!
8253  * Returns a new empty instance of MEDFileFieldMultiTS.
8254  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8255  *          is to delete this field using decrRef() as it is no more needed.
8256  */
8257 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
8258 {
8259   return new MEDFileFieldMultiTS;
8260 }
8261
8262 /*!
8263  * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
8264  * that has been read from a specified MED file.
8265  *  \param [in] fileName - the name of the MED file to read.
8266  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8267  *          is to delete this field using decrRef() as it is no more needed.
8268  *  \throw If reading the file fails.
8269  */
8270 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
8271 {
8272   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,loadAll);
8273   ret->contentNotNull();//to check that content type matches with \a this type.
8274   return ret.retn();
8275 }
8276
8277 /*!
8278  * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
8279  * that has been read from a specified MED file.
8280  *  \param [in] fileName - the name of the MED file to read.
8281  *  \param [in] fieldName - the name of the field to read.
8282  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8283  *          is to delete this field using decrRef() as it is no more needed.
8284  *  \throw If reading the file fails.
8285  *  \throw If there is no field named \a fieldName in the file.
8286  */
8287 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
8288 {
8289   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,fieldName,loadAll);
8290   ret->contentNotNull();//to check that content type matches with \a this type.
8291   return ret.retn();
8292 }
8293
8294 /*!
8295  * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8296  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8297  *
8298  * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
8299  * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8300  * \warning this is a shallow copy constructor
8301  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
8302  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8303  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8304  *          is to delete this field using decrRef() as it is no more needed.
8305  */
8306 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8307 {
8308   return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
8309 }
8310
8311 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const throw(INTERP_KERNEL::Exception)
8312 {
8313   return new MEDFileFieldMultiTS(*this);
8314 }
8315
8316 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const throw(INTERP_KERNEL::Exception)
8317 {
8318   if(!f1ts)
8319     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8320   const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
8321   if(!f1tsC)
8322     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8323 }
8324
8325 /*!
8326  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
8327  * following the given input policy.
8328  *
8329  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8330  *                            By default (true) the globals are deeply copied.
8331  * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
8332  */
8333 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
8334 {
8335   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret;
8336   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8337   if(content)
8338     {
8339       const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
8340       if(!contc)
8341         throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
8342       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
8343       ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc,getFileName()));
8344     }
8345   else
8346     ret=MEDFileIntFieldMultiTS::New();
8347   if(deepCpyGlobs)
8348     ret->deepCpyGlobs(*this);
8349   else
8350     ret->shallowCpyGlobs(*this);
8351   return ret.retn();
8352 }
8353
8354 /*!
8355  * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
8356  *  \param [in] pos - a time step id.
8357  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8358  *          delete this field using decrRef() as it is no more needed.
8359  *  \throw If \a pos is not a valid time step id.
8360  */
8361 MEDFileAnyTypeField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const throw(INTERP_KERNEL::Exception)
8362 {
8363   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8364   if(!item)
8365     {
8366       std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8367       throw INTERP_KERNEL::Exception(oss.str().c_str());
8368     }
8369   const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
8370   if(itemC)
8371     {
8372       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
8373       ret->shallowCpyGlobs(*this);
8374       return ret.retn();
8375     }
8376   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
8377   throw INTERP_KERNEL::Exception(oss.str().c_str());
8378 }
8379
8380 /*!
8381  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8382  * mesh entities of a given dimension of the first mesh in MED file.
8383  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8384  *  \param [in] type - a spatial discretization of interest.
8385  *  \param [in] iteration - the iteration number of a required time step.
8386  *  \param [in] order - the iteration order number of required time step.
8387  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8388  *  \param [in] renumPol - specifies how to permute values of the result field according to
8389  *          the optional numbers of cells and nodes, if any. The valid values are
8390  *          - 0 - do not permute.
8391  *          - 1 - permute cells.
8392  *          - 2 - permute nodes.
8393  *          - 3 - permute cells and nodes.
8394  *
8395  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8396  *          caller is to delete this field using decrRef() as it is no more needed.
8397  *  \throw If the MED file is not readable.
8398  *  \throw If there is no mesh in the MED file.
8399  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8400  *  \throw If no field values of the required parameters are available.
8401  */
8402 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
8403 {
8404   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8405   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8406   if(!myF1TSC)
8407     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
8408   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8409   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arrOut,*contentNotNullBase());
8410   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8411   return ret.retn();
8412 }
8413
8414 /*!
8415  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8416  * the top level cells of the first mesh in MED file.
8417  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8418  *  \param [in] type - a spatial discretization of interest.
8419  *  \param [in] iteration - the iteration number of a required time step.
8420  *  \param [in] order - the iteration order number of required time step.
8421  *  \param [in] renumPol - specifies how to permute values of the result field according to
8422  *          the optional numbers of cells and nodes, if any. The valid values are
8423  *          - 0 - do not permute.
8424  *          - 1 - permute cells.
8425  *          - 2 - permute nodes.
8426  *          - 3 - permute cells and nodes.
8427  *
8428  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8429  *          caller is to delete this field using decrRef() as it is no more needed.
8430  *  \throw If the MED file is not readable.
8431  *  \throw If there is no mesh in the MED file.
8432  *  \throw If no field values of the required parameters are available.
8433  */
8434 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const throw(INTERP_KERNEL::Exception)
8435 {
8436   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8437   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8438   if(!myF1TSC)
8439     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
8440   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8441   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arrOut,*contentNotNullBase());
8442   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8443   return ret.retn();
8444 }
8445
8446 /*!
8447  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8448  * a given support.
8449  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8450  *  \param [in] type - a spatial discretization of interest.
8451  *  \param [in] iteration - the iteration number of a required time step.
8452  *  \param [in] order - the iteration order number of required time step.
8453  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8454  *  \param [in] mesh - the supporting mesh.
8455  *  \param [in] renumPol - specifies how to permute values of the result field according to
8456  *          the optional numbers of cells and nodes, if any. The valid values are
8457  *          - 0 - do not permute.
8458  *          - 1 - permute cells.
8459  *          - 2 - permute nodes.
8460  *          - 3 - permute cells and nodes.
8461  *
8462  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8463  *          caller is to delete this field using decrRef() as it is no more needed.
8464  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8465  *  \throw If no field of \a this is lying on \a mesh.
8466  *  \throw If no field values of the required parameters are available.
8467  */
8468 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
8469 {
8470   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8471   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8472   if(!myF1TSC)
8473     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8474   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8475   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
8476   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8477   return ret.retn();
8478 }
8479
8480 /*!
8481  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8482  * given support.
8483  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8484  *  \param [in] type - a spatial discretization of the new field.
8485  *  \param [in] iteration - the iteration number of a required time step.
8486  *  \param [in] order - the iteration order number of required time step.
8487  *  \param [in] mesh - the supporting mesh.
8488  *  \param [in] renumPol - specifies how to permute values of the result field according to
8489  *          the optional numbers of cells and nodes, if any. The valid values are
8490  *          - 0 - do not permute.
8491  *          - 1 - permute cells.
8492  *          - 2 - permute nodes.
8493  *          - 3 - permute cells and nodes.
8494  *
8495  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8496  *          caller is to delete this field using decrRef() as it is no more needed.
8497  *  \throw If no field of \a this is lying on \a mesh.
8498  *  \throw If no field values of the required parameters are available.
8499  */
8500 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
8501 {
8502   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8503   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8504   if(!myF1TSC)
8505     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8506   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8507   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
8508   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8509   return ret.retn();
8510 }
8511
8512 /*!
8513  * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
8514  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8515  * This method is useful for MED2 file format when field on different mesh was autorized.
8516  */
8517 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const char *mname, int iteration, int order, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
8518 {
8519   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8520   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8521   if(!myF1TSC)
8522     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
8523   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8524   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
8525   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8526   return ret.retn();
8527 }
8528
8529 /*!
8530  * Returns values and a profile of the field of a given type, of a given time step,
8531  * lying on a given support.
8532  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8533  *  \param [in] type - a spatial discretization of the field.
8534  *  \param [in] iteration - the iteration number of a required time step.
8535  *  \param [in] order - the iteration order number of required time step.
8536  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8537  *  \param [in] mesh - the supporting mesh.
8538  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8539  *          field of interest lies on. If the field lies on all entities of the given
8540  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8541  *          using decrRef() as it is no more needed.
8542  *  \param [in] glob - the global data storing profiles and localization.
8543  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
8544  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8545  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8546  *  \throw If no field of \a this is lying on \a mesh.
8547  *  \throw If no field values of the required parameters are available.
8548  */
8549 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
8550 {
8551   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8552   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8553   if(!myF1TSC)
8554     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
8555   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8556   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
8557 }
8558
8559 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const throw(INTERP_KERNEL::Exception)
8560 {
8561   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8562   if(!pt)
8563     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
8564   const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
8565   if(!ret)
8566     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 !");
8567   return ret;
8568 }
8569
8570  MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() throw(INTERP_KERNEL::Exception)
8571 {
8572   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8573   if(!pt)
8574     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
8575   MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
8576   if(!ret)
8577     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 !");
8578   return ret;
8579 }
8580
8581 /*!
8582  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8583  * the given field is checked if its elements are sorted suitable for writing to MED file
8584  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8585  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8586  *  \param [in] field - the field to add to \a this.
8587  *  \throw If the name of \a field is empty.
8588  *  \throw If the data array of \a field is not set.
8589  *  \throw If existing time steps have different name or number of components than \a field.
8590  *  \throw If the underlying mesh of \a field has no name.
8591  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8592  */
8593 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
8594 {
8595   const DataArrayDouble *arr=0;
8596   if(field)
8597     arr=field->getArray();
8598   contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
8599 }
8600
8601 /*!
8602  * Adds a MEDCouplingFieldDouble to \a this as another time step.
8603  * The mesh support of input parameter \a field is ignored here, it can be NULL.
8604  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
8605  * and \a profile.
8606  *
8607  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
8608  * A new profile is added only if no equal profile is missing.
8609  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8610  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
8611  *  \param [in] mesh - the supporting mesh of \a field.
8612  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
8613  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
8614  *  \throw If either \a field or \a mesh or \a profile has an empty name.
8615  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8616  *  \throw If the data array of \a field is not set.
8617  *  \throw If the data array of \a this is already allocated but has different number of
8618  *         components than \a field.
8619  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
8620  *  \sa setFieldNoProfileSBT()
8621  */
8622 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
8623 {
8624   const DataArrayDouble *arr=0;
8625   if(field)
8626     arr=field->getArray();
8627   contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
8628 }
8629
8630 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
8631 {
8632   _content=new MEDFileFieldMultiTSWithoutSDA;
8633 }
8634
8635 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
8636 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
8637 {
8638 }
8639 catch(INTERP_KERNEL::Exception& e)
8640   { throw e; }
8641
8642 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
8643 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
8644 {
8645 }
8646 catch(INTERP_KERNEL::Exception& e)
8647   { throw e; }
8648
8649 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
8650 {
8651 }
8652
8653 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)
8654 {
8655   return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
8656 }
8657
8658 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
8659 {
8660   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
8661 }
8662
8663 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)
8664 {
8665   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
8666 }
8667
8668 //= MEDFileAnyTypeFieldMultiTSIterator
8669
8670 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
8671 {
8672   if(fmts)
8673     {
8674       fmts->incrRef();
8675       _nb_iter=fmts->getNumberOfTS();
8676     }
8677 }
8678
8679 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
8680 {
8681 }
8682
8683 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt() throw(INTERP_KERNEL::Exception)
8684 {
8685   if(_iter_id<_nb_iter)
8686     {
8687       MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
8688       if(fmts)
8689         return fmts->getTimeStepAtPos(_iter_id++);
8690       else
8691         return 0;
8692     }
8693   else
8694     return 0;
8695 }
8696
8697 //= MEDFileIntFieldMultiTS
8698
8699 /*!
8700  * Returns a new empty instance of MEDFileFieldMultiTS.
8701  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8702  *          is to delete this field using decrRef() as it is no more needed.
8703  */
8704 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
8705 {
8706   return new MEDFileIntFieldMultiTS;
8707 }
8708
8709 /*!
8710  * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
8711  * that has been read from a specified MED file.
8712  *  \param [in] fileName - the name of the MED file to read.
8713  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8714  *          is to delete this field using decrRef() as it is no more needed.
8715  *  \throw If reading the file fails.
8716  */
8717 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
8718 {
8719   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,loadAll);
8720   ret->contentNotNull();//to check that content type matches with \a this type.
8721   return ret.retn();
8722 }
8723
8724 /*!
8725  * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
8726  * that has been read from a specified MED file.
8727  *  \param [in] fileName - the name of the MED file to read.
8728  *  \param [in] fieldName - the name of the field to read.
8729  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8730  *          is to delete this field using decrRef() as it is no more needed.
8731  *  \throw If reading the file fails.
8732  *  \throw If there is no field named \a fieldName in the file.
8733  */
8734 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
8735 {
8736   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,fieldName,loadAll);
8737   ret->contentNotNull();//to check that content type matches with \a this type.
8738   return ret.retn();
8739 }
8740
8741 /*!
8742  * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8743  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8744  *
8745  * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
8746  * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8747  * \warning this is a shallow copy constructor
8748  *  \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
8749  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8750  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8751  *          is to delete this field using decrRef() as it is no more needed.
8752  */
8753 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8754 {
8755   return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
8756 }
8757
8758 /*!
8759  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
8760  * following the given input policy.
8761  *
8762  * \param [in] deepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8763  *                            By default (true) the globals are deeply copied.
8764  * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
8765  */
8766 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool deepCpyGlobs) const throw(INTERP_KERNEL::Exception)
8767 {
8768   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret;
8769   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8770   if(content)
8771     {
8772       const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
8773       if(!contc)
8774         throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
8775       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
8776       ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc,getFileName()));
8777     }
8778   else
8779     ret=MEDFileFieldMultiTS::New();
8780   if(deepCpyGlobs)
8781     ret->deepCpyGlobs(*this);
8782   else
8783     ret->shallowCpyGlobs(*this);
8784   return ret.retn();
8785 }
8786
8787 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const throw(INTERP_KERNEL::Exception)
8788 {
8789   return new MEDFileIntFieldMultiTS(*this);
8790 }
8791
8792 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const throw(INTERP_KERNEL::Exception)
8793 {
8794   if(!f1ts)
8795     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8796   const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
8797   if(!f1tsC)
8798     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
8799 }
8800
8801 /*!
8802  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8803  * mesh entities of a given dimension of the first mesh in MED file.
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 [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8809  *  \param [out] arrOut - the DataArrayInt containing values of field.
8810  *  \param [in] renumPol - specifies how to permute values of the result field according to
8811  *          the optional numbers of cells and nodes, if any. The valid values are
8812  *          - 0 - do not permute.
8813  *          - 1 - permute cells.
8814  *          - 2 - permute nodes.
8815  *          - 3 - permute cells and nodes.
8816  *
8817  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8818  *          caller is to delete this field using decrRef() as it is no more needed.
8819  *  \throw If the MED file is not readable.
8820  *  \throw If there is no mesh in the MED file.
8821  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8822  *  \throw If no field values of the required parameters are available.
8823  */
8824 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, 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("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
8830   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8831   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this,arr,*contentNotNullBase());
8832   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8833   return ret.retn();
8834 }
8835
8836 /*!
8837  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8838  * the top level cells of the first mesh in MED file.
8839  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8840  *  \param [in] type - a spatial discretization of interest.
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 [out] arrOut - the DataArrayInt containing values of field.
8844  *  \param [in] renumPol - specifies how to permute values of the result field according to
8845  *          the optional numbers of cells and nodes, if any. The valid values are
8846  *          - 0 - do not permute.
8847  *          - 1 - permute cells.
8848  *          - 2 - permute nodes.
8849  *          - 3 - permute cells and nodes.
8850  *
8851  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8852  *          caller is to delete this field using decrRef() as it is no more needed.
8853  *  \throw If the MED file is not readable.
8854  *  \throw If there is no mesh in the MED file.
8855  *  \throw If no field values of the required parameters are available.
8856  */
8857 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, 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("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
8863   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8864   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,0,renumPol,this,arr,*contentNotNullBase());
8865   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8866   return ret.retn();
8867 }
8868
8869 /*!
8870  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8871  * a given support.
8872  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8873  *  \param [in] type - a spatial discretization of interest.
8874  *  \param [in] iteration - the iteration number of a required time step.
8875  *  \param [in] order - the iteration order number of required time step.
8876  *  \param [out] arrOut - the DataArrayInt containing values of field.
8877  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8878  *  \param [in] mesh - the supporting mesh.
8879  *  \param [in] renumPol - specifies how to permute values of the result field according to
8880  *          the optional numbers of cells and nodes, if any. The valid values are
8881  *          - 0 - do not permute.
8882  *          - 1 - permute cells.
8883  *          - 2 - permute nodes.
8884  *          - 3 - permute cells and nodes.
8885  *
8886  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8887  *          caller is to delete this field using decrRef() as it is no more needed.
8888  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8889  *  \throw If no field of \a this is lying on \a mesh.
8890  *  \throw If no field values of the required parameters are available.
8891  */
8892 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8893 {
8894   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8895   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8896   if(!myF1TSC)
8897     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
8898   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8899   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase());
8900   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8901   return ret.retn();
8902 }
8903
8904 /*!
8905  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8906  * given support.
8907  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8908  *  \param [in] type - a spatial discretization of the new field.
8909  *  \param [in] iteration - the iteration number of a required time step.
8910  *  \param [in] order - the iteration order number of required time step.
8911  *  \param [in] mesh - the supporting mesh.
8912  *  \param [out] arrOut - the DataArrayInt containing values of field.
8913  *  \param [in] renumPol - specifies how to permute values of the result field according to
8914  *          the optional numbers of cells and nodes, if any. The valid values are
8915  *          - 0 - do not permute.
8916  *          - 1 - permute cells.
8917  *          - 2 - permute nodes.
8918  *          - 3 - permute cells and nodes.
8919  *
8920  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8921  *          caller is to delete this field using decrRef() as it is no more needed.
8922  *  \throw If no field of \a this is lying on \a mesh.
8923  *  \throw If no field values of the required parameters are available.
8924  */
8925 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8926 {
8927   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8928   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8929   if(!myF1TSC)
8930     throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
8931   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8932   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase());
8933   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8934   return ret.retn();
8935 }
8936
8937 /*!
8938  * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
8939  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8940  * This method is useful for MED2 file format when field on different mesh was autorized.
8941  */
8942 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const char *mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const throw(INTERP_KERNEL::Exception)
8943 {
8944   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8945   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8946   if(!myF1TSC)
8947     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
8948   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
8949   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase());
8950   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
8951   return ret.retn();
8952 }
8953
8954 /*!
8955  * Returns values and a profile of the field of a given type, of a given time step,
8956  * lying on a given support.
8957  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8958  *  \param [in] type - a spatial discretization of the field.
8959  *  \param [in] iteration - the iteration number of a required time step.
8960  *  \param [in] order - the iteration order number of required time step.
8961  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8962  *  \param [in] mesh - the supporting mesh.
8963  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8964  *          field of interest lies on. If the field lies on all entities of the given
8965  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8966  *          using decrRef() as it is no more needed.
8967  *  \param [in] glob - the global data storing profiles and localization.
8968  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
8969  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8970  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8971  *  \throw If no field of \a this is lying on \a mesh.
8972  *  \throw If no field values of the required parameters are available.
8973  */
8974 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
8975 {
8976   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8977   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
8978   if(!myF1TSC)
8979     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
8980   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8981   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(ret);
8982 }
8983
8984 /*!
8985  * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
8986  *  \param [in] pos - a time step id.
8987  *  \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
8988  *          delete this field using decrRef() as it is no more needed.
8989  *  \throw If \a pos is not a valid time step id.
8990  */
8991 MEDFileAnyTypeField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const throw(INTERP_KERNEL::Exception)
8992 {
8993   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8994   if(!item)
8995     {
8996       std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8997       throw INTERP_KERNEL::Exception(oss.str().c_str());
8998     }
8999   const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
9000   if(itemC)
9001     {
9002       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
9003       ret->shallowCpyGlobs(*this);
9004       return ret.retn();
9005     }
9006   std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
9007   throw INTERP_KERNEL::Exception(oss.str().c_str());
9008 }
9009
9010 /*!
9011  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
9012  * the given field is checked if its elements are sorted suitable for writing to MED file
9013  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
9014  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9015  *  \param [in] field - the field to add to \a this.
9016  *  \throw If the name of \a field is empty.
9017  *  \throw If the data array of \a field is not set.
9018  *  \throw If existing time steps have different name or number of components than \a field.
9019  *  \throw If the underlying mesh of \a field has no name.
9020  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
9021  */
9022 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals) throw(INTERP_KERNEL::Exception)
9023 {
9024   contentNotNull()->appendFieldNoProfileSBT(field,arrOfVals,*this);
9025 }
9026
9027 /*!
9028  * Adds a MEDCouplingFieldDouble to \a this as another time step.
9029  * The mesh support of input parameter \a field is ignored here, it can be NULL.
9030  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
9031  * and \a profile.
9032  *
9033  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
9034  * A new profile is added only if no equal profile is missing.
9035  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9036  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
9037  *  \param [in] arrOfVals - the values of the field \a field used.
9038  *  \param [in] mesh - the supporting mesh of \a field.
9039  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
9040  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
9041  *  \throw If either \a field or \a mesh or \a profile has an empty name.
9042  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9043  *  \throw If the data array of \a field is not set.
9044  *  \throw If the data array of \a this is already allocated but has different number of
9045  *         components than \a field.
9046  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
9047  *  \sa setFieldNoProfileSBT()
9048  */
9049 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
9050 {
9051   contentNotNull()->appendFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this);
9052 }
9053
9054 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const throw(INTERP_KERNEL::Exception)
9055 {
9056   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9057   if(!pt)
9058     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
9059   const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9060   if(!ret)
9061     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 !");
9062   return ret;
9063 }
9064
9065  MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() throw(INTERP_KERNEL::Exception)
9066 {
9067   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9068   if(!pt)
9069     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
9070   MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9071   if(!ret)
9072     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 !");
9073   return ret;
9074 }
9075
9076 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
9077 {
9078   _content=new MEDFileIntFieldMultiTSWithoutSDA;
9079 }
9080
9081 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
9082 {
9083 }
9084
9085 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
9086 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
9087 {
9088 }
9089 catch(INTERP_KERNEL::Exception& e)
9090   { throw e; }
9091
9092 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const char *fileName, const char *fieldName, bool loadAll) throw(INTERP_KERNEL::Exception)
9093 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
9094 {
9095 }
9096 catch(INTERP_KERNEL::Exception& e)
9097   { throw e; }
9098
9099 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
9100 {
9101   return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
9102 }
9103
9104 //= MEDFileFields
9105
9106 MEDFileFields *MEDFileFields::New()
9107 {
9108   return new MEDFileFields;
9109 }
9110
9111 MEDFileFields *MEDFileFields::New(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
9112 {
9113   return new MEDFileFields(fileName,loadAll);
9114 }
9115
9116 std::size_t MEDFileFields::getHeapMemorySize() const
9117 {
9118   std::size_t ret=_fields.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
9119   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9120     if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)*it)
9121       ret+=(*it)->getHeapMemorySize();
9122   return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
9123 }
9124
9125 MEDFileFields *MEDFileFields::deepCpy() const throw(INTERP_KERNEL::Exception)
9126 {
9127   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9128   std::size_t i=0;
9129   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9130     {
9131       if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9132         ret->_fields[i]=(*it)->deepCpy();
9133     }
9134   ret->deepCpyGlobs(*this);
9135   return ret.retn();
9136 }
9137
9138 MEDFileFields *MEDFileFields::shallowCpy() const throw(INTERP_KERNEL::Exception)
9139 {
9140   return new MEDFileFields(*this);
9141 }
9142
9143 /*!
9144  * 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
9145  * 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.
9146  * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
9147  *
9148  * \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.
9149  * \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.
9150  *
9151  * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9152  */
9153 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const throw(INTERP_KERNEL::Exception)
9154 {
9155   std::set< std::pair<int,int> > s;
9156   bool firstShot=true;
9157   areThereSomeForgottenTS=false;
9158   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9159     {
9160       if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9161         continue;
9162       std::vector< std::pair<int,int> > v=(*it)->getIterations();
9163       std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
9164       if(firstShot)
9165         { s=s1; firstShot=false; }
9166       else
9167         {
9168           std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
9169           if(s!=s2)
9170             areThereSomeForgottenTS=true;
9171           s=s2;
9172         }
9173     }
9174   std::vector< std::pair<int,int> > ret;
9175   std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
9176   return ret;
9177 }
9178
9179 int MEDFileFields::getNumberOfFields() const
9180 {
9181   return _fields.size();
9182 }
9183
9184 std::vector<std::string> MEDFileFields::getFieldsNames() const throw(INTERP_KERNEL::Exception)
9185 {
9186   std::vector<std::string> ret(_fields.size());
9187   int i=0;
9188   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9189     {
9190       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
9191       if(f)
9192         {
9193           ret[i]=f->getName();
9194         }
9195       else
9196         {
9197           std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
9198           throw INTERP_KERNEL::Exception(oss.str().c_str());
9199         }
9200     }
9201   return ret;
9202 }
9203
9204 std::vector<std::string> MEDFileFields::getMeshesNames() const throw(INTERP_KERNEL::Exception)
9205 {
9206   std::vector<std::string> ret;
9207   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9208     {
9209       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9210       if(cur)
9211         ret.push_back(cur->getMeshName());
9212     }
9213   return ret;
9214 }
9215
9216 std::string MEDFileFields::simpleRepr() const
9217 {
9218   std::ostringstream oss;
9219   oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
9220   simpleRepr(0,oss);
9221   return oss.str();
9222 }
9223
9224 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
9225 {
9226   int nbOfFields=getNumberOfFields();
9227   std::string startLine(bkOffset,' ');
9228   oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
9229   int i=0;
9230   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9231     {
9232       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9233       if(cur)
9234         {
9235           oss << startLine << "  - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
9236         }
9237       else
9238         {
9239           oss << startLine << "  - not defined !" << std::endl;
9240         }
9241     }
9242   i=0;
9243   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9244     {
9245       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9246       std::string chapter(17,'0'+i);
9247       oss << startLine << chapter << std::endl;
9248       if(cur)
9249         {
9250           cur->simpleRepr(bkOffset+2,oss,i);
9251         }
9252       else
9253         {
9254           oss << startLine << "  - not defined !" << std::endl;
9255         }
9256       oss << startLine << chapter << std::endl;
9257     }
9258   simpleReprGlobs(oss);
9259 }
9260
9261 MEDFileFields::MEDFileFields()
9262 {
9263 }
9264
9265 MEDFileFields::MEDFileFields(const char *fileName, bool loadAll) throw(INTERP_KERNEL::Exception)
9266 try:MEDFileFieldGlobsReal(fileName)
9267   {
9268     MEDFileUtilities::CheckFileForRead(fileName);
9269     MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
9270     int nbFields=MEDnField(fid);
9271     _fields.resize(nbFields);
9272     med_field_type typcha;
9273     for(int i=0;i<nbFields;i++)
9274       {
9275         std::vector<std::string> infos;
9276         std::string fieldName,dtunit;
9277         int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,fileName,i,false,fieldName,typcha,infos,dtunit);
9278         switch(typcha)
9279           {
9280           case MED_FLOAT64:
9281             {
9282               _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9283               break;
9284             }
9285           case MED_INT32:
9286             {
9287               _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9288               break;
9289             }
9290           default:
9291             {
9292               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] !";
9293               throw INTERP_KERNEL::Exception(oss.str().c_str());
9294             }
9295           }
9296       }
9297     loadAllGlobals(fid);
9298   }
9299 catch(INTERP_KERNEL::Exception& e)
9300   {
9301     throw e;
9302   }
9303
9304 void MEDFileFields::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
9305 {
9306   int i=0;
9307   writeGlobals(fid,*this);
9308   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9309     {
9310       const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
9311       if(!elt)
9312         {
9313           std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
9314           throw INTERP_KERNEL::Exception(oss.str().c_str());
9315         }
9316       elt->writeLL(fid,*this);
9317     }
9318 }
9319
9320 void MEDFileFields::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
9321 {
9322   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
9323   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
9324   writeLL(fid);
9325 }
9326
9327 /*!
9328  * This method alloc the arrays and load potentially huge arrays contained in this field.
9329  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
9330  * This method can be also called to refresh or reinit values from a file.
9331  *
9332  * \throw If the fileName is not set or points to a non readable MED file.
9333  */
9334 void MEDFileFields::loadArrays() throw(INTERP_KERNEL::Exception)
9335 {
9336   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9337   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9338     {
9339       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9340       if(elt)
9341         elt->loadBigArraysRecursively(fid,*elt);
9342     }
9343 }
9344
9345 /*!
9346  * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
9347  * But once data loaded once, this method does nothing.
9348  *
9349  * \throw If the fileName is not set or points to a non readable MED file.
9350  * \sa MEDFileFields::loadArrays, MEDFileFields::releaseArrays
9351  */
9352 void MEDFileFields::loadArraysIfNecessary() throw(INTERP_KERNEL::Exception)
9353 {
9354   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9355   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9356     {
9357       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9358       if(elt)
9359         elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
9360     }
9361 }
9362
9363 /*!
9364  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
9365  * This method does not release arrays set outside the context of a MED file.
9366  *
9367  * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary
9368  */
9369 void MEDFileFields::releaseArrays() throw(INTERP_KERNEL::Exception)
9370 {
9371   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName(),MED_ACC_RDONLY);
9372   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9373     {
9374       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9375       if(elt)
9376         elt->releaseArrays();
9377     }
9378 }
9379
9380 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
9381 {
9382   std::vector<std::string> ret;
9383   std::set<std::string> ret2;
9384   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9385     {
9386       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
9387       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9388         if(ret2.find(*it2)==ret2.end())
9389           {
9390             ret.push_back(*it2);
9391             ret2.insert(*it2);
9392           }
9393     }
9394   return ret;
9395 }
9396
9397 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
9398 {
9399   std::vector<std::string> ret;
9400   std::set<std::string> ret2;
9401   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9402     {
9403       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9404       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9405         if(ret2.find(*it2)==ret2.end())
9406           {
9407             ret.push_back(*it2);
9408             ret2.insert(*it2);
9409           }
9410     }
9411   return ret;
9412 }
9413
9414 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
9415 {
9416   std::vector<std::string> ret;
9417   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9418     {
9419       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
9420       ret.insert(ret.end(),tmp.begin(),tmp.end());
9421     }
9422   return ret;
9423 }
9424
9425 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
9426 {
9427   std::vector<std::string> ret;
9428   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9429     {
9430       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9431       ret.insert(ret.end(),tmp.begin(),tmp.end());
9432     }
9433   return ret;
9434 }
9435
9436 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
9437 {
9438   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9439     (*it)->changePflsRefsNamesGen2(mapOfModif);
9440 }
9441
9442 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
9443 {
9444   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9445     (*it)->changeLocsRefsNamesGen2(mapOfModif);
9446 }
9447
9448 void MEDFileFields::resize(int newSize) throw(INTERP_KERNEL::Exception)
9449 {
9450   _fields.resize(newSize);
9451 }
9452
9453 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields) throw(INTERP_KERNEL::Exception)
9454 {
9455   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
9456     pushField(*it);
9457 }
9458
9459 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field) throw(INTERP_KERNEL::Exception)
9460 {
9461   if(!field)
9462     throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
9463   _fields.push_back(field->getContent());
9464   appendGlobs(*field,1e-12);
9465 }
9466
9467 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field) throw(INTERP_KERNEL::Exception)
9468 {
9469   if(!field)
9470     throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
9471   if(i>=(int)_fields.size())
9472     _fields.resize(i+1);
9473   _fields[i]=field->getContent();
9474   appendGlobs(*field,1e-12);
9475 }
9476
9477 void MEDFileFields::destroyFieldAtPos(int i) throw(INTERP_KERNEL::Exception)
9478 {
9479   destroyFieldsAtPos(&i,&i+1);
9480 }
9481
9482 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
9483 {
9484   std::vector<bool> b(_fields.size(),true);
9485   for(const int *i=startIds;i!=endIds;i++)
9486     {
9487       if(*i<0 || *i>=(int)_fields.size())
9488         {
9489           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9490           throw INTERP_KERNEL::Exception(oss.str().c_str());
9491         }
9492       b[*i]=false;
9493     }
9494   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9495   std::size_t j=0;
9496   for(std::size_t i=0;i<_fields.size();i++)
9497     if(b[i])
9498       fields[j++]=_fields[i];
9499   _fields=fields;
9500 }
9501
9502 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step) throw(INTERP_KERNEL::Exception)
9503 {
9504   static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
9505   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
9506   std::vector<bool> b(_fields.size(),true);
9507   int k=bg;
9508   for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
9509     {
9510       if(k<0 || k>=(int)_fields.size())
9511         {
9512           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
9513           throw INTERP_KERNEL::Exception(oss.str().c_str());
9514         }
9515       b[k]=false;
9516     }
9517   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9518   std::size_t j=0;
9519   for(std::size_t i=0;i<_fields.size();i++)
9520     if(b[i])
9521       fields[j++]=_fields[i];
9522   _fields=fields;
9523 }
9524
9525 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
9526 {
9527   bool ret=false;
9528   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9529     {
9530       MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9531       if(cur)
9532         ret=cur->changeMeshNames(modifTab) || ret;
9533     }
9534   return ret;
9535 }
9536
9537 /*!
9538  * \param [in] meshName the name of the mesh that will be renumbered.
9539  * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
9540  *             This code corresponds to the distribution of types in the corresponding mesh.
9541  * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
9542  * \param [in] renumO2N the old to new renumber array.
9543  * \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
9544  *         field in \a this.
9545  */
9546 bool MEDFileFields::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N) throw(INTERP_KERNEL::Exception)
9547 {
9548   bool ret=false;
9549   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9550     {
9551       MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
9552       if(fmts)
9553         {
9554           ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
9555         }
9556     }
9557   return ret;
9558 }
9559
9560 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const throw(INTERP_KERNEL::Exception)
9561 {
9562   if(i<0 || i>=(int)_fields.size())
9563     {
9564       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
9565       throw INTERP_KERNEL::Exception(oss.str().c_str());
9566     }
9567   const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
9568   if(!fmts)
9569     return 0;
9570   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret;
9571   const MEDFileFieldMultiTSWithoutSDA *fmtsC=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts);
9572   const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts);
9573   if(fmtsC)
9574     ret=MEDFileFieldMultiTS::New(*fmtsC,false);
9575   else if(fmtsC2)
9576     ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
9577   else
9578     {
9579       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
9580       throw INTERP_KERNEL::Exception(oss.str().c_str());
9581     }
9582   ret->shallowCpyGlobs(*this);
9583   return ret.retn();
9584 }
9585
9586 /*!
9587  * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
9588  * This method is accessible in python using __getitem__ with a list in input.
9589  * \return a new object that the caller should deal with.
9590  */
9591 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const throw(INTERP_KERNEL::Exception)
9592 {
9593   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9594   std::size_t sz=std::distance(startIds,endIds);
9595   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
9596   int j=0;
9597   for(const int *i=startIds;i!=endIds;i++,j++)
9598     {
9599       if(*i<0 || *i>=(int)_fields.size())
9600         {
9601           std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9602           throw INTERP_KERNEL::Exception(oss.str().c_str());
9603         }
9604       fields[j]=_fields[*i];
9605     }
9606   ret->_fields=fields;
9607   return ret.retn();
9608 }
9609
9610 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const char *fieldName) const throw(INTERP_KERNEL::Exception)
9611 {
9612   return getFieldAtPos(getPosFromFieldName(fieldName));
9613 }
9614
9615 /*!
9616  * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
9617  * This method can be seen as a filter applied on \a this, that returns an object containing
9618  * 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
9619  * shallow copied from \a this.
9620  *
9621  * \param [in] meshName - the name of the mesh on w
9622  * \return a new object that the caller should deal with.
9623  */
9624 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const char *meshName) const throw(INTERP_KERNEL::Exception)
9625 {
9626   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9627   ret->shallowCpyOnlyUsedGlobs(*this);
9628   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9629     {
9630       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9631       if(!cur)
9632         continue;
9633       if(cur->getMeshName()==meshName)
9634         {
9635           cur->incrRef();
9636           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
9637           ret->_fields.push_back(cur2);
9638         }
9639     }
9640   return ret.retn();
9641 }
9642
9643 /*!
9644  * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
9645  * Input time steps are specified using a pair of integer (iteration, order).
9646  * 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,
9647  * but for each multitimestep only the time steps in \a timeSteps are kept.
9648  * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
9649  *
9650  * The returned object points to shallow copy of elements in \a this.
9651  *
9652  * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
9653  * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
9654  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9655  */
9656 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
9657 {
9658   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9659   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9660     {
9661       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9662       if(!cur)
9663         continue;
9664       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
9665       ret->_fields.push_back(elt);
9666     }
9667   ret->shallowCpyOnlyUsedGlobs(*this);
9668   return ret.retn();
9669 }
9670
9671 /*!
9672  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
9673  */
9674 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const throw(INTERP_KERNEL::Exception)
9675 {
9676   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9677   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9678     {
9679       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9680       if(!cur)
9681         continue;
9682       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
9683       if(elt->getNumberOfTS()!=0)
9684         ret->_fields.push_back(elt);
9685     }
9686   ret->shallowCpyOnlyUsedGlobs(*this);
9687   return ret.retn();
9688 }
9689
9690 MEDFileFieldsIterator *MEDFileFields::iterator() throw(INTERP_KERNEL::Exception)
9691 {
9692   return new MEDFileFieldsIterator(this);
9693 }
9694
9695 int MEDFileFields::getPosFromFieldName(const char *fieldName) const throw(INTERP_KERNEL::Exception)
9696 {
9697   std::string tmp(fieldName);
9698   std::vector<std::string> poss;
9699   for(std::size_t i=0;i<_fields.size();i++)
9700     {
9701       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=_fields[i];
9702       if(f)
9703         {
9704           std::string fname(f->getName());
9705           if(tmp==fname)
9706             return i;
9707           else
9708             poss.push_back(fname);
9709         }
9710     }
9711   std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
9712   std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
9713   oss << " !";
9714   throw INTERP_KERNEL::Exception(oss.str().c_str());
9715 }
9716
9717 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
9718 {
9719   if(fs)
9720     {
9721       fs->incrRef();
9722       _nb_iter=fs->getNumberOfFields();
9723     }
9724 }
9725
9726 MEDFileFieldsIterator::~MEDFileFieldsIterator()
9727 {
9728 }
9729
9730 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
9731 {
9732   if(_iter_id<_nb_iter)
9733     {
9734       MEDFileFields *fs(_fs);
9735       if(fs)
9736         return fs->getFieldAtPos(_iter_id++);
9737       else
9738         return 0;
9739     }
9740   else
9741     return 0;
9742 }