src/MEDLoader/MEDFileField.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "MEDFileField.hxx"
  22 #include "MEDFileMesh.hxx"
  23 #include "MEDLoaderBase.hxx"
  24 #include "MEDFileUtilities.hxx"
  25 #include "MEDFileFieldOverView.hxx"
  26
  27 #include "MEDCouplingFieldDouble.hxx"
  28 #include "MEDCouplingFieldDiscretization.hxx"
  29
  30 #include "InterpKernelAutoPtr.hxx"
  31 #include "CellModel.hxx"
  32
  33 #include <algorithm>
  34 #include <iterator>
  35
  36 extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
  37 extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
  38 extern med_geometry_type typmainoeud[1];
  39 extern med_geometry_type typmai3[34];
  40
  41 using namespace ParaMEDMEM;
  42
  43 const char MEDFileField1TSWithoutSDA::TYPE_STR[]="FLOAT64";
  44 const char MEDFileIntField1TSWithoutSDA::TYPE_STR[]="INT32";
  45
  46 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, const std::string& locName)
  47 {
  48   return new MEDFileFieldLoc(fid,locName);
  49 }
  50
  51 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, int id)
  52 {
  53   return new MEDFileFieldLoc(fid,id);
  54 }
  55
  56 MEDFileFieldLoc *MEDFileFieldLoc::New(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
  57 {
  58   return new MEDFileFieldLoc(locName,geoType,refCoo,gsCoo,w);
  59 }
  60
  61 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, const std::string& locName):_name(locName)
  62 {
  63   med_geometry_type geotype;
  64   med_geometry_type sectiongeotype;
  65   int nsectionmeshcell;
  66   INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  67   INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  68   MEDlocalizationInfoByName(fid,locName.c_str(),&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
  69   _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype)));
  70   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
  71   _nb_node_per_cell=cm.getNumberOfNodes();
  72   _ref_coo.resize(_dim*_nb_node_per_cell);
  73   _gs_coo.resize(_dim*_nb_gauss_pt);
  74   _w.resize(_nb_gauss_pt);
  75   MEDlocalizationRd(fid,locName.c_str(),MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
  76 }
  77
  78 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, int id)
  79 {
  80   med_geometry_type geotype;
  81   med_geometry_type sectiongeotype;
  82   int nsectionmeshcell;
  83   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  84   INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  85   INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
  86   MEDlocalizationInfo(fid,id+1,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
  87   _name=locName;
  88   _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype)));
  89   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
  90   _nb_node_per_cell=cm.getNumberOfNodes();
  91   _ref_coo.resize(_dim*_nb_node_per_cell);
  92   _gs_coo.resize(_dim*_nb_gauss_pt);
  93   _w.resize(_nb_gauss_pt);
  94   MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
  95 }
  96
  97 MEDFileFieldLoc::MEDFileFieldLoc(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType,
  98                                  const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w):_name(locName),_geo_type(geoType),_ref_coo(refCoo),_gs_coo(gsCoo),
  99                                                                                                                                     _w(w)
 100 {
 101   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
 102   _dim=cm.getDimension();
 103   _nb_node_per_cell=cm.getNumberOfNodes();
 104   _nb_gauss_pt=_w.size();
 105 }
 106
 107 MEDFileFieldLoc *MEDFileFieldLoc::deepCpy() const
 108 {
 109   return new MEDFileFieldLoc(*this);
 110 }
 111
 112 std::size_t MEDFileFieldLoc::getHeapMemorySizeWithoutChildren() const
 113 {
 114   return (_ref_coo.capacity()+_gs_coo.capacity()+_w.capacity())*sizeof(double)+_name.capacity();
 115 }
 116
 117 std::vector<const BigMemoryObject *> MEDFileFieldLoc::getDirectChildren() const
 118 {
 119   return std::vector<const BigMemoryObject *>();
 120 }
 121
 122 void MEDFileFieldLoc::simpleRepr(std::ostream& oss) const
 123 {
 124   static const char OFF7[]="\n    ";
 125   oss << "\"" << _name << "\"" << OFF7;
 126   oss << "GeoType=" << INTERP_KERNEL::CellModel::GetCellModel(_geo_type).getRepr() << OFF7;
 127   oss << "Dimension=" << _dim << OFF7;
 128   oss << "Number of Gauss points=" << _nb_gauss_pt << OFF7;
 129   oss << "Number of nodes per cell=" << _nb_node_per_cell << OFF7;
 130   oss << "RefCoords="; std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 131   oss << "Weights="; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 132   oss << "GaussPtsCoords="; std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," ")); oss << std::endl;
 133 }
 134
 135 void MEDFileFieldLoc::setName(const std::string& name)
 136 {
 137   _name=name;
 138 }
 139
 140 bool MEDFileFieldLoc::isEqual(const MEDFileFieldLoc& other, double eps) const
 141 {
 142   if(_name!=other._name)
 143     return false;
 144   if(_dim!=other._dim)
 145     return false;
 146   if(_nb_gauss_pt!=other._nb_gauss_pt)
 147     return false;
 148   if(_nb_node_per_cell!=other._nb_node_per_cell)
 149     return false;
 150   if(_geo_type!=other._geo_type)
 151     return false;
 152   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_ref_coo,other._ref_coo,eps))
 153     return false;
 154   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_gs_coo,other._gs_coo,eps))
 155     return false;
 156   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_w,other._w,eps))
 157     return false;
 158
 159   return true;
 160 }
 161
 162 void MEDFileFieldLoc::writeLL(med_idt fid) const
 163 {
 164   MEDlocalizationWr(fid,_name.c_str(),typmai3[(int)_geo_type],_dim,&_ref_coo[0],MED_FULL_INTERLACE,_nb_gauss_pt,&_gs_coo[0],&_w[0],MED_NO_INTERPOLATION,MED_NO_MESH_SUPPORT);
 165 }
 166
 167 std::string MEDFileFieldLoc::repr() const
 168 {
 169   std::ostringstream oss; oss.precision(15);
 170   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
 171   oss << "Localization \"" << _name << "\" :\n" << "  - Geometric Type : " << cm.getRepr();
 172   oss << "\n  - Dimension : " << _dim << "\n  - Number of gauss points : ";
 173   oss << _nb_gauss_pt << "\n  - Number of nodes in cell : " << _nb_node_per_cell;
 174   oss << "\n  - Ref coords are : ";
 175   int sz=_ref_coo.size();
 176   if(sz%_dim==0)
 177     {
 178       int nbOfTuples=sz/_dim;
 179       for(int i=0;i<nbOfTuples;i++)
 180         {
 181           oss << "(";
 182           for(int j=0;j<_dim;j++)
 183             { oss << _ref_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 184           oss << ") ";
 185         }
 186     }
 187   else
 188     std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," "));
 189   oss << "\n  - Gauss coords in reference element : ";
 190   sz=_gs_coo.size();
 191   if(sz%_dim==0)
 192     {
 193       int nbOfTuples=sz/_dim;
 194       for(int i=0;i<nbOfTuples;i++)
 195         {
 196           oss << "(";
 197           for(int j=0;j<_dim;j++)
 198             { oss << _gs_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 199           oss << ") ";
 200         }
 201     }
 202   else
 203     std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," "));
 204   oss << "\n  - Weights of Gauss coords are : "; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," "));
 205   return oss.str();
 206 }
 207
 208 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
 209 {
 210   _type=field->getTypeOfField();
 211   _start=start;
 212   switch(_type)
 213     {
 214     case ON_CELLS:
 215       {
 216         getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,offset,offset+nbOfCells,1);
 217         _end=_start+nbOfCells;
 218         _nval=nbOfCells;
 219         break;
 220       }
 221     case ON_GAUSS_NE:
 222       {
 223         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(field->getMesh());
 224         const int *arrPtr=arr->getConstPointer();
 225         getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,arrPtr[offset],arrPtr[offset+nbOfCells],1);
 226         _end=_start+(arrPtr[offset+nbOfCells]-arrPtr[offset]);
 227         _nval=nbOfCells;
 228         break;
 229       }
 230     case ON_GAUSS_PT:
 231       {
 232         const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
 233         const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
 234         const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
 235         if(!disc2)
 236           throw INTERP_KERNEL::Exception("assignFieldNoProfile : invalid call to this method ! Internal Error !");
 237         const DataArrayInt *dai=disc2->getArrayOfDiscIds();
 238         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai2=disc2->getOffsetArr(field->getMesh());
 239         const int *dai2Ptr=dai2->getConstPointer();
 240         int nbi=gsLoc.getWeights().size();
 241         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=dai->selectByTupleId2(offset,offset+nbOfCells,1);
 242         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
 243         const int *da3Ptr=da3->getConstPointer();
 244         if(da3->getNumberOfTuples()!=nbOfCells)
 245           {//profile : for gauss even in NoProfile !!!
 246             std::ostringstream oss; oss << "Pfl_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 247             _profile=oss.str();
 248             da3->setName(_profile.c_str());
 249             glob.appendProfile(da3);
 250           }
 251         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=DataArrayInt::New();
 252         _nval=da3->getNbOfElems();
 253         da4->alloc(_nval*nbi,1);
 254         int *da4Ptr=da4->getPointer();
 255         for(int i=0;i<_nval;i++)
 256           {
 257             int ref=dai2Ptr[offset+da3Ptr[i]];
 258             for(int j=0;j<nbi;j++)
 259               *da4Ptr++=ref+j;
 260           }
 261         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 262         _localization=oss2.str();
 263         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,da4);
 264         _end=_start+_nval*nbi;
 265         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 266         break;
 267       }
 268     default:
 269       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile : not implemented yet for such discretization type of field !");
 270     }
 271   start=_end;
 272 }
 273
 274 /*!
 275  * Leaf method of field with profile assignement. This method is the most general one. No optimization is done here.
 276  * \param [in] pflName input containing name of profile if any. 0 if no profile (except for GAUSS_PT where a no profile can hide a profile when splitted by loc_id).
 277  * \param [in] multiTypePfl is the end user profile specified in high level API
 278  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
 279  * \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
 280  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
 281  * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
 282  */
 283 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const DataArray *arrr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
 284 {
 285   _profile.clear();
 286   _type=field->getTypeOfField();
 287   std::string pflName(multiTypePfl->getName());
 288   std::ostringstream oss; oss << pflName;
 289   if(_type!=ON_NODES) { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType()); oss << "_" <<  cm.getRepr(); } else { oss << "_NODE"; }
 290   if(locIds)
 291     {
 292       if(pflName.empty())
 293         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : existing profile with empty name !");
 294       if(_type!=ON_GAUSS_PT)
 295         {
 296           locIds->setName(oss.str().c_str());
 297           glob.appendProfile(locIds);
 298           _profile=oss.str();
 299         }
 300     }
 301   _start=start;
 302   switch(_type)
 303     {
 304     case ON_NODES:
 305       {
 306          _nval=idsInPfl->getNumberOfTuples();
 307          getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,arrr->getNumberOfTuples(),1);
 308          _end=_start+_nval;
 309          break;
 310       }
 311     case ON_CELLS:
 312       {
 313         _nval=idsInPfl->getNumberOfTuples();
 314         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,idsInPfl);
 315         _end=_start+_nval;
 316         break;
 317       }
 318     case ON_GAUSS_NE:
 319       {
 320         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(mesh);
 321         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr->deltaShiftIndex();
 322         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3=arr2->selectByTupleId(multiTypePfl->begin(),multiTypePfl->end());
 323         arr3->computeOffsets2();
 324         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=idsInPfl->buildExplicitArrByRanges(arr3);
 325         int trueNval=tmp->getNumberOfTuples();
 326         _nval=idsInPfl->getNumberOfTuples();
 327         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 328         _end=_start+trueNval;
 329         break;
 330       }
 331     case ON_GAUSS_PT:
 332       {
 333         const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
 334         if(!disc2)
 335           throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
 336         const DataArrayInt *da1=disc2->getArrayOfDiscIds();
 337         const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
 338         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da1->selectByTupleId(idsInPfl->begin(),idsInPfl->end());
 339         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
 340         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=idsInPfl->selectByTupleId(da3->begin(),da3->end());
 341         //
 342         MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPart(multiTypePfl->begin(),multiTypePfl->end());
 343         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=disc2->getOffsetArr(mesh2);
 344         //
 345         MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=DataArrayInt::New();
 346         int trueNval=0;
 347         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 348           trueNval+=arr->getIJ(*pt+1,0)-arr->getIJ(*pt,0);
 349         tmp->alloc(trueNval,1);
 350         int *tmpPtr=tmp->getPointer();
 351         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 352           for(int j=arr->getIJ(*pt,0);j<arr->getIJ(*pt+1,0);j++)
 353             *tmpPtr++=j;
 354         //
 355         _nval=da4->getNumberOfTuples();
 356         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 357         _end=_start+trueNval;
 358         oss << "_loc_" << _loc_id;
 359         if(locIds)
 360           {
 361             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da5=locIds->selectByTupleId(da3->begin(),da3->end());
 362             da5->setName(oss.str().c_str());
 363             glob.appendProfile(da5);
 364             _profile=oss.str();
 365           }
 366         else
 367           {
 368             if(da3->getNumberOfTuples()!=nbOfEltsInWholeMesh || !da3->isIdentity())
 369               {
 370                 da3->setName(oss.str().c_str());
 371                 glob.appendProfile(da3);
 372                 _profile=oss.str();
 373               }
 374           }
 375         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 376         _localization=oss2.str();
 377         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 378         break;
 379       }
 380     default:
 381       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : not implemented yet for such discretization type of field !");
 382     }
 383   start=_end;
 384 }
 385
 386 void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob)
 387 {
 388   _start=start;
 389   _nval=arrr->getNumberOfTuples();
 390   getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,_nval,1);
 391   _end=_start+_nval;
 392   start=_end;
 393 }
 394
 395 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int profileIt)
 396 {
 397   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,profileIt);
 398 }
 399
 400 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId)
 401 {
 402   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,locId,std::string());
 403 }
 404
 405 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(const MEDFileFieldPerMeshPerTypePerDisc& other)
 406 {
 407   return new MEDFileFieldPerMeshPerTypePerDisc(other);
 408 }
 409
 410 std::size_t MEDFileFieldPerMeshPerTypePerDisc::getHeapMemorySizeWithoutChildren() const
 411 {
 412   return _profile.capacity()+_localization.capacity()+5*sizeof(int);
 413 }
 414
 415 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerTypePerDisc::getDirectChildren() const
 416 {
 417   return std::vector<const BigMemoryObject *>();
 418 }
 419
 420 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::deepCpy(MEDFileFieldPerMeshPerType *father) const
 421 {
 422   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> ret=new MEDFileFieldPerMeshPerTypePerDisc(*this);
 423   ret->_father=father;
 424   return ret.retn();
 425 }
 426
 427 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField atype, int profileIt)
 428 try:_type(atype),_father(fath),_profile_it(profileIt)
 429   {
 430   }
 431 catch(INTERP_KERNEL::Exception& e)
 432 {
 433   throw e;
 434 }
 435
 436 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId, const std::string& dummy):_type(type),_father(fath),_loc_id(locId)
 437 {
 438 }
 439
 440 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc& other):RefCountObject(other),_type(other._type),_father(0),_start(other._start),_end(other._end),_nval(other._nval),_profile(other._profile),_localization(other._localization),_loc_id(other._loc_id),_tmp_work1(other._tmp_work1)
 441 {
 442 }
 443
 444 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(0),_start(-std::numeric_limits<int>::max()),_end(-std::numeric_limits<int>::max()),
 445                                                                        _nval(-std::numeric_limits<int>::max()),_loc_id(-std::numeric_limits<int>::max())
 446 {
 447 }
 448
 449 const MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerTypePerDisc::getFather() const
 450 {
 451   return _father;
 452 }
 453
 454 void MEDFileFieldPerMeshPerTypePerDisc::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
 455 {
 456   INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 457   INTERP_KERNEL::AutoPtr<char> pflname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 458   std::string fieldName=nasc.getName();
 459   std::string meshName=getMeshName();
 460   int iteration=getIteration();
 461   int order=getOrder();
 462   TypeOfField type=getType();
 463   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 464   int profilesize,nbi;
 465   med_geometry_type mgeoti;
 466   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 467   _nval=MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile_it,MED_COMPACT_PFLMODE,
 468                                   pflname,&profilesize,locname,&nbi);
 469   _profile=MEDLoaderBase::buildStringFromFortran(pflname,MED_NAME_SIZE);
 470   _localization=MEDLoaderBase::buildStringFromFortran(locname,MED_NAME_SIZE);
 471   _start=start;
 472   _end=start+_nval*nbi;
 473   start=_end;
 474   if(type==ON_CELLS && !_localization.empty())
 475     {
 476       if(_localization!="MED_GAUSS_ELNO")//For compatibily with MED2.3
 477         setType(ON_GAUSS_PT);
 478       else
 479         {
 480           setType(ON_GAUSS_NE);
 481           _localization.clear();
 482         }
 483     }
 484 }
 485
 486 void MEDFileFieldPerMeshPerTypePerDisc::loadBigArray(med_idt fid, const MEDFileFieldNameScope& nasc)
 487 {
 488   std::string fieldName=nasc.getName();
 489   std::string meshName=getMeshName();
 490   int iteration=getIteration();
 491   int order=getOrder();
 492   TypeOfField type=getType();
 493   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 494   med_geometry_type mgeoti;
 495   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 496   if(_start>_end)
 497     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : internal error in range !");
 498   if(_start==_end)
 499     return ;
 500   DataArray *arr=getOrCreateAndGetArray();//arr is not null due to the spec of getOrCreateAndGetArray
 501   if(_start<0 || _start>=arr->getNumberOfTuples())
 502     {
 503       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << ") !";
 504       throw INTERP_KERNEL::Exception(oss.str().c_str());
 505     }
 506   if(_end<0 || _end>arr->getNumberOfTuples())
 507     {
 508       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << "] !";
 509       throw INTERP_KERNEL::Exception(oss.str().c_str());
 510     }
 511   med_int tmp1,nbi;
 512   INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
 513   med_int nbValsInFile=MEDfieldnValueWithProfileByName(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile.c_str(),MED_COMPACT_PFLMODE,&tmp1,locname,&nbi);
 514   int nbOfCompo=arr->getNumberOfComponents();
 515   if(_end-_start!=nbValsInFile*nbi)
 516     {
 517       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : The number of tuples to read is " << nbValsInFile << "*" << nbi <<  " (nb integration points) ! But in data structure it values " << _end-_start << " is expected !";
 518       throw INTERP_KERNEL::Exception(oss.str().c_str());
 519     }
 520   DataArrayDouble *arrD=dynamic_cast<DataArrayDouble *>(arr);
 521   if(arrD)
 522     {
 523       double *startFeeding=arrD->getPointer()+_start*nbOfCompo;
 524       MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
 525                                  _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
 526       return ;
 527     }
 528   DataArrayInt *arrI=dynamic_cast<DataArrayInt *>(arr);
 529   if(arrI)
 530     {
 531       int *startFeeding=arrI->getPointer()+_start*nbOfCompo;
 532       MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
 533                                  _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
 534       return ;
 535     }
 536   throw INTERP_KERNEL::Exception("Error on array reading ! Unrecognized type of field ! Should be in FLOAT64 or INT32 !");
 537 }
 538
 539 /*!
 540  * Set a \c this->_start **and** \c this->_end keeping the same delta between the two.
 541  */
 542 void MEDFileFieldPerMeshPerTypePerDisc::setNewStart(int newValueOfStart)
 543 {
 544   int delta=_end-_start;
 545   _start=newValueOfStart;
 546   _end=_start+delta;
 547 }
 548
 549 int MEDFileFieldPerMeshPerTypePerDisc::getIteration() const
 550 {
 551   return _father->getIteration();
 552 }
 553
 554 int MEDFileFieldPerMeshPerTypePerDisc::getOrder() const
 555 {
 556   return _father->getOrder();
 557 }
 558
 559 double MEDFileFieldPerMeshPerTypePerDisc::getTime() const
 560 {
 561   return _father->getTime();
 562 }
 563
 564 std::string MEDFileFieldPerMeshPerTypePerDisc::getMeshName() const
 565 {
 566   return _father->getMeshName();
 567 }
 568
 569 void MEDFileFieldPerMeshPerTypePerDisc::simpleRepr(int bkOffset, std::ostream& oss, int id) const
 570 {
 571   const char startLine[]="    ## ";
 572   std::string startLine2(bkOffset,' ');
 573   startLine2+=startLine;
 574   MEDCouplingFieldDiscretization *tmp=MEDCouplingFieldDiscretization::New(_type);
 575   oss << startLine2 << "Localization #" << id << "." << std::endl;
 576   oss << startLine2 << "  Type=" << tmp->getRepr() << "." << std::endl;
 577   delete tmp;
 578   oss << startLine2 << "  This type discretization lies on profile : \"" << _profile << "\" and on the following localization : \"" << _localization << "\"." << std::endl;
 579   oss << startLine2 << "  This type discretization has " << _end-_start << " tuples (start=" << _start << ", end=" << _end << ")." << std::endl;
 580   oss << startLine2 << "  This type discretization has " << (_end-_start)/_nval << " integration points." << std::endl;
 581 }
 582
 583 TypeOfField MEDFileFieldPerMeshPerTypePerDisc::getType() const
 584 {
 585   return _type;
 586 }
 587
 588 void MEDFileFieldPerMeshPerTypePerDisc::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
 589 {
 590   types.insert(_type);
 591 }
 592
 593 void MEDFileFieldPerMeshPerTypePerDisc::setType(TypeOfField newType)
 594 {
 595   _type=newType;
 596 }
 597
 598 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerTypePerDisc::getGeoType() const
 599 {
 600   return _father->getGeoType();
 601 }
 602
 603 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfComponents() const
 604 {
 605   return _father->getNumberOfComponents();
 606 }
 607
 608 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfTuples() const
 609 {
 610   return _end-_start;
 611 }
 612
 613 DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray()
 614 {
 615   return _father->getOrCreateAndGetArray();
 616 }
 617
 618 const DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray() const
 619 {
 620   const MEDFileFieldPerMeshPerType *fath=_father;
 621   return fath->getOrCreateAndGetArray();
 622 }
 623
 624 const std::vector<std::string>& MEDFileFieldPerMeshPerTypePerDisc::getInfo() const
 625 {
 626   return _father->getInfo();
 627 }
 628
 629 std::string MEDFileFieldPerMeshPerTypePerDisc::getProfile() const
 630 {
 631   return _profile;
 632 }
 633
 634 void MEDFileFieldPerMeshPerTypePerDisc::setProfile(const std::string& newPflName)
 635 {
 636   _profile=newPflName;
 637 }
 638
 639 std::string MEDFileFieldPerMeshPerTypePerDisc::getLocalization() const
 640 {
 641   return _localization;
 642 }
 643
 644 void MEDFileFieldPerMeshPerTypePerDisc::setLocalization(const std::string& newLocName)
 645 {
 646   _localization=newLocName;
 647 }
 648
 649 void MEDFileFieldPerMeshPerTypePerDisc::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
 650 {
 651   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 652     {
 653       if(std::find((*it2).first.begin(),(*it2).first.end(),_profile)!=(*it2).first.end())
 654         {
 655           _profile=(*it2).second;
 656           return;
 657         }
 658     }
 659 }
 660
 661 void MEDFileFieldPerMeshPerTypePerDisc::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
 662 {
 663   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 664     {
 665       if(std::find((*it2).first.begin(),(*it2).first.end(),_localization)!=(*it2).first.end())
 666         {
 667           _localization=(*it2).second;
 668           return;
 669         }
 670     }
 671 }
 672
 673 void MEDFileFieldPerMeshPerTypePerDisc::getFieldAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<int,int> >& dads, std::vector<const DataArrayInt *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const
 674 {
 675   if(type!=_type)
 676     return ;
 677   dads.push_back(std::pair<int,int>(_start,_end));
 678   geoTypes.push_back(getGeoType());
 679   if(_profile.empty())
 680     pfls.push_back(0);
 681   else
 682     {
 683       pfls.push_back(glob->getProfile(_profile.c_str()));
 684     }
 685   if(_localization.empty())
 686     locs.push_back(-1);
 687   else
 688     {
 689       locs.push_back(glob->getLocalizationId(_localization.c_str()));
 690     }
 691 }
 692
 693 void MEDFileFieldPerMeshPerTypePerDisc::fillValues(int discId, int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
 694 {
 695   entries[startEntryId]=std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int> ,std::pair<int,int> >(std::pair<INTERP_KERNEL::NormalizedCellType,int>(getGeoType(),discId),std::pair<int,int>(_start,_end));
 696   startEntryId++;
 697 }
 698
 699 void MEDFileFieldPerMeshPerTypePerDisc::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
 700 {
 701   TypeOfField type=getType();
 702   INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
 703   med_geometry_type mgeoti;
 704   med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
 705   const DataArray *arr=getOrCreateAndGetArray();
 706   if(!arr)
 707     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : no array set !");
 708   const DataArrayDouble *arrD=dynamic_cast<const DataArrayDouble *>(arr);
 709   const DataArrayInt *arrI=dynamic_cast<const DataArrayInt *>(arr);
 710   const unsigned char *locToWrite=0;
 711   if(arrD)
 712     locToWrite=reinterpret_cast<const unsigned char *>(arrD->getConstPointer()+_start*arr->getNumberOfComponents());
 713   else if(arrI)
 714     locToWrite=reinterpret_cast<const unsigned char *>(arrI->getConstPointer()+_start*arr->getNumberOfComponents());
 715   else
 716     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : not recognized type of values ! Supported are FLOAT64 and INT32 !");
 717   MEDfieldValueWithProfileWr(fid,nasc.getName().c_str(),getIteration(),getOrder(),getTime(),menti,mgeoti,
 718                              MED_COMPACT_PFLMODE,_profile.c_str(),_localization.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,_nval,
 719                              locToWrite);
 720 }
 721
 722 void MEDFileFieldPerMeshPerTypePerDisc::getCoarseData(TypeOfField& type, std::pair<int,int>& dad, std::string& pfl, std::string& loc) const
 723 {
 724   type=_type;
 725   pfl=_profile;
 726   loc=_localization;
 727   dad.first=_start; dad.second=_end;
 728 }
 729
 730 /*!
 731  * \param [in] codeOfMesh is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
 732  *             This code corresponds to the distribution of types in the corresponding mesh.
 733  * \param [out] ptToFill memory zone where the output will be stored.
 734  * \return the size of data pushed into output param \a ptToFill
 735  */
 736 int MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode(int offset, const std::vector<int>& codeOfMesh, const MEDFileFieldGlobsReal& glob, int *ptToFill) const
 737 {
 738   _loc_id=offset;
 739   std::ostringstream oss;
 740   std::size_t nbOfType=codeOfMesh.size()/3;
 741   int found=-1;
 742   for(std::size_t i=0;i<nbOfType && found==-1;i++)
 743     if(getGeoType()==(INTERP_KERNEL::NormalizedCellType)codeOfMesh[3*i])
 744       found=(int)i;
 745   if(found==-1)
 746     {
 747       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 748       oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : not found geometric type " << cm.getRepr() << " in the referenced mesh of field !";
 749       throw INTERP_KERNEL::Exception(oss.str().c_str());
 750     }
 751   int *work=ptToFill;
 752   if(_profile.empty())
 753     {
 754       if(_nval!=codeOfMesh[3*found+1])
 755         {
 756           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 757           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << " number of elt ids in mesh is equal to " << _nval;
 758           oss << " whereas mesh has " << codeOfMesh[3*found+1] << " for this geometric type !";
 759           throw INTERP_KERNEL::Exception(oss.str().c_str());
 760         }
 761       for(int ii=codeOfMesh[3*found+2];ii<codeOfMesh[3*found+2]+_nval;ii++)
 762         *work++=ii;
 763     }
 764   else
 765     {
 766       const DataArrayInt *pfl=glob.getProfile(_profile.c_str());
 767       if(pfl->getNumberOfTuples()!=_nval)
 768         {
 769           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 770           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << ", field is defined on profile \"" << _profile << "\" and size of profile is ";
 771           oss << _nval;
 772           oss << pfl->getNumberOfTuples() << " whereas the number of ids is set to " << _nval << " for this geometric type !";
 773           throw INTERP_KERNEL::Exception(oss.str().c_str());
 774         }
 775       int offset2=codeOfMesh[3*found+2];
 776       for(const int *pflId=pfl->begin();pflId!=pfl->end();pflId++)
 777         {
 778           if(*pflId<codeOfMesh[3*found+1])
 779             *work++=offset2+*pflId;
 780         }
 781     }
 782   return _nval;
 783 }
 784
 785 int MEDFileFieldPerMeshPerTypePerDisc::fillTupleIds(int *ptToFill) const
 786 {
 787   for(int i=_start;i<_end;i++)
 788     *ptToFill++=i;
 789   return _end-_start;
 790 }
 791
 792 int MEDFileFieldPerMeshPerTypePerDisc::ConvertType(TypeOfField type, int locId)
 793 {
 794   switch(type)
 795     {
 796     case ON_CELLS:
 797       return -2;
 798     case ON_GAUSS_NE:
 799       return -1;
 800     case ON_GAUSS_PT:
 801       return locId;
 802     default:
 803       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::ConvertType : not managed type of field !");
 804     }
 805 }
 806
 807 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entries)
 808 {
 809   int id=0;
 810   std::map<std::pair<std::string,TypeOfField>,int> m;
 811   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > ret;
 812   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 813     if(m.find(std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType()))==m.end())
 814       m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]=id++;
 815   ret.resize(id);
 816   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 817     ret[m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]].push_back(*it);
 818   return ret;
 819 }
 820
 821 /*!
 822  * - \c this->_loc_id mutable attribute is used for elt id in mesh offsets.
 823  *
 824  * \param [in] offset the offset id used to take into account that \a result is not compulsary empty in input
 825  * \param [in] entriesOnSameDisc some entries **on same localization** if not the result can be invalid. The _start and _end on them are relative to \a arr parameter.
 826  * \param [in] explicitIdsInMesh ids in mesh of the considered chunk.
 827  * \param [in] newCode one of the input parameter to explicit the new geo type dispatch (in classical format same than those asked by MEDFileFields::renumberEntitiesLyingOnMesh)
 828  * \param [in,out] glob if necessary by the method, new profiles can be added to it
 829  * \param [in,out] arr after the call of this method \a arr is renumbered to be compliant with added entries to \a result.
 830  * \param [out] result All new entries will be appended on it.
 831  * \return false if the configuration of renumbering leads to an unnecessary resplit of input \a entriesOnSameDisc. If not true is returned (the most general case !)
 832  */
 833 bool MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(int offset, const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
 834                                                        const DataArrayInt *explicitIdsInMesh,
 835                                                        const std::vector<int>& newCode,
 836                                                        MEDFileFieldGlobsReal& glob, DataArrayDouble *arr,
 837                                                        std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >& result)
 838 {
 839   if(entriesOnSameDisc.empty())
 840     return false;
 841   TypeOfField type=entriesOnSameDisc[0]->getType();
 842   int szEntities=0,szTuples=0;
 843   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++)
 844     { szEntities+=(*it)->_nval; szTuples+=(*it)->_end-(*it)->_start; }
 845   int nbi=szTuples/szEntities;
 846   if(szTuples%szEntities!=0)
 847     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks : internal error the splitting into same dicretization failed !");
 848   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTuples=DataArrayInt::New(); renumTuples->alloc(szTuples,1);
 849   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ranges=MEDCouplingUMesh::ComputeRangesFromTypeDistribution(newCode);
 850   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk(entriesOnSameDisc.size());
 851   std::vector< const DataArrayInt * > newGeoTypesPerChunk2(entriesOnSameDisc.size());
 852   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk_bis(entriesOnSameDisc.size());
 853   std::vector< const DataArrayInt * > newGeoTypesPerChunk3(entriesOnSameDisc.size());
 854   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesPerChunk4=DataArrayInt::New(); newGeoTypesPerChunk4->alloc(szEntities,nbi);
 855   int id=0;
 856   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
 857     {
 858       int startOfEltIdOfChunk=(*it)->_start;
 859       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newEltIds=explicitIdsInMesh->substr(startOfEltIdOfChunk,startOfEltIdOfChunk+(*it)->_nval);
 860       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> rangeIdsForChunk=newEltIds->findRangeIdForEachTuple(ranges);
 861       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idsInRrangeForChunk=newEltIds->findIdInRangeForEachTuple(ranges);
 862       //
 863       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=rangeIdsForChunk->duplicateEachTupleNTimes(nbi); rangeIdsForChunk->rearrange(nbi);
 864       newGeoTypesPerChunk4->setPartOfValues1(tmp,(*it)->_tmp_work1-offset,(*it)->_tmp_work1+(*it)->_nval*nbi-offset,1,0,nbi,1);
 865       //
 866       newGeoTypesPerChunk[id]=rangeIdsForChunk; newGeoTypesPerChunk2[id]=rangeIdsForChunk;
 867       newGeoTypesPerChunk_bis[id]=idsInRrangeForChunk; newGeoTypesPerChunk3[id]=idsInRrangeForChunk;
 868     }
 869   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather=DataArrayInt::Aggregate(newGeoTypesPerChunk2); newGeoTypesPerChunk.clear(); newGeoTypesPerChunk2.clear();
 870   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather2=DataArrayInt::Aggregate(newGeoTypesPerChunk3); newGeoTypesPerChunk_bis.clear(); newGeoTypesPerChunk3.clear();
 871   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> diffVals=newGeoTypesEltIdsAllGather->getDifferentValues();
 872   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
 873   //
 874   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTupleIds=newGeoTypesPerChunk4->buildPermArrPerLevel();
 875   //
 876   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arrPart=arr->substr(offset,offset+szTuples);
 877   arrPart->renumberInPlace(renumTupleIds->begin());
 878   arr->setPartOfValues1(arrPart,offset,offset+szTuples,1,0,arrPart->getNumberOfComponents(),1);
 879   bool ret=false;
 880   const int *idIt=diffVals->begin();
 881   std::list<const MEDFileFieldPerMeshPerTypePerDisc *> li(entriesOnSameDisc.begin(),entriesOnSameDisc.end());
 882   int offset2=0;
 883   for(int i=0;i<diffVals->getNumberOfTuples();i++,idIt++)
 884     {
 885       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=newGeoTypesEltIdsAllGather->getIdsEqual(*idIt);
 886       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> subIds=newGeoTypesEltIdsAllGather2->selectByTupleId(ids->begin(),ids->end());
 887       int nbEntityElts=subIds->getNumberOfTuples();
 888       bool ret2;
 889       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
 890         NewObjectOnSameDiscThanPool(type,(INTERP_KERNEL::NormalizedCellType)newCode[3*(*idIt)],subIds,!subIds->isIdentity() || nbEntityElts!=newCode[3*(*idIt)+1],nbi,
 891                                     offset+offset2,
 892                                     li,glob,ret2);
 893       ret=ret || ret2;
 894       result.push_back(eltToAdd);
 895       offset2+=nbEntityElts*nbi;
 896     }
 897   ret=ret || li.empty();
 898   return ret;
 899 }
 900
 901 /*!
 902  * \param [in] typeF type of field of new chunk
 903  * \param [in] geoType the geometric type of the chunk
 904  * \param [in] idsOfMeshElt the entity ids of mesh (cells or nodes) of the new chunk.
 905  * \param [in] isPfl specifies if a profile is requested regarding size of \a idsOfMeshElt and the number of such entities regarding underlying mesh.
 906  * \param [in] nbi number of integration points
 907  * \param [in] offset The offset in the **global array of data**.
 908  * \param [in,out] entriesOnSameDisc the pool **on the same discretization** inside which it will be attempted to find an existing entry corresponding exactly
 909  *                 to the new chunk to create.
 910  * \param [in,out] glob the global shared info that will be requested for existing profiles or to append a new profile if needed.
 911  * \param [out] notInExisting If false the return newly allocated entry is not coming from \a entriesOnSameDisc. If true the output comes from copy of \a entriesOnSameDisc
 912  *              and corresponding entry erased from \a entriesOnSameDisc.
 913  * \return a newly allocated chunk
 914  */
 915 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewObjectOnSameDiscThanPool(TypeOfField typeF, INTERP_KERNEL::NormalizedCellType geoType, DataArrayInt *idsOfMeshElt,
 916                                                                                                   bool isPfl, int nbi, int offset,
 917                                                                                                   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
 918                                                                                                   MEDFileFieldGlobsReal& glob,
 919                                                                                                   bool &notInExisting) throw(INTERP_KERNEL::Exception)
 920 {
 921   int nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
 922   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>::iterator it=entriesOnSameDisc.begin();
 923   for(;it!=entriesOnSameDisc.end();it++)
 924     {
 925       if(((INTERP_KERNEL::NormalizedCellType)(*it)->_loc_id)==geoType && (*it)->_nval==nbMeshEntities)
 926         {
 927           if(!isPfl)
 928             {
 929               if((*it)->_profile.empty())
 930                 break;
 931               else
 932                 if(!(*it)->_profile.empty())
 933                   {
 934                     const DataArrayInt *pfl=glob.getProfile((*it)->_profile.c_str());
 935                     if(pfl->isEqualWithoutConsideringStr(*idsOfMeshElt))
 936                       break;
 937                   }
 938             }
 939         }
 940     }
 941   if(it==entriesOnSameDisc.end())
 942     {
 943       notInExisting=true;
 944       MEDFileFieldPerMeshPerTypePerDisc *ret=new MEDFileFieldPerMeshPerTypePerDisc;
 945       ret->_type=typeF;
 946       ret->_loc_id=(int)geoType;
 947       ret->_nval=nbMeshEntities;
 948       ret->_start=offset;
 949       ret->_end=ret->_start+ret->_nval*nbi;
 950       if(isPfl)
 951         {
 952           idsOfMeshElt->setName(glob.createNewNameOfPfl().c_str());
 953           glob.appendProfile(idsOfMeshElt);
 954           ret->_profile=idsOfMeshElt->getName();
 955         }
 956       //tony treatment of localization
 957       return ret;
 958     }
 959   else
 960     {
 961       notInExisting=false;
 962       MEDFileFieldPerMeshPerTypePerDisc *ret=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
 963       ret->_loc_id=(int)geoType;
 964       ret->setNewStart(offset);
 965       entriesOnSameDisc.erase(it);
 966       return ret;
 967     }
 968
 969 }
 970
 971 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc)
 972 {
 973   return new MEDFileFieldPerMeshPerType(fid,fath,type,geoType,nasc);
 974 }
 975
 976 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::New(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType)
 977 {
 978   return new MEDFileFieldPerMeshPerType(fath,geoType);
 979 }
 980
 981 std::size_t MEDFileFieldPerMeshPerType::getHeapMemorySizeWithoutChildren() const
 982 {
 983   return _field_pm_pt_pd.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc>);
 984 }
 985
 986 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerType::getDirectChildren() const
 987 {
 988   std::vector<const BigMemoryObject *> ret;
 989   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
 990     {
 991       const MEDFileFieldPerMeshPerTypePerDisc *cur(*it);
 992       if(cur)
 993         ret.push_back(cur);
 994     }
 995   return ret;
 996 }
 997
 998 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::deepCpy(MEDFileFieldPerMesh *father) const
 999 {
1000   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> ret=new MEDFileFieldPerMeshPerType(*this);
1001   ret->_father=father;
1002   std::size_t i=0;
1003   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1004     {
1005       if((const MEDFileFieldPerMeshPerTypePerDisc *)*it)
1006         ret->_field_pm_pt_pd[i]=(*it)->deepCpy((MEDFileFieldPerMeshPerType *)ret);
1007     }
1008   return ret.retn();
1009 }
1010
1011 void MEDFileFieldPerMeshPerType::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1012 {
1013   std::vector<int> pos=addNewEntryIfNecessary(field,offset,nbOfCells);
1014   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1015     _field_pm_pt_pd[*it]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1016 }
1017
1018 /*!
1019  * This method is the most general one. No optimization is done here.
1020  * \param [in] multiTypePfl is the end user profile specified in high level API
1021  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
1022  * \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
1023  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
1024  * \param [in] nbOfEltsInWholeMesh nb of elts of type \a this->_geo_type in \b WHOLE mesh
1025  * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
1026  */
1027 void MEDFileFieldPerMeshPerType::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1028 {
1029   std::vector<int> pos=addNewEntryIfNecessary(field,idsInPfl);
1030   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1031     _field_pm_pt_pd[*it]->assignFieldProfile(start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,arr,mesh,glob,nasc);
1032 }
1033
1034 void MEDFileFieldPerMeshPerType::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
1035 {
1036   _field_pm_pt_pd.resize(1);
1037   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1038   _field_pm_pt_pd[0]->assignNodeFieldNoProfile(start,field,arr,glob);
1039 }
1040
1041 void MEDFileFieldPerMeshPerType::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1042 {
1043   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2=pfl->deepCpy();
1044   if(!arr || !arr->isAllocated())
1045     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::assignNodeFieldProfile : input array is null, or not allocated !");
1046   _field_pm_pt_pd.resize(1);
1047   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1048   _field_pm_pt_pd[0]->assignFieldProfile(start,pfl,pfl2,pfl2,-1,field,arr,0,glob,nasc);//mesh is not requested so 0 is send.
1049 }
1050
1051 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1052 {
1053   TypeOfField type=field->getTypeOfField();
1054   if(type!=ON_GAUSS_PT)
1055     {
1056       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1057       int sz=_field_pm_pt_pd.size();
1058       bool found=false;
1059       for(int j=0;j<sz && !found;j++)
1060         {
1061           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1062             {
1063               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1064               found=true;
1065             }
1066         }
1067       if(!found)
1068         {
1069           _field_pm_pt_pd.resize(sz+1);
1070           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1071         }
1072       std::vector<int> ret(1,(int)sz);
1073       return ret;
1074     }
1075   else
1076     {
1077       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
1078       int sz2=ret2.size();
1079       std::vector<int> ret3(sz2);
1080       int k=0;
1081       for(int i=0;i<sz2;i++)
1082         {
1083           int sz=_field_pm_pt_pd.size();
1084           int locIdToFind=ret2[i];
1085           bool found=false;
1086           for(int j=0;j<sz && !found;j++)
1087             {
1088               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1089                 {
1090                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1091                   ret3[k++]=j;
1092                   found=true;
1093                 }
1094             }
1095           if(!found)
1096             {
1097               _field_pm_pt_pd.resize(sz+1);
1098               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1099               ret3[k++]=sz;
1100             }
1101         }
1102       return ret3;
1103     }
1104 }
1105
1106 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1107 {
1108   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1109   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1110   if(!disc2)
1111     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1112   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1113   if(!da)
1114     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss (no profile) : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1115   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleId2(offset,offset+nbOfCells,1);
1116   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1117   if(retTmp->presenceOfValue(-1))
1118     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1119   std::vector<int> ret(retTmp->begin(),retTmp->end());
1120   return ret;
1121 }
1122
1123 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1124 {
1125   TypeOfField type=field->getTypeOfField();
1126   if(type!=ON_GAUSS_PT)
1127     {
1128       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1129       int sz=_field_pm_pt_pd.size();
1130       bool found=false;
1131       for(int j=0;j<sz && !found;j++)
1132         {
1133           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1134             {
1135               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1136               found=true;
1137             }
1138         }
1139       if(!found)
1140         {
1141           _field_pm_pt_pd.resize(sz+1);
1142           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1143         }
1144       std::vector<int> ret(1,0);
1145       return ret;
1146     }
1147   else
1148     {
1149       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,subCells);
1150       int sz2=ret2.size();
1151       std::vector<int> ret3(sz2);
1152       int k=0;
1153       for(int i=0;i<sz2;i++)
1154         {
1155           int sz=_field_pm_pt_pd.size();
1156           int locIdToFind=ret2[i];
1157           bool found=false;
1158           for(int j=0;j<sz && !found;j++)
1159             {
1160               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1161                 {
1162                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1163                   ret3[k++]=j;
1164                   found=true;
1165                 }
1166             }
1167           if(!found)
1168             {
1169               _field_pm_pt_pd.resize(sz+1);
1170               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1171               ret3[k++]=sz;
1172             }
1173         }
1174       return ret3;
1175     }
1176 }
1177
1178 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1179 {
1180   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1181   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1182   if(!disc2)
1183     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1184   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1185   if(!da)
1186     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1187   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleIdSafe(subCells->getConstPointer(),subCells->getConstPointer()+subCells->getNumberOfTuples());
1188   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1189   if(retTmp->presenceOfValue(-1))
1190     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1191   std::vector<int> ret(retTmp->begin(),retTmp->end());
1192   return ret;
1193 }
1194
1195 const MEDFileFieldPerMesh *MEDFileFieldPerMeshPerType::getFather() const
1196 {
1197   return _father;
1198 }
1199
1200 void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
1201 {
1202   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1203   int curDim=(int)cm.getDimension();
1204   dim=std::max(dim,curDim);
1205 }
1206
1207 void MEDFileFieldPerMeshPerType::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
1208 {
1209   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1210     {
1211       (*it)->fillTypesOfFieldAvailable(types);
1212     }
1213 }
1214
1215 void MEDFileFieldPerMeshPerType::fillFieldSplitedByType(std::vector< std::pair<int,int> >& dads, std::vector<TypeOfField>& types, std::vector<std::string>& pfls, std::vector<std::string>& locs) const
1216 {
1217   int sz=_field_pm_pt_pd.size();
1218   dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
1219   for(int i=0;i<sz;i++)
1220     {
1221       _field_pm_pt_pd[i]->getCoarseData(types[i],dads[i],pfls[i],locs[i]);
1222     }
1223 }
1224
1225 int MEDFileFieldPerMeshPerType::getIteration() const
1226 {
1227   return _father->getIteration();
1228 }
1229
1230 int MEDFileFieldPerMeshPerType::getOrder() const
1231 {
1232   return _father->getOrder();
1233 }
1234
1235 double MEDFileFieldPerMeshPerType::getTime() const
1236 {
1237   return _father->getTime();
1238 }
1239
1240 std::string MEDFileFieldPerMeshPerType::getMeshName() const
1241 {
1242   return _father->getMeshName();
1243 }
1244
1245 void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1246 {
1247   const char startLine[]="  ## ";
1248   std::string startLine2(bkOffset,' ');
1249   std::string startLine3(startLine2);
1250   startLine3+=startLine;
1251   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1252     {
1253       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1254       oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry types " << cm.getRepr() << "." << std::endl;
1255     }
1256   else
1257     oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
1258   oss << startLine3 << "Entry is defined on " <<  _field_pm_pt_pd.size() << " localizations." << std::endl;
1259   int i=0;
1260   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1261     {
1262       const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
1263       if(cur)
1264         cur->simpleRepr(bkOffset,oss,i);
1265       else
1266         {
1267           oss << startLine2 << "    ## " << "Localization #" << i << " is empty !" << std::endl;
1268         }
1269     }
1270 }
1271
1272 void MEDFileFieldPerMeshPerType::getSizes(int& globalSz, int& nbOfEntries) const
1273 {
1274   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1275     {
1276       globalSz+=(*it)->getNumberOfTuples();
1277     }
1278   nbOfEntries+=(int)_field_pm_pt_pd.size();
1279 }
1280
1281 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
1282 {
1283   return _geo_type;
1284 }
1285
1286
1287 int MEDFileFieldPerMeshPerType::getNumberOfComponents() const
1288 {
1289   return _father->getNumberOfComponents();
1290 }
1291
1292 DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray()
1293 {
1294   return _father->getOrCreateAndGetArray();
1295 }
1296
1297 const DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray() const
1298 {
1299   const MEDFileFieldPerMesh *fath=_father;
1300   return fath->getOrCreateAndGetArray();
1301 }
1302
1303 const std::vector<std::string>& MEDFileFieldPerMeshPerType::getInfo() const
1304 {
1305   return _father->getInfo();
1306 }
1307
1308 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsed() const
1309 {
1310   std::vector<std::string> ret;
1311   std::set<std::string> ret2;
1312   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1313     {
1314       std::string tmp=(*it1)->getProfile();
1315       if(!tmp.empty())
1316         if(ret2.find(tmp)==ret2.end())
1317           {
1318             ret.push_back(tmp);
1319             ret2.insert(tmp);
1320           }
1321     }
1322   return ret;
1323 }
1324
1325 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsed() const
1326 {
1327   std::vector<std::string> ret;
1328   std::set<std::string> ret2;
1329   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1330     {
1331       std::string tmp=(*it1)->getLocalization();
1332       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1333         if(ret2.find(tmp)==ret2.end())
1334           {
1335             ret.push_back(tmp);
1336             ret2.insert(tmp);
1337           }
1338     }
1339   return ret;
1340 }
1341
1342 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsedMulti() const
1343 {
1344   std::vector<std::string> ret;
1345   std::set<std::string> ret2;
1346   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1347     {
1348       std::string tmp=(*it1)->getProfile();
1349       if(!tmp.empty())
1350         ret.push_back(tmp);
1351     }
1352   return ret;
1353 }
1354
1355 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsedMulti() const
1356 {
1357   std::vector<std::string> ret;
1358   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1359     {
1360       std::string tmp=(*it1)->getLocalization();
1361       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1362         ret.push_back(tmp);
1363     }
1364   return ret;
1365 }
1366
1367 void MEDFileFieldPerMeshPerType::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1368 {
1369   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1370     (*it1)->changePflsRefsNamesGen(mapOfModif);
1371 }
1372
1373 void MEDFileFieldPerMeshPerType::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1374 {
1375   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1376     (*it1)->changeLocsRefsNamesGen(mapOfModif);
1377 }
1378
1379 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId)
1380 {
1381   if(_field_pm_pt_pd.empty())
1382     {
1383       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1384       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1385       throw INTERP_KERNEL::Exception(oss.str().c_str());
1386     }
1387   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1388     return _field_pm_pt_pd[locId];
1389   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1390   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1391   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1392   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1393   return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
1394 }
1395
1396 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) const
1397 {
1398   if(_field_pm_pt_pd.empty())
1399     {
1400       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1401       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1402       throw INTERP_KERNEL::Exception(oss.str().c_str());
1403     }
1404   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1405     return _field_pm_pt_pd[locId];
1406   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1407   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1408   oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1409   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1410   return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
1411 }
1412
1413 void MEDFileFieldPerMeshPerType::getFieldAtLevel(int meshDim, TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<int,int> >& dads, std::vector<const DataArrayInt *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const
1414 {
1415   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1416     {
1417       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1418       if(meshDim!=(int)cm.getDimension())
1419         return ;
1420     }
1421   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1422     (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
1423 }
1424
1425 void MEDFileFieldPerMeshPerType::fillValues(int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
1426 {
1427   int i=0;
1428   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1429     {
1430       (*it)->fillValues(i,startEntryId,entries);
1431     }
1432 }
1433
1434 void MEDFileFieldPerMeshPerType::setLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
1435 {
1436   _field_pm_pt_pd=leaves;
1437   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1438     (*it)->setFather(this);
1439 }
1440
1441 /*!
1442  *  \param [in,out] globalNum a global numbering counter for the renumbering.
1443  *  \param [out] its - list of pair (start,stop) kept
1444  *  \return bool - false if the type of field \a tof is not contained in \a this.
1445  */
1446 bool MEDFileFieldPerMeshPerType::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
1447 {
1448   bool ret=false;
1449   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd;
1450   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1451     if((*it)->getType()==tof)
1452       {
1453         newPmPtPd.push_back(*it);
1454         std::pair<int,int> bgEnd; bgEnd.first=(*it)->getStart(); bgEnd.second=(*it)->getEnd();
1455         (*it)->setNewStart(globalNum);
1456         globalNum=(*it)->getEnd();
1457         its.push_back(bgEnd);
1458         ret=true;
1459       }
1460   if(ret)
1461     _field_pm_pt_pd=newPmPtPd;
1462   return ret;
1463 }
1464
1465 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType):_father(fath),_geo_type(geoType)
1466 {
1467 }
1468
1469 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc):_father(fath),_geo_type(geoType)
1470 {
1471   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1472   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1473   med_geometry_type mgeoti;
1474   med_entity_type menti;
1475   menti=ConvertIntoMEDFileType(type,geoType,mgeoti);
1476   int nbProfiles=MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),menti,mgeoti,pflName,locName);
1477   _field_pm_pt_pd.resize(nbProfiles);
1478   for(int i=0;i<nbProfiles;i++)
1479     {
1480       _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,type,i+1);
1481     }
1482   if(type==ON_CELLS)
1483     {
1484       int nbProfiles2=MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,mgeoti,pflName,locName);
1485       for(int i=0;i<nbProfiles2;i++)
1486         _field_pm_pt_pd.push_back(MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,ON_GAUSS_NE,i+1));
1487     }
1488 }
1489
1490 void MEDFileFieldPerMeshPerType::loadOnlyStructureOfDataRecursively(med_idt fid, int &start, const MEDFileFieldNameScope& nasc)
1491 {
1492   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1493     (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1494 }
1495
1496 void MEDFileFieldPerMeshPerType::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
1497 {
1498   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1499     (*it)->loadBigArray(fid,nasc);
1500 }
1501
1502 void MEDFileFieldPerMeshPerType::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
1503 {
1504   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1505     {
1506       (*it)->copyOptionsFrom(*this);
1507       (*it)->writeLL(fid,nasc);
1508     }
1509 }
1510
1511 med_entity_type MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(TypeOfField ikType, INTERP_KERNEL::NormalizedCellType ikGeoType, med_geometry_type& medfGeoType)
1512 {
1513   switch(ikType)
1514     {
1515     case ON_CELLS:
1516       medfGeoType=typmai3[(int)ikGeoType];
1517       return MED_CELL;
1518     case ON_NODES:
1519       medfGeoType=MED_NONE;
1520       return MED_NODE;
1521     case ON_GAUSS_NE:
1522       medfGeoType=typmai3[(int)ikGeoType];
1523       return MED_NODE_ELEMENT;
1524     case ON_GAUSS_PT:
1525       medfGeoType=typmai3[(int)ikGeoType];
1526       return MED_CELL;
1527     default:
1528       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType : unexpected entity type ! internal error");
1529     }
1530   return MED_UNDEF_ENTITY_TYPE;
1531 }
1532
1533 MEDFileFieldPerMesh *MEDFileFieldPerMesh::NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc)
1534 {
1535   return new MEDFileFieldPerMesh(fid,fath,meshCsit,meshIteration,meshOrder,nasc);
1536 }
1537
1538 MEDFileFieldPerMesh *MEDFileFieldPerMesh::New(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh)
1539 {
1540   return new MEDFileFieldPerMesh(fath,mesh);
1541 }
1542
1543 std::size_t MEDFileFieldPerMesh::getHeapMemorySizeWithoutChildren() const
1544 {
1545   return _mesh_name.capacity()+_field_pm_pt.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType >);
1546 }
1547
1548 std::vector<const BigMemoryObject *> MEDFileFieldPerMesh::getDirectChildren() const
1549 {
1550   std::vector<const BigMemoryObject *> ret;
1551   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1552     {
1553       const MEDFileFieldPerMeshPerType *cur(*it);
1554       if(cur)
1555         ret.push_back(cur);
1556     }
1557   return ret;
1558 }
1559
1560 MEDFileFieldPerMesh *MEDFileFieldPerMesh::deepCpy(MEDFileAnyTypeField1TSWithoutSDA *father) const
1561 {
1562   MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
1563   ret->_father=father;
1564   std::size_t i=0;
1565   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1566     {
1567       if((const MEDFileFieldPerMeshPerType *)*it)
1568         ret->_field_pm_pt[i]=(*it)->deepCpy((MEDFileFieldPerMesh *)(ret));
1569     }
1570   return ret.retn();
1571 }
1572
1573 void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1574 {
1575   std::string startLine(bkOffset,' ');
1576   oss << startLine << "## Field part (" << id << ") lying on mesh \"" << _mesh_name << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
1577   oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
1578   int i=0;
1579   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1580     {
1581       const MEDFileFieldPerMeshPerType *cur=*it;
1582       if(cur)
1583         cur->simpleRepr(bkOffset,oss,i);
1584       else
1585         {
1586           oss << startLine << "  ## Entry geometry type #" << i << " is empty !" << std::endl;
1587         }
1588     }
1589 }
1590
1591 void MEDFileFieldPerMesh::copyTinyInfoFrom(const MEDCouplingMesh *mesh)
1592 {
1593   _mesh_name=mesh->getName();
1594   mesh->getTime(_mesh_iteration,_mesh_order);
1595 }
1596
1597 void MEDFileFieldPerMesh::assignFieldNoProfileNoRenum(int& start, const std::vector<int>& code, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1598 {
1599   int nbOfTypes=code.size()/3;
1600   int offset=0;
1601   for(int i=0;i<nbOfTypes;i++)
1602     {
1603       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1604       int nbOfCells=code[3*i+1];
1605       int pos=addNewEntryIfNecessary(type);
1606       _field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1607       offset+=nbOfCells;
1608     }
1609 }
1610
1611 /*!
1612  * This method is the most general one. No optimization is done here.
1613  * \param [in] multiTypePfl is the end user profile specified in high level API
1614  * \param [in] code is the code of \a mesh[multiTypePfl] mesh. It is of size of number of different geometric types into \a mesh[multiTypePfl].
1615  * \param [in] code2 is the code of the \b WHOLE mesh on the same level. So all types in \a code are in \a code2.
1616  * \param [in] idsInPflPerType is the selection into the \a multiTypePfl whole profile that corresponds to the given geometric type. This vector is always 3 times smaller than \a code.
1617  * \param [in] idsPerType is a vector containing the profiles needed to be created for MED file format. \b WARNING these processed MED file profiles can be subdivided again in case of Gauss points.
1618  * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
1619  */
1620 void MEDFileFieldPerMesh::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const std::vector<int>& code, const std::vector<int>& code2, const std::vector<DataArrayInt *>& idsInPflPerType, const std::vector<DataArrayInt *>& idsPerType, const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1621 {
1622   int nbOfTypes=code.size()/3;
1623   for(int i=0;i<nbOfTypes;i++)
1624     {
1625       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1626       int pos=addNewEntryIfNecessary(type);
1627       DataArrayInt *pfl=0;
1628       if(code[3*i+2]!=-1)
1629         pfl=idsPerType[code[3*i+2]];
1630       int nbOfTupes2=code2.size()/3;
1631       int found=0;
1632       for(;found<nbOfTupes2;found++)
1633         if(code[3*i]==code2[3*found])
1634           break;
1635       if(found==nbOfTupes2)
1636         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::assignFieldProfile : internal problem ! Should never happen ! Please report bug to anthony.geay@cea.fr !");
1637       _field_pm_pt[pos]->assignFieldProfile(start,multiTypePfl,idsInPflPerType[i],pfl,code2[3*found+1],field,arr,mesh,glob,nasc);
1638     }
1639 }
1640
1641 void MEDFileFieldPerMesh::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
1642 {
1643   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1644   _field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
1645 }
1646
1647 void MEDFileFieldPerMesh::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1648 {
1649   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1650   _field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,arr,glob,nasc);
1651 }
1652
1653 void MEDFileFieldPerMesh::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
1654 {
1655   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1656     (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1657 }
1658
1659 void MEDFileFieldPerMesh::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
1660 {
1661   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1662     (*it)->loadBigArraysRecursively(fid,nasc);
1663 }
1664
1665 void MEDFileFieldPerMesh::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
1666 {
1667   int nbOfTypes=_field_pm_pt.size();
1668   for(int i=0;i<nbOfTypes;i++)
1669     {
1670       _field_pm_pt[i]->copyOptionsFrom(*this);
1671       _field_pm_pt[i]->writeLL(fid,nasc);
1672     }
1673 }
1674
1675 void MEDFileFieldPerMesh::getDimension(int& dim) const
1676 {
1677   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1678     (*it)->getDimension(dim);
1679 }
1680
1681 void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
1682 {
1683   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1684     (*it)->fillTypesOfFieldAvailable(types);
1685 }
1686
1687 std::vector< std::vector< std::pair<int,int> > > MEDFileFieldPerMesh::getFieldSplitedByType(std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> > & locs) const
1688 {
1689   int sz=_field_pm_pt.size();
1690   std::vector< std::vector<std::pair<int,int> > > ret(sz);
1691   types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
1692   for(int i=0;i<sz;i++)
1693     {
1694       types[i]=_field_pm_pt[i]->getGeoType();
1695       _field_pm_pt[i]->fillFieldSplitedByType(ret[i],typesF[i],pfls[i],locs[i]);
1696     }
1697   return ret;
1698 }
1699
1700 double MEDFileFieldPerMesh::getTime() const
1701 {
1702   int tmp1,tmp2;
1703   return _father->getTime(tmp1,tmp2);
1704 }
1705
1706 int MEDFileFieldPerMesh::getIteration() const
1707 {
1708   return _father->getIteration();
1709 }
1710
1711 int MEDFileFieldPerMesh::getOrder() const
1712 {
1713   return _father->getOrder();
1714 }
1715
1716 int MEDFileFieldPerMesh::getNumberOfComponents() const
1717 {
1718   return _father->getNumberOfComponents();
1719 }
1720
1721 DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray()
1722 {
1723   if(!_father)
1724     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1725   return _father->getOrCreateAndGetArray();
1726 }
1727
1728 const DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray() const
1729 {
1730   if(!_father)
1731     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1732   return _father->getOrCreateAndGetArray();
1733 }
1734
1735 const std::vector<std::string>& MEDFileFieldPerMesh::getInfo() const
1736 {
1737   return _father->getInfo();
1738 }
1739
1740 /*!
1741  * type,geoTypes,dads,pfls,locs are input parameters. They should have the same size.
1742  * Before the call of this method 'geoTypes','dads','pfls','locs' must be reorganized so that types in geoTypes are contiguous and ordered following typmai2 array.
1743  * It returns 2 output vectors :
1744  * - 'code' of size 3*sz where sz is the number of different values into 'geoTypes'
1745  * - 'notNullPfls' contains sz2 values that are extracted from 'pfls' in which null profiles have been removed.
1746  * 'code' and 'notNullPfls' are in MEDCouplingUMesh::checkTypeConsistencyAndContig format.
1747  */
1748 void MEDFileFieldPerMesh::SortArraysPerType(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<int,int> >& dads, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& locs, std::vector<int>& code, std::vector<DataArrayInt *>& notNullPfls)
1749 {
1750   int notNullPflsSz=0;
1751   int nbOfArrs=geoTypes.size();
1752   for(int i=0;i<nbOfArrs;i++)
1753     if(pfls[i])
1754       notNullPflsSz++;
1755   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
1756   int nbOfDiffGeoTypes=geoTypes3.size();
1757   code.resize(3*nbOfDiffGeoTypes);
1758   notNullPfls.resize(notNullPflsSz);
1759   notNullPflsSz=0;
1760   int j=0;
1761   for(int i=0;i<nbOfDiffGeoTypes;i++)
1762     {
1763       int startZone=j;
1764       INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
1765       std::vector<const DataArrayInt *> notNullTmp;
1766       if(pfls[j])
1767         notNullTmp.push_back(pfls[j]);
1768       j++;
1769       for(;j<nbOfArrs;j++)
1770         if(geoTypes[j]==refType)
1771           {
1772             if(pfls[j])
1773               notNullTmp.push_back(pfls[j]);
1774           }
1775         else
1776           break;
1777       std::vector< std::pair<int,int> > tmpDads(dads.begin()+startZone,dads.begin()+j);
1778       std::vector<const DataArrayInt *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
1779       std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
1780       code[3*i]=(int)refType;
1781       std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
1782       code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
1783       if(notNullTmp.empty())
1784         code[3*i+2]=-1;
1785       else
1786         {
1787           notNullPfls[notNullPflsSz]=DataArrayInt::Aggregate(notNullTmp);
1788           code[3*i+2]=notNullPflsSz++;
1789         }
1790     }
1791 }
1792
1793 /*!
1794  * 'dads' 'geoTypes' and 'locs' are input parameters that should have same size sz. sz should be >=1.
1795  */
1796 int MEDFileFieldPerMesh::ComputeNbOfElems(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs)
1797 {
1798   int sz=dads.size();
1799   int ret=0;
1800   for(int i=0;i<sz;i++)
1801     {
1802       if(locs[i]==-1)
1803         {
1804           if(type!=ON_GAUSS_NE)
1805             ret+=dads[i].second-dads[i].first;
1806           else
1807             {
1808               const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(geoTypes[i]);
1809               ret+=(dads[i].second-dads[i].first)/cm.getNumberOfNodes();
1810             }
1811         }
1812       else
1813         {
1814           int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
1815           ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
1816         }
1817     }
1818   return ret;
1819 }
1820
1821 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsed() const
1822 {
1823   std::vector<std::string> ret;
1824   std::set<std::string> ret2;
1825   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1826     {
1827       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
1828       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1829         if(ret2.find(*it2)==ret2.end())
1830           {
1831             ret.push_back(*it2);
1832             ret2.insert(*it2);
1833           }
1834     }
1835   return ret;
1836 }
1837
1838 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
1839 {
1840   std::vector<std::string> ret;
1841   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1842     {
1843       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
1844       ret.insert(ret.end(),tmp.begin(),tmp.end());
1845     }
1846   return ret;
1847 }
1848
1849 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsed() const
1850 {
1851   std::vector<std::string> ret;
1852   std::set<std::string> ret2;
1853   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1854     {
1855       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
1856       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1857         if(ret2.find(*it2)==ret2.end())
1858           {
1859             ret.push_back(*it2);
1860             ret2.insert(*it2);
1861           }
1862     }
1863   return ret;
1864 }
1865
1866 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
1867 {
1868   std::vector<std::string> ret;
1869   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1870     {
1871       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
1872       ret.insert(ret.end(),tmp.begin(),tmp.end());
1873     }
1874   return ret;
1875 }
1876
1877 bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
1878 {
1879   for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
1880     {
1881       if((*it).first==_mesh_name)
1882         {
1883           _mesh_name=(*it).second;
1884           return true;
1885         }
1886     }
1887   return false;
1888 }
1889
1890 bool MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
1891                                                       MEDFileFieldGlobsReal& glob)
1892 {
1893   if(_mesh_name!=meshName)
1894     return false;
1895   std::set<INTERP_KERNEL::NormalizedCellType> typesToKeep;
1896   for(std::size_t i=0;i<oldCode.size()/3;i++) typesToKeep.insert((INTERP_KERNEL::NormalizedCellType)oldCode[3*i]);
1897   std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > > entries;
1898   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKept;
1899   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> otherEntries;
1900   getUndergroundDataArrayExt(entries);
1901   DataArray *arr0=getOrCreateAndGetArray();//tony
1902   if(!arr0)
1903     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values of field is null !");
1904   DataArrayDouble *arr=dynamic_cast<DataArrayDouble *>(arr0);//tony
1905   if(!arr0)
1906     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values is double ! Not managed for the moment !");
1907   int sz=0;
1908   if(!arr)
1909     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
1910   for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >::const_iterator it=entries.begin();it!=entries.end();it++)
1911     {
1912       if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
1913         {
1914           entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1915           sz+=(*it).second.second-(*it).second.first;
1916         }
1917       else
1918         otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1919     }
1920   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumDefrag=DataArrayInt::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
1921   ////////////////////
1922   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInMesh=DataArrayInt::New(); explicitIdsOldInMesh->alloc(sz,1);//sz is a majorant of the real size. A realloc will be done after
1923   int *workI2=explicitIdsOldInMesh->getPointer();
1924   int sz1=0,sz2=0,sid=1;
1925   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptML=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKept);
1926   // std::vector<int> tupleIdOfStartOfNewChuncksV(entriesKeptML.size());
1927   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator itL1=entriesKeptML.begin();itL1!=entriesKeptML.end();itL1++,sid++)
1928     {
1929       //  tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
1930       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInArr=DataArrayInt::New(); explicitIdsOldInArr->alloc(sz,1);
1931       int *workI=explicitIdsOldInArr->getPointer();
1932       for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
1933         {
1934           int delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
1935           (*itL2)->setLocId(sz2);
1936           (*itL2)->_tmp_work1=(*itL2)->getStart();
1937           int delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
1938         }
1939       renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
1940     }
1941   explicitIdsOldInMesh->reAlloc(sz2);
1942   int tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
1943   ////////////////////
1944   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
1945   // perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
1946   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
1947   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
1948     {
1949       otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
1950       otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
1951       otherEntriesNew.back()->setLocId((*it)->getGeoType());
1952     }
1953   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
1954   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
1955   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
1956     {
1957       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
1958       int newStart=elt->getLocId();
1959       elt->setLocId((*it)->getGeoType());
1960       elt->setNewStart(newStart);
1961       elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
1962       entriesKeptNew.push_back(elt);
1963       entriesKeptNew2.push_back(elt);
1964     }
1965   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
1966   // perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
1967   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
1968   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
1969   bool ret=false;
1970   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
1971     {
1972       sid=0;
1973       /*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
1974         {
1975           MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
1976           curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
1977           }*/
1978       ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
1979                                                             glob,arr2,otherEntriesNew) || ret;
1980     }
1981   if(!ret)
1982     return false;
1983   // Assign new dispatching
1984   assignNewLeaves(otherEntriesNew);
1985   arr->cpyFrom(*arr2);
1986   return true;
1987 }
1988
1989 /*!
1990  * \param [in,out] globalNum a global numbering counter for the renumbering.
1991  * \param [out] its - list of pair (start,stop) kept
1992  */
1993 void MEDFileFieldPerMesh::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
1994 {
1995   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > ret;
1996   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1997     {
1998       std::vector< std::pair<int,int> > its2;
1999       if((*it)->keepOnlySpatialDiscretization(tof,globalNum,its2))
2000         {
2001           ret.push_back(*it);
2002           its.insert(its.end(),its2.begin(),its2.end());
2003         }
2004     }
2005   _field_pm_pt=ret;
2006 }
2007
2008 void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
2009 {
2010   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > > types;
2011   for( std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
2012     types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
2013   //
2014   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > fieldPmPt(types.size());
2015   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
2016   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=fieldPmPt.begin();
2017   for(;it1!=types.end();it1++,it2++)
2018     {
2019       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
2020       elt->setLeaves((*it1).second);
2021       *it2=elt;
2022     }
2023   _field_pm_pt=fieldPmPt;
2024 }
2025
2026 void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2027 {
2028   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2029     (*it)->changePflsRefsNamesGen(mapOfModif);
2030 }
2031
2032 void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2033 {
2034   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2035     (*it)->changeLocsRefsNamesGen(mapOfModif);
2036 }
2037
2038 /*!
2039  * \param [in] mesh is the whole mesh
2040  */
2041 MEDCouplingFieldDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2042 {
2043   if(_field_pm_pt.empty())
2044     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2045   //
2046   std::vector< std::pair<int,int> > dads;
2047   std::vector<const DataArrayInt *> pfls;
2048   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2049   std::vector<int> locs,code;
2050   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2051   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2052     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2053   // Sort by types
2054   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2055   if(code.empty())
2056     {
2057       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2058       throw INTERP_KERNEL::Exception(oss.str().c_str());
2059     }
2060   //
2061   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2062   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2063   if(type!=ON_NODES)
2064     {
2065       DataArrayInt *arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2066       if(!arr)
2067         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2068       else
2069         {
2070           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr);
2071           return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl,arrOut,nasc);
2072         }
2073     }
2074   else
2075     {
2076       if(code.size()!=3)
2077         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2078       int nb=code[1];
2079       if(code[2]==-1)
2080         {
2081           if(nb!=mesh->getNumberOfNodes())
2082             {
2083               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2084               oss << " nodes in mesh !";
2085               throw INTERP_KERNEL::Exception(oss.str().c_str());
2086             }
2087           return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2088         }
2089       else
2090         return finishFieldNode2(glob,dads,locs,mesh,notNullPflsPerGeoType3[0],isPfl,arrOut,nasc);
2091     }
2092 }
2093
2094 DataArray *MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
2095 {
2096   if(_field_pm_pt.empty())
2097     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2098   //
2099   std::vector<std::pair<int,int> > dads;
2100   std::vector<const DataArrayInt *> pfls;
2101   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2102   std::vector<int> locs,code;
2103   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2104   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2105     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2106   // Sort by types
2107   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2108   if(code.empty())
2109     {
2110       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2111       throw INTERP_KERNEL::Exception(oss.str().c_str());
2112     }
2113   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2114   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2115   if(type!=ON_NODES)
2116     {
2117       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2118       return finishField4(dads,arr,mesh->getNumberOfCells(),pfl);
2119     }
2120   else
2121     {
2122       if(code.size()!=3)
2123         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2124       int nb=code[1];
2125       if(code[2]==-1)
2126         {
2127           if(nb!=mesh->getNumberOfNodes())
2128             {
2129               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2130               oss << " nodes in mesh !";
2131               throw INTERP_KERNEL::Exception(oss.str().c_str());
2132             }
2133         }
2134       return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
2135     }
2136   //
2137   return 0;
2138 }
2139
2140 void MEDFileFieldPerMesh::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
2141 {
2142   int globalSz=0;
2143   int nbOfEntries=0;
2144   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2145     {
2146       (*it)->getSizes(globalSz,nbOfEntries);
2147     }
2148   entries.resize(nbOfEntries);
2149   nbOfEntries=0;
2150   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2151     {
2152       (*it)->fillValues(nbOfEntries,entries);
2153     }
2154 }
2155
2156 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId)
2157 {
2158   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2159     {
2160       if((*it)->getGeoType()==typ)
2161         return (*it)->getLeafGivenLocId(locId);
2162     }
2163   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2164   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2165   oss << "Possiblities are : ";
2166   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2167     {
2168       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2169       oss << "\"" << cm2.getRepr() << "\", ";
2170     }
2171   throw INTERP_KERNEL::Exception(oss.str().c_str());
2172 }
2173
2174 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) const
2175 {
2176   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2177     {
2178       if((*it)->getGeoType()==typ)
2179         return (*it)->getLeafGivenLocId(locId);
2180     }
2181   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2182   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2183   oss << "Possiblities are : ";
2184   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2185     {
2186       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2187       oss << "\"" << cm2.getRepr() << "\", ";
2188     }
2189   throw INTERP_KERNEL::Exception(oss.str().c_str());
2190 }
2191
2192 int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
2193 {
2194   int i=0;
2195   int pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
2196   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=_field_pm_pt.begin();
2197   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
2198     {
2199       INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
2200       if(type==curType)
2201         return i;
2202       else
2203         {
2204           int pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
2205           if(pos>pos2)
2206             it2=it+1;
2207         }
2208     }
2209   int ret=std::distance(_field_pm_pt.begin(),it2);
2210   _field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
2211   return ret;
2212 }
2213
2214 /*!
2215  * 'dads' and 'locs' input parameters have the same number of elements
2216  * \param [in] mesh is \b NOT the global mesh, but the possibly reduced mesh. \a mesh parameter will be directly aggregated in the returned field
2217  */
2218 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2219                                                          const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs,
2220                                                          const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2221 {
2222   isPfl=false;
2223   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(type,ONE_TIME);
2224   ret->setMesh(mesh); ret->setName(nasc.getName().c_str()); ret->setTime(getTime(),getIteration(),getOrder()); ret->setTimeUnit(nasc.getDtUnit().c_str());
2225   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2226   const std::vector<std::string>& infos=getInfo();
2227   da->setInfoOnComponents(infos);
2228   da->setName("");
2229   if(type==ON_GAUSS_PT)
2230     {
2231       int offset=0;
2232       int nbOfArrs=dads.size();
2233       for(int i=0;i<nbOfArrs;i++)
2234         {
2235           std::vector<std::pair<int,int> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
2236           const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
2237           int nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
2238           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> di=DataArrayInt::New();
2239           di->alloc(nbOfElems,1);
2240           di->iota(offset);
2241           const MEDFileFieldLoc& fl=glob->getLocalizationFromId(locs[i]);
2242           ret->setGaussLocalizationOnCells(di->getConstPointer(),di->getConstPointer()+nbOfElems,fl.getRefCoords(),fl.getGaussCoords(),fl.getGaussWeights());
2243           offset+=nbOfElems;
2244         }
2245     }
2246   arrOut=da;
2247   return ret.retn();
2248 }
2249
2250 /*!
2251  * This method is an extension of MEDFileFieldPerMesh::finishField method. It deals with profiles. This method should be called when type is different from ON_NODES.
2252  * 'dads', 'locs' and 'geoTypes' input parameters have the same number of elements.
2253  * No check of this is performed. 'da' array contains an array in old2New style to be applyied to mesh to obtain the right support.
2254  * The order of cells in the returned field is those imposed by the profile.
2255  * \param [in] mesh is the global mesh.
2256  */
2257 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2258                                                           const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2259                                                           const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
2260                                                           const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2261 {
2262   if(da->isIdentity())
2263     {
2264       int nbOfTuples=da->getNumberOfTuples();
2265       if(nbOfTuples==mesh->getNumberOfCells())
2266         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2267     }
2268   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m2=mesh->buildPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2269   m2->setName(mesh->getName().c_str());
2270   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(type,glob,dads,locs,m2,isPfl,arrOut,nasc);
2271   isPfl=true;
2272   return ret.retn();
2273 }
2274
2275 /*!
2276  * This method is the complement of MEDFileFieldPerMesh::finishField2 method except that this method works for node profiles.
2277  */
2278 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishFieldNode2(const MEDFileFieldGlobsReal *glob,
2279                                                               const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2280                                                               const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2281 {
2282   if(da->isIdentity())
2283     {
2284       int nbOfTuples=da->getNumberOfTuples();
2285       if(nbOfTuples==mesh->getNumberOfNodes())//No problem for NORM_ERROR because it is in context of node
2286         return finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2287     }
2288   // Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
2289   const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
2290   if(meshu)
2291     {
2292       if(meshu->getNodalConnectivity()==0)
2293         {
2294           MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2295           int nb=da->getNbOfElems();
2296           const int *ptr=da->getConstPointer();
2297           MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
2298           meshuc->allocateCells(nb);
2299           for(int i=0;i<nb;i++)
2300             meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
2301           meshuc->finishInsertingCells();
2302           ret->setMesh(meshuc);
2303           const MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
2304           if(!disc) throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::finishFieldNode2 : internal error, no discretization on field !");
2305           disc->checkCoherencyBetween(meshuc,arrOut);
2306           return ret.retn();
2307         }
2308     }
2309   //
2310   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2311   isPfl=true;
2312   DataArrayInt *arr2=0;
2313   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2314   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
2315   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3(arr2);
2316   int nnodes=mesh2->getNumberOfNodes();
2317   if(nnodes==(int)da->getNbOfElems())
2318     {
2319       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
2320       arrOut->renumberInPlace(da3->getConstPointer());
2321       mesh2->setName(mesh->getName().c_str());
2322       ret->setMesh(mesh2);
2323       return ret.retn();
2324     }
2325   else
2326     {
2327       std::ostringstream oss; oss << "MEDFileFieldPerMesh::finishFieldNode2 : The field on nodes lies on a node profile so that it is impossible to find a submesh having exactly the same nodes of that profile !!!";
2328       oss << "So it is impossible to return a well definied MEDCouplingFieldDouble instance on specified mesh on a specified meshDim !" << std::endl;
2329       oss << "To retrieve correctly such a field you have 3 possibilities :" << std::endl;
2330       oss << " - use an another meshDim compatible with the field on nodes (MED file does not have such information)" << std::endl;
2331       oss << " - use an another a meshDimRelToMax equal to 1 -> it will return a mesh with artificial cell POINT1 containing the profile !" << std::endl;
2332       oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
2333       throw INTERP_KERNEL::Exception(oss.str().c_str());
2334     }
2335   return 0;
2336 }
2337
2338 /*!
2339  * This method is the most light method of field retrieving.
2340  */
2341 DataArray *MEDFileFieldPerMesh::finishField4(const std::vector<std::pair<int,int> >& dads, const DataArrayInt *pflIn, int nbOfElems, DataArrayInt *&pflOut) const
2342 {
2343   if(!pflIn)
2344     {
2345       pflOut=DataArrayInt::New();
2346       pflOut->alloc(nbOfElems,1);
2347       pflOut->iota(0);
2348     }
2349   else
2350     {
2351       pflOut=const_cast<DataArrayInt*>(pflIn);
2352       pflOut->incrRef();
2353     }
2354   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> safePfl(pflOut);
2355   MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2356   const std::vector<std::string>& infos=getInfo();
2357   int nbOfComp=infos.size();
2358   for(int i=0;i<nbOfComp;i++)
2359     da->setInfoOnComponent(i,infos[i].c_str());
2360   safePfl->incrRef();
2361   return da.retn();
2362 }
2363
2364 MEDFileFieldPerMesh::MEDFileFieldPerMesh(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc):_mesh_iteration(meshIteration),_mesh_order(meshOrder),
2365                                                                                                                                                                                                                  _mesh_csit(meshCsit),_father(fath)
2366 {
2367   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2368   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2369   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2370   for(int i=0;i<MED_N_CELL_FIXED_GEO;i++)
2371     {
2372       int nbProfile =MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL        ,typmai[i],_mesh_csit,meshName,pflName,locName);
2373       std::string name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
2374       int nbProfile2=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[i],_mesh_csit,meshName,pflName,locName);
2375       std::string name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
2376       if(nbProfile>0 || nbProfile2>0)
2377         {
2378           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[i],nasc));
2379           if(nbProfile>0)
2380             _mesh_name=name0;
2381           else
2382             _mesh_name=name1;
2383         }
2384     }
2385   int nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,_mesh_csit,meshName,pflName,locName);
2386   if(nbProfile>0)
2387     {
2388       _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc));
2389       _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2390     }
2391 }
2392
2393 MEDFileFieldPerMesh::MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh):_father(fath)
2394 {
2395   copyTinyInfoFrom(mesh);
2396 }
2397
2398 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int id, const std::string& pflName)
2399 {
2400   if(id>=(int)_pfls.size())
2401     _pfls.resize(id+1);
2402   _pfls[id]=DataArrayInt::New();
2403   int lgth=MEDprofileSizeByName(fid,pflName.c_str());
2404   _pfls[id]->setName(pflName);
2405   _pfls[id]->alloc(lgth,1);
2406   MEDprofileRd(fid,pflName.c_str(),_pfls[id]->getPointer());
2407   _pfls[id]->applyLin(1,-1,0);//Converting into C format
2408 }
2409
2410 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int i)
2411 {
2412   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2413   int sz;
2414   MEDprofileInfo(fid,i+1,pflName,&sz);
2415   std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
2416   if(i>=(int)_pfls.size())
2417     _pfls.resize(i+1);
2418   _pfls[i]=DataArrayInt::New();
2419   _pfls[i]->alloc(sz,1);
2420   _pfls[i]->setName(pflCpp.c_str());
2421   MEDprofileRd(fid,pflName,_pfls[i]->getPointer());
2422   _pfls[i]->applyLin(1,-1,0);//Converting into C format
2423 }
2424
2425 void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
2426 {
2427   int nbOfPfls=_pfls.size();
2428   for(int i=0;i<nbOfPfls;i++)
2429     {
2430       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cpy=_pfls[i]->deepCpy();
2431       cpy->applyLin(1,1,0);
2432       INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2433       MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
2434       MEDprofileWr(fid,pflName,_pfls[i]->getNumberOfTuples(),cpy->getConstPointer());
2435     }
2436   //
2437   int nbOfLocs=_locs.size();
2438   for(int i=0;i<nbOfLocs;i++)
2439     _locs[i]->writeLL(fid);
2440 }
2441
2442 void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps)
2443 {
2444   std::vector<std::string> pfls=getPfls();
2445   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
2446     {
2447       std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
2448       if(it2==pfls.end())
2449         {
2450           _pfls.push_back(*it);
2451         }
2452       else
2453         {
2454           int id=std::distance(pfls.begin(),it2);
2455           if(!(*it)->isEqual(*_pfls[id]))
2456             {
2457               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2458               throw INTERP_KERNEL::Exception(oss.str().c_str());
2459             }
2460         }
2461     }
2462   std::vector<std::string> locs=getLocs();
2463   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=other._locs.begin();it!=other._locs.end();it++)
2464     {
2465       std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
2466       if(it2==locs.end())
2467         {
2468           _locs.push_back(*it);
2469         }
2470       else
2471         {
2472           int id=std::distance(locs.begin(),it2);
2473           if(!(*it)->isEqual(*_locs[id],eps))
2474             {
2475               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2476               throw INTERP_KERNEL::Exception(oss.str().c_str());
2477             }
2478         }
2479     }
2480 }
2481
2482 void MEDFileFieldGlobs::checkGlobsPflsPartCoherency(const std::vector<std::string>& pflsUsed) const
2483 {
2484   for(std::vector<std::string>::const_iterator it=pflsUsed.begin();it!=pflsUsed.end();it++)
2485     getProfile((*it).c_str());
2486 }
2487
2488 void MEDFileFieldGlobs::checkGlobsLocsPartCoherency(const std::vector<std::string>& locsUsed) const
2489 {
2490   for(std::vector<std::string>::const_iterator it=locsUsed.begin();it!=locsUsed.end();it++)
2491     getLocalization((*it).c_str());
2492 }
2493
2494 void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real)
2495 {
2496   std::vector<std::string> profiles=real.getPflsReallyUsed();
2497   int sz=profiles.size();
2498   _pfls.resize(sz);
2499   for(int i=0;i<sz;i++)
2500     loadProfileInFile(fid,i,profiles[i].c_str());
2501   //
2502   std::vector<std::string> locs=real.getLocsReallyUsed();
2503   sz=locs.size();
2504   _locs.resize(sz);
2505   for(int i=0;i<sz;i++)
2506     _locs[i]=MEDFileFieldLoc::New(fid,locs[i].c_str());
2507 }
2508
2509 void MEDFileFieldGlobs::loadAllGlobals(med_idt fid)
2510 {
2511   int nProfil=MEDnProfile(fid);
2512   for(int i=0;i<nProfil;i++)
2513     loadProfileInFile(fid,i);
2514   int sz=MEDnLocalization(fid);
2515   _locs.resize(sz);
2516   for(int i=0;i<sz;i++)
2517     {
2518       _locs[i]=MEDFileFieldLoc::New(fid,i);
2519     }
2520 }
2521
2522 MEDFileFieldGlobs *MEDFileFieldGlobs::New(const std::string& fname)
2523 {
2524   return new MEDFileFieldGlobs(fname);
2525 }
2526
2527 MEDFileFieldGlobs *MEDFileFieldGlobs::New()
2528 {
2529   return new MEDFileFieldGlobs;
2530 }
2531
2532 std::size_t MEDFileFieldGlobs::getHeapMemorySizeWithoutChildren() const
2533 {
2534   return _file_name.capacity()+_pfls.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<DataArrayInt>)+_locs.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>);
2535 }
2536
2537 std::vector<const BigMemoryObject *> MEDFileFieldGlobs::getDirectChildren() const
2538 {
2539   std::vector<const BigMemoryObject *> ret;
2540   for(std::vector< MEDCouplingAutoRefCountObjectPtr< DataArrayInt > >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2541     {
2542       const DataArrayInt *cur(*it);
2543       if(cur)
2544         ret.push_back(cur);
2545     }
2546   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2547     {
2548       const MEDFileFieldLoc *cur(*it);
2549       if(cur)
2550         ret.push_back(cur);
2551     }
2552   return ret;
2553 }
2554
2555 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpy() const
2556 {
2557   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
2558   std::size_t i=0;
2559   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2560     {
2561       if((const DataArrayInt *)*it)
2562         ret->_pfls[i]=(*it)->deepCpy();
2563     }
2564   i=0;
2565   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2566     {
2567       if((const MEDFileFieldLoc*)*it)
2568         ret->_locs[i]=(*it)->deepCpy();
2569     }
2570   return ret.retn();
2571 }
2572
2573 /*!
2574  * \throw if a profile in \a pfls in not in \a this.
2575  * \throw if a localization in \a locs in not in \a this.
2576  * \sa MEDFileFieldGlobs::deepCpyPart
2577  */
2578 MEDFileFieldGlobs *MEDFileFieldGlobs::shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
2579 {
2580   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2581   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2582     {
2583       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2584       if(!pfl)
2585         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! pfl null !");
2586       pfl->incrRef();
2587       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2(pfl);
2588       ret->_pfls.push_back(pfl2);
2589     }
2590   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2591     {
2592       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2593       if(!loc)
2594         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! loc null !");
2595       loc->incrRef();
2596       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> loc2(loc);
2597       ret->_locs.push_back(loc2);
2598     }
2599   ret->setFileName(getFileName());
2600   return ret.retn();
2601 }
2602
2603 /*!
2604  * \throw if a profile in \a pfls in not in \a this.
2605  * \throw if a localization in \a locs in not in \a this.
2606  * \sa MEDFileFieldGlobs::shallowCpyPart
2607  */
2608 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
2609 {
2610   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2611   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2612     {
2613       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2614       if(!pfl)
2615         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! pfl null !");
2616       ret->_pfls.push_back(pfl->deepCpy());
2617     }
2618   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2619     {
2620       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2621       if(!loc)
2622         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! loc null !");
2623       ret->_locs.push_back(loc->deepCpy());
2624     }
2625   ret->setFileName(getFileName());
2626   return ret.retn();
2627 }
2628
2629 MEDFileFieldGlobs::MEDFileFieldGlobs(const std::string& fname):_file_name(fname)
2630 {
2631 }
2632
2633 MEDFileFieldGlobs::MEDFileFieldGlobs()
2634 {
2635 }
2636
2637 MEDFileFieldGlobs::~MEDFileFieldGlobs()
2638 {
2639 }
2640
2641 void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
2642 {
2643   oss << "Profiles :\n";
2644   std::size_t n=_pfls.size();
2645   for(std::size_t i=0;i<n;i++)
2646     {
2647       oss << "  - #" << i << " ";
2648       const DataArrayInt *pfl=_pfls[i];
2649       if(pfl)
2650         oss << "\"" << pfl->getName() << "\"\n";
2651       else
2652         oss << "EMPTY !\n";
2653     }
2654   n=_locs.size();
2655   oss << "Localizations :\n";
2656   for(std::size_t i=0;i<n;i++)
2657     {
2658       oss << "  - #" << i << " ";
2659       const MEDFileFieldLoc *loc=_locs[i];
2660       if(loc)
2661         loc->simpleRepr(oss);
2662       else
2663         oss<< "EMPTY !\n";
2664     }
2665 }
2666
2667 void MEDFileFieldGlobs::setFileName(const std::string& fileName)
2668 {
2669   _file_name=fileName;
2670 }
2671
2672 void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2673 {
2674   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
2675     {
2676       DataArrayInt *elt(*it);
2677       if(elt)
2678         {
2679           std::string name(elt->getName());
2680           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2681             {
2682               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2683                 {
2684                   elt->setName((*it2).second.c_str());
2685                   return;
2686                 }
2687             }
2688         }
2689     }
2690 }
2691
2692 void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2693 {
2694   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
2695     {
2696       MEDFileFieldLoc *elt(*it);
2697       if(elt)
2698         {
2699           std::string name(elt->getName());
2700           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2701             {
2702               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2703                 {
2704                   elt->setName((*it2).second.c_str());
2705                   return;
2706                 }
2707             }
2708         }
2709     }
2710 }
2711
2712 int MEDFileFieldGlobs::getNbOfGaussPtPerCell(int locId) const
2713 {
2714   if(locId<0 || locId>=(int)_locs.size())
2715     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getNbOfGaussPtPerCell : Invalid localization id !");
2716   return _locs[locId]->getNbOfGaussPtPerCell();
2717 }
2718
2719 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const std::string& locName) const
2720 {
2721   return getLocalizationFromId(getLocalizationId(locName));
2722 }
2723
2724 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) const
2725 {
2726   if(locId<0 || locId>=(int)_locs.size())
2727     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2728   return *_locs[locId];
2729 }
2730
2731 namespace ParaMEDMEMImpl
2732 {
2733   class LocFinder
2734   {
2735   public:
2736     LocFinder(const std::string& loc):_loc(loc) { }
2737     bool operator() (const MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>& loc) { return loc->isName(_loc); }
2738   private:
2739     const std::string &_loc;
2740   };
2741
2742   class PflFinder
2743   {
2744   public:
2745     PflFinder(const std::string& pfl):_pfl(pfl) { }
2746     bool operator() (const MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& pfl) { return _pfl==pfl->getName(); }
2747   private:
2748     const std::string& _pfl;
2749   };
2750 }
2751
2752 int MEDFileFieldGlobs::getLocalizationId(const std::string& loc) const
2753 {
2754   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),ParaMEDMEMImpl::LocFinder(loc));
2755   if(it==_locs.end())
2756     {
2757       std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
2758       for(it=_locs.begin();it!=_locs.end();it++)
2759         oss << "\"" << (*it)->getName() << "\", ";
2760       throw INTERP_KERNEL::Exception(oss.str().c_str());
2761     }
2762   return std::distance(_locs.begin(),it);
2763 }
2764
2765 /*!
2766  * The returned value is never null.
2767  */
2768 const DataArrayInt *MEDFileFieldGlobs::getProfile(const std::string& pflName) const
2769 {
2770   std::string pflNameCpp(pflName);
2771   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2772   if(it==_pfls.end())
2773     {
2774       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2775       for(it=_pfls.begin();it!=_pfls.end();it++)
2776         oss << "\"" << (*it)->getName() << "\", ";
2777       throw INTERP_KERNEL::Exception(oss.str().c_str());
2778     }
2779   return *it;
2780 }
2781
2782 const DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) const
2783 {
2784   if(pflId<0 || pflId>=(int)_pfls.size())
2785     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2786   return _pfls[pflId];
2787 }
2788
2789 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId)
2790 {
2791   if(locId<0 || locId>=(int)_locs.size())
2792     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2793   return *_locs[locId];
2794 }
2795
2796 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const std::string& locName)
2797 {
2798   return getLocalizationFromId(getLocalizationId(locName));
2799 }
2800
2801 /*!
2802  * The returned value is never null.
2803  */
2804 DataArrayInt *MEDFileFieldGlobs::getProfile(const std::string& pflName)
2805 {
2806   std::string pflNameCpp(pflName);
2807   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2808   if(it==_pfls.end())
2809     {
2810       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2811       for(it=_pfls.begin();it!=_pfls.end();it++)
2812         oss << "\"" << (*it)->getName() << "\", ";
2813       throw INTERP_KERNEL::Exception(oss.str().c_str());
2814     }
2815   return *it;
2816 }
2817
2818 DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId)
2819 {
2820   if(pflId<0 || pflId>=(int)_pfls.size())
2821     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2822   return _pfls[pflId];
2823 }
2824
2825 void MEDFileFieldGlobs::killProfileIds(const std::vector<int>& pflIds)
2826 {
2827   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newPfls;
2828   int i=0;
2829   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2830     {
2831       if(std::find(pflIds.begin(),pflIds.end(),i)==pflIds.end())
2832         newPfls.push_back(*it);
2833     }
2834   _pfls=newPfls;
2835 }
2836
2837 void MEDFileFieldGlobs::killLocalizationIds(const std::vector<int>& locIds)
2838 {
2839   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> > newLocs;
2840   int i=0;
2841   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2842     {
2843       if(std::find(locIds.begin(),locIds.end(),i)==locIds.end())
2844         newLocs.push_back(*it);
2845     }
2846   _locs=newLocs;
2847 }
2848
2849 std::vector<std::string> MEDFileFieldGlobs::getPfls() const
2850 {
2851   int sz=_pfls.size();
2852   std::vector<std::string> ret(sz);
2853   for(int i=0;i<sz;i++)
2854     ret[i]=_pfls[i]->getName();
2855   return ret;
2856 }
2857
2858 std::vector<std::string> MEDFileFieldGlobs::getLocs() const
2859 {
2860   int sz=_locs.size();
2861   std::vector<std::string> ret(sz);
2862   for(int i=0;i<sz;i++)
2863     ret[i]=_locs[i]->getName();
2864   return ret;
2865 }
2866
2867 bool MEDFileFieldGlobs::existsPfl(const std::string& pflName) const
2868 {
2869   std::vector<std::string> v=getPfls();
2870   std::string s(pflName);
2871   return std::find(v.begin(),v.end(),s)!=v.end();
2872 }
2873
2874 bool MEDFileFieldGlobs::existsLoc(const std::string& locName) const
2875 {
2876   std::vector<std::string> v=getLocs();
2877   std::string s(locName);
2878   return std::find(v.begin(),v.end(),s)!=v.end();
2879 }
2880
2881 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualProfiles() const
2882 {
2883   std::map<int,std::vector<int> > m;
2884   int i=0;
2885   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2886     {
2887       const DataArrayInt *tmp=(*it);
2888       if(tmp)
2889         {
2890           m[tmp->getHashCode()].push_back(i);
2891         }
2892     }
2893   std::vector< std::vector<int> > ret;
2894   for(std::map<int,std::vector<int> >::const_iterator it2=m.begin();it2!=m.end();it2++)
2895     {
2896       if((*it2).second.size()>1)
2897         {
2898           std::vector<int> ret0;
2899           bool equalityOrNot=false;
2900           for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
2901             {
2902               std::vector<int>::const_iterator it4=it3; it4++;
2903               for(;it4!=(*it2).second.end();it4++)
2904                 {
2905                   if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
2906                     {
2907                       if(!equalityOrNot)
2908                         ret0.push_back(*it3);
2909                       ret0.push_back(*it4);
2910                       equalityOrNot=true;
2911                     }
2912                 }
2913             }
2914           if(!ret0.empty())
2915             ret.push_back(ret0);
2916         }
2917     }
2918   return ret;
2919 }
2920
2921 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
2922 {
2923   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
2924 }
2925
2926 void MEDFileFieldGlobs::appendProfile(DataArrayInt *pfl)
2927 {
2928   std::string name(pfl->getName());
2929   if(name.empty())
2930     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
2931   for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2932     if(name==(*it)->getName())
2933       {
2934         if(!pfl->isEqual(*(*it)))
2935           {
2936             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
2937             throw INTERP_KERNEL::Exception(oss.str().c_str());
2938           }
2939       }
2940   pfl->incrRef();
2941   _pfls.push_back(pfl);
2942 }
2943
2944 void MEDFileFieldGlobs::appendLoc(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
2945 {
2946   std::string name(locName);
2947   if(name.empty())
2948     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
2949   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
2950   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2951     if((*it)->isName(locName))
2952       {
2953         if(!(*it)->isEqual(*obj,1e-12))
2954           {
2955             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
2956             throw INTERP_KERNEL::Exception(oss.str().c_str());
2957           }
2958       }
2959   _locs.push_back(obj);
2960 }
2961
2962 std::string MEDFileFieldGlobs::createNewNameOfPfl() const
2963 {
2964   std::vector<std::string> names=getPfls();
2965   return CreateNewNameNotIn("NewPfl_",names);
2966 }
2967
2968 std::string MEDFileFieldGlobs::createNewNameOfLoc() const
2969 {
2970   std::vector<std::string> names=getLocs();
2971   return CreateNewNameNotIn("NewLoc_",names);
2972 }
2973
2974 std::string MEDFileFieldGlobs::CreateNewNameNotIn(const std::string& prefix, const std::vector<std::string>& namesToAvoid)
2975 {
2976   for(std::size_t sz=0;sz<100000;sz++)
2977     {
2978       std::ostringstream tryName;
2979       tryName << prefix << sz;
2980       if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tryName.str())==namesToAvoid.end())
2981         return tryName.str();
2982     }
2983   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::CreateNewNameNotIn : impossible to create an additional profile limit of 100000 profiles reached !");
2984 }
2985
2986 /*!
2987  * Creates a MEDFileFieldGlobsReal on a given file name. Nothing is read here.
2988  *  \param [in] fname - the file name.
2989  */
2990 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal(const std::string& fname):_globals(MEDFileFieldGlobs::New(fname))
2991 {
2992 }
2993
2994 /*!
2995  * Creates an empty MEDFileFieldGlobsReal.
2996  */
2997 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal():_globals(MEDFileFieldGlobs::New())
2998 {
2999 }
3000
3001 std::size_t MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren() const
3002 {
3003   return 0;
3004 }
3005
3006 std::vector<const BigMemoryObject *> MEDFileFieldGlobsReal::getDirectChildren() const
3007 {
3008   std::vector<const BigMemoryObject *> ret;
3009   if((const MEDFileFieldGlobs *)_globals)
3010     ret.push_back((const MEDFileFieldGlobs *)_globals);
3011   return ret;
3012 }
3013
3014 /*!
3015  * Returns a string describing profiles and Gauss points held in \a this.
3016  *  \return std::string - the description string.
3017  */
3018 void MEDFileFieldGlobsReal::simpleReprGlobs(std::ostream& oss) const
3019 {
3020   const MEDFileFieldGlobs *glob=_globals;
3021   std::ostringstream oss2; oss2 << glob;
3022   std::string stars(oss2.str().length(),'*');
3023   oss << "Globals information on fields (at " << oss2.str() << "):" << "\n************************************" << stars  << "\n\n";
3024   if(glob)
3025     glob->simpleRepr(oss);
3026   else
3027     oss << "NO GLOBAL INFORMATION !\n";
3028 }
3029
3030 void MEDFileFieldGlobsReal::resetContent()
3031 {
3032   _globals=MEDFileFieldGlobs::New();
3033 }
3034
3035 MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
3036 {
3037 }
3038
3039 /*!
3040  * Copies references to profiles and Gauss points from another MEDFileFieldGlobsReal.
3041  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3042  */
3043 void MEDFileFieldGlobsReal::shallowCpyGlobs(const MEDFileFieldGlobsReal& other)
3044 {
3045   _globals=other._globals;
3046 }
3047
3048 /*!
3049  * Copies references to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3050  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3051  */
3052 void MEDFileFieldGlobsReal::shallowCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3053 {
3054   const MEDFileFieldGlobs *otherg(other._globals);
3055   if(!otherg)
3056     return ;
3057   _globals=otherg->shallowCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3058 }
3059
3060 /*!
3061  * Copies deeply to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3062  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3063  */
3064 void MEDFileFieldGlobsReal::deepCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3065 {
3066   const MEDFileFieldGlobs *otherg(other._globals);
3067   if(!otherg)
3068     return ;
3069   _globals=otherg->deepCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3070 }
3071
3072 void MEDFileFieldGlobsReal::deepCpyGlobs(const MEDFileFieldGlobsReal& other)
3073 {
3074   _globals=other._globals;
3075   if((const MEDFileFieldGlobs *)_globals)
3076     _globals=other._globals->deepCpy();
3077 }
3078
3079 /*!
3080  * Adds profiles and Gauss points held by another MEDFileFieldGlobsReal to \a this one.
3081  *  \param [in] other - the MEDFileFieldGlobsReal to copy data from.
3082  *  \param [in] eps - a precision used to compare Gauss points with same name held by
3083  *         \a this and \a other MEDFileFieldGlobsReal.
3084  *  \throw If \a this and \a other hold profiles with equal names but different ids.
3085  *  \throw If  \a this and \a other hold different Gauss points with equal names.
3086  */
3087 void MEDFileFieldGlobsReal::appendGlobs(const MEDFileFieldGlobsReal& other, double eps)
3088 {
3089   const MEDFileFieldGlobs *thisGlobals(_globals),*otherGlobals(other._globals);
3090   if(thisGlobals==otherGlobals)
3091     return ;
3092   if(!thisGlobals)
3093     {
3094       _globals=other._globals;
3095       return ;
3096     }
3097   _globals->appendGlobs(*other._globals,eps);
3098 }
3099
3100 void MEDFileFieldGlobsReal::checkGlobsCoherency() const
3101 {
3102   checkGlobsPflsPartCoherency();
3103   checkGlobsLocsPartCoherency();
3104 }
3105
3106 void MEDFileFieldGlobsReal::checkGlobsPflsPartCoherency() const
3107 {
3108   contentNotNull()->checkGlobsPflsPartCoherency(getPflsReallyUsed());
3109 }
3110
3111 void MEDFileFieldGlobsReal::checkGlobsLocsPartCoherency() const
3112 {
3113   contentNotNull()->checkGlobsLocsPartCoherency(getLocsReallyUsed());
3114 }
3115
3116 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id, const std::string& pflName)
3117 {
3118   contentNotNull()->loadProfileInFile(fid,id,pflName);
3119 }
3120
3121 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id)
3122 {
3123   contentNotNull()->loadProfileInFile(fid,id);
3124 }
3125
3126 void MEDFileFieldGlobsReal::loadGlobals(med_idt fid)
3127 {
3128   contentNotNull()->loadGlobals(fid,*this);
3129 }
3130
3131 void MEDFileFieldGlobsReal::loadAllGlobals(med_idt fid)
3132 {
3133   contentNotNull()->loadAllGlobals(fid);
3134 }
3135
3136 void MEDFileFieldGlobsReal::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
3137 {
3138   contentNotNull()->writeGlobals(fid,opt);
3139 }
3140
3141 /*!
3142  * Returns names of all profiles. To get only used profiles call getPflsReallyUsed()
3143  * or getPflsReallyUsedMulti().
3144  *  \return std::vector<std::string> - a sequence of names of all profiles.
3145  */
3146 std::vector<std::string> MEDFileFieldGlobsReal::getPfls() const
3147 {
3148   return contentNotNull()->getPfls();
3149 }
3150
3151 /*!
3152  * Returns names of all localizations. To get only used localizations call getLocsReallyUsed()
3153  * or getLocsReallyUsedMulti().
3154  *  \return std::vector<std::string> - a sequence of names of all localizations.
3155  */
3156 std::vector<std::string> MEDFileFieldGlobsReal::getLocs() const
3157 {
3158   return contentNotNull()->getLocs();
3159 }
3160
3161 /*!
3162  * Checks if the profile with a given name exists.
3163  *  \param [in] pflName - the profile name of interest.
3164  *  \return bool - \c true if the profile named \a pflName exists.
3165  */
3166 bool MEDFileFieldGlobsReal::existsPfl(const std::string& pflName) const
3167 {
3168   return contentNotNull()->existsPfl(pflName);
3169 }
3170
3171 /*!
3172  * Checks if the localization with a given name exists.
3173  *  \param [in] locName - the localization name of interest.
3174  *  \return bool - \c true if the localization named \a locName exists.
3175  */
3176 bool MEDFileFieldGlobsReal::existsLoc(const std::string& locName) const
3177 {
3178   return contentNotNull()->existsLoc(locName);
3179 }
3180
3181 std::string MEDFileFieldGlobsReal::createNewNameOfPfl() const
3182 {
3183   return contentNotNull()->createNewNameOfPfl();
3184 }
3185
3186 std::string MEDFileFieldGlobsReal::createNewNameOfLoc() const
3187 {
3188   return contentNotNull()->createNewNameOfLoc();
3189 }
3190
3191 /*!
3192  * Sets the name of a MED file.
3193  *  \param [inout] fileName - the file name.
3194  */
3195 void MEDFileFieldGlobsReal::setFileName(const std::string& fileName)
3196 {
3197   contentNotNull()->setFileName(fileName);
3198 }
3199
3200 /*!
3201  * Finds equal profiles. Two profiles are considered equal if they contain the same ids
3202  * in the same order.
3203  *  \return std::vector< std::vector<int> > - a sequence of groups of equal profiles.
3204  *          Each item of this sequence is a vector containing ids of equal profiles.
3205  */
3206 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualProfiles() const
3207 {
3208   return contentNotNull()->whichAreEqualProfiles();
3209 }
3210
3211 /*!
3212  * Finds equal localizations.
3213  *  \param [in] eps - a precision used to compare real values of the localizations.
3214  *  \return std::vector< std::vector<int> > - a sequence of groups of equal localizations.
3215  *          Each item of this sequence is a vector containing ids of equal localizations.
3216  */
3217 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualLocs(double eps) const
3218 {
3219   return contentNotNull()->whichAreEqualLocs(eps);
3220 }
3221
3222 /*!
3223  * Renames the profiles. References to profiles (a reference is a profile name) are not changed.
3224  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3225  *        this sequence is a pair whose
3226  *        - the first item is a vector of profile names to replace by the second item,
3227  *        - the second item is a profile name to replace every profile name of the first item.
3228  */
3229 void MEDFileFieldGlobsReal::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3230 {
3231   contentNotNull()->changePflsNamesInStruct(mapOfModif);
3232 }
3233
3234 /*!
3235  * Renames the localizations. References to localizations (a reference is a localization name) are not changed.
3236  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3237  *        this sequence is a pair whose
3238  *        - the first item is a vector of localization names to replace by the second item,
3239  *        - the second item is a localization name to replace every localization name of the first item.
3240  */
3241 void MEDFileFieldGlobsReal::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3242 {
3243   contentNotNull()->changeLocsNamesInStruct(mapOfModif);
3244 }
3245
3246 /*!
3247  * Replaces references to some profiles (a reference is a profile name) by references
3248  * to other profiles and, contrary to changePflsRefsNamesGen(), renames the profiles
3249  * them-selves accordingly. <br>
3250  * This method is a generalization of changePflName().
3251  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3252  *        this sequence is a pair whose
3253  *        - the first item is a vector of profile names to replace by the second item,
3254  *        - the second item is a profile name to replace every profile of the first item.
3255  * \sa changePflsRefsNamesGen()
3256  * \sa changePflName()
3257  */
3258 void MEDFileFieldGlobsReal::changePflsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3259 {
3260   changePflsRefsNamesGen(mapOfModif);
3261   changePflsNamesInStruct(mapOfModif);
3262 }
3263
3264 /*!
3265  * Replaces references to some localizations (a reference is a localization name) by references
3266  * to other localizations and, contrary to changeLocsRefsNamesGen(), renames the localizations
3267  * them-selves accordingly. <br>
3268  * This method is a generalization of changeLocName().
3269  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3270  *        this sequence is a pair whose
3271  *        - the first item is a vector of localization names to replace by the second item,
3272  *        - the second item is a localization name to replace every localization of the first item.
3273  * \sa changeLocsRefsNamesGen()
3274  * \sa changeLocName()
3275  */
3276 void MEDFileFieldGlobsReal::changeLocsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3277 {
3278   changeLocsRefsNamesGen(mapOfModif);
3279   changeLocsNamesInStruct(mapOfModif);
3280 }
3281
3282 /*!
3283  * Renames the profile having a given name and updates references to this profile.
3284  *  \param [in] oldName - the name of the profile to rename.
3285  *  \param [in] newName - a new name of the profile.
3286  * \sa changePflsNames().
3287  */
3288 void MEDFileFieldGlobsReal::changePflName(const std::string& oldName, const std::string& newName)
3289 {
3290   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3291   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3292   mapOfModif[0]=p;
3293   changePflsNames(mapOfModif);
3294 }
3295
3296 /*!
3297  * Renames the localization having a given name and updates references to this localization.
3298  *  \param [in] oldName - the name of the localization to rename.
3299  *  \param [in] newName - a new name of the localization.
3300  * \sa changeLocsNames().
3301  */
3302 void MEDFileFieldGlobsReal::changeLocName(const std::string& oldName, const std::string& newName)
3303 {
3304   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3305   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3306   mapOfModif[0]=p;
3307   changeLocsNames(mapOfModif);
3308 }
3309
3310 /*!
3311  * Removes duplicated profiles. Returns a map used to update references to removed
3312  * profiles via changePflsRefsNamesGen().
3313  * Equal profiles are found using whichAreEqualProfiles().
3314  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3315  *          a sequence describing the performed replacements of profiles. Each element of
3316  *          this sequence is a pair whose
3317  *          - the first item is a vector of profile names replaced by the second item,
3318  *          - the second item is a profile name replacing every profile of the first item.
3319  */
3320 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipPflsNames()
3321 {
3322   std::vector< std::vector<int> > pseudoRet=whichAreEqualProfiles();
3323   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3324   int i=0;
3325   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3326     {
3327       std::vector< std::string > tmp((*it).size());
3328       int j=0;
3329       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3330         tmp[j]=std::string(getProfileFromId(*it2)->getName());
3331       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3332       ret[i]=p;
3333       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3334       killProfileIds(tmp2);
3335     }
3336   changePflsRefsNamesGen(ret);
3337   return ret;
3338 }
3339
3340 /*!
3341  * Removes duplicated localizations. Returns a map used to update references to removed
3342  * localizations via changeLocsRefsNamesGen().
3343  * Equal localizations are found using whichAreEqualLocs().
3344  *  \param [in] eps - a precision used to compare real values of the localizations.
3345  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3346  *          a sequence describing the performed replacements of localizations. Each element of
3347  *          this sequence is a pair whose
3348  *          - the first item is a vector of localization names replaced by the second item,
3349  *          - the second item is a localization name replacing every localization of the first item.
3350  */
3351 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipLocsNames(double eps)
3352 {
3353   std::vector< std::vector<int> > pseudoRet=whichAreEqualLocs(eps);
3354   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3355   int i=0;
3356   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3357     {
3358       std::vector< std::string > tmp((*it).size());
3359       int j=0;
3360       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3361         tmp[j]=std::string(getLocalizationFromId(*it2).getName());
3362       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3363       ret[i]=p;
3364       std::vector<int> tmp2((*it).begin()+1,(*it).end());
3365       killLocalizationIds(tmp2);
3366     }
3367   changeLocsRefsNamesGen(ret);
3368   return ret;
3369 }
3370
3371 /*!
3372  * Returns number of Gauss points per cell in a given localization.
3373  *  \param [in] locId - an id of the localization of interest.
3374  *  \return int - the number of the Gauss points per cell.
3375  */
3376 int MEDFileFieldGlobsReal::getNbOfGaussPtPerCell(int locId) const
3377 {
3378   return contentNotNull()->getNbOfGaussPtPerCell(locId);
3379 }
3380
3381 /*!
3382  * Returns an id of a localization by its name.
3383  *  \param [in] loc - the localization name of interest.
3384  *  \return int - the id of the localization.
3385  *  \throw If there is no a localization named \a loc.
3386  */
3387 int MEDFileFieldGlobsReal::getLocalizationId(const std::string& loc) const
3388 {
3389   return contentNotNull()->getLocalizationId(loc);
3390 }
3391
3392 /*!
3393  * Returns the name of the MED file.
3394  *  \return const std::string&  - the MED file name.
3395  */
3396 std::string MEDFileFieldGlobsReal::getFileName() const
3397 {
3398   return contentNotNull()->getFileName();
3399 }
3400
3401 std::string MEDFileFieldGlobsReal::getFileName2() const
3402 {
3403   return contentNotNull()->getFileName2();
3404 }
3405
3406 /*!
3407  * Returns a localization object by its name.
3408  *  \param [in] locName - the name of the localization of interest.
3409  *  \return const MEDFileFieldLoc& - the localization object having the name \a locName.
3410  *  \throw If there is no a localization named \a locName.
3411  */
3412 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const std::string& locName) const
3413 {
3414   return contentNotNull()->getLocalization(locName);
3415 }
3416
3417 /*!
3418  * Returns a localization object by its id.
3419  *  \param [in] locId - the id of the localization of interest.
3420  *  \return const MEDFileFieldLoc& - the localization object having the id \a locId.
3421  *  \throw If there is no a localization with id \a locId.
3422  */
3423 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) const
3424 {
3425   return contentNotNull()->getLocalizationFromId(locId);
3426 }
3427
3428 /*!
3429  * Returns a profile array by its name.
3430  *  \param [in] pflName - the name of the profile of interest.
3431  *  \return const DataArrayInt * - the profile array having the name \a pflName.
3432  *  \throw If there is no a profile named \a pflName.
3433  */
3434 const DataArrayInt *MEDFileFieldGlobsReal::getProfile(const std::string& pflName) const
3435 {
3436   return contentNotNull()->getProfile(pflName);
3437 }
3438
3439 /*!
3440  * Returns a profile array by its id.
3441  *  \param [in] pflId - the id of the profile of interest.
3442  *  \return const DataArrayInt * - the profile array having the id \a pflId.
3443  *  \throw If there is no a profile with id \a pflId.
3444  */
3445 const DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) const
3446 {
3447   return contentNotNull()->getProfileFromId(pflId);
3448 }
3449
3450 /*!
3451  * Returns a localization object, apt for modification, by its id.
3452  *  \param [in] locId - the id of the localization of interest.
3453  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3454  *          having the id \a locId.
3455  *  \throw If there is no a localization with id \a locId.
3456  */
3457 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId)
3458 {
3459   return contentNotNull()->getLocalizationFromId(locId);
3460 }
3461
3462 /*!
3463  * Returns a localization object, apt for modification, by its name.
3464  *  \param [in] locName - the name of the localization of interest.
3465  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
3466  *          having the name \a locName.
3467  *  \throw If there is no a localization named \a locName.
3468  */
3469 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const std::string& locName)
3470 {
3471   return contentNotNull()->getLocalization(locName);
3472 }
3473
3474 /*!
3475  * Returns a profile array, apt for modification, by its name.
3476  *  \param [in] pflName - the name of the profile of interest.
3477  *  \return DataArrayInt * - a non-const pointer to the profile array having the name \a pflName.
3478  *  \throw If there is no a profile named \a pflName.
3479  */
3480 DataArrayInt *MEDFileFieldGlobsReal::getProfile(const std::string& pflName)
3481 {
3482   return contentNotNull()->getProfile(pflName);
3483 }
3484
3485 /*!
3486  * Returns a profile array, apt for modification, by its id.
3487  *  \param [in] pflId - the id of the profile of interest.
3488  *  \return DataArrayInt * - a non-const pointer to the profile array having the id \a pflId.
3489  *  \throw If there is no a profile with id \a pflId.
3490  */
3491 DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId)
3492 {
3493   return contentNotNull()->getProfileFromId(pflId);
3494 }
3495
3496 /*!
3497  * Removes profiles given by their ids. No data is updated to track this removal.
3498  *  \param [in] pflIds - a sequence of ids of the profiles to remove.
3499  */
3500 void MEDFileFieldGlobsReal::killProfileIds(const std::vector<int>& pflIds)
3501 {
3502   contentNotNull()->killProfileIds(pflIds);
3503 }
3504
3505 /*!
3506  * Removes localizations given by their ids. No data is updated to track this removal.
3507  *  \param [in] locIds - a sequence of ids of the localizations to remove.
3508  */
3509 void MEDFileFieldGlobsReal::killLocalizationIds(const std::vector<int>& locIds)
3510 {
3511   contentNotNull()->killLocalizationIds(locIds);
3512 }
3513
3514 /*!
3515  * Stores a profile array.
3516  *  \param [in] pfl - the profile array to store.
3517  *  \throw If the name of \a pfl is empty.
3518  *  \throw If a profile with the same name as that of \a pfl already exists but contains
3519  *         different ids.
3520  */
3521 void MEDFileFieldGlobsReal::appendProfile(DataArrayInt *pfl)
3522 {
3523   contentNotNull()->appendProfile(pfl);
3524 }
3525
3526 /*!
3527  * Adds a new localization of Gauss points.
3528  *  \param [in] locName - the name of the new localization.
3529  *  \param [in] geoType - a geometrical type of the reference cell.
3530  *  \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
3531  *         must be \c nbOfNodesPerCell * \c dimOfType.
3532  *  \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
3533  *         must be  _wg_.size() * \c dimOfType.
3534  *  \param [in] w - the weights of Gauss points.
3535  *  \throw If \a locName is empty.
3536  *  \throw If a localization with the name \a locName already exists but is
3537  *         different form the new one.
3538  */
3539 void MEDFileFieldGlobsReal::appendLoc(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
3540 {
3541   contentNotNull()->appendLoc(locName,geoType,refCoo,gsCoo,w);
3542 }
3543
3544 MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull()
3545 {
3546   MEDFileFieldGlobs *g(_globals);
3547   if(!g)
3548     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in not const !");
3549   return g;
3550 }
3551
3552 const MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() const
3553 {
3554   const MEDFileFieldGlobs *g(_globals);
3555   if(!g)
3556     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in const !");
3557   return g;
3558 }
3559
3560 //= MEDFileFieldNameScope
3561
3562 MEDFileFieldNameScope::MEDFileFieldNameScope()
3563 {
3564 }
3565
3566 MEDFileFieldNameScope::MEDFileFieldNameScope(const std::string& fieldName):_name(fieldName)
3567 {
3568 }
3569
3570 /*!
3571  * Returns the name of \a this field.
3572  *  \return std::string - a string containing the field name.
3573  */
3574 std::string MEDFileFieldNameScope::getName() const
3575 {
3576   return _name;
3577 }
3578
3579 /*!
3580  * Sets name of \a this field
3581  *  \param [in] name - the new field name.
3582  */
3583 void MEDFileFieldNameScope::setName(const std::string& fieldName)
3584 {
3585   _name=fieldName;
3586 }
3587
3588 std::string MEDFileFieldNameScope::getDtUnit() const
3589 {
3590   return _dt_unit;
3591 }
3592
3593 void MEDFileFieldNameScope::setDtUnit(const std::string& dtUnit)
3594 {
3595   _dt_unit=dtUnit;
3596 }
3597
3598 void MEDFileFieldNameScope::copyNameScope(const MEDFileFieldNameScope& other)
3599 {
3600   _name=other._name;
3601   _dt_unit=other._dt_unit;
3602 }
3603
3604 //= MEDFileAnyTypeField1TSWithoutSDA
3605
3606 void MEDFileAnyTypeField1TSWithoutSDA::deepCpyLeavesFrom(const MEDFileAnyTypeField1TSWithoutSDA& other)
3607 {
3608   _field_per_mesh.resize(other._field_per_mesh.size());
3609   std::size_t i=0;
3610   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
3611     {
3612       if((const MEDFileFieldPerMesh *)*it)
3613         _field_per_mesh[i]=(*it)->deepCpy(this);
3614     }
3615 }
3616
3617 /*!
3618  * Prints a string describing \a this field into a stream. This string is outputted
3619  * by \c print Python command.
3620  *  \param [in] bkOffset - number of white spaces printed at the beginning of each line.
3621  *  \param [in,out] oss - the out stream.
3622  *  \param [in] f1tsId - the field index within a MED file. If \a f1tsId < 0, the tiny
3623  *          info id printed, else, not.
3624  */
3625 void MEDFileAnyTypeField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
3626 {
3627   std::string startOfLine(bkOffset,' ');
3628   oss << startOfLine << "Field ";
3629   if(bkOffset==0)
3630     oss << "[Type=" << getTypeStr() << "] with name \"" << getName() << "\" ";
3631   oss << "on one time Step ";
3632   if(f1tsId>=0)
3633     oss << "(" << f1tsId << ") ";
3634   oss << "on iteration=" << _iteration << " order=" << _order << "." << std::endl;
3635   oss << startOfLine << "Time attached is : " << _dt << " [" << _dt_unit << "]." << std::endl;
3636   const DataArray *arr=getUndergroundDataArray();
3637   if(arr)
3638     {
3639       const std::vector<std::string> &comps=arr->getInfoOnComponents();
3640       if(f1tsId<0)
3641         {
3642           oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
3643           for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
3644             oss << startOfLine << "  -  \"" << (*it) << "\"" << std::endl;
3645         }
3646       if(arr->isAllocated())
3647         {
3648           oss << startOfLine << "Whole field contains " << arr->getNumberOfTuples() << " tuples." << std::endl;
3649         }
3650       else
3651         oss << startOfLine << "The array of the current field has not allocated yet !" << std::endl;
3652     }
3653   else
3654     {
3655       oss << startOfLine << "Field infos are empty ! Not defined yet !" << std::endl;
3656     }
3657   oss << startOfLine << "----------------------" << std::endl;
3658   if(!_field_per_mesh.empty())
3659     {
3660       int i=0;
3661       for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
3662         {
3663           const MEDFileFieldPerMesh *cur=(*it2);
3664           if(cur)
3665             cur->simpleRepr(bkOffset,oss,i);
3666           else
3667             oss << startOfLine << "Field per mesh #" << i << " is not defined !" << std::endl;
3668         }
3669     }
3670   else
3671     {
3672       oss << startOfLine << "Field is not defined on any meshes !" << std::endl;
3673     }
3674   oss << startOfLine << "----------------------" << std::endl;
3675 }
3676
3677 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitComponents() const
3678 {
3679   const DataArray *arr(getUndergroundDataArray());
3680   if(!arr)
3681     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitComponents : no array defined !");
3682   int nbOfCompo=arr->getNumberOfComponents();
3683   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfCompo);
3684   for(int i=0;i<nbOfCompo;i++)
3685     {
3686       ret[i]=deepCpy();
3687       std::vector<int> v(1,i);
3688       MEDCouplingAutoRefCountObjectPtr<DataArray> arr2=arr->keepSelectedComponents(v);
3689       ret[i]->setArray(arr2);
3690     }
3691   return ret;
3692 }
3693
3694 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA(const std::string& fieldName, int csit, int iteration, int order):MEDFileFieldNameScope(fieldName),_iteration(iteration),_order(order),_csit(csit),_nb_of_tuples_to_be_allocated(-2)
3695 {
3696 }
3697
3698 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA():_iteration(-1),_order(-1),_dt(0.),_csit(-1),_nb_of_tuples_to_be_allocated(-1)
3699 {
3700 }
3701
3702 /*!
3703  * Returns the maximal dimension of supporting elements. Returns -2 if \a this is
3704  * empty. Returns -1 if this in on nodes.
3705  *  \return int - the dimension of \a this.
3706  */
3707 int MEDFileAnyTypeField1TSWithoutSDA::getDimension() const
3708 {
3709   int ret=-2;
3710   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3711     (*it)->getDimension(ret);
3712   return ret;
3713 }
3714
3715 /*!
3716  * Returns the mesh name.
3717  *  \return std::string - a string holding the mesh name.
3718  *  \throw If \c _field_per_mesh.empty()
3719  */
3720 std::string MEDFileAnyTypeField1TSWithoutSDA::getMeshName() const
3721 {
3722   if(_field_per_mesh.empty())
3723     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshName : No field set !");
3724   return _field_per_mesh[0]->getMeshName();
3725 }
3726
3727 void MEDFileAnyTypeField1TSWithoutSDA::setMeshName(const std::string& newMeshName)
3728 {
3729   std::string oldName(getMeshName());
3730   std::vector< std::pair<std::string,std::string> > v(1);
3731   v[0].first=oldName; v[0].second=newMeshName;
3732   changeMeshNames(v);
3733 }
3734
3735 bool MEDFileAnyTypeField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
3736 {
3737   bool ret=false;
3738   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3739     {
3740       MEDFileFieldPerMesh *cur(*it);
3741       if(cur)
3742         ret=cur->changeMeshNames(modifTab) || ret;
3743     }
3744   return ret;
3745 }
3746
3747 /*!
3748  * Returns the number of iteration of the state of underlying mesh.
3749  *  \return int - the iteration number.
3750  *  \throw If \c _field_per_mesh.empty()
3751  */
3752 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIteration() const
3753 {
3754   if(_field_per_mesh.empty())
3755     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshIteration : No field set !");
3756   return _field_per_mesh[0]->getMeshIteration();
3757 }
3758
3759 /*!
3760  * Returns the order number of iteration of the state of underlying mesh.
3761  *  \return int - the order number.
3762  *  \throw If \c _field_per_mesh.empty()
3763  */
3764 int MEDFileAnyTypeField1TSWithoutSDA::getMeshOrder() const
3765 {
3766   if(_field_per_mesh.empty())
3767     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshOrder : No field set !");
3768   return _field_per_mesh[0]->getMeshOrder();
3769 }
3770
3771 /*!
3772  * Checks if \a this field is tagged by a given iteration number and a given
3773  * iteration order number.
3774  *  \param [in] iteration - the iteration number of interest.
3775  *  \param [in] order - the iteration order number of interest.
3776  *  \return bool - \c true if \a this->getIteration() == \a iteration &&
3777  *          \a this->getOrder() == \a order.
3778  */
3779 bool MEDFileAnyTypeField1TSWithoutSDA::isDealingTS(int iteration, int order) const
3780 {
3781   return iteration==_iteration && order==_order;
3782 }
3783
3784 /*!
3785  * Returns number of iteration and order number of iteration when
3786  * \a this field has been calculated.
3787  *  \return std::pair<int,int> - a pair of the iteration number and the iteration
3788  *          order number.
3789  */
3790 std::pair<int,int> MEDFileAnyTypeField1TSWithoutSDA::getDtIt() const
3791 {
3792   std::pair<int,int> p;
3793   fillIteration(p);
3794   return p;
3795 }
3796
3797 /*!
3798  * Returns number of iteration and order number of iteration when
3799  * \a this field has been calculated.
3800  *  \param [in,out] p - a pair returning the iteration number and the iteration
3801  *          order number.
3802  */
3803 void MEDFileAnyTypeField1TSWithoutSDA::fillIteration(std::pair<int,int>& p) const
3804 {
3805   p.first=_iteration;
3806   p.second=_order;
3807 }
3808
3809 /*!
3810  * Returns all types of spatial discretization of \a this field.
3811  *  \param [in,out] types - a sequence of types of \a this field.
3812  */
3813 void MEDFileAnyTypeField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
3814 {
3815   std::set<TypeOfField> types2;
3816   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3817     {
3818       (*it)->fillTypesOfFieldAvailable(types2);
3819     }
3820   std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
3821   std::copy(types2.begin(),types2.end(),bi);
3822 }
3823
3824 /*!
3825  * Returns all types of spatial discretization of \a this field.
3826  *  \return std::vector<TypeOfField> - a sequence of types of spatial discretization
3827  *          of \a this field.
3828  */
3829 std::vector<TypeOfField> MEDFileAnyTypeField1TSWithoutSDA::getTypesOfFieldAvailable() const
3830 {
3831   std::vector<TypeOfField> ret;
3832   fillTypesOfFieldAvailable(ret);
3833   return ret;
3834 }
3835
3836 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsed2() const
3837 {
3838   std::vector<std::string> ret;
3839   std::set<std::string> ret2;
3840   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3841     {
3842       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
3843       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3844         if(ret2.find(*it2)==ret2.end())
3845           {
3846             ret.push_back(*it2);
3847             ret2.insert(*it2);
3848           }
3849     }
3850   return ret;
3851 }
3852
3853 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsed2() const
3854 {
3855   std::vector<std::string> ret;
3856   std::set<std::string> ret2;
3857   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3858     {
3859       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
3860       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3861         if(ret2.find(*it2)==ret2.end())
3862           {
3863             ret.push_back(*it2);
3864             ret2.insert(*it2);
3865           }
3866     }
3867   return ret;
3868 }
3869
3870 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsedMulti2() const
3871 {
3872   std::vector<std::string> ret;
3873   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3874     {
3875       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
3876       ret.insert(ret.end(),tmp.begin(),tmp.end());
3877     }
3878   return ret;
3879 }
3880
3881 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsedMulti2() const
3882 {
3883   std::vector<std::string> ret;
3884   std::set<std::string> ret2;
3885   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3886     {
3887       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
3888       ret.insert(ret.end(),tmp.begin(),tmp.end());
3889     }
3890   return ret;
3891 }
3892
3893 void MEDFileAnyTypeField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3894 {
3895   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3896     (*it)->changePflsRefsNamesGen(mapOfModif);
3897 }
3898
3899 void MEDFileAnyTypeField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3900 {
3901   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3902     (*it)->changeLocsRefsNamesGen(mapOfModif);
3903 }
3904
3905 /*!
3906  * Returns all attributes of parts of \a this field lying on a given mesh.
3907  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
3908  * item of every of returned sequences refers to the _i_-th part of \a this field.
3909  * Thus all sequences returned by this method are of the same length equal to number
3910  * of different types of supporting entities.<br>
3911  * A field part can include sub-parts with several different spatial discretizations,
3912  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
3913  * for example. Hence, some of the returned sequences contains nested sequences, and an item
3914  * of a nested sequence corresponds to a type of spatial discretization.<br>
3915  * This method allows for iteration over MEDFile DataStructure without any overhead.
3916  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3917  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3918  *          not checked if \a mname == \c NULL).
3919  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
3920  *          a field part is returned.
3921  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
3922  *          This sequence is of the same length as \a types.
3923  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
3924  *          discretization. A profile name can be empty.
3925  *          Length of this and of nested sequences is the same as that of \a typesF.
3926  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
3927  *          discretization. A localization name can be empty.
3928  *          Length of this and of nested sequences is the same as that of \a typesF.
3929  *  \return std::vector< std::vector< std::pair<int,int> > > - a sequence holding a range
3930  *          of ids of tuples within the data array, per each type of spatial
3931  *          discretization within one mesh entity type.
3932  *          Length of this and of nested sequences is the same as that of \a typesF.
3933  *  \throw If no field is lying on \a mname.
3934  */
3935 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeField1TSWithoutSDA::getFieldSplitedByType(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const
3936 {
3937   int meshId=0;
3938   if(!mname.empty())
3939     meshId=getMeshIdFromMeshName(mname);
3940   else
3941     if(_field_per_mesh.empty())
3942       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
3943   return _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3944 }
3945
3946 /*!
3947  * Returns dimensions of mesh elements \a this field lies on. The returned value is a
3948  * maximal absolute dimension and values returned via the out parameter \a levs are
3949  * dimensions relative to the maximal absolute dimension. <br>
3950  * This method is designed for MEDFileField1TS instances that have a discretization
3951  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS",
3952  * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT",
3953  * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE".
3954  * Only these 3 discretizations will be taken into account here. If \a this is
3955  * \ref ParaMEDMEM::ON_NODES "ON_NODES", -1 is returned and \a levs are empty.<br>
3956  * This method is useful to make the link between the dimension of the underlying mesh
3957  * and the levels of \a this, because it is possible that the highest dimension of \a this
3958  * field is not equal to the dimension of the underlying mesh.
3959  *
3960  * Let's consider the following case:
3961  * - mesh \a m1 has a meshDimension 3 and has non empty levels [0,-1,-2] with elements
3962  * TETRA4, HEXA8, TRI3 and SEG2.
3963  * - field \a f1 lies on \a m1 and is defined on 3D and 1D elements TETRA4 and SEG2.
3964  * - field \a f2 lies on \a m1 and is defined on 2D and 1D elements TRI3 and SEG2.
3965  *
3966  * In this case \a f1->getNonEmptyLevels() returns (3,[0,-2]) and \a
3967  * f2->getNonEmptyLevels() returns (2,[0,-1]). <br>
3968  * The returned values can be used for example to retrieve a MEDCouplingFieldDouble lying
3969  * on elements of a certain relative level by calling getFieldAtLevel(). \a meshDimRelToMax
3970  * parameter of getFieldAtLevel() is computed basing on the returned values as this:
3971  * <em> meshDimRelToMax = absDim - meshDim + relativeLev </em>.
3972  * For example<br>
3973  * to retrieve the highest level of
3974  * \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+0 ); // absDim - meshDim + relativeLev</em><br>
3975  * to retrieve the lowest level of \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+(-2) );</em><br>
3976  * to retrieve the highest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+0 );</em><br>
3977  * to retrieve the lowest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+(-1) )</em>.
3978  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3979  *          for the case with only one underlying mesh. (Actually, the number of meshes is
3980  *          not checked if \a mname == \c NULL).
3981  *  \param [in,out] levs - a sequence returning the dimensions relative to the maximal
3982  *          absolute one. They are in decreasing order. This sequence is cleared before
3983  *          filling it in.
3984  *  \return int - the maximal absolute dimension of elements \a this fields lies on.
3985  *  \throw If no field is lying on \a mname.
3986  */
3987 int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
3988 {
3989   levs.clear();
3990   int meshId=getMeshIdFromMeshName(mname);
3991   std::vector<INTERP_KERNEL::NormalizedCellType> types;
3992   std::vector< std::vector<TypeOfField> > typesF;
3993   std::vector< std::vector<std::string> > pfls, locs;
3994   _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3995   if(types.empty())
3996     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getNonEmptyLevels : 'this' is empty !");
3997   std::set<INTERP_KERNEL::NormalizedCellType> st(types.begin(),types.end());
3998   if(st.size()==1 && (*st.begin())==INTERP_KERNEL::NORM_ERROR)
3999     return -1;
4000   st.erase(INTERP_KERNEL::NORM_ERROR);
4001   std::set<int> ret1;
4002   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
4003     {
4004       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
4005       ret1.insert((int)cm.getDimension());
4006     }
4007   int ret=*std::max_element(ret1.begin(),ret1.end());
4008   std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
4009   std::transform(levs.begin(),levs.end(),levs.begin(),std::bind2nd(std::plus<int>(),-ret));
4010   return ret;
4011 }
4012
4013 /*!
4014  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
4015  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
4016  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4017  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4018  */
4019 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
4020 {
4021   int mid=getMeshIdFromMeshName(mName);
4022   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
4023 }
4024
4025 /*!
4026  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
4027  * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
4028  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4029  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4030  */
4031 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
4032 {
4033   int mid=getMeshIdFromMeshName(mName);
4034   return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
4035 }
4036
4037 /*!
4038  * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
4039  */
4040 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIdFromMeshName(const std::string& mName) const
4041 {
4042   if(_field_per_mesh.empty())
4043     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
4044   if(mName.empty())
4045     return 0;
4046   std::string mName2(mName);
4047   int ret=0;
4048   std::vector<std::string> msg;
4049   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
4050     if(mName2==(*it)->getMeshName())
4051       return ret;
4052     else
4053       msg.push_back((*it)->getMeshName());
4054   std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
4055   oss << "Possible meshes are : ";
4056   for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
4057     oss << "\"" << (*it2) << "\" ";
4058   throw INTERP_KERNEL::Exception(oss.str().c_str());
4059 }
4060
4061 int MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary(const MEDCouplingMesh *mesh)
4062 {
4063   if(!mesh)
4064     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary : input mesh is NULL !");
4065   std::string tmp(mesh->getName());
4066   if(tmp.empty())
4067     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
4068   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();
4069   int i=0;
4070   for(;it!=_field_per_mesh.end();it++,i++)
4071     {
4072       if((*it)->getMeshName()==tmp)
4073         return i;
4074     }
4075   int sz=_field_per_mesh.size();
4076   _field_per_mesh.resize(sz+1);
4077   _field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
4078   return sz;
4079 }
4080
4081 bool MEDFileAnyTypeField1TSWithoutSDA::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
4082                                                             MEDFileFieldGlobsReal& glob)
4083 {
4084   bool ret=false;
4085   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4086     {
4087       MEDFileFieldPerMesh *fpm(*it);
4088       if(fpm)
4089         ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
4090     }
4091   return ret;
4092 }
4093
4094 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations() const
4095 {
4096   std::vector<INTERP_KERNEL::NormalizedCellType> types;
4097   std::vector< std::vector<TypeOfField> > typesF;
4098   std::vector< std::vector<std::string> > pfls,locs;
4099   std::vector< std::vector<std::pair<int,int> > > bgEnd=getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs);
4100   std::set<TypeOfField> allEnt;
4101   for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++)
4102     for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4103       allEnt.insert(*it2);
4104   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(allEnt.size());
4105   std::set<TypeOfField>::const_iterator it3(allEnt.begin());
4106   for(std::size_t i=0;i<allEnt.size();i++,it3++)
4107     {
4108       std::vector< std::pair<int,int> > its;
4109       ret[i]=shallowCpy();
4110       int newLgth=ret[i]->keepOnlySpatialDiscretization(*it3,its);
4111       ret[i]->updateData(newLgth,its);
4112     }
4113   return ret;
4114 }
4115
4116 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlySpatialDiscretization(TypeOfField tof, std::vector< std::pair<int,int> >& its)
4117 {
4118   int globalCounter=0;
4119   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4120     (*it)->keepOnlySpatialDiscretization(tof,globalCounter,its);
4121   return globalCounter;
4122 }
4123
4124 void MEDFileAnyTypeField1TSWithoutSDA::updateData(int newLgth, const std::vector< std::pair<int,int> >& oldStartStops)
4125 {
4126   if(_nb_of_tuples_to_be_allocated>=0)
4127     {
4128       _nb_of_tuples_to_be_allocated=newLgth;
4129       const DataArray *oldArr(getUndergroundDataArray());
4130       if(oldArr)
4131         {
4132           MEDCouplingAutoRefCountObjectPtr<DataArray> newArr(createNewEmptyDataArrayInstance());
4133           newArr->setInfoAndChangeNbOfCompo(oldArr->getInfoOnComponents());
4134           setArray(newArr);
4135           _nb_of_tuples_to_be_allocated=newLgth;//force the _nb_of_tuples_to_be_allocated because setArray has been used specialy
4136         }
4137       return ;
4138     }
4139   if(_nb_of_tuples_to_be_allocated==-1)
4140     return ;
4141   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4142     {
4143       const DataArray *oldArr(getUndergroundDataArray());
4144       if(!oldArr || !oldArr->isAllocated())
4145         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 1 !");
4146       MEDCouplingAutoRefCountObjectPtr<DataArray> newArr(createNewEmptyDataArrayInstance());
4147       newArr->alloc(newLgth,getNumberOfComponents());
4148       if(oldArr)
4149         newArr->copyStringInfoFrom(*oldArr);
4150       int pos=0;
4151       for(std::vector< std::pair<int,int> >::const_iterator it=oldStartStops.begin();it!=oldStartStops.end();it++)
4152         {
4153           if((*it).second<(*it).first)
4154             throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : the range in the leaves was invalid !");
4155           newArr->setContigPartOfSelectedValues2(pos,oldArr,(*it).first,(*it).second,1);
4156           pos+=(*it).second-(*it).first;
4157         }
4158       setArray(newArr);
4159       return ;
4160     }
4161   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 2 !");
4162 }
4163
4164 void MEDFileAnyTypeField1TSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts, const MEDFileFieldNameScope& nasc) const
4165 {
4166   if(_field_per_mesh.empty())
4167     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : empty field !");
4168   if(_field_per_mesh.size()>1)
4169     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : In MED3.0 mode in writting mode only ONE underlying mesh supported !");
4170   _field_per_mesh[0]->copyOptionsFrom(opts);
4171   _field_per_mesh[0]->writeLL(fid,nasc);
4172 }
4173
4174 /*!
4175  * 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.
4176  * If false is returned the memory allocation is not required.
4177  */
4178 bool MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile()
4179 {
4180   if(_nb_of_tuples_to_be_allocated>=0)
4181     {
4182       getOrCreateAndGetArray()->alloc(_nb_of_tuples_to_be_allocated,getNumberOfComponents());
4183       _nb_of_tuples_to_be_allocated=-2;
4184       return true;
4185     }
4186   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4187     return false;
4188   if(_nb_of_tuples_to_be_allocated==-1)
4189     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : trying to read from a file an empty instance ! Need to prepare the structure before !");
4190   if(_nb_of_tuples_to_be_allocated<-3)
4191     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4192   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4193 }
4194
4195 void MEDFileAnyTypeField1TSWithoutSDA::loadOnlyStructureOfDataRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4196 {
4197   med_int numdt,numit;
4198   med_float dt;
4199   med_int nmesh;
4200   med_bool localMesh;
4201   med_int meshnumdt,meshnumit;
4202   INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
4203   MEDfieldComputingStepInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&_dt);
4204   MEDfield23ComputingStepMeshInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&dt,&nmesh,meshName,&localMesh,&meshnumdt,&meshnumit);
4205   if(_iteration!=numdt || _order!=numit)
4206     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively : unexpected exception internal error !");
4207   _field_per_mesh.resize(nmesh);
4208   for(int i=0;i<nmesh;i++)
4209     _field_per_mesh[i]=MEDFileFieldPerMesh::NewOnRead(fid,this,i+1,meshnumdt,meshnumit,nasc);//tony
4210   _nb_of_tuples_to_be_allocated=0;
4211   for(int i=0;i<nmesh;i++)
4212     _field_per_mesh[i]->loadOnlyStructureOfDataRecursively(fid,_nb_of_tuples_to_be_allocated,nasc);
4213 }
4214
4215 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4216 {
4217   allocIfNecessaryTheArrayToReceiveDataFromFile();
4218   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4219     (*it)->loadBigArraysRecursively(fid,nasc);
4220 }
4221
4222 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
4223 {
4224   if(allocIfNecessaryTheArrayToReceiveDataFromFile())
4225     for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4226       (*it)->loadBigArraysRecursively(fid,nasc);
4227 }
4228
4229 void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4230 {
4231   loadOnlyStructureOfDataRecursively(fid,nasc);
4232   loadBigArraysRecursively(fid,nasc);
4233 }
4234
4235 void MEDFileAnyTypeField1TSWithoutSDA::unloadArrays()
4236 {
4237   DataArray *thisArr(getUndergroundDataArray());
4238   if(thisArr && thisArr->isAllocated())
4239     {
4240       _nb_of_tuples_to_be_allocated=thisArr->getNumberOfTuples();
4241       thisArr->desallocate();
4242     }
4243 }
4244
4245 std::size_t MEDFileAnyTypeField1TSWithoutSDA::getHeapMemorySizeWithoutChildren() const
4246 {
4247   return _dt_unit.capacity()+_field_per_mesh.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh >);
4248 }
4249
4250 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TSWithoutSDA::getDirectChildren() const
4251 {
4252   std::vector<const BigMemoryObject *> ret;
4253   if(getUndergroundDataArray())
4254     ret.push_back(getUndergroundDataArray());
4255   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4256     {
4257       const MEDFileFieldPerMesh *cur(*it);
4258       if(cur)
4259         ret.push_back(cur);
4260     }
4261   return ret;
4262 }
4263
4264 /*!
4265  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
4266  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
4267  * "Sort By Type"), if not, an exception is thrown.
4268  *  \param [in] field - the field to add to \a this. The array of field \a field is ignored
4269  *  \param [in] arr - the array of values.
4270  *  \param [in,out] glob - the global data where profiles and localization present in
4271  *          \a field, if any, are added.
4272  *  \throw If the name of \a field is empty.
4273  *  \throw If the data array of \a field is not set.
4274  *  \throw If \a this->_arr is already allocated but has different number of components
4275  *         than \a field.
4276  *  \throw If the underlying mesh of \a field has no name.
4277  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
4278  */
4279 void MEDFileAnyTypeField1TSWithoutSDA::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
4280 {
4281   const MEDCouplingMesh *mesh=field->getMesh();
4282   //
4283   TypeOfField type=field->getTypeOfField();
4284   std::vector<DataArrayInt *> dummy;
4285   int start=copyTinyInfoFrom(field,arr);
4286   int pos=addNewEntryIfNecessary(mesh);
4287   if(type!=ON_NODES)
4288     {
4289       std::vector<int> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
4290       _field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,arr,glob,nasc);
4291     }
4292   else
4293     _field_per_mesh[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
4294 }
4295
4296 /*!
4297  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
4298  * of a given mesh are used as the support of the given field (a real support is not used).
4299  * Elements of the given mesh must be sorted suitable for writing to MED file.
4300  * Order of underlying mesh entities of the given field specified by \a profile parameter
4301  * is not prescribed; this method permutes field values to have them sorted by element
4302  * type as required for writing to MED file. A new profile is added only if no equal
4303  * profile is missing.
4304  *  \param [in] field - the field to add to \a this. The field double values are ignored.
4305  *  \param [in] arrOfVals - the values of the field \a field used.
4306  *  \param [in] mesh - the supporting mesh of \a field.
4307  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
4308  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
4309  *  \param [in,out] glob - the global data where profiles and localization present in
4310  *          \a field, if any, are added.
4311  *  \throw If either \a field or \a mesh or \a profile has an empty name.
4312  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4313  *  \throw If the data array of \a field is not set.
4314  *  \throw If \a this->_arr is already allocated but has different number of components
4315  *         than \a field.
4316  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4317  *  \sa setFieldNoProfileSBT()
4318  */
4319 void MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
4320 {
4321   if(!field)
4322     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input field is null !");
4323   if(!arrOfVals || !arrOfVals->isAllocated())
4324     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input array is null or not allocated !");
4325   TypeOfField type=field->getTypeOfField();
4326   std::vector<DataArrayInt *> idsInPflPerType;
4327   std::vector<DataArrayInt *> idsPerType;
4328   std::vector<int> code,code2;
4329   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4330   if(type!=ON_NODES)
4331     {
4332       m->splitProfilePerType(profile,code,idsInPflPerType,idsPerType);
4333       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsInPflPerType2(idsInPflPerType.size()); std::copy(idsInPflPerType.begin(),idsInPflPerType.end(),idsInPflPerType2.begin());
4334       std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsPerType2(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType2.begin());
4335       std::vector<const DataArrayInt *> idsPerType3(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType3.begin());
4336       // start of check
4337       MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field2=field->clone(false);
4338       int nbOfTuplesExp=field2->getNumberOfTuplesExpectedRegardingCode(code,idsPerType3);
4339       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4340         {
4341           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : The array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4342           throw INTERP_KERNEL::Exception(oss.str().c_str());
4343         }
4344       // end of check
4345       int start=copyTinyInfoFrom(field,arrOfVals);
4346       code2=m->getDistributionOfTypes();
4347       //
4348       int pos=addNewEntryIfNecessary(m);
4349       _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
4350     }
4351   else
4352     {
4353       if(!profile || !profile->isAllocated() || profile->getNumberOfComponents()!=1)
4354         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input profile is null, not allocated or with number of components != 1 !");
4355       std::vector<int> v(3); v[0]=-1; v[1]=profile->getNumberOfTuples(); v[2]=0;
4356       std::vector<const DataArrayInt *> idsPerType3(1); idsPerType3[0]=profile;
4357       int nbOfTuplesExp=field->getNumberOfTuplesExpectedRegardingCode(v,idsPerType3);
4358       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4359         {
4360           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : For node field, the array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4361           throw INTERP_KERNEL::Exception(oss.str().c_str());
4362         }
4363       int start=copyTinyInfoFrom(field,arrOfVals);
4364       int pos=addNewEntryIfNecessary(m);
4365       _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
4366     }
4367 }
4368
4369 /*!
4370  * \param [in] newNbOfTuples - The new nb of tuples to be allocated.
4371  */
4372 void MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile(int newNbOfTuples)
4373 {
4374   if(_nb_of_tuples_to_be_allocated>=0)
4375     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 !");
4376   DataArray *arr(getOrCreateAndGetArray());
4377   arr->alloc(newNbOfTuples,arr->getNumberOfComponents());
4378   _nb_of_tuples_to_be_allocated=-3;
4379 }
4380
4381 /*!
4382  * Copies tiny info and allocates \a this->_arr instance of DataArrayDouble to
4383  * append data of a given MEDCouplingFieldDouble. So that the size of \a this->_arr becomes
4384  * larger by the size of \a field. Returns an id of the first not filled
4385  * tuple of \a this->_arr.
4386  *  \param [in] field - the field to copy the info on components and the name from.
4387  *  \return int - the id of first not initialized tuple of \a this->_arr.
4388  *  \throw If the name of \a field is empty.
4389  *  \throw If the data array of \a field is not set.
4390  *  \throw If \a this->_arr is already allocated but has different number of components
4391  *         than \a field.
4392  */
4393 int MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
4394 {
4395   if(!field)
4396     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
4397   std::string name(field->getName());
4398   setName(name.c_str());
4399   setDtUnit(field->getTimeUnit());
4400   if(name.empty())
4401     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
4402   if(!arr)
4403     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
4404   if(!arr->isAllocated())
4405     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : array is not allocated !");
4406   _dt=field->getTime(_iteration,_order);
4407   getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
4408   if(!getOrCreateAndGetArray()->isAllocated())
4409     {
4410       allocNotFromFile(arr->getNumberOfTuples());
4411       return 0;
4412     }
4413   else
4414     {
4415       int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
4416       int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
4417       getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
4418       _nb_of_tuples_to_be_allocated=-3;
4419       return oldNbOfTuples;
4420     }
4421 }
4422
4423 /*!
4424  * Returns number of components in \a this field
4425  *  \return int - the number of components.
4426  */
4427 int MEDFileAnyTypeField1TSWithoutSDA::getNumberOfComponents() const
4428 {
4429   return getOrCreateAndGetArray()->getNumberOfComponents();
4430 }
4431
4432 /*!
4433  * Change info on components in \a this.
4434  * \throw If size of \a infos is not equal to the number of components already in \a this.
4435  */
4436 void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos)
4437 {
4438   DataArray *arr=getOrCreateAndGetArray();
4439   arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
4440 }
4441
4442 /*!
4443  * Returns info on components of \a this field.
4444  *  \return const std::vector<std::string>& - a sequence of strings each being an
4445  *          information on _i_-th component.
4446  */
4447 const std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo() const
4448 {
4449   const DataArray *arr=getOrCreateAndGetArray();
4450   return arr->getInfoOnComponents();
4451 }
4452
4453 /*!
4454  * Returns a mutable info on components of \a this field.
4455  *  \return std::vector<std::string>& - a sequence of strings each being an
4456  *          information on _i_-th component.
4457  */
4458 std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo()
4459 {
4460   DataArray *arr=getOrCreateAndGetArray();
4461   return arr->getInfoOnComponents();
4462 }
4463
4464 /*!
4465  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4466  *  \param [in] type - a spatial discretization of the new field.
4467  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4468  *  \param [in] mName - a name of the supporting mesh.
4469  *  \param [in] renumPol - specifies how to permute values of the result field according to
4470  *          the optional numbers of cells and nodes, if any. The valid values are
4471  *          - 0 - do not permute.
4472  *          - 1 - permute cells.
4473  *          - 2 - permute nodes.
4474  *          - 3 - permute cells and nodes.
4475  *
4476  *  \param [in] glob - the global data storing profiles and localization.
4477  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4478  *          caller is to delete this field using decrRef() as it is no more needed.
4479  *  \throw If the MED file is not readable.
4480  *  \throw If there is no mesh named \a mName in the MED file.
4481  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4482  *  \throw If no field of \a this is lying on the mesh \a mName.
4483  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4484  */
4485 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, const std::string& mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4486 {
4487   MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4488   if(mName.empty())
4489     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4490   else
4491     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4492   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4493 }
4494
4495 /*!
4496  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4497  *  \param [in] type - a spatial discretization of the new field.
4498  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4499  *  \param [in] renumPol - specifies how to permute values of the result field according to
4500  *          the optional numbers of cells and nodes, if any. The valid values are
4501  *          - 0 - do not permute.
4502  *          - 1 - permute cells.
4503  *          - 2 - permute nodes.
4504  *          - 3 - permute cells and nodes.
4505  *
4506  *  \param [in] glob - the global data storing profiles and localization.
4507  *  \param [in] mesh - the supporting mesh.
4508  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4509  *          caller is to delete this field using decrRef() as it is no more needed.
4510  *  \throw If the MED file is not readable.
4511  *  \throw If no field of \a this is lying on \a mesh.
4512  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4513  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4514  */
4515 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4516 {
4517   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax,false);
4518   const DataArrayInt *d=mesh->getNumberFieldAtLevel(meshDimRelToMax);
4519   const DataArrayInt *e=mesh->getNumberFieldAtLevel(1);
4520   if(meshDimRelToMax==1)
4521     (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
4522   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e,arrOut,nasc);
4523 }
4524
4525 /*!
4526  * Returns a new MEDCouplingFieldDouble of a given type lying on the top level cells of a
4527  * given mesh.
4528  *  \param [in] type - a spatial discretization of the new field.
4529  *  \param [in] mName - a name of the supporting mesh.
4530  *  \param [in] renumPol - specifies how to permute values of the result field according to
4531  *          the optional numbers of cells and nodes, if any. The valid values are
4532  *          - 0 - do not permute.
4533  *          - 1 - permute cells.
4534  *          - 2 - permute nodes.
4535  *          - 3 - permute cells and nodes.
4536  *
4537  *  \param [in] glob - the global data storing profiles and localization.
4538  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4539  *          caller is to delete this field using decrRef() as it is no more needed.
4540  *  \throw If the MED file is not readable.
4541  *  \throw If there is no mesh named \a mName in the MED file.
4542  *  \throw If there are no mesh entities in the mesh.
4543  *  \throw If no field values of the given \a type are available.
4544  */
4545 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const std::string& mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4546 {
4547   MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4548   if(mName.empty())
4549     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4550   else
4551     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4552   int absDim=getDimension();
4553   int meshDimRelToMax=absDim-mm->getMeshDimension();
4554   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4555 }
4556
4557 /*!
4558  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4559  *  \param [in] type - a spatial discretization of the new field.
4560  *  \param [in] renumPol - specifies how to permute values of the result field according to
4561  *          the optional numbers of cells and nodes, if any. The valid values are
4562  *          - 0 - do not permute.
4563  *          - 1 - permute cells.
4564  *          - 2 - permute nodes.
4565  *          - 3 - permute cells and nodes.
4566  *
4567  *  \param [in] glob - the global data storing profiles and localization.
4568  *  \param [in] mesh - the supporting mesh.
4569  *  \param [in] cellRenum - the cell numbers array used for permutation of the result
4570  *         field according to \a renumPol.
4571  *  \param [in] nodeRenum - the node numbers array used for permutation of the result
4572  *         field according to \a renumPol.
4573  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4574  *          caller is to delete this field using decrRef() as it is no more needed.
4575  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4576  *  \throw If no field of \a this is lying on \a mesh.
4577  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4578  */
4579 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
4580 {
4581   static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
4582   int meshId=getMeshIdFromMeshName(mesh->getName());
4583   bool isPfl=false;
4584   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl,arrOut,nasc);
4585   switch(renumPol)
4586     {
4587     case 0:
4588       {
4589         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4590         return ret.retn();
4591       }
4592     case 3:
4593     case 1:
4594       {
4595         if(isPfl)
4596           throw INTERP_KERNEL::Exception(msg1);
4597         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4598         if(cellRenum)
4599           {
4600             if((int)cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
4601               {
4602                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4603                 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
4604                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4605               }
4606             MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
4607             if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
4608             std::vector<DataArray *> arrOut2(1,arrOut);
4609             // 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
4610             disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
4611             (const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
4612           }
4613         if(renumPol==1)
4614           return ret.retn();
4615       }
4616     case 2:
4617       {
4618         //no need to test _field_per_mesh.empty() because geMeshName has already done it
4619         if(isPfl)
4620           throw INTERP_KERNEL::Exception(msg1);
4621         if(nodeRenum)
4622           {
4623             if((int)nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
4624               {
4625                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4626                 oss << "\"" << nasc.getName() << "\" not defined on all nodes !";
4627                 throw INTERP_KERNEL::Exception(oss.str().c_str());
4628               }
4629             MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
4630             if(!dynamic_cast<DataArrayDouble *>((DataArray *)arrOut))
4631               throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : node renumbering not implemented for not double DataArrays !");
4632             ret->renumberNodes(nodeRenumSafe->getConstPointer());
4633           }
4634         return ret.retn();
4635       }
4636     default:
4637       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
4638     }
4639 }
4640
4641 /*!
4642  * Returns values and a profile of the field of a given type lying on a given support.
4643  *  \param [in] type - a spatial discretization of the field.
4644  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4645  *  \param [in] mesh - the supporting mesh.
4646  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
4647  *          field of interest lies on. If the field lies on all entities of the given
4648  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
4649  *          using decrRef() as it is no more needed.
4650  *  \param [in] glob - the global data storing profiles and localization.
4651  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
4652  *          field. The caller is to delete this array using decrRef() as it is no more needed.
4653  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4654  *  \throw If no field of \a this is lying on \a mesh.
4655  *  \throw If no field values of the given \a type are available.
4656  */
4657 DataArray *MEDFileAnyTypeField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
4658 {
4659   MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4660   int meshId=getMeshIdFromMeshName(mesh->getName().c_str());
4661   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob,nasc);
4662   ret->setName(nasc.getName().c_str());
4663   return ret.retn();
4664 }
4665
4666 //= MEDFileField1TSWithoutSDA
4667
4668 /*!
4669  * Throws if a given value is not a valid (non-extended) relative dimension.
4670  *  \param [in] meshDimRelToMax - the relative dimension value.
4671  *  \throw If \a meshDimRelToMax > 0.
4672  */
4673 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax)
4674 {
4675   if(meshDimRelToMax>0)
4676     throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
4677 }
4678
4679 /*!
4680  * Checks if elements of a given mesh are in the order suitable for writing
4681  * to the MED file. If this is not so, an exception is thrown. In a case of success, returns a
4682  * vector describing types of elements and their number.
4683  *  \param [in] mesh - the mesh to check.
4684  *  \return std::vector<int> - a vector holding for each element type (1) item of
4685  *          INTERP_KERNEL::NormalizedCellType, (2) number of elements, (3) -1.
4686  *          These values are in full-interlace mode.
4687  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4688  */
4689 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh)
4690 {
4691   if(!mesh)
4692     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
4693   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
4694   int nbOfTypes=geoTypes.size();
4695   std::vector<int> code(3*nbOfTypes);
4696   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr1=DataArrayInt::New();
4697   arr1->alloc(nbOfTypes,1);
4698   int *arrPtr=arr1->getPointer();
4699   std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
4700   for(int i=0;i<nbOfTypes;i++,it++)
4701     arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
4702   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
4703   const int *arrPtr2=arr2->getConstPointer();
4704   int i=0;
4705   for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
4706     {
4707       int pos=arrPtr2[i];
4708       int nbCells=mesh->getNumberOfCellsWithType(*it);
4709       code[3*pos]=(int)(*it);
4710       code[3*pos+1]=nbCells;
4711       code[3*pos+2]=-1;//no profiles
4712     }
4713   std::vector<const DataArrayInt *> idsPerType;//no profiles
4714   DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
4715   if(da)
4716     {
4717       da->decrRef();
4718       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
4719     }
4720   return code;
4721 }
4722
4723 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const std::string& fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos)
4724 {
4725   return new MEDFileField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4726 }
4727
4728 /*!
4729  * Returns all attributes and values of parts of \a this field lying on a given mesh.
4730  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
4731  * item of every of returned sequences refers to the _i_-th part of \a this field.
4732  * Thus all sequences returned by this method are of the same length equal to number
4733  * of different types of supporting entities.<br>
4734  * A field part can include sub-parts with several different spatial discretizations,
4735  * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
4736  * for example. Hence, some of the returned sequences contains nested sequences, and an item
4737  * of a nested sequence corresponds to a type of spatial discretization.<br>
4738  * This method allows for iteration over MEDFile DataStructure with a reduced overhead.
4739  * The overhead is due to selecting values into new instances of DataArrayDouble.
4740  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4741  *          for the case with only one underlying mesh. (Actually, the number of meshes is
4742  *          not checked if \a mname == \c NULL).
4743  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
4744  *          a field part is returned.
4745  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
4746  *          A field part can include sub-parts with several different spatial discretizations,
4747  *          \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and
4748  *          \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT" for example.
4749  *          This sequence is of the same length as \a types.
4750  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
4751  *          discretization. A profile name can be empty.
4752  *          Length of this and of nested sequences is the same as that of \a typesF.
4753  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
4754  *          discretization. A localization name can be empty.
4755  *          Length of this and of nested sequences is the same as that of \a typesF.
4756  *  \return std::vector< std::vector<DataArrayDouble *> > - a sequence holding arrays of values
4757  *          per each type of spatial discretization within one mesh entity type.
4758  *          The caller is to delete each DataArrayDouble using decrRef() as it is no more needed.
4759  *          Length of this and of nested sequences is the same as that of \a typesF.
4760  *  \throw If no field is lying on \a mname.
4761  */
4762 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TSWithoutSDA::getFieldSplitedByType2(const std::string& 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
4763 {
4764   int meshId=0;
4765   if(!mname.empty())
4766     meshId=getMeshIdFromMeshName(mname);
4767   else
4768     if(_field_per_mesh.empty())
4769       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
4770   std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
4771   int nbOfRet=ret0.size();
4772   std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
4773   for(int i=0;i<nbOfRet;i++)
4774     {
4775       const std::vector< std::pair<int,int> >& p=ret0[i];
4776       int nbOfRet1=p.size();
4777       ret[i].resize(nbOfRet1);
4778       for(int j=0;j<nbOfRet1;j++)
4779         {
4780           DataArrayDouble *tmp=_arr->selectByTupleId2(p[j].first,p[j].second,1);
4781           ret[i][j]=tmp;
4782         }
4783     }
4784   return ret;
4785 }
4786
4787 /*!
4788  * Returns a pointer to the underground DataArrayDouble instance. So the
4789  * caller should not decrRef() it. This method allows for a direct access to the field
4790  * values. This method is quite unusable if there is more than a nodal field or a cell
4791  * field on single geometric cell type.
4792  *  \return DataArrayDouble * - the pointer to the field values array.
4793  */
4794 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDouble() const
4795 {
4796   const DataArrayDouble *ret=_arr;
4797   if(ret)
4798     return const_cast<DataArrayDouble *>(ret);
4799   else
4800     return 0;
4801 }
4802
4803 const char *MEDFileField1TSWithoutSDA::getTypeStr() const
4804 {
4805   return TYPE_STR;
4806 }
4807
4808 MEDFileIntField1TSWithoutSDA *MEDFileField1TSWithoutSDA::convertToInt() const
4809 {
4810   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA);
4811   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4812   ret->deepCpyLeavesFrom(*this);
4813   const DataArrayDouble *arr(_arr);
4814   if(arr)
4815     {
4816       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr->convertToIntArr());
4817       ret->setArray(arr2);
4818     }
4819   return ret.retn();
4820 }
4821
4822 /*!
4823  * Returns a pointer to the underground DataArrayDouble instance. So the
4824  * caller should not decrRef() it. This method allows for a direct access to the field
4825  * values. This method is quite unusable if there is more than a nodal field or a cell
4826  * field on single geometric cell type.
4827  *  \return DataArrayDouble * - the pointer to the field values array.
4828  */
4829 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArray() const
4830 {
4831   return getUndergroundDataArrayDouble();
4832 }
4833
4834 /*!
4835  * Returns a pointer to the underground DataArrayDouble instance and a
4836  * sequence describing parameters of a support of each part of \a this field. The
4837  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4838  * direct access to the field values. This method is intended for the field lying on one
4839  * mesh only.
4840  *  \param [in,out] entries - the sequence describing parameters of a support of each
4841  *         part of \a this field. Each item of this sequence consists of two parts. The
4842  *         first part describes a type of mesh entity and an id of discretization of a
4843  *         current field part. The second part describes a range of values [begin,end)
4844  *         within the returned array relating to the current field part.
4845  *  \return DataArrayDouble * - the pointer to the field values array.
4846  *  \throw If the number of underlying meshes is not equal to 1.
4847  *  \throw If no field values are available.
4848  *  \sa getUndergroundDataArray()
4849  */
4850 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDoubleExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
4851 {
4852   if(_field_per_mesh.size()!=1)
4853     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
4854   if(_field_per_mesh[0]==0)
4855     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
4856   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
4857   return getUndergroundDataArrayDouble();
4858 }
4859
4860 /*!
4861  * Returns a pointer to the underground DataArrayDouble instance and a
4862  * sequence describing parameters of a support of each part of \a this field. The
4863  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4864  * direct access to the field values. This method is intended for the field lying on one
4865  * mesh only.
4866  *  \param [in,out] entries - the sequence describing parameters of a support of each
4867  *         part of \a this field. Each item of this sequence consists of two parts. The
4868  *         first part describes a type of mesh entity and an id of discretization of a
4869  *         current field part. The second part describes a range of values [begin,end)
4870  *         within the returned array relating to the current field part.
4871  *  \return DataArrayDouble * - the pointer to the field values array.
4872  *  \throw If the number of underlying meshes is not equal to 1.
4873  *  \throw If no field values are available.
4874  *  \sa getUndergroundDataArray()
4875  */
4876 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
4877 {
4878   return getUndergroundDataArrayDoubleExt(entries);
4879 }
4880
4881 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const std::string& fieldName, int csit, int iteration, int order,
4882                                                      const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4883 {
4884   DataArrayDouble *arr=getOrCreateAndGetArrayDouble();
4885   arr->setInfoAndChangeNbOfCompo(infos);
4886 }
4887
4888 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4889 {
4890 }
4891
4892 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::shallowCpy() const
4893 {
4894   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA(*this));
4895   ret->deepCpyLeavesFrom(*this);
4896   return ret.retn();
4897 }
4898
4899 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCpy() const
4900 {
4901   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret=static_cast<MEDFileField1TSWithoutSDA *>(shallowCpy());
4902   if((const DataArrayDouble *)_arr)
4903     ret->_arr=_arr->deepCpy();
4904   return ret.retn();
4905 }
4906
4907 void MEDFileField1TSWithoutSDA::setArray(DataArray *arr)
4908 {
4909   if(!arr)
4910     {
4911       _nb_of_tuples_to_be_allocated=-1;
4912       _arr=0;
4913       return ;
4914     }
4915   DataArrayDouble *arrC=dynamic_cast<DataArrayDouble *>(arr);
4916   if(!arrC)
4917     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayDouble !");
4918   else
4919     _nb_of_tuples_to_be_allocated=-3;
4920   arrC->incrRef();
4921   _arr=arrC;
4922 }
4923
4924 DataArray *MEDFileField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
4925 {
4926   return DataArrayDouble::New();
4927 }
4928
4929 DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble()
4930 {
4931   DataArrayDouble *ret=_arr;
4932   if(ret)
4933     return ret;
4934   _arr=DataArrayDouble::New();
4935   return _arr;
4936 }
4937
4938 DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray()
4939 {
4940   return getOrCreateAndGetArrayDouble();
4941 }
4942
4943 const DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble() const
4944 {
4945   const DataArrayDouble *ret=_arr;
4946   if(ret)
4947     return ret;
4948   DataArrayDouble *ret2=DataArrayDouble::New();
4949   const_cast<MEDFileField1TSWithoutSDA *>(this)->_arr=DataArrayDouble::New();
4950   return ret2;
4951 }
4952
4953 const DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray() const
4954 {
4955   return getOrCreateAndGetArrayDouble();
4956 }
4957
4958 //= MEDFileIntField1TSWithoutSDA
4959
4960 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::New(const std::string& fieldName, int csit, int iteration, int order,
4961                                                                 const std::vector<std::string>& infos)
4962 {
4963   return new MEDFileIntField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4964 }
4965
4966 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4967 {
4968 }
4969
4970 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA(const std::string& fieldName, int csit, int iteration, int order,
4971                                                            const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4972 {
4973   DataArrayInt *arr=getOrCreateAndGetArrayInt();
4974   arr->setInfoAndChangeNbOfCompo(infos);
4975 }
4976
4977 const char *MEDFileIntField1TSWithoutSDA::getTypeStr() const
4978 {
4979   return TYPE_STR;
4980 }
4981
4982 MEDFileField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::convertToDouble() const
4983 {
4984   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
4985   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4986   ret->deepCpyLeavesFrom(*this);
4987   const DataArrayInt *arr(_arr);
4988   if(arr)
4989     {
4990       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2(arr->convertToDblArr());
4991       ret->setArray(arr2);
4992     }
4993   return ret.retn();
4994 }
4995
4996 /*!
4997  * Returns a pointer to the underground DataArrayInt instance. So the
4998  * caller should not decrRef() it. This method allows for a direct access to the field
4999  * values. This method is quite unusable if there is more than a nodal field or a cell
5000  * field on single geometric cell type.
5001  *  \return DataArrayInt * - the pointer to the field values array.
5002  */
5003 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArray() const
5004 {
5005   return getUndergroundDataArrayInt();
5006 }
5007
5008 /*!
5009  * Returns a pointer to the underground DataArrayInt instance. So the
5010  * caller should not decrRef() it. This method allows for a direct access to the field
5011  * values. This method is quite unusable if there is more than a nodal field or a cell
5012  * field on single geometric cell type.
5013  *  \return DataArrayInt * - the pointer to the field values array.
5014  */
5015 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayInt() const
5016 {
5017   const DataArrayInt *ret=_arr;
5018   if(ret)
5019     return const_cast<DataArrayInt *>(ret);
5020   else
5021     return 0;
5022 }
5023
5024 /*!
5025  * Returns a pointer to the underground DataArrayInt instance and a
5026  * sequence describing parameters of a support of each part of \a this field. The
5027  * caller should not decrRef() the returned DataArrayInt. This method allows for a
5028  * direct access to the field values. This method is intended for the field lying on one
5029  * mesh only.
5030  *  \param [in,out] entries - the sequence describing parameters of a support of each
5031  *         part of \a this field. Each item of this sequence consists of two parts. The
5032  *         first part describes a type of mesh entity and an id of discretization of a
5033  *         current field part. The second part describes a range of values [begin,end)
5034  *         within the returned array relating to the current field part.
5035  *  \return DataArrayInt * - the pointer to the field values array.
5036  *  \throw If the number of underlying meshes is not equal to 1.
5037  *  \throw If no field values are available.
5038  *  \sa getUndergroundDataArray()
5039  */
5040 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5041 {
5042   return getUndergroundDataArrayIntExt(entries);
5043 }
5044
5045 /*!
5046  * Returns a pointer to the underground DataArrayInt instance and a
5047  * sequence describing parameters of a support of each part of \a this field. The
5048  * caller should not decrRef() the returned DataArrayInt. This method allows for a
5049  * direct access to the field values. This method is intended for the field lying on one
5050  * mesh only.
5051  *  \param [in,out] entries - the sequence describing parameters of a support of each
5052  *         part of \a this field. Each item of this sequence consists of two parts. The
5053  *         first part describes a type of mesh entity and an id of discretization of a
5054  *         current field part. The second part describes a range of values [begin,end)
5055  *         within the returned array relating to the current field part.
5056  *  \return DataArrayInt * - the pointer to the field values array.
5057  *  \throw If the number of underlying meshes is not equal to 1.
5058  *  \throw If no field values are available.
5059  *  \sa getUndergroundDataArray()
5060  */
5061 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5062 {
5063   if(_field_per_mesh.size()!=1)
5064     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
5065   if(_field_per_mesh[0]==0)
5066     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
5067   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
5068   return getUndergroundDataArrayInt();
5069 }
5070
5071 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::shallowCpy() const
5072 {
5073   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA(*this));
5074   ret->deepCpyLeavesFrom(*this);
5075   return ret.retn();
5076 }
5077
5078 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::deepCpy() const
5079 {
5080   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret=static_cast<MEDFileIntField1TSWithoutSDA *>(shallowCpy());
5081   if((const DataArrayInt *)_arr)
5082     ret->_arr=_arr->deepCpy();
5083   return ret.retn();
5084 }
5085
5086 void MEDFileIntField1TSWithoutSDA::setArray(DataArray *arr)
5087 {
5088   if(!arr)
5089     {
5090       _nb_of_tuples_to_be_allocated=-1;
5091       _arr=0;
5092       return ;
5093     }
5094   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>(arr);
5095   if(!arrC)
5096     throw INTERP_KERNEL::Exception("MEDFileIntField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayInt !");
5097   else
5098     _nb_of_tuples_to_be_allocated=-3;
5099   arrC->incrRef();
5100   _arr=arrC;
5101 }
5102
5103 DataArray *MEDFileIntField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
5104 {
5105   return DataArrayInt::New();
5106 }
5107
5108 DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt()
5109 {
5110   DataArrayInt *ret=_arr;
5111   if(ret)
5112     return ret;
5113   _arr=DataArrayInt::New();
5114   return _arr;
5115 }
5116
5117 DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray()
5118 {
5119   return getOrCreateAndGetArrayInt();
5120 }
5121
5122 const DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt() const
5123 {
5124   const DataArrayInt *ret=_arr;
5125   if(ret)
5126     return ret;
5127   DataArrayInt *ret2=DataArrayInt::New();
5128   const_cast<MEDFileIntField1TSWithoutSDA *>(this)->_arr=DataArrayInt::New();
5129   return ret2;
5130 }
5131
5132 const DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray() const
5133 {
5134   return getOrCreateAndGetArrayInt();
5135 }
5136
5137 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
5138 {
5139 }
5140
5141 //= MEDFileAnyTypeField1TS
5142
5143 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fileName, bool loadAll)
5144 {
5145   med_field_type typcha;
5146   //
5147   std::vector<std::string> infos;
5148   std::string dtunit,fieldName;
5149   LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
5150   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5151   switch(typcha)
5152     {
5153     case MED_FLOAT64:
5154       {
5155         ret=MEDFileField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5156         break;
5157       }
5158     case MED_INT32:
5159       {
5160         ret=MEDFileIntField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5161         break;
5162       }
5163     default:
5164       {
5165         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] !";
5166         throw INTERP_KERNEL::Exception(oss.str().c_str());
5167       }
5168     }
5169   ret->setDtUnit(dtunit.c_str());
5170   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5171   //
5172   med_int numdt,numit;
5173   med_float dt;
5174   MEDfieldComputingStepInfo(fid,fieldName.c_str(),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 std::string& fileName, bool loadAll)
5185 try:MEDFileFieldGlobsReal(fileName)
5186 {
5187   MEDFileUtilities::CheckFileForRead(fileName);
5188   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5189   _content=BuildContentFrom(fid,fileName,loadAll);
5190   loadGlobals(fid);
5191 }
5192 catch(INTERP_KERNEL::Exception& e)
5193   {
5194     throw e;
5195   }
5196
5197 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fileName, const std::string& fieldName, bool loadAll)
5198 {
5199   med_field_type typcha;
5200   std::vector<std::string> infos;
5201   std::string dtunit;
5202   int iii=-1;
5203   int nbSteps=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5204   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5205   switch(typcha)
5206     {
5207     case MED_FLOAT64:
5208       {
5209         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5210         break;
5211       }
5212     case MED_INT32:
5213       {
5214         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5215         break;
5216       }
5217     default:
5218       {
5219         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] !";
5220         throw INTERP_KERNEL::Exception(oss.str().c_str());
5221       }
5222     }
5223   ret->setDtUnit(dtunit.c_str());
5224   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5225   //
5226   if(nbSteps<1)
5227     {
5228       std::ostringstream oss; oss << "MEDFileField1TS(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but there is no time steps on it !";
5229       throw INTERP_KERNEL::Exception(oss.str().c_str());
5230     }
5231   //
5232   med_int numdt,numit;
5233   med_float dt;
5234   MEDfieldComputingStepInfo(fid,fieldName.c_str(),1,&numdt,&numit,&dt);
5235   ret->setTime(numdt,numit,dt);
5236   ret->_csit=1;
5237   if(loadAll)
5238     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5239   else
5240     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5241   return ret.retn();
5242 }
5243
5244 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const std::string& fileName, const std::string& fieldName, bool loadAll)
5245 try:MEDFileFieldGlobsReal(fileName)
5246 {
5247   MEDFileUtilities::CheckFileForRead(fileName);
5248   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5249   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
5250   loadGlobals(fid);
5251 }
5252 catch(INTERP_KERNEL::Exception& e)
5253   {
5254     throw e;
5255   }
5256
5257 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c, const std::string& fileName)
5258 {
5259   if(!c)
5260     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
5261   if(dynamic_cast<const MEDFileField1TSWithoutSDA *>(c))
5262     {
5263       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New();
5264       ret->setFileName(fileName);
5265       ret->_content=c; c->incrRef();
5266       return ret.retn();
5267     }
5268   if(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(c))
5269     {
5270       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New();
5271       ret->setFileName(fileName);
5272       ret->_content=c; c->incrRef();
5273       return ret.retn();
5274     }
5275   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
5276 }
5277
5278 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, bool loadAll)
5279 {
5280   MEDFileUtilities::CheckFileForRead(fileName);
5281   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5282   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
5283   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5284   ret->loadGlobals(fid);
5285   return ret.retn();
5286 }
5287
5288 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
5289 {
5290   MEDFileUtilities::CheckFileForRead(fileName);
5291   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5292   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
5293   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5294   ret->loadGlobals(fid);
5295   return ret.retn();
5296 }
5297
5298 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5299 {
5300   MEDFileUtilities::CheckFileForRead(fileName);
5301   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5302   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5303   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5304   ret->loadGlobals(fid);
5305   return ret.retn();
5306 }
5307
5308 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5309 {
5310   med_field_type typcha;
5311   std::vector<std::string> infos;
5312   std::string dtunit;
5313   int iii=-1;
5314   int nbOfStep2=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5315   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5316   switch(typcha)
5317     {
5318     case MED_FLOAT64:
5319       {
5320         ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5321         break;
5322       }
5323     case MED_INT32:
5324       {
5325         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5326         break;
5327       }
5328     default:
5329       {
5330         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] !";
5331         throw INTERP_KERNEL::Exception(oss.str().c_str());
5332       }
5333     }
5334   ret->setDtUnit(dtunit.c_str());
5335   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5336   //
5337   bool found=false;
5338   std::vector< std::pair<int,int> > dtits(nbOfStep2);
5339   for(int i=0;i<nbOfStep2 && !found;i++)
5340     {
5341       med_int numdt,numit;
5342       med_float dt;
5343       MEDfieldComputingStepInfo(fid,fieldName.c_str(),i+1,&numdt,&numit,&dt);
5344       if(numdt==iteration && numit==order)
5345         {
5346           found=true;
5347           ret->_csit=i+1;
5348         }
5349       else
5350         dtits[i]=std::pair<int,int>(numdt,numit);
5351     }
5352   if(!found)
5353     {
5354       std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << fileName << "' ! Available iterations are : ";
5355       for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
5356         oss << "(" << (*iter).first << "," << (*iter).second << "), ";
5357       throw INTERP_KERNEL::Exception(oss.str().c_str());
5358     }
5359   if(loadAll)
5360     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5361   else
5362     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5363   return ret.retn();
5364 }
5365
5366 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5367 try:MEDFileFieldGlobsReal(fileName)
5368 {
5369   MEDFileUtilities::CheckFileForRead(fileName);
5370   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5371   _content=BuildContentFrom(fid,fileName.c_str(),fieldName.c_str(),iteration,order,loadAll);
5372   loadGlobals(fid);
5373 }
5374 catch(INTERP_KERNEL::Exception& e)
5375   {
5376     throw e;
5377   }
5378
5379 /*!
5380  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5381  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5382  *
5383  * \warning this is a shallow copy constructor
5384  */
5385 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent)
5386 {
5387   if(!shallowCopyOfContent)
5388     {
5389       const MEDFileAnyTypeField1TSWithoutSDA *otherPtr(&other);
5390       otherPtr->incrRef();
5391       _content=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(otherPtr);
5392     }
5393   else
5394     {
5395       _content=other.shallowCpy();
5396     }
5397 }
5398
5399 int MEDFileAnyTypeField1TS::LocateField2(med_idt fid, const std::string& fileName, int fieldIdCFormat, bool checkFieldId, std::string& fieldName, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut)
5400 {
5401   if(checkFieldId)
5402     {
5403       int nbFields=MEDnField(fid);
5404       if(fieldIdCFormat>=nbFields)
5405         {
5406           std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << fileName << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
5407           throw INTERP_KERNEL::Exception(oss.str().c_str());
5408         }
5409     }
5410   int ncomp=MEDfieldnComponent(fid,fieldIdCFormat+1);
5411   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5412   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5413   INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5414   INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5415   INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5416   med_bool localMesh;
5417   int nbOfStep;
5418   MEDfieldInfo(fid,fieldIdCFormat+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
5419   fieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
5420   dtunitOut=MEDLoaderBase::buildStringFromFortran(dtunit,MED_LNAME_SIZE);
5421   infos.clear(); infos.resize(ncomp);
5422   for(int j=0;j<ncomp;j++)
5423     infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
5424   return nbOfStep;
5425 }
5426
5427 /*!
5428  * This method throws an INTERP_KERNEL::Exception if \a fieldName field is not in file pointed by \a fid and with name \a fileName.
5429  *
5430  * \param [out]
5431  * \return in case of success the number of time steps available for the field with name \a fieldName.
5432  */
5433 int MEDFileAnyTypeField1TS::LocateField(med_idt fid, const std::string& fileName, const std::string& fieldName, int& posCFormat, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut)
5434 {
5435   int nbFields=MEDnField(fid);
5436   bool found=false;
5437   std::vector<std::string> fns(nbFields);
5438   int nbOfStep2=-1;
5439   for(int i=0;i<nbFields && !found;i++)
5440     {
5441       std::string tmp;
5442       nbOfStep2=LocateField2(fid,fileName,i,false,tmp,typcha,infos,dtunitOut);
5443       fns[i]=tmp;
5444       found=(tmp==fieldName);
5445       if(found)
5446         posCFormat=i;
5447     }
5448   if(!found)
5449     {
5450       std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << fileName << "' ! Available fields are : ";
5451       for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
5452         oss << "\"" << *it << "\" ";
5453       throw INTERP_KERNEL::Exception(oss.str().c_str());
5454     }
5455   return nbOfStep2;
5456 }
5457
5458 /*!
5459  * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5460  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5461  * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5462  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5463  * to keep a valid instance.
5464  * 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.
5465  * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
5466  * 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.
5467  *
5468  * \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.
5469  * \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.
5470  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5471  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5472  * \param [in] newLocName is the new localization name.
5473  * \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.
5474  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
5475  */
5476 void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newPflName, bool forceRenameOnGlob)
5477 {
5478   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5479   std::string oldPflName=disc->getProfile();
5480   std::vector<std::string> vv=getPflsReallyUsedMulti();
5481   int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
5482   if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
5483     {
5484       disc->setProfile(newPflName);
5485       DataArrayInt *pfl=getProfile(oldPflName.c_str());
5486       pfl->setName(newPflName);
5487     }
5488   else
5489     {
5490       std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
5491       throw INTERP_KERNEL::Exception(oss.str().c_str());
5492     }
5493 }
5494
5495 /*!
5496  * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5497  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5498  * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5499  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5500  * to keep a valid instance.
5501  * 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.
5502  * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
5503  * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
5504  * 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.
5505  *
5506  * \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.
5507  * \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.
5508  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5509  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5510  * \param [in] newLocName is the new localization name.
5511  * \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.
5512  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
5513  */
5514 void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newLocName, bool forceRenameOnGlob)
5515 {
5516   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5517   std::string oldLocName=disc->getLocalization();
5518   std::vector<std::string> vv=getLocsReallyUsedMulti();
5519   int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
5520   if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
5521     {
5522       disc->setLocalization(newLocName);
5523       MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
5524       loc.setName(newLocName);
5525     }
5526   else
5527     {
5528       std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
5529       throw INTERP_KERNEL::Exception(oss.str().c_str());
5530     }
5531 }
5532
5533 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase()
5534 {
5535   MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5536   if(!ret)
5537     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : content is expected to be not null !");
5538   return ret;
5539 }
5540
5541 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() const
5542 {
5543   const MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5544   if(!ret)
5545     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : const content is expected to be not null !");
5546   return ret;
5547 }
5548
5549 /*!
5550  * Writes \a this field into a MED file specified by its name.
5551  *  \param [in] fileName - the MED file name.
5552  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
5553  * - 2 - erase; an existing file is removed.
5554  * - 1 - append; same data should not be present in an existing file.
5555  * - 0 - overwrite; same data present in an existing file is overwritten.
5556  *  \throw If the field name is not set.
5557  *  \throw If no field data is set.
5558  *  \throw If \a mode == 1 and the same data is present in an existing file.
5559  */
5560 void MEDFileAnyTypeField1TS::write(const std::string& fileName, int mode) const
5561 {
5562   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
5563   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
5564   writeLL(fid);
5565 }
5566
5567 /*!
5568  * This method alloc the arrays and load potentially huge arrays contained in this field.
5569  * This method should be called when a MEDFileAnyTypeField1TS::New constructor has been with false as the last parameter.
5570  * This method can be also called to refresh or reinit values from a file.
5571  *
5572  * \throw If the fileName is not set or points to a non readable MED file.
5573  * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5574  */
5575 void MEDFileAnyTypeField1TS::loadArrays()
5576 {
5577   if(getFileName().empty())
5578     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::loadArrays : the structure does not come from a file !");
5579   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
5580   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
5581 }
5582
5583 /*!
5584  * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
5585  * But once data loaded once, this method does nothing. Contrary to MEDFileAnyTypeField1TS::loadArrays and MEDFileAnyTypeField1TS::unloadArrays
5586  * this method does not throw if \a this does not come from file read.
5587  *
5588  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::unloadArrays
5589  */
5590 void MEDFileAnyTypeField1TS::loadArraysIfNecessary()
5591 {
5592   if(!getFileName().empty())
5593     {
5594       MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
5595       contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
5596     }
5597 }
5598
5599 /*!
5600  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
5601  * This method does not release arrays set outside the context of a MED file.
5602  *
5603  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary
5604  */
5605 void MEDFileAnyTypeField1TS::unloadArrays()
5606 {
5607   contentNotNullBase()->unloadArrays();
5608 }
5609
5610 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const
5611 {
5612   int nbComp=getNumberOfComponents();
5613   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5614   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5615   for(int i=0;i<nbComp;i++)
5616     {
5617       std::string info=getInfo()[i];
5618       std::string c,u;
5619       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
5620       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
5621       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
5622     }
5623   if(getName().empty())
5624     throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
5625   MEDfieldCr(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
5626   writeGlobals(fid,*this);
5627   contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
5628 }
5629
5630 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySizeWithoutChildren() const
5631 {
5632   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
5633 }
5634
5635 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TS::getDirectChildren() const
5636 {
5637   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
5638   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5639     ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)_content);
5640   return ret;
5641 }
5642
5643 /*!
5644  * Returns a string describing \a this field. This string is outputted
5645  * by \c print Python command.
5646  */
5647 std::string MEDFileAnyTypeField1TS::simpleRepr() const
5648 {
5649   std::ostringstream oss;
5650   contentNotNullBase()->simpleRepr(0,oss,-1);
5651   simpleReprGlobs(oss);
5652   return oss.str();
5653 }
5654
5655 /*!
5656  * This method returns all profiles whose name is non empty used.
5657  * \b WARNING If profile is used several times it will be reported \b only \b once.
5658  * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
5659  */
5660 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
5661 {
5662   return contentNotNullBase()->getPflsReallyUsed2();
5663 }
5664
5665 /*!
5666  * This method returns all localizations whose name is non empty used.
5667  * \b WARNING If localization is used several times it will be reported \b only \b once.
5668  */
5669 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
5670 {
5671   return contentNotNullBase()->getLocsReallyUsed2();
5672 }
5673
5674 /*!
5675  * This method returns all profiles whose name is non empty used.
5676  * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
5677  */
5678 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
5679 {
5680   return contentNotNullBase()->getPflsReallyUsedMulti2();
5681 }
5682
5683 /*!
5684  * This method returns all localizations whose name is non empty used.
5685  * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
5686  */
5687 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
5688 {
5689   return contentNotNullBase()->getLocsReallyUsedMulti2();
5690 }
5691
5692 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5693 {
5694   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
5695 }
5696
5697 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5698 {
5699   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
5700 }
5701
5702 int MEDFileAnyTypeField1TS::getDimension() const
5703 {
5704   return contentNotNullBase()->getDimension();
5705 }
5706
5707 int MEDFileAnyTypeField1TS::getIteration() const
5708 {
5709   return contentNotNullBase()->getIteration();
5710 }
5711
5712 int MEDFileAnyTypeField1TS::getOrder() const
5713 {
5714   return contentNotNullBase()->getOrder();
5715 }
5716
5717 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
5718 {
5719   return contentNotNullBase()->getTime(iteration,order);
5720 }
5721
5722 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
5723 {
5724   contentNotNullBase()->setTime(iteration,order,val);
5725 }
5726
5727 std::string MEDFileAnyTypeField1TS::getName() const
5728 {
5729   return contentNotNullBase()->getName();
5730 }
5731
5732 void MEDFileAnyTypeField1TS::setName(const std::string& name)
5733 {
5734   contentNotNullBase()->setName(name);
5735 }
5736
5737 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
5738 {
5739   contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
5740 }
5741
5742 std::string MEDFileAnyTypeField1TS::getDtUnit() const
5743 {
5744   return contentNotNullBase()->getDtUnit();
5745 }
5746
5747 void MEDFileAnyTypeField1TS::setDtUnit(const std::string& dtUnit)
5748 {
5749   contentNotNullBase()->setDtUnit(dtUnit);
5750 }
5751
5752 std::string MEDFileAnyTypeField1TS::getMeshName() const
5753 {
5754   return contentNotNullBase()->getMeshName();
5755 }
5756
5757 void MEDFileAnyTypeField1TS::setMeshName(const std::string& newMeshName)
5758 {
5759   contentNotNullBase()->setMeshName(newMeshName);
5760 }
5761
5762 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
5763 {
5764   return contentNotNullBase()->changeMeshNames(modifTab);
5765 }
5766
5767 int MEDFileAnyTypeField1TS::getMeshIteration() const
5768 {
5769   return contentNotNullBase()->getMeshIteration();
5770 }
5771
5772 int MEDFileAnyTypeField1TS::getMeshOrder() const
5773 {
5774   return contentNotNullBase()->getMeshOrder();
5775 }
5776
5777 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
5778 {
5779   return contentNotNullBase()->getNumberOfComponents();
5780 }
5781
5782 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
5783 {
5784   return contentNotNullBase()->isDealingTS(iteration,order);
5785 }
5786
5787 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
5788 {
5789   return contentNotNullBase()->getDtIt();
5790 }
5791
5792 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
5793 {
5794   contentNotNullBase()->fillIteration(p);
5795 }
5796
5797 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
5798 {
5799   contentNotNullBase()->fillTypesOfFieldAvailable(types);
5800 }
5801
5802 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos)
5803 {
5804   contentNotNullBase()->setInfo(infos);
5805 }
5806
5807 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
5808 {
5809   return contentNotNullBase()->getInfo();
5810 }
5811 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
5812 {
5813   return contentNotNullBase()->getInfo();
5814 }
5815
5816 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
5817 {
5818   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5819 }
5820
5821 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
5822 {
5823   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5824 }
5825
5826 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
5827 {
5828   return contentNotNullBase()->getNonEmptyLevels(mname,levs);
5829 }
5830
5831 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const
5832 {
5833   return contentNotNullBase()->getTypesOfFieldAvailable();
5834 }
5835
5836 std::vector< std::vector<std::pair<int,int> > > MEDFileAnyTypeField1TS::getFieldSplitedByType(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
5837                                                                                        std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5838 {
5839   return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
5840 }
5841
5842 /*!
5843  * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
5844  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5845  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
5846  */
5847 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const
5848 {
5849   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5850   if(!content)
5851     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
5852   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
5853   std::size_t sz(contentsSplit.size());
5854   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5855   for(std::size_t i=0;i<sz;i++)
5856     {
5857       ret[i]=shallowCpy();
5858       ret[i]->_content=contentsSplit[i];
5859     }
5860   return ret;
5861 }
5862
5863 /*!
5864  * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
5865  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5866  */
5867 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const
5868 {
5869   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5870   if(!content)
5871     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
5872   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitDiscretizations();
5873   std::size_t sz(contentsSplit.size());
5874   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5875   for(std::size_t i=0;i<sz;i++)
5876     {
5877       ret[i]=shallowCpy();
5878       ret[i]->_content=contentsSplit[i];
5879     }
5880   return ret;
5881 }
5882
5883 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCpy() const
5884 {
5885   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=shallowCpy();
5886   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5887     ret->_content=_content->deepCpy();
5888   ret->deepCpyGlobs(*this);
5889   return ret.retn();
5890 }
5891
5892 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
5893 {
5894   return contentNotNullBase()->copyTinyInfoFrom(field,arr);
5895 }
5896
5897 //= MEDFileField1TS
5898
5899 /*!
5900  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5901  * the first field that has been read from a specified MED file.
5902  *  \param [in] fileName - the name of the MED file to read.
5903  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5904  *          is to delete this field using decrRef() as it is no more needed.
5905  *  \throw If reading the file fails.
5906  */
5907 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, bool loadAll)
5908 {
5909   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,loadAll);
5910   ret->contentNotNull();
5911   return ret.retn();
5912 }
5913
5914 /*!
5915  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5916  * a given field that has been read from a specified MED file.
5917  *  \param [in] fileName - the name of the MED file to read.
5918  *  \param [in] fieldName - the name of the field to read.
5919  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5920  *          is to delete this field using decrRef() as it is no more needed.
5921  *  \throw If reading the file fails.
5922  *  \throw If there is no field named \a fieldName in the file.
5923  */
5924 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
5925 {
5926   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,loadAll);
5927   ret->contentNotNull();
5928   return ret.retn();
5929 }
5930
5931 /*!
5932  * Returns a new instance of MEDFileField1TS holding data of a given time step of
5933  * a given field that has been read from a specified MED file.
5934  *  \param [in] fileName - the name of the MED file to read.
5935  *  \param [in] fieldName - the name of the field to read.
5936  *  \param [in] iteration - the iteration number of a required time step.
5937  *  \param [in] order - the iteration order number of required time step.
5938  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5939  *          is to delete this field using decrRef() as it is no more needed.
5940  *  \throw If reading the file fails.
5941  *  \throw If there is no field named \a fieldName in the file.
5942  *  \throw If the required time step is missing from the file.
5943  */
5944 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5945 {
5946   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,iteration,order,loadAll);
5947   ret->contentNotNull();
5948   return ret.retn();
5949 }
5950
5951 /*!
5952  * Returns a new instance of MEDFileField1TS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5953  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5954  *
5955  * Returns a new instance of MEDFileField1TS holding either a shallow copy
5956  * of a given MEDFileField1TSWithoutSDA ( \a other ) or \a other itself.
5957  * \warning this is a shallow copy constructor
5958  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
5959  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
5960  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5961  *          is to delete this field using decrRef() as it is no more needed.
5962  */
5963 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5964 {
5965   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(other,shallowCopyOfContent);
5966   ret->contentNotNull();
5967   return ret.retn();
5968 }
5969
5970 /*!
5971  * Returns a new empty instance of MEDFileField1TS.
5972  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5973  *          is to delete this field using decrRef() as it is no more needed.
5974  */
5975 MEDFileField1TS *MEDFileField1TS::New()
5976 {
5977   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS;
5978   ret->contentNotNull();
5979   return ret.retn();
5980 }
5981
5982 /*!
5983  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
5984  * following the given input policy.
5985  *
5986  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
5987  *                            By default (true) the globals are deeply copied.
5988  * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
5989  */
5990 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool isDeepCpyGlobs) const
5991 {
5992   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret;
5993   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5994   if(content)
5995     {
5996       const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
5997       if(!contc)
5998         throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
5999       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
6000       ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc,getFileName()));
6001     }
6002   else
6003     ret=MEDFileIntField1TS::New();
6004   if(isDeepCpyGlobs)
6005     ret->deepCpyGlobs(*this);
6006   else
6007     ret->shallowCpyGlobs(*this);
6008   return ret.retn();
6009 }
6010
6011 const MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() const
6012 {
6013   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6014   if(!pt)
6015     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is null !");
6016   const MEDFileField1TSWithoutSDA *ret=dynamic_cast<const MEDFileField1TSWithoutSDA *>(pt);
6017   if(!ret)
6018     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 !");
6019   return ret;
6020 }
6021
6022 MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull()
6023 {
6024   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6025   if(!pt)
6026     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is null !");
6027   MEDFileField1TSWithoutSDA *ret=dynamic_cast<MEDFileField1TSWithoutSDA *>(pt);
6028   if(!ret)
6029     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 !");
6030   return ret;
6031 }
6032
6033 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6034 {
6035   if(!f)
6036     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
6037   if(!((DataArray*)arr))
6038     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
6039   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6040   if(!arrOutC)
6041     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6042   f->setArray(arrOutC);
6043 }
6044
6045 DataArrayDouble *MEDFileField1TS::ReturnSafelyDataArrayDouble(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6046 {
6047   if(!((DataArray*)arr))
6048     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : no array !");
6049   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6050   if(!arrOutC)
6051     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6052   arrOutC->incrRef();
6053   return arrOutC;
6054 }
6055
6056 MEDFileField1TS::MEDFileField1TS(const std::string& fileName, bool loadAll)
6057 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6058 {
6059 }
6060 catch(INTERP_KERNEL::Exception& e)
6061   { throw e; }
6062
6063 MEDFileField1TS::MEDFileField1TS(const std::string& fileName, const std::string& fieldName, bool loadAll)
6064 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6065 {
6066 }
6067 catch(INTERP_KERNEL::Exception& e)
6068   { throw e; }
6069
6070 MEDFileField1TS::MEDFileField1TS(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6071 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6072 {
6073 }
6074 catch(INTERP_KERNEL::Exception& e)
6075   { throw e; }
6076
6077 /*!
6078  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6079  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6080  *
6081  * \warning this is a shallow copy constructor
6082  */
6083 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
6084 try:MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6085 {
6086 }
6087 catch(INTERP_KERNEL::Exception& e)
6088   { throw e; }
6089
6090 MEDFileField1TS::MEDFileField1TS()
6091 {
6092   _content=new MEDFileField1TSWithoutSDA;
6093 }
6094
6095 /*!
6096  * Returns a new MEDCouplingFieldDouble of a given type lying on
6097  * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6098  * has not been constructed via file reading, an exception is thrown.
6099  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6100  *  \param [in] type - a spatial discretization of interest.
6101  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6102  *  \param [in] renumPol - specifies how to permute values of the result field according to
6103  *          the optional numbers of cells and nodes, if any. The valid values are
6104  *          - 0 - do not permute.
6105  *          - 1 - permute cells.
6106  *          - 2 - permute nodes.
6107  *          - 3 - permute cells and nodes.
6108  *
6109  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6110  *          caller is to delete this field using decrRef() as it is no more needed.
6111  *  \throw If \a this field has not been constructed via file reading.
6112  *  \throw If the MED file is not readable.
6113  *  \throw If there is no mesh in the MED file.
6114  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6115  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6116  *  \sa getFieldOnMeshAtLevel()
6117  */
6118 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const
6119 {
6120   if(getFileName2().empty())
6121     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6122   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6123   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNull());
6124   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6125   return ret.retn();
6126 }
6127
6128 /*!
6129  * Returns a new MEDCouplingFieldDouble of a given type lying on
6130  * the top level cells of the first mesh in MED file. If \a this field
6131  * has not been constructed via file reading, an exception is thrown.
6132  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6133  *  \param [in] type - a spatial discretization of interest.
6134  *  \param [in] renumPol - specifies how to permute values of the result field according to
6135  *          the optional numbers of cells and nodes, if any. The valid values are
6136  *          - 0 - do not permute.
6137  *          - 1 - permute cells.
6138  *          - 2 - permute nodes.
6139  *          - 3 - permute cells and nodes.
6140  *
6141  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6142  *          caller is to delete this field using decrRef() as it is no more needed.
6143  *  \throw If \a this field has not been constructed via file reading.
6144  *  \throw If the MED file is not readable.
6145  *  \throw If there is no mesh in the MED file.
6146  *  \throw If no field values of the given \a type.
6147  *  \throw If no field values lying on the top level support.
6148  *  \sa getFieldAtLevel()
6149  */
6150 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const
6151 {
6152   if(getFileName2().empty())
6153     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6154   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6155   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNull());
6156   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6157   return ret.retn();
6158 }
6159
6160 /*!
6161  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6162  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6163  *  \param [in] type - a spatial discretization of the new field.
6164  *  \param [in] mesh - the supporting mesh.
6165  *  \param [in] renumPol - specifies how to permute values of the result field according to
6166  *          the optional numbers of cells and nodes, if any. The valid values are
6167  *          - 0 - do not permute.
6168  *          - 1 - permute cells.
6169  *          - 2 - permute nodes.
6170  *          - 3 - permute cells and nodes.
6171  *
6172  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6173  *          caller is to delete this field using decrRef() as it is no more needed.
6174  *  \throw If no field of \a this is lying on \a mesh.
6175  *  \throw If the mesh is empty.
6176  *  \throw If no field values of the given \a type are available.
6177  *  \sa getFieldAtLevel()
6178  *  \sa getFieldOnMeshAtLevel()
6179  */
6180 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const
6181 {
6182   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6183   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull());
6184   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6185   return ret.retn();
6186 }
6187
6188 /*!
6189  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6190  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6191  *  \param [in] type - a spatial discretization of interest.
6192  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6193  *  \param [in] mesh - the supporting mesh.
6194  *  \param [in] renumPol - specifies how to permute values of the result field according to
6195  *          the optional numbers of cells and nodes, if any. The valid values are
6196  *          - 0 - do not permute.
6197  *          - 1 - permute cells.
6198  *          - 2 - permute nodes.
6199  *          - 3 - permute cells and nodes.
6200  *
6201  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6202  *          caller is to delete this field using decrRef() as it is no more needed.
6203  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6204  *  \throw If no field of \a this is lying on \a mesh.
6205  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6206  *  \sa getFieldAtLevel()
6207  *  \sa getFieldOnMeshAtLevel()
6208  */
6209 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
6210 {
6211   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6212   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull());
6213   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6214   return ret.retn();
6215 }
6216
6217 /*!
6218  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6219  * This method is called "Old" because in MED3 norm a field has only one meshName
6220  * attached, so this method is for readers of MED2 files. If \a this field
6221  * has not been constructed via file reading, an exception is thrown.
6222  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6223  *  \param [in] type - a spatial discretization of interest.
6224  *  \param [in] mName - a name of the supporting mesh.
6225  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6226  *  \param [in] renumPol - specifies how to permute values of the result field according to
6227  *          the optional numbers of cells and nodes, if any. The valid values are
6228  *          - 0 - do not permute.
6229  *          - 1 - permute cells.
6230  *          - 2 - permute nodes.
6231  *          - 3 - permute cells and nodes.
6232  *
6233  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6234  *          caller is to delete this field using decrRef() as it is no more needed.
6235  *  \throw If the MED file is not readable.
6236  *  \throw If there is no mesh named \a mName in the MED file.
6237  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6238  *  \throw If \a this field has not been constructed via file reading.
6239  *  \throw If no field of \a this is lying on the mesh named \a mName.
6240  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6241  *  \sa getFieldAtLevel()
6242  */
6243 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, int renumPol) const
6244 {
6245   if(getFileName2().empty())
6246     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6247   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6248   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
6249   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6250   return ret.retn();
6251 }
6252
6253 /*!
6254  * Returns values and a profile of the field of a given type lying on a given support.
6255  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6256  *  \param [in] type - a spatial discretization of the field.
6257  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6258  *  \param [in] mesh - the supporting mesh.
6259  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6260  *          field of interest lies on. If the field lies on all entities of the given
6261  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6262  *          using decrRef() as it is no more needed.
6263  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
6264  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6265  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6266  *  \throw If no field of \a this is lying on \a mesh.
6267  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6268  */
6269 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6270 {
6271   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6272   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
6273 }
6274
6275 /*!
6276  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6277  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6278  * "Sort By Type"), if not, an exception is thrown.
6279  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6280  *  \param [in] field - the field to add to \a this.
6281  *  \throw If the name of \a field is empty.
6282  *  \throw If the data array of \a field is not set.
6283  *  \throw If the data array is already allocated but has different number of components
6284  *         than \a field.
6285  *  \throw If the underlying mesh of \a field has no name.
6286  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6287  */
6288 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
6289 {
6290   setFileName("");
6291   contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
6292 }
6293
6294 /*!
6295  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6296  * can be an aggregation of several MEDCouplingFieldDouble instances.
6297  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6298  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6299  * and \a profile.
6300  *
6301  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6302  * A new profile is added only if no equal profile is missing.
6303  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6304  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
6305  *  \param [in] mesh - the supporting mesh of \a field.
6306  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6307  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6308  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6309  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6310  *  \throw If the data array of \a field is not set.
6311  *  \throw If the data array of \a this is already allocated but has different number of
6312  *         components than \a field.
6313  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6314  *  \sa setFieldNoProfileSBT()
6315  */
6316 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6317 {
6318   setFileName("");
6319   contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6320 }
6321
6322 MEDFileAnyTypeField1TS *MEDFileField1TS::shallowCpy() const
6323 {
6324   return new MEDFileField1TS(*this);
6325 }
6326
6327 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const
6328 {
6329   return contentNotNull()->getUndergroundDataArrayDouble();
6330 }
6331
6332 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6333 {
6334   return contentNotNull()->getUndergroundDataArrayDoubleExt(entries);
6335 }
6336
6337 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6338                                                                                       std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
6339 {
6340   return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
6341 }
6342
6343 //= MEDFileIntField1TS
6344
6345 MEDFileIntField1TS *MEDFileIntField1TS::New()
6346 {
6347   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS;
6348   ret->contentNotNull();
6349   return ret.retn();
6350 }
6351
6352 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, bool loadAll)
6353 {
6354   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,loadAll);
6355   ret->contentNotNull();
6356   return ret.retn();
6357 }
6358
6359 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
6360 {
6361   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,loadAll);
6362   ret->contentNotNull();
6363   return ret.retn();
6364 }
6365
6366 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6367 {
6368   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,iteration,order,loadAll);
6369   ret->contentNotNull();
6370   return ret.retn();
6371 }
6372
6373 MEDFileIntField1TS *MEDFileIntField1TS::New(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent)
6374 {
6375   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(other,shallowCopyOfContent);
6376   ret->contentNotNull();
6377   return ret.retn();
6378 }
6379
6380 MEDFileIntField1TS::MEDFileIntField1TS()
6381 {
6382   _content=new MEDFileIntField1TSWithoutSDA;
6383 }
6384
6385 MEDFileIntField1TS::MEDFileIntField1TS(const std::string& fileName, bool loadAll)
6386 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6387 {
6388 }
6389 catch(INTERP_KERNEL::Exception& e)
6390   { throw e; }
6391
6392 MEDFileIntField1TS::MEDFileIntField1TS(const std::string& fileName, const std::string& fieldName, bool loadAll)
6393 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6394 {
6395 }
6396 catch(INTERP_KERNEL::Exception& e)
6397   { throw e; }
6398
6399 MEDFileIntField1TS::MEDFileIntField1TS(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6400 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6401 {
6402 }
6403 catch(INTERP_KERNEL::Exception& e)
6404   { throw e; }
6405
6406 /*!
6407  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6408  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6409  *
6410  * \warning this is a shallow copy constructor
6411  */
6412 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6413 {
6414 }
6415
6416 MEDFileAnyTypeField1TS *MEDFileIntField1TS::shallowCpy() const
6417 {
6418   return new MEDFileIntField1TS(*this);
6419 }
6420
6421 /*!
6422  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
6423  * following the given input policy.
6424  *
6425  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6426  *                            By default (true) the globals are deeply copied.
6427  * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
6428  */
6429 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool isDeepCpyGlobs) const
6430 {
6431   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret;
6432   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6433   if(content)
6434     {
6435       const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
6436       if(!contc)
6437         throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
6438       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
6439       ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc,getFileName()));
6440     }
6441   else
6442     ret=MEDFileField1TS::New();
6443   if(isDeepCpyGlobs)
6444     ret->deepCpyGlobs(*this);
6445   else
6446     ret->shallowCpyGlobs(*this);
6447   return ret.retn();
6448 }
6449
6450 /*!
6451  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6452  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6453  * "Sort By Type"), if not, an exception is thrown.
6454  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6455  *  \param [in] field - the field to add to \a this. The field double values are ignored.
6456  *  \param [in] arrOfVals - the values of the field \a field used.
6457  *  \throw If the name of \a field is empty.
6458  *  \throw If the data array of \a field is not set.
6459  *  \throw If the data array is already allocated but has different number of components
6460  *         than \a field.
6461  *  \throw If the underlying mesh of \a field has no name.
6462  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6463  */
6464 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
6465 {
6466   setFileName("");
6467   contentNotNull()->setFieldNoProfileSBT(field,arrOfVals,*this,*contentNotNull());
6468 }
6469
6470 /*!
6471  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6472  * can be an aggregation of several MEDCouplingFieldDouble instances.
6473  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6474  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6475  * and \a profile.
6476  *
6477  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6478  * A new profile is added only if no equal profile is missing.
6479  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6480  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
6481  *  \param [in] arrOfVals - the values of the field \a field used.
6482  *  \param [in] mesh - the supporting mesh of \a field.
6483  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6484  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6485  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6486  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6487  *  \throw If the data array of \a field is not set.
6488  *  \throw If the data array of \a this is already allocated but has different number of
6489  *         components than \a field.
6490  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6491  *  \sa setFieldNoProfileSBT()
6492  */
6493 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6494 {
6495   setFileName("");
6496   contentNotNull()->setFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6497 }
6498
6499 const MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() const
6500 {
6501   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6502   if(!pt)
6503     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is null !");
6504   const MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(pt);
6505   if(!ret)
6506     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 !");
6507   return ret;
6508 }
6509
6510 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6511 {
6512   if(getFileName2().empty())
6513     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6514   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut2;
6515   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut2,*contentNotNull());
6516   DataArrayInt *arrOutC=dynamic_cast<DataArrayInt *>((DataArray *)arrOut2);
6517   if(!arrOutC)
6518     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : mismatch between dataArrays type and MEDFileIntField1TS ! Expected int32 !");
6519   arrOut=arrOutC;
6520   return ret.retn();
6521 }
6522
6523 DataArrayInt *MEDFileIntField1TS::ReturnSafelyDataArrayInt(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6524 {
6525   if(!((DataArray *)arr))
6526     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is NULL !");
6527   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>((DataArray *)arr);
6528   if(!arrC)
6529     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is not of type INT32 !");
6530   arrC->incrRef();
6531   return arrC;
6532 }
6533
6534 /*!
6535  * Returns a new MEDCouplingFieldDouble of a given type lying on
6536  * the top level cells of the first mesh in MED file. If \a this field
6537  * has not been constructed via file reading, an exception is thrown.
6538  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6539  *  \param [in] type - a spatial discretization of interest.
6540  *  \param [out] arrOut - the DataArrayInt containing values of field.
6541  *  \param [in] renumPol - specifies how to permute values of the result field according to
6542  *          the optional numbers of cells and nodes, if any. The valid values are
6543  *          - 0 - do not permute.
6544  *          - 1 - permute cells.
6545  *          - 2 - permute nodes.
6546  *          - 3 - permute cells and nodes.
6547  *
6548  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6549  *          caller is to delete this field using decrRef() as it is no more needed.
6550  *  \throw If \a this field has not been constructed via file reading.
6551  *  \throw If the MED file is not readable.
6552  *  \throw If there is no mesh in the MED file.
6553  *  \throw If no field values of the given \a type.
6554  *  \throw If no field values lying on the top level support.
6555  *  \sa getFieldAtLevel()
6556  */
6557 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, DataArrayInt* &arrOut, int renumPol) const
6558 {
6559   if(getFileName2().empty())
6560     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6561   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6562   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arr,*contentNotNull());
6563   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6564   return ret.retn();
6565 }
6566
6567 /*!
6568  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6569  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6570  *  \param [in] type - a spatial discretization of the new field.
6571  *  \param [in] mesh - the supporting mesh.
6572  *  \param [out] arrOut - the DataArrayInt containing values of field.
6573  *  \param [in] renumPol - specifies how to permute values of the result field according to
6574  *          the optional numbers of cells and nodes, if any. The valid values are
6575  *          - 0 - do not permute.
6576  *          - 1 - permute cells.
6577  *          - 2 - permute nodes.
6578  *          - 3 - permute cells and nodes.
6579  *
6580  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6581  *          caller is to delete this field using decrRef() as it is no more needed.
6582  *  \throw If no field of \a this is lying on \a mesh.
6583  *  \throw If the mesh is empty.
6584  *  \throw If no field values of the given \a type are available.
6585  *  \sa getFieldAtLevel()
6586  *  \sa getFieldOnMeshAtLevel()
6587  */
6588 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6589 {
6590   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6591   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNull());
6592   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6593   return ret.retn();
6594 }
6595
6596 /*!
6597  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6598  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6599  *  \param [in] type - a spatial discretization of interest.
6600  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6601  *  \param [out] arrOut - the DataArrayInt containing values of field.
6602  *  \param [in] mesh - the supporting mesh.
6603  *  \param [in] renumPol - specifies how to permute values of the result field according to
6604  *          the optional numbers of cells and nodes, if any. The valid values are
6605  *          - 0 - do not permute.
6606  *          - 1 - permute cells.
6607  *          - 2 - permute nodes.
6608  *          - 3 - permute cells and nodes.
6609  *
6610  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6611  *          caller is to delete this field using decrRef() as it is no more needed.
6612  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6613  *  \throw If no field of \a this is lying on \a mesh.
6614  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6615  *  \sa getFieldAtLevel()
6616  *  \sa getFieldOnMeshAtLevel()
6617  */
6618 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6619 {
6620   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6621   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNull());
6622   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6623   return ret.retn();
6624 }
6625
6626 /*!
6627  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6628  * This method is called "Old" because in MED3 norm a field has only one meshName
6629  * attached, so this method is for readers of MED2 files. If \a this field
6630  * has not been constructed via file reading, an exception is thrown.
6631  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6632  *  \param [in] type - a spatial discretization of interest.
6633  *  \param [in] mName - a name of the supporting mesh.
6634  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6635  *  \param [out] arrOut - the DataArrayInt containing values of field.
6636  *  \param [in] renumPol - specifies how to permute values of the result field according to
6637  *          the optional numbers of cells and nodes, if any. The valid values are
6638  *          - 0 - do not permute.
6639  *          - 1 - permute cells.
6640  *          - 2 - permute nodes.
6641  *          - 3 - permute cells and nodes.
6642  *
6643  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6644  *          caller is to delete this field using decrRef() as it is no more needed.
6645  *  \throw If the MED file is not readable.
6646  *  \throw If there is no mesh named \a mName in the MED file.
6647  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6648  *  \throw If \a this field has not been constructed via file reading.
6649  *  \throw If no field of \a this is lying on the mesh named \a mName.
6650  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6651  *  \sa getFieldAtLevel()
6652  */
6653 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6654 {
6655   if(getFileName2().empty())
6656     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6657   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6658   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNull());
6659   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6660   return ret.retn();
6661 }
6662
6663 /*!
6664  * Returns values and a profile of the field of a given type lying on a given support.
6665  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6666  *  \param [in] type - a spatial discretization of the field.
6667  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6668  *  \param [in] mesh - the supporting mesh.
6669  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6670  *          field of interest lies on. If the field lies on all entities of the given
6671  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6672  *          using decrRef() as it is no more needed.
6673  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
6674  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6675  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6676  *  \throw If no field of \a this is lying on \a mesh.
6677  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6678  */
6679 DataArrayInt *MEDFileIntField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6680 {
6681   MEDCouplingAutoRefCountObjectPtr<DataArray> arr=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6682   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6683 }
6684
6685 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull()
6686 {
6687   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6688   if(!pt)
6689     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is null !");
6690   MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<MEDFileIntField1TSWithoutSDA *>(pt);
6691   if(!ret)
6692     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 !");
6693   return ret;
6694 }
6695
6696 DataArrayInt *MEDFileIntField1TS::getUndergroundDataArray() const
6697 {
6698   return contentNotNull()->getUndergroundDataArrayInt();
6699 }
6700
6701 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
6702
6703 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
6704 {
6705 }
6706
6707 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileFieldNameScope(fieldName)
6708 {
6709 }
6710
6711 /*!
6712  * \param [in] fieldId field id in C mode
6713  */
6714 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
6715 {
6716   med_field_type typcha;
6717   std::string dtunitOut;
6718   int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,"",fieldId,false,_name,typcha,_infos,dtunitOut);
6719   setDtUnit(dtunitOut.c_str());
6720   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll);
6721 }
6722
6723 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll)
6724 try:MEDFileFieldNameScope(fieldName),_infos(infos)
6725 {
6726   setDtUnit(dtunit.c_str());
6727   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll);
6728 }
6729 catch(INTERP_KERNEL::Exception& e)
6730 {
6731   throw e;
6732 }
6733
6734 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySizeWithoutChildren() const
6735 {
6736   std::size_t ret(_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA>));
6737   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6738     ret+=(*it).capacity();
6739   return ret;
6740 }
6741
6742 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTSWithoutSDA::getDirectChildren() const
6743 {
6744   std::vector<const BigMemoryObject *> ret;
6745   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6746     {
6747       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6748       if(cur)
6749         ret.push_back(cur);
6750     }
6751   return ret;
6752 }
6753
6754 /*!
6755  * 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
6756  * NULL.
6757  */
6758 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const
6759 {
6760   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6761   ret->setInfo(_infos);
6762   int sz=(int)_time_steps.size();
6763   for(const int *id=startIds;id!=endIds;id++)
6764     {
6765       if(*id>=0 && *id<sz)
6766         {
6767           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
6768           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6769           if(tse)
6770             {
6771               tse->incrRef();
6772               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6773             }
6774           ret->pushBackTimeStep(tse2);
6775         }
6776       else
6777         {
6778           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
6779           oss << " ! Should be in [0," << sz << ") !";
6780           throw INTERP_KERNEL::Exception(oss.str().c_str());
6781         }
6782     }
6783   if(ret->getNumberOfTS()>0)
6784     ret->synchronizeNameScope();
6785   ret->copyNameScope(*this);
6786   return ret.retn();
6787 }
6788
6789 /*!
6790  * 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
6791  * NULL.
6792  */
6793 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const
6794 {
6795   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
6796   int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
6797   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6798   ret->setInfo(_infos);
6799   int sz=(int)_time_steps.size();
6800   int j=bg;
6801   for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
6802     {
6803       if(j>=0 && j<sz)
6804         {
6805           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
6806           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6807           if(tse)
6808             {
6809               tse->incrRef();
6810               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6811             }
6812           ret->pushBackTimeStep(tse2);
6813         }
6814       else
6815         {
6816           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
6817           oss << " ! Should be in [0," << sz << ") !";
6818           throw INTERP_KERNEL::Exception(oss.str().c_str());
6819         }
6820     }
6821   if(ret->getNumberOfTS()>0)
6822     ret->synchronizeNameScope();
6823   ret->copyNameScope(*this);
6824   return ret.retn();
6825 }
6826
6827 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6828 {
6829   int id=0;
6830   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6831   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6832     {
6833       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6834       if(!cur)
6835         continue;
6836       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6837       if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
6838         ids->pushBackSilent(id);
6839     }
6840   return buildFromTimeStepIds(ids->begin(),ids->end());
6841 }
6842
6843 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6844 {
6845   int id=0;
6846   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6847   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6848     {
6849       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6850       if(!cur)
6851         continue;
6852       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6853       if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
6854         ids->pushBackSilent(id);
6855     }
6856   return buildFromTimeStepIds(ids->begin(),ids->end());
6857 }
6858
6859 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const
6860 {
6861   return _infos;
6862 }
6863
6864 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info)
6865 {
6866   _infos=info;
6867 }
6868
6869 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const
6870 {
6871   int ret=0;
6872   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
6873     {
6874       const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
6875       if(pt->isDealingTS(iteration,order))
6876         return ret;
6877     }
6878   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
6879   std::vector< std::pair<int,int> > vp=getIterations();
6880   for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
6881     oss << "(" << (*it2).first << "," << (*it2).second << ") ";
6882   throw INTERP_KERNEL::Exception(oss.str().c_str());
6883 }
6884
6885 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const
6886 {
6887   return *_time_steps[getTimeStepPos(iteration,order)];
6888 }
6889
6890 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order)
6891 {
6892   return *_time_steps[getTimeStepPos(iteration,order)];
6893 }
6894
6895 std::string MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshName() const
6896 {
6897   if(_time_steps.empty())
6898     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
6899   return _time_steps[0]->getMeshName();
6900 }
6901
6902 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setMeshName(const std::string& newMeshName)
6903 {
6904   std::string oldName(getMeshName());
6905   std::vector< std::pair<std::string,std::string> > v(1);
6906   v[0].first=oldName; v[0].second=newMeshName;
6907   changeMeshNames(v);
6908 }
6909
6910 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
6911 {
6912   bool ret=false;
6913   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6914     {
6915       MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6916       if(cur)
6917         ret=cur->changeMeshNames(modifTab) || ret;
6918     }
6919   return ret;
6920 }
6921
6922 /*!
6923  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
6924  */
6925 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const
6926 {
6927   return getTimeStepEntry(iteration,order).getUndergroundDataArray();
6928 }
6929
6930 /*!
6931  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
6932  */
6933 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6934 {
6935   return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
6936 }
6937
6938 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
6939                                                                 MEDFileFieldGlobsReal& glob)
6940 {
6941   bool ret=false;
6942   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6943     {
6944       MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
6945       if(f1ts)
6946         ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
6947     }
6948   return ret;
6949 }
6950
6951 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
6952 {
6953   std::string startLine(bkOffset,' ');
6954   oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
6955   if(fmtsId>=0)
6956     oss << " (" << fmtsId << ")";
6957   oss << " has the following name: \"" << _name << "\"." << std::endl;
6958   oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
6959   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6960     {
6961       oss << startLine << "  -  \"" << *it << "\"" << std::endl;
6962     }
6963   int i=0;
6964   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
6965     {
6966       std::string chapter(17,'0'+i);
6967       oss << startLine << chapter << std::endl;
6968       const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6969       if(cur)
6970         cur->simpleRepr(bkOffset+2,oss,i);
6971       else
6972         oss << startLine << "  Field on one time step #" << i << " is not defined !" << std::endl;
6973       oss << startLine << chapter << std::endl;
6974     }
6975 }
6976
6977 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const
6978 {
6979   std::size_t sz=_time_steps.size();
6980   std::vector< std::pair<int,int> > ret(sz);
6981   ret1.resize(sz);
6982   for(std::size_t i=0;i<sz;i++)
6983     {
6984       const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
6985       if(f1ts)
6986         {
6987           ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
6988         }
6989       else
6990         {
6991           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
6992           throw INTERP_KERNEL::Exception(oss.str().c_str());
6993         }
6994     }
6995   return ret;
6996 }
6997
6998 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>& tse)
6999 {
7000   MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
7001   if(!tse2)
7002     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
7003   checkCoherencyOfType(tse2);
7004   if(_time_steps.empty())
7005     {
7006       setName(tse2->getName().c_str());
7007       setInfo(tse2->getInfo());
7008     }
7009   checkThatComponentsMatch(tse2->getInfo());
7010   _time_steps.push_back(tse);
7011 }
7012
7013 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope()
7014 {
7015   std::size_t nbOfCompo=_infos.size();
7016   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7017     {
7018       MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
7019       if(cur)
7020         {
7021           if((cur->getInfo()).size()!=nbOfCompo)
7022             {
7023               std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
7024               oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
7025               throw INTERP_KERNEL::Exception(oss.str().c_str());
7026             }
7027           cur->copyNameScope(*this);
7028         }
7029     }
7030 }
7031
7032 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll)
7033 {
7034   _time_steps.resize(nbPdt);
7035   for(int i=0;i<nbPdt;i++)
7036     {
7037       std::vector< std::pair<int,int> > ts;
7038       med_int numdt=0,numo=0;
7039       med_int meshIt=0,meshOrder=0;
7040       med_float dt=0.0;
7041       MEDfieldComputingStepMeshInfo(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder);
7042       switch(fieldTyp)
7043         {
7044         case MED_FLOAT64:
7045           {
7046             _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7047             break;
7048           }
7049         case MED_INT32:
7050           {
7051             _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7052             break;
7053           }
7054         default:
7055           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
7056         }
7057       if(loadAll)
7058         _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this);
7059       else
7060         _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this);
7061     }
7062 }
7063
7064 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const
7065 {
7066   if(_time_steps.empty())
7067     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
7068   checkThatNbOfCompoOfTSMatchThis();
7069   std::vector<std::string> infos(getInfo());
7070   int nbComp=infos.size();
7071   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7072   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7073   for(int i=0;i<nbComp;i++)
7074     {
7075       std::string info=infos[i];
7076       std::string c,u;
7077       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
7078       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7079       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7080     }
7081   if(_name.empty())
7082     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
7083   MEDfieldCr(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
7084   int nbOfTS=_time_steps.size();
7085   for(int i=0;i<nbOfTS;i++)
7086     _time_steps[i]->writeLL(fid,opts,*this);
7087 }
7088
7089 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
7090 {
7091   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7092     {
7093       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7094       if(elt)
7095         elt->loadBigArraysRecursively(fid,nasc);
7096     }
7097 }
7098
7099 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
7100 {
7101   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7102     {
7103       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7104       if(elt)
7105         elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
7106     }
7107 }
7108
7109 void MEDFileAnyTypeFieldMultiTSWithoutSDA::unloadArrays()
7110 {
7111   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7112     {
7113       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7114       if(elt)
7115         elt->unloadArrays();
7116     }
7117 }
7118
7119 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
7120 {
7121   return _time_steps.size();
7122 }
7123
7124 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS()
7125 {
7126   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  > newTS;
7127   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7128     {
7129       const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
7130       if(tmp)
7131         newTS.push_back(*it);
7132     }
7133   _time_steps=newTS;
7134 }
7135
7136 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds)
7137 {
7138   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7139   int maxId=(int)_time_steps.size();
7140   int ii=0;
7141   std::set<int> idsToDel;
7142   for(const int *id=startIds;id!=endIds;id++,ii++)
7143     {
7144       if(*id>=0 && *id<maxId)
7145         {
7146           idsToDel.insert(*id);
7147         }
7148       else
7149         {
7150           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
7151           throw INTERP_KERNEL::Exception(oss.str().c_str());
7152         }
7153     }
7154   for(int iii=0;iii<maxId;iii++)
7155     if(idsToDel.find(iii)==idsToDel.end())
7156       newTS.push_back(_time_steps[iii]);
7157   _time_steps=newTS;
7158 }
7159
7160 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step)
7161 {
7162   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
7163   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7164   if(nbOfEntriesToKill==0)
7165     return ;
7166   std::size_t sz=_time_steps.size();
7167   std::vector<bool> b(sz,true);
7168   int j=bg;
7169   for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
7170     b[j]=false;
7171   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7172   for(std::size_t i=0;i<sz;i++)
7173     if(b[i])
7174       newTS.push_back(_time_steps[i]);
7175   _time_steps=newTS;
7176 }
7177
7178 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const
7179 {
7180   int ret=0;
7181   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
7182   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7183     {
7184       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7185       if(tmp)
7186         {
7187           int it2,ord;
7188           tmp->getTime(it2,ord);
7189           if(it2==iteration && order==ord)
7190             return ret;
7191           else
7192             oss << "(" << it2 << ","  << ord << "), ";
7193         }
7194     }
7195   throw INTERP_KERNEL::Exception(oss.str().c_str());
7196 }
7197
7198 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const
7199 {
7200   int ret=0;
7201   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
7202   oss.precision(15);
7203   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7204     {
7205       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7206       if(tmp)
7207         {
7208           int it2,ord;
7209           double ti=tmp->getTime(it2,ord);
7210           if(fabs(time-ti)<eps)
7211             return ret;
7212           else
7213             oss << ti << ", ";
7214         }
7215     }
7216   throw INTERP_KERNEL::Exception(oss.str().c_str());
7217 }
7218
7219 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
7220 {
7221   int lgth=_time_steps.size();
7222   std::vector< std::pair<int,int> > ret(lgth);
7223   for(int i=0;i<lgth;i++)
7224     _time_steps[i]->fillIteration(ret[i]);
7225   return ret;
7226 }
7227
7228 /*!
7229  * 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'
7230  * This method returns two things.
7231  * - The absolute dimension of 'this' in first parameter.
7232  * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
7233  *   to the first output parameter. The values in 'levs' will be returned in decreasing order.
7234  *
7235  * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
7236  * Only these 3 discretizations will be taken into account here.
7237  *
7238  * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
7239  * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
7240  * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
7241  *
7242  * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
7243  * 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'.
7244  *
7245  * Let's consider the typical following case :
7246  * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
7247  * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
7248  * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
7249  *   TETRA4 and SEG2
7250  * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
7251  *
7252  * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
7253  *
7254  * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
7255  * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
7256  * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
7257  * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
7258  */
7259 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
7260 {
7261   return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
7262 }
7263
7264 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const
7265 {
7266   if(pos<0 || pos>=(int)_time_steps.size())
7267     {
7268       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7269       throw INTERP_KERNEL::Exception(oss.str().c_str());
7270     }
7271   const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7272   if(item==0)
7273     {
7274       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7275       oss << "\nTry to use following method eraseEmptyTS !";
7276       throw INTERP_KERNEL::Exception(oss.str().c_str());
7277     }
7278   return item;
7279 }
7280
7281 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos)
7282 {
7283   if(pos<0 || pos>=(int)_time_steps.size())
7284     {
7285       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7286       throw INTERP_KERNEL::Exception(oss.str().c_str());
7287     }
7288   MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7289   if(item==0)
7290     {
7291       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7292       oss << "\nTry to use following method eraseEmptyTS !";
7293       throw INTERP_KERNEL::Exception(oss.str().c_str());
7294     }
7295   return item;
7296 }
7297
7298 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
7299 {
7300   std::vector<std::string> ret;
7301   std::set<std::string> ret2;
7302   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7303     {
7304       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
7305       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7306         if(ret2.find(*it2)==ret2.end())
7307           {
7308             ret.push_back(*it2);
7309             ret2.insert(*it2);
7310           }
7311     }
7312   return ret;
7313 }
7314
7315 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
7316 {
7317   std::vector<std::string> ret;
7318   std::set<std::string> ret2;
7319   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7320     {
7321       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
7322       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7323         if(ret2.find(*it2)==ret2.end())
7324           {
7325             ret.push_back(*it2);
7326             ret2.insert(*it2);
7327           }
7328     }
7329   return ret;
7330 }
7331
7332 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
7333 {
7334   std::vector<std::string> ret;
7335   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7336     {
7337       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
7338       ret.insert(ret.end(),tmp.begin(),tmp.end());
7339     }
7340   return ret;
7341 }
7342
7343 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
7344 {
7345   std::vector<std::string> ret;
7346   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7347     {
7348       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
7349       ret.insert(ret.end(),tmp.begin(),tmp.end());
7350     }
7351   return ret;
7352 }
7353
7354 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7355 {
7356   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7357     (*it)->changePflsRefsNamesGen2(mapOfModif);
7358 }
7359
7360 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7361 {
7362   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7363     (*it)->changeLocsRefsNamesGen2(mapOfModif);
7364 }
7365
7366 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const
7367 {
7368   int lgth=_time_steps.size();
7369   std::vector< std::vector<TypeOfField> > ret(lgth);
7370   for(int i=0;i<lgth;i++)
7371     _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
7372   return ret;
7373 }
7374
7375 /*!
7376  * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
7377  */
7378 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeFieldMultiTSWithoutSDA::getFieldSplitedByType(int iteration, int order, const std::string& 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
7379 {
7380   return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
7381 }
7382
7383 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCpy() const
7384 {
7385   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
7386   std::size_t i=0;
7387   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7388     {
7389       if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
7390         ret->_time_steps[i]=(*it)->deepCpy();
7391     }
7392   return ret.retn();
7393 }
7394
7395 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const
7396 {
7397   std::size_t sz(_infos.size()),sz2(_time_steps.size());
7398   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
7399   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
7400   for(std::size_t i=0;i<sz;i++)
7401     {
7402       ret[i]=shallowCpy();
7403       ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
7404     }
7405   for(std::size_t i=0;i<sz2;i++)
7406     {
7407       std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
7408       if(ret1.size()!=sz)
7409         {
7410           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
7411           throw INTERP_KERNEL::Exception(oss.str().c_str());
7412         }
7413       ts[i]=ret1;
7414     }
7415   for(std::size_t i=0;i<sz;i++)
7416     for(std::size_t j=0;j<sz2;j++)
7417       ret[i]->_time_steps[j]=ts[j][i];
7418   return ret;
7419 }
7420
7421 /*!
7422  * This method splits into discretization each time steps in \a this.
7423  * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
7424  */
7425 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const
7426 {
7427   std::size_t sz(_time_steps.size());
7428   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7429   for(std::size_t i=0;i<sz;i++)
7430     {
7431       const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7432       if(!timeStep)
7433         {
7434           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
7435           throw INTERP_KERNEL::Exception(oss.str().c_str());
7436         }
7437       items[i]=timeStep->splitDiscretizations();
7438     }
7439   //
7440   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
7441   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
7442   std::vector< TypeOfField > types;
7443   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7444     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7445       {
7446         std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
7447         if(ts.size()!=1)
7448           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
7449         std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
7450         if(it2==types.end())
7451           types.push_back(ts[0]);
7452       }
7453   ret.resize(types.size()); ret2.resize(types.size());
7454   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7455     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7456       {
7457         TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
7458         std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
7459         ret2[pos].push_back(*it1);
7460       }
7461   for(std::size_t i=0;i<types.size();i++)
7462     {
7463       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=createNew();
7464       for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
7465         elt->pushBackTimeStep(*it1);//also updates infos in elt
7466       ret[i]=elt;
7467       elt->MEDFileFieldNameScope::operator=(*this);
7468     }
7469   return ret;
7470 }
7471
7472 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
7473 {
7474   _name=field->getName();
7475   if(_name.empty())
7476     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
7477   if(!arr)
7478     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
7479   _infos=arr->getInfoOnComponents();
7480 }
7481
7482 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const
7483 {
7484   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
7485   if(_name!=field->getName())
7486     {
7487       std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
7488       oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
7489       throw INTERP_KERNEL::Exception(oss.str().c_str());
7490     }
7491   if(!arr)
7492     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
7493   checkThatComponentsMatch(arr->getInfoOnComponents());
7494 }
7495
7496 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const
7497 {
7498   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
7499   if(getInfo().size()!=compos.size())
7500     {
7501       std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
7502       oss << " number of components of element to append (" << compos.size() << ") !";
7503       throw INTERP_KERNEL::Exception(oss.str().c_str());
7504     }
7505   if(_infos!=compos)
7506     {
7507       std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
7508       std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
7509       oss << " But compo in input fields are : ";
7510       std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
7511       oss << " !";
7512       throw INTERP_KERNEL::Exception(oss.str().c_str());
7513     }
7514 }
7515
7516 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const
7517 {
7518   std::size_t sz=_infos.size();
7519   int j=0;
7520   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
7521     {
7522       const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7523       if(elt)
7524         if(elt->getInfo().size()!=sz)
7525           {
7526             std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
7527             oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
7528             throw INTERP_KERNEL::Exception(oss.str().c_str());
7529           }
7530     }
7531 }
7532
7533 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
7534 {
7535   if(!field)
7536     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7537   if(!_time_steps.empty())
7538     checkCoherencyOfTinyInfo(field,arr);
7539   MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
7540   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7541   objC->setFieldNoProfileSBT(field,arr,glob,*this);
7542   copyTinyInfoFrom(field,arr);
7543   _time_steps.push_back(obj);
7544 }
7545
7546 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob)
7547 {
7548   if(!field)
7549     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7550   if(!_time_steps.empty())
7551     checkCoherencyOfTinyInfo(field,arr);
7552   MEDFileField1TSWithoutSDA *objC=new MEDFileField1TSWithoutSDA;
7553   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7554   objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
7555   copyTinyInfoFrom(field,arr);
7556   _time_steps.push_back(obj);
7557 }
7558
7559 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ts)
7560 {
7561   int sz=(int)_time_steps.size();
7562   if(i<0 || i>=sz)
7563     {
7564       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
7565       throw INTERP_KERNEL::Exception(oss.str().c_str());
7566     }
7567   const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
7568   if(tsPtr)
7569     {
7570       if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
7571         {
7572           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() <<  " !";
7573           throw INTERP_KERNEL::Exception(oss.str().c_str());
7574         }
7575     }
7576   _time_steps[i]=ts;
7577 }
7578
7579 //= MEDFileFieldMultiTSWithoutSDA
7580
7581 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::New(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll)
7582 {
7583   return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7584 }
7585
7586 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
7587 {
7588 }
7589
7590 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7591 {
7592 }
7593
7594 /*!
7595  * \param [in] fieldId field id in C mode
7596  */
7597 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7598 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7599 {
7600 }
7601 catch(INTERP_KERNEL::Exception& e)
7602   { throw e; }
7603
7604 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll)
7605 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7606 {
7607 }
7608 catch(INTERP_KERNEL::Exception& e)
7609 { throw e; }
7610
7611 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7612 {
7613   return new MEDFileField1TSWithoutSDA;
7614 }
7615
7616 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7617 {
7618   if(!f1ts)
7619     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7620   const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
7621   if(!f1tsC)
7622     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
7623 }
7624
7625 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const
7626 {
7627   return MEDFileField1TSWithoutSDA::TYPE_STR;
7628 }
7629
7630 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const
7631 {
7632   return new MEDFileFieldMultiTSWithoutSDA(*this);
7633 }
7634
7635 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const
7636 {
7637   return new MEDFileFieldMultiTSWithoutSDA;
7638 }
7639
7640 /*!
7641  * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
7642  * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
7643  */
7644 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2(int iteration, int order, const std::string& 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
7645 {
7646   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
7647   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
7648   if(!myF1TSC)
7649     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
7650   return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
7651 }
7652
7653 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const
7654 {
7655   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
7656   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7657   int i=0;
7658   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7659     {
7660       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7661       if(eltToConv)
7662         {
7663           const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
7664           if(!eltToConvC)
7665             throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
7666           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
7667           ret->setIteration(i,elt);
7668         }
7669     }
7670   return ret.retn();
7671 }
7672
7673 //= MEDFileAnyTypeFieldMultiTS
7674
7675 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
7676 {
7677 }
7678
7679 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const std::string& fileName, bool loadAll)
7680 try:MEDFileFieldGlobsReal(fileName)
7681 {
7682   MEDFileUtilities::CheckFileForRead(fileName);
7683   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7684   _content=BuildContentFrom(fid,fileName,loadAll);
7685   loadGlobals(fid);
7686 }
7687 catch(INTERP_KERNEL::Exception& e)
7688   {
7689     throw e;
7690   }
7691
7692 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const std::string& fileName, const std::string& fieldName, bool loadAll)
7693 {
7694   med_field_type typcha;
7695   std::vector<std::string> infos;
7696   std::string dtunit;
7697   int i=-1;
7698   MEDFileAnyTypeField1TS::LocateField(fid,fileName,fieldName,i,typcha,infos,dtunit);
7699   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7700   switch(typcha)
7701     {
7702     case MED_FLOAT64:
7703       {
7704         ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll);
7705         break;
7706       }
7707     case MED_INT32:
7708       {
7709         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll);
7710         break;
7711       }
7712     default:
7713       {
7714         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] !";
7715         throw INTERP_KERNEL::Exception(oss.str().c_str());
7716       }
7717     }
7718   ret->setDtUnit(dtunit.c_str());
7719   return ret.retn();
7720 }
7721
7722 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const std::string& fileName, bool loadAll)
7723 {
7724   med_field_type typcha;
7725   //
7726   std::vector<std::string> infos;
7727   std::string dtunit,fieldName;
7728   MEDFileAnyTypeField1TS::LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
7729   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7730   switch(typcha)
7731     {
7732     case MED_FLOAT64:
7733       {
7734         ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll);
7735         break;
7736       }
7737     case MED_INT32:
7738       {
7739         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll);
7740         break;
7741       }
7742     default:
7743       {
7744         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] !";
7745         throw INTERP_KERNEL::Exception(oss.str().c_str());
7746       }
7747     }
7748   ret->setDtUnit(dtunit.c_str());
7749   return ret.retn();
7750 }
7751
7752 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, const std::string& fileName)
7753 {
7754   if(!c)
7755     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
7756   if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
7757     {
7758       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=MEDFileFieldMultiTS::New();
7759       ret->setFileName(fileName);
7760       ret->_content=c;  c->incrRef();
7761       return ret.retn();
7762     }
7763   if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
7764     {
7765       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=MEDFileIntFieldMultiTS::New();
7766       ret->setFileName(fileName);
7767       ret->_content=c;  c->incrRef();
7768       return ret.retn();
7769     }
7770   throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
7771 }
7772
7773 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const std::string& fileName, const std::string& fieldName, bool loadAll)
7774 try:MEDFileFieldGlobsReal(fileName)
7775 {
7776   MEDFileUtilities::CheckFileForRead(fileName);
7777   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7778   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
7779   loadGlobals(fid);
7780 }
7781 catch(INTERP_KERNEL::Exception& e)
7782   {
7783     throw e;
7784   }
7785
7786 //= MEDFileIntFieldMultiTSWithoutSDA
7787
7788 MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::New(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll)
7789 {
7790   return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7791 }
7792
7793 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
7794 {
7795 }
7796
7797 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7798 {
7799 }
7800
7801 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll)
7802 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7803 {
7804 }
7805 catch(INTERP_KERNEL::Exception& e)
7806 { throw e; }
7807
7808 /*!
7809  * \param [in] fieldId field id in C mode
7810  */
7811 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7812 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7813 {
7814 }
7815 catch(INTERP_KERNEL::Exception& e)
7816   { throw e; }
7817
7818 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7819 {
7820   return new MEDFileIntField1TSWithoutSDA;
7821 }
7822
7823 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7824 {
7825   if(!f1ts)
7826     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7827   const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
7828   if(!f1tsC)
7829     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
7830 }
7831
7832 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const
7833 {
7834   return MEDFileIntField1TSWithoutSDA::TYPE_STR;
7835 }
7836
7837 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const
7838 {
7839   return new MEDFileIntFieldMultiTSWithoutSDA(*this);
7840 }
7841
7842 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const
7843 {
7844   return new MEDFileIntFieldMultiTSWithoutSDA;
7845 }
7846
7847 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const
7848 {
7849   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
7850   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7851   int i=0;
7852   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7853     {
7854       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7855       if(eltToConv)
7856         {
7857           const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
7858           if(!eltToConvC)
7859             throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
7860           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
7861           ret->setIteration(i,elt);
7862         }
7863     }
7864   return ret.retn();
7865 }
7866
7867 //= MEDFileAnyTypeFieldMultiTS
7868
7869 /*!
7870  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
7871  * that has been read from a specified MED file.
7872  *  \param [in] fileName - the name of the MED file to read.
7873  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7874  *          is to delete this field using decrRef() as it is no more needed.
7875  *  \throw If reading the file fails.
7876  */
7877 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, bool loadAll)
7878 {
7879   MEDFileUtilities::CheckFileForRead(fileName);
7880   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7881   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
7882   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7883   ret->loadGlobals(fid);
7884   return ret.retn();
7885 }
7886
7887 /*!
7888  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
7889  * that has been read from a specified MED file.
7890  *  \param [in] fileName - the name of the MED file to read.
7891  *  \param [in] fieldName - the name of the field to read.
7892  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7893  *          is to delete this field using decrRef() as it is no more needed.
7894  *  \throw If reading the file fails.
7895  *  \throw If there is no field named \a fieldName in the file.
7896  */
7897 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
7898 {
7899   MEDFileUtilities::CheckFileForRead(fileName);
7900   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7901   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
7902   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7903   ret->loadGlobals(fid);
7904   return ret.retn();
7905 }
7906
7907 /*!
7908  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
7909  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
7910  *
7911  * \warning this is a shallow copy constructor
7912  */
7913 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
7914 {
7915   if(!shallowCopyOfContent)
7916     {
7917       const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
7918       otherPtr->incrRef();
7919       _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
7920     }
7921   else
7922     {
7923       _content=other.shallowCpy();
7924     }
7925 }
7926
7927 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase()
7928 {
7929   MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7930   if(!ret)
7931     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
7932   return ret;
7933 }
7934
7935 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const
7936 {
7937   const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7938   if(!ret)
7939     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
7940   return ret;
7941 }
7942
7943 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
7944 {
7945   return contentNotNullBase()->getPflsReallyUsed2();
7946 }
7947
7948 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
7949 {
7950   return contentNotNullBase()->getLocsReallyUsed2();
7951 }
7952
7953 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
7954 {
7955   return contentNotNullBase()->getPflsReallyUsedMulti2();
7956 }
7957
7958 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
7959 {
7960   return contentNotNullBase()->getLocsReallyUsedMulti2();
7961 }
7962
7963 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7964 {
7965   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
7966 }
7967
7968 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7969 {
7970   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
7971 }
7972
7973 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
7974 {
7975   return contentNotNullBase()->getNumberOfTS();
7976 }
7977
7978 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS()
7979 {
7980   contentNotNullBase()->eraseEmptyTS();
7981 }
7982
7983 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
7984 {
7985   contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
7986 }
7987
7988 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step)
7989 {
7990   contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
7991 }
7992
7993 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const
7994 {
7995   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
7996   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7997   ret->_content=c;
7998   return ret.retn();
7999 }
8000
8001 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const
8002 {
8003   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
8004   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8005   ret->_content=c;
8006   return ret.retn();
8007 }
8008
8009 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
8010 {
8011   return contentNotNullBase()->getIterations();
8012 }
8013
8014 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts)
8015 {
8016   for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
8017     pushBackTimeStep(*it);
8018 }
8019
8020 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts)
8021 {
8022   if(!f1ts)
8023     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
8024   checkCoherencyOfType(f1ts);
8025   f1ts->incrRef();
8026   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
8027   MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
8028   c->incrRef();
8029   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
8030   if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
8031     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
8032   _content->pushBackTimeStep(cSafe);
8033   appendGlobs(*f1ts,1e-12);
8034 }
8035
8036 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope()
8037 {
8038   contentNotNullBase()->synchronizeNameScope();
8039 }
8040
8041 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const
8042 {
8043   return contentNotNullBase()->getPosOfTimeStep(iteration,order);
8044 }
8045
8046 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const
8047 {
8048   return contentNotNullBase()->getPosGivenTime(time,eps);
8049 }
8050
8051 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
8052 {
8053   return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
8054 }
8055
8056 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const
8057 {
8058   return contentNotNullBase()->getTypesOfFieldAvailable();
8059 }
8060
8061 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeFieldMultiTS::getFieldSplitedByType(int iteration, int order, const std::string& 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
8062 {
8063   return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
8064 }
8065
8066 std::string MEDFileAnyTypeFieldMultiTS::getName() const
8067 {
8068   return contentNotNullBase()->getName();
8069 }
8070
8071 void MEDFileAnyTypeFieldMultiTS::setName(const std::string& name)
8072 {
8073   contentNotNullBase()->setName(name);
8074 }
8075
8076 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const
8077 {
8078   return contentNotNullBase()->getDtUnit();
8079 }
8080
8081 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const std::string& dtUnit)
8082 {
8083   contentNotNullBase()->setDtUnit(dtUnit);
8084 }
8085
8086 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
8087 {
8088   contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
8089 }
8090
8091 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const
8092 {
8093   return contentNotNullBase()->getTimeSteps(ret1);
8094 }
8095
8096 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const
8097 {
8098   return contentNotNullBase()->getMeshName();
8099 }
8100
8101 void MEDFileAnyTypeFieldMultiTS::setMeshName(const std::string& newMeshName)
8102 {
8103   contentNotNullBase()->setMeshName(newMeshName);
8104 }
8105
8106 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
8107 {
8108   return contentNotNullBase()->changeMeshNames(modifTab);
8109 }
8110
8111 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const
8112 {
8113   return contentNotNullBase()->getInfo();
8114 }
8115
8116 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info)
8117 {
8118   return contentNotNullBase()->setInfo(info);
8119 }
8120
8121 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const
8122 {
8123   const std::vector<std::string> ret=getInfo();
8124   return (int)ret.size();
8125 }
8126
8127 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const
8128 {
8129   writeGlobals(fid,*this);
8130   contentNotNullBase()->writeLL(fid,*this);
8131 }
8132
8133 /*!
8134  * Writes \a this field into a MED file specified by its name.
8135  *  \param [in] fileName - the MED file name.
8136  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
8137  * - 2 - erase; an existing file is removed.
8138  * - 1 - append; same data should not be present in an existing file.
8139  * - 0 - overwrite; same data present in an existing file is overwritten.
8140  *  \throw If the field name is not set.
8141  *  \throw If no field data is set.
8142  *  \throw If \a mode == 1 and the same data is present in an existing file.
8143  */
8144 void MEDFileAnyTypeFieldMultiTS::write(const std::string& fileName, int mode) const
8145 {
8146   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
8147   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
8148   writeLL(fid);
8149 }
8150
8151 /*!
8152  * This method alloc the arrays and load potentially huge arrays contained in this field.
8153  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
8154  * This method can be also called to refresh or reinit values from a file.
8155  *
8156  * \throw If the fileName is not set or points to a non readable MED file.
8157  */
8158 void MEDFileAnyTypeFieldMultiTS::loadArrays()
8159 {
8160   if(getFileName().empty())
8161     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::loadArrays : the structure does not come from a file !");
8162   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
8163   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
8164 }
8165
8166 /*!
8167  * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
8168  * But once data loaded once, this method does nothing.
8169  *
8170  * \throw If the fileName is not set or points to a non readable MED file.
8171  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::unloadArrays
8172  */
8173 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary()
8174 {
8175   if(!getFileName().empty())
8176     {
8177       MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
8178       contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
8179     }
8180 }
8181
8182 /*!
8183  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
8184  * This method does not release arrays set outside the context of a MED file.
8185  *
8186  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
8187  */
8188 void MEDFileAnyTypeFieldMultiTS::unloadArrays()
8189 {
8190   contentNotNullBase()->unloadArrays();
8191 }
8192
8193 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
8194 {
8195   std::ostringstream oss;
8196   contentNotNullBase()->simpleRepr(0,oss,-1);
8197   simpleReprGlobs(oss);
8198   return oss.str();
8199 }
8200
8201 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySizeWithoutChildren() const
8202 {
8203   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
8204 }
8205
8206 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTS::getDirectChildren() const
8207 {
8208   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
8209   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8210     ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content);
8211   return ret;
8212 }
8213
8214 /*!
8215  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
8216  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8217  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
8218  */
8219 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const
8220 {
8221   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8222   if(!content)
8223     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
8224   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
8225   std::size_t sz(contentsSplit.size());
8226   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8227   for(std::size_t i=0;i<sz;i++)
8228     {
8229       ret[i]=shallowCpy();
8230       ret[i]->_content=contentsSplit[i];
8231     }
8232   return ret;
8233 }
8234
8235 /*!
8236  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
8237  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8238  */
8239 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const
8240 {
8241   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8242   if(!content)
8243     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
8244   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitDiscretizations();
8245   std::size_t sz(contentsSplit.size());
8246   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8247   for(std::size_t i=0;i<sz;i++)
8248     {
8249       ret[i]=shallowCpy();
8250       ret[i]->_content=contentsSplit[i];
8251     }
8252   return ret;
8253 }
8254
8255 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCpy() const
8256 {
8257   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8258   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8259     ret->_content=_content->deepCpy();
8260   ret->deepCpyGlobs(*this);
8261   return ret.retn();
8262 }
8263
8264 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
8265 {
8266   return _content;
8267 }
8268
8269 /*!
8270  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8271  *  \param [in] iteration - the iteration number of a required time step.
8272  *  \param [in] order - the iteration order number of required time step.
8273  *  \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
8274  *          delete this field using decrRef() as it is no more needed.
8275  *  \throw If there is no required time step in \a this field.
8276  */
8277 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const
8278 {
8279   int pos=getPosOfTimeStep(iteration,order);
8280   return getTimeStepAtPos(pos);
8281 }
8282
8283 /*!
8284  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8285  *  \param [in] time - the time of the time step of interest.
8286  *  \param [in] eps - a precision used to compare time values.
8287  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8288  *          delete this field using decrRef() as it is no more needed.
8289  *  \throw If there is no required time step in \a this field.
8290  */
8291 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const
8292 {
8293   int pos=getPosGivenTime(time,eps);
8294   return getTimeStepAtPos(pos);
8295 }
8296
8297 /*!
8298  * 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.
8299  * The float64 value of time attached to the pair of integers are not considered here.
8300  * WARNING the returned pointers are not incremented. The caller is \b not responsible to deallocate them ! This method only reorganizes entries in \a vectFMTS.
8301  *
8302  * \param [in] vectFMTS - vector of not null fields defined on a same global data pointer.
8303  * \throw If there is a null pointer in \a vectFMTS.
8304  */
8305 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS)
8306 {
8307   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries : presence of null instance in input vector !";
8308   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8309   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8310   while(!lstFMTS.empty())
8311     {
8312       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8313       MEDFileAnyTypeFieldMultiTS *curIt(*it);
8314       if(!curIt)
8315         throw INTERP_KERNEL::Exception(msg);
8316       std::vector< std::pair<int,int> > refIts=curIt->getIterations();
8317       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8318       elt.push_back(curIt); it=lstFMTS.erase(it);
8319       while(it!=lstFMTS.end())
8320         {
8321           curIt=*it;
8322           if(!curIt)
8323             throw INTERP_KERNEL::Exception(msg);
8324           std::vector< std::pair<int,int> > curIts=curIt->getIterations();
8325           if(refIts==curIts)
8326             { elt.push_back(curIt); it=lstFMTS.erase(it); }
8327           else
8328             it++;
8329         }
8330       ret.push_back(elt);
8331     }
8332   return ret;
8333 }
8334
8335 /*!
8336  * This method splits the input list \a vectFMTS considering the aspect of the geometrical support over time.
8337  * All returned instances in a subvector can be safely loaded, rendered along time
8338  * All items must be defined on the same time step ids ( see MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries method ).
8339  * Each item in \a vectFMTS is expected to have one and exactly one spatial discretization along time.
8340  * All items in \a vectFMTS must lie on the mesh (located by meshname and time step) and compatible with the input mesh \a mesh (having the same name than those in items).
8341  * All items in \a vectFMTS whose spatial discretization is not ON_NODES will appear once.
8342  * For items in \a vectFMTS that are ON_NODES it is possible to appear several times (more than once or once) in the returned vector.
8343  *
8344  * \param [in] vectFMTS - list of multi times step part all defined each on a same spatial discretization along time and pointing to a mesh whose name is equal to \c mesh->getName().
8345  * \param [in] mesh - the mesh shared by all items in \a vectFMTS across time.
8346  * \param [out] fsc - A vector having same size than returned vector. It specifies the support comporator of the corresponding vector of MEDFileAnyTypeFieldMultiTS in returned vector of vector.
8347  * \return - A vector of vector of objects that contains the same pointers (objects) than thoose in \a vectFMTS except that there are organized differently. So pointers included in returned vector of vector should \b not been dealt by the caller.
8348  *
8349  * \throw If an element in \a vectFMTS has not only one spatial discretization set.
8350  * \throw If an element in \a vectFMTS change of spatial discretization along time.
8351  * \throw If an element in \a vectFMTS lies on a mesh with meshname different from those in \a mesh.
8352  * \thorw If some elements in \a vectFMTS do not have the same times steps.
8353  * \throw If mesh is null.
8354  * \throw If an element in \a vectFMTS is null.
8355  * \sa MEDFileAnyTypeFieldMultiTS::AreOnSameSupportAcrossTime
8356  */
8357 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& fsc)
8358 {
8359   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : presence of a null instance in the input vector !";
8360   if(!mesh)
8361     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : input mesh is null !");
8362   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8363   if(vectFMTS.empty())
8364     return ret;
8365   std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it(vectFMTS.begin());
8366   MEDFileAnyTypeFieldMultiTS *frstElt(*it);
8367   if(!frstElt)
8368     throw INTERP_KERNEL::Exception(msg);
8369   std::size_t i=0;
8370   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNotNodes;
8371   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNodes;
8372   for(;it!=vectFMTS.end();it++,i++)
8373     {
8374       if(!(*it))
8375         throw INTERP_KERNEL::Exception(msg);
8376       TypeOfField tof0,tof1;
8377       if(CheckSupportAcrossTime(frstElt,*it,mesh,tof0,tof1)>0)
8378         {
8379           if(tof1!=ON_NODES)
8380             vectFMTSNotNodes.push_back(*it);
8381           else
8382             vectFMTSNodes.push_back(*it);
8383         }
8384       else
8385         vectFMTSNotNodes.push_back(*it);
8386     }
8387   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> > cmps;
8388   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > retCell=SplitPerCommonSupportNotNodesAlg(vectFMTSNotNodes,mesh,cmps);
8389   ret=retCell;
8390   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it2=vectFMTSNodes.begin();it2!=vectFMTSNodes.end();it2++)
8391     {
8392       i=0;
8393       bool isFetched(false);
8394       for(std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> >::const_iterator it0=retCell.begin();it0!=retCell.end();it0++,i++)
8395         {
8396           if((*it0).empty())
8397             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : internal error !");
8398           if(cmps[i]->isCompatibleWithNodesDiscr(*it2))
8399             { ret[i].push_back(*it2); isFetched=true; }
8400         }
8401       if(!isFetched)
8402         {
8403           std::vector<MEDFileAnyTypeFieldMultiTS *> tmp(1,*it2);
8404           MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> tmp2(MEDFileMeshStruct::New(mesh));
8405           ret.push_back(tmp); retCell.push_back(tmp); cmps.push_back(MEDFileFastCellSupportComparator::New(tmp2,*it2));
8406         }
8407     }
8408   fsc=cmps;
8409   return ret;
8410 }
8411
8412 /*!
8413  * WARNING no check here. The caller must be sure that all items in vectFMTS are coherent each other in time steps, only one same spatial discretization and not ON_NODES.
8414  * \param [out] cmps - same size than the returned vector.
8415  */
8416 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupportNotNodesAlg(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& cmps)
8417 {
8418   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8419   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8420   while(!lstFMTS.empty())
8421     {
8422       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8423       MEDFileAnyTypeFieldMultiTS *ref(*it);
8424       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8425       elt.push_back(ref); it=lstFMTS.erase(it);
8426       MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(mesh));
8427       MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> cmp(MEDFileFastCellSupportComparator::New(mst,ref));
8428       while(it!=lstFMTS.end())
8429         {
8430           MEDFileAnyTypeFieldMultiTS *curIt(*it);
8431           if(cmp->isEqual(curIt))
8432             { elt.push_back(curIt); it=lstFMTS.erase(it); }
8433           else
8434             it++;
8435         }
8436       ret.push_back(elt); cmps.push_back(cmp);
8437     }
8438   return ret;
8439 }
8440
8441 /*!
8442  * This method scan the two main structs along time of \a f0 and \a f1 to see if there are all lying on the same mesh along time than those in \a mesh.
8443  * \a f0 and \a f1 must be defined each only on a same spatial discretization even if this can be different each other.
8444  *
8445  * \throw If \a f0 or \a f1 has not only one spatial discretization set.
8446  * \throw If \a f0 or \a f1 change of spatial discretization along time.
8447  * \throw If \a f0 or \a f1 on a mesh with meshname different from those in \a mesh.
8448  * \thorw If \a f0 and \a f1 do not have the same times steps.
8449  * \throw If mesh is null.
8450  * \throw If \a f0 or \a f1 is null.
8451  * \sa MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport
8452  */
8453 int MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime(MEDFileAnyTypeFieldMultiTS *f0, MEDFileAnyTypeFieldMultiTS *f1, const MEDFileMesh *mesh, TypeOfField& tof0, TypeOfField& tof1)
8454 {
8455   if(!mesh)
8456     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : input mesh is null !");
8457   if(!f0 || !f1)
8458     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : presence of null instance in fields over time !");
8459   if(f0->getMeshName()!=mesh->getName())
8460     {
8461       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh \""<< f0->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8462       throw INTERP_KERNEL::Exception(oss.str().c_str());
8463     }
8464   if(f1->getMeshName()!=mesh->getName())
8465     {
8466       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh \""<< f1->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8467       throw INTERP_KERNEL::Exception(oss.str().c_str());
8468     }
8469   int nts=f0->getNumberOfTS();
8470   if(nts!=f1->getNumberOfTS())
8471     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : number of time steps are not the same !");
8472   if(nts==0)
8473     return nts;
8474   for(int i=0;i<nts;i++)
8475     {
8476       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f0cur=f0->getTimeStepAtPos(i);
8477       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1cur=f1->getTimeStepAtPos(i);
8478       std::vector<TypeOfField> tofs0(f0cur->getTypesOfFieldAvailable()),tofs1(f1cur->getTypesOfFieldAvailable());
8479       if(tofs0.size()!=1 || tofs1.size()!=1)
8480         throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : All time steps must be defined on only one spatial discretization !");
8481       if(i!=0)
8482         {
8483           if(tof0!=tofs0[0] || tof1!=tofs1[0])
8484             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : Across times steps MEDFileAnyTypeFieldMultiTS instances have to keep the same unique spatial discretization !");
8485         }
8486       else
8487         { tof0=tofs0[0]; tof1=tofs1[0]; }
8488       if(f0cur->getMeshIteration()!=mesh->getIteration() || f0cur->getMeshOrder()!=mesh->getOrder())
8489         {
8490           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh time step (" << f0cur->getMeshIteration() << ","<< f0cur->getMeshOrder() << ") whereas input mesh points to time step (" << mesh->getIteration() << "," << mesh->getOrder() << ") !";
8491           throw INTERP_KERNEL::Exception(oss.str().c_str());
8492         }
8493       if(f1cur->getMeshIteration()!=mesh->getIteration() || f1cur->getMeshOrder()!=mesh->getOrder())
8494         {
8495           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh time step (" << f1cur->getMeshIteration() << ","<< f1cur->getMeshOrder() << ") whereas input mesh points to time step (" << mesh->getIteration() << "," << mesh->getOrder() << ") !";
8496           throw INTERP_KERNEL::Exception(oss.str().c_str());
8497         }
8498       if(f0cur->getIteration()!=f1cur->getIteration() || f0cur->getOrder()!=f1cur->getOrder())
8499         {
8500           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : all the time steps must be the same ! it is not the case (" << f0cur->getIteration() << "," << f0cur->getOrder() << ")!=(" << f1cur->getIteration() << "," << f1cur->getOrder() << ") !";
8501           throw INTERP_KERNEL::Exception(oss.str().c_str());
8502         }
8503     }
8504   return nts;
8505 }
8506
8507 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator()
8508 {
8509   return new MEDFileAnyTypeFieldMultiTSIterator(this);
8510 }
8511
8512 //= MEDFileFieldMultiTS
8513
8514 /*!
8515  * Returns a new empty instance of MEDFileFieldMultiTS.
8516  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8517  *          is to delete this field using decrRef() as it is no more needed.
8518  */
8519 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
8520 {
8521   return new MEDFileFieldMultiTS;
8522 }
8523
8524 /*!
8525  * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
8526  * that has been read from a specified MED file.
8527  *  \param [in] fileName - the name of the MED file to read.
8528  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8529  *          is to delete this field using decrRef() as it is no more needed.
8530  *  \throw If reading the file fails.
8531  */
8532 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, bool loadAll)
8533 {
8534   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,loadAll);
8535   ret->contentNotNull();//to check that content type matches with \a this type.
8536   return ret.retn();
8537 }
8538
8539 /*!
8540  * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
8541  * that has been read from a specified MED file.
8542  *  \param [in] fileName - the name of the MED file to read.
8543  *  \param [in] fieldName - the name of the field to read.
8544  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8545  *          is to delete this field using decrRef() as it is no more needed.
8546  *  \throw If reading the file fails.
8547  *  \throw If there is no field named \a fieldName in the file.
8548  */
8549 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
8550 {
8551   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,fieldName,loadAll);
8552   ret->contentNotNull();//to check that content type matches with \a this type.
8553   return ret.retn();
8554 }
8555
8556 /*!
8557  * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8558  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8559  *
8560  * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
8561  * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8562  * \warning this is a shallow copy constructor
8563  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
8564  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8565  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8566  *          is to delete this field using decrRef() as it is no more needed.
8567  */
8568 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8569 {
8570   return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
8571 }
8572
8573 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const
8574 {
8575   return new MEDFileFieldMultiTS(*this);
8576 }
8577
8578 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
8579 {
8580   if(!f1ts)
8581     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8582   const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
8583   if(!f1tsC)
8584     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8585 }
8586
8587 /*!
8588  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
8589  * following the given input policy.
8590  *
8591  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8592  *                            By default (true) the globals are deeply copied.
8593  * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
8594  */
8595 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool isDeepCpyGlobs) const
8596 {
8597   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret;
8598   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8599   if(content)
8600     {
8601       const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
8602       if(!contc)
8603         throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
8604       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
8605       ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc,getFileName()));
8606     }
8607   else
8608     ret=MEDFileIntFieldMultiTS::New();
8609   if(isDeepCpyGlobs)
8610     ret->deepCpyGlobs(*this);
8611   else
8612     ret->shallowCpyGlobs(*this);
8613   return ret.retn();
8614 }
8615
8616 /*!
8617  * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
8618  *  \param [in] pos - a time step id.
8619  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8620  *          delete this field using decrRef() as it is no more needed.
8621  *  \throw If \a pos is not a valid time step id.
8622  */
8623 MEDFileAnyTypeField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const
8624 {
8625   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8626   if(!item)
8627     {
8628       std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8629       throw INTERP_KERNEL::Exception(oss.str().c_str());
8630     }
8631   const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
8632   if(itemC)
8633     {
8634       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
8635       ret->shallowCpyGlobs(*this);
8636       return ret.retn();
8637     }
8638   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
8639   throw INTERP_KERNEL::Exception(oss.str().c_str());
8640 }
8641
8642 /*!
8643  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8644  * mesh entities of a given dimension of the first mesh in MED file.
8645  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8646  *  \param [in] type - a spatial discretization of interest.
8647  *  \param [in] iteration - the iteration number of a required time step.
8648  *  \param [in] order - the iteration order number of required time step.
8649  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8650  *  \param [in] renumPol - specifies how to permute values of the result field according to
8651  *          the optional numbers of cells and nodes, if any. The valid values are
8652  *          - 0 - do not permute.
8653  *          - 1 - permute cells.
8654  *          - 2 - permute nodes.
8655  *          - 3 - permute cells and nodes.
8656  *
8657  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8658  *          caller is to delete this field using decrRef() as it is no more needed.
8659  *  \throw If the MED file is not readable.
8660  *  \throw If there is no mesh in the MED file.
8661  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8662  *  \throw If no field values of the required parameters are available.
8663  */
8664 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const
8665 {
8666   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8667   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8668   if(!myF1TSC)
8669     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
8670   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8671   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNullBase());
8672   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8673   return ret.retn();
8674 }
8675
8676 /*!
8677  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8678  * the top level cells of the first mesh in MED file.
8679  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8680  *  \param [in] type - a spatial discretization of interest.
8681  *  \param [in] iteration - the iteration number of a required time step.
8682  *  \param [in] order - the iteration order number of required time step.
8683  *  \param [in] renumPol - specifies how to permute values of the result field according to
8684  *          the optional numbers of cells and nodes, if any. The valid values are
8685  *          - 0 - do not permute.
8686  *          - 1 - permute cells.
8687  *          - 2 - permute nodes.
8688  *          - 3 - permute cells and nodes.
8689  *
8690  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8691  *          caller is to delete this field using decrRef() as it is no more needed.
8692  *  \throw If the MED file is not readable.
8693  *  \throw If there is no mesh in the MED file.
8694  *  \throw If no field values of the required parameters are available.
8695  */
8696 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const
8697 {
8698   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8699   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8700   if(!myF1TSC)
8701     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
8702   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8703   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNullBase());
8704   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8705   return ret.retn();
8706 }
8707
8708 /*!
8709  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8710  * a given support.
8711  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8712  *  \param [in] type - a spatial discretization of interest.
8713  *  \param [in] iteration - the iteration number of a required time step.
8714  *  \param [in] order - the iteration order number of required time step.
8715  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8716  *  \param [in] mesh - the supporting mesh.
8717  *  \param [in] renumPol - specifies how to permute values of the result field according to
8718  *          the optional numbers of cells and nodes, if any. The valid values are
8719  *          - 0 - do not permute.
8720  *          - 1 - permute cells.
8721  *          - 2 - permute nodes.
8722  *          - 3 - permute cells and nodes.
8723  *
8724  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8725  *          caller is to delete this field using decrRef() as it is no more needed.
8726  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8727  *  \throw If no field of \a this is lying on \a mesh.
8728  *  \throw If no field values of the required parameters are available.
8729  */
8730 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
8731 {
8732   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8733   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8734   if(!myF1TSC)
8735     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8736   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8737   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
8738   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8739   return ret.retn();
8740 }
8741
8742 /*!
8743  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8744  * given support.
8745  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8746  *  \param [in] type - a spatial discretization of the new field.
8747  *  \param [in] iteration - the iteration number of a required time step.
8748  *  \param [in] order - the iteration order number of required time step.
8749  *  \param [in] mesh - the supporting mesh.
8750  *  \param [in] renumPol - specifies how to permute values of the result field according to
8751  *          the optional numbers of cells and nodes, if any. The valid values are
8752  *          - 0 - do not permute.
8753  *          - 1 - permute cells.
8754  *          - 2 - permute nodes.
8755  *          - 3 - permute cells and nodes.
8756  *
8757  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8758  *          caller is to delete this field using decrRef() as it is no more needed.
8759  *  \throw If no field of \a this is lying on \a mesh.
8760  *  \throw If no field values of the required parameters are available.
8761  */
8762 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const
8763 {
8764   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8765   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8766   if(!myF1TSC)
8767     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8768   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8769   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
8770   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8771   return ret.retn();
8772 }
8773
8774 /*!
8775  * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
8776  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8777  * This method is useful for MED2 file format when field on different mesh was autorized.
8778  */
8779 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int iteration, int order, int meshDimRelToMax, int renumPol) const
8780 {
8781   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8782   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8783   if(!myF1TSC)
8784     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
8785   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8786   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
8787   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8788   return ret.retn();
8789 }
8790
8791 /*!
8792  * Returns values and a profile of the field of a given type, of a given time step,
8793  * lying on a given support.
8794  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8795  *  \param [in] type - a spatial discretization of the field.
8796  *  \param [in] iteration - the iteration number of a required time step.
8797  *  \param [in] order - the iteration order number of required time step.
8798  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8799  *  \param [in] mesh - the supporting mesh.
8800  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8801  *          field of interest lies on. If the field lies on all entities of the given
8802  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8803  *          using decrRef() as it is no more needed.
8804  *  \param [in] glob - the global data storing profiles and localization.
8805  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
8806  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8807  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8808  *  \throw If no field of \a this is lying on \a mesh.
8809  *  \throw If no field values of the required parameters are available.
8810  */
8811 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
8812 {
8813   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8814   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8815   if(!myF1TSC)
8816     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
8817   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8818   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
8819 }
8820
8821 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const
8822 {
8823   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8824   if(!pt)
8825     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
8826   const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
8827   if(!ret)
8828     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 !");
8829   return ret;
8830 }
8831
8832  MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull()
8833 {
8834   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8835   if(!pt)
8836     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
8837   MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
8838   if(!ret)
8839     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 !");
8840   return ret;
8841 }
8842
8843 /*!
8844  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8845  * the given field is checked if its elements are sorted suitable for writing to MED file
8846  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8847  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8848  *  \param [in] field - the field to add to \a this.
8849  *  \throw If the name of \a field is empty.
8850  *  \throw If the data array of \a field is not set.
8851  *  \throw If existing time steps have different name or number of components than \a field.
8852  *  \throw If the underlying mesh of \a field has no name.
8853  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8854  */
8855 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
8856 {
8857   const DataArrayDouble *arr=0;
8858   if(field)
8859     arr=field->getArray();
8860   contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
8861 }
8862
8863 /*!
8864  * Adds a MEDCouplingFieldDouble to \a this as another time step.
8865  * The mesh support of input parameter \a field is ignored here, it can be NULL.
8866  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
8867  * and \a profile.
8868  *
8869  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
8870  * A new profile is added only if no equal profile is missing.
8871  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8872  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
8873  *  \param [in] mesh - the supporting mesh of \a field.
8874  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
8875  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
8876  *  \throw If either \a field or \a mesh or \a profile has an empty name.
8877  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8878  *  \throw If the data array of \a field is not set.
8879  *  \throw If the data array of \a this is already allocated but has different number of
8880  *         components than \a field.
8881  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
8882  *  \sa setFieldNoProfileSBT()
8883  */
8884 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
8885 {
8886   const DataArrayDouble *arr=0;
8887   if(field)
8888     arr=field->getArray();
8889   contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
8890 }
8891
8892 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
8893 {
8894   _content=new MEDFileFieldMultiTSWithoutSDA;
8895 }
8896
8897 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const std::string& fileName, bool loadAll)
8898 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
8899 {
8900 }
8901 catch(INTERP_KERNEL::Exception& e)
8902   { throw e; }
8903
8904 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const std::string& fileName, const std::string& fieldName, bool loadAll)
8905 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
8906 {
8907 }
8908 catch(INTERP_KERNEL::Exception& e)
8909   { throw e; }
8910
8911 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
8912 {
8913 }
8914
8915 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTS::getFieldSplitedByType2(int iteration, int order, const std::string& 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
8916 {
8917   return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
8918 }
8919
8920 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
8921 {
8922   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
8923 }
8924
8925 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
8926 {
8927   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
8928 }
8929
8930 //= MEDFileAnyTypeFieldMultiTSIterator
8931
8932 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
8933 {
8934   if(fmts)
8935     {
8936       fmts->incrRef();
8937       _nb_iter=fmts->getNumberOfTS();
8938     }
8939 }
8940
8941 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
8942 {
8943 }
8944
8945 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt()
8946 {
8947   if(_iter_id<_nb_iter)
8948     {
8949       MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
8950       if(fmts)
8951         return fmts->getTimeStepAtPos(_iter_id++);
8952       else
8953         return 0;
8954     }
8955   else
8956     return 0;
8957 }
8958
8959 //= MEDFileIntFieldMultiTS
8960
8961 /*!
8962  * Returns a new empty instance of MEDFileFieldMultiTS.
8963  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8964  *          is to delete this field using decrRef() as it is no more needed.
8965  */
8966 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
8967 {
8968   return new MEDFileIntFieldMultiTS;
8969 }
8970
8971 /*!
8972  * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
8973  * that has been read from a specified MED file.
8974  *  \param [in] fileName - the name of the MED file to read.
8975  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8976  *          is to delete this field using decrRef() as it is no more needed.
8977  *  \throw If reading the file fails.
8978  */
8979 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, bool loadAll)
8980 {
8981   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,loadAll);
8982   ret->contentNotNull();//to check that content type matches with \a this type.
8983   return ret.retn();
8984 }
8985
8986 /*!
8987  * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
8988  * that has been read from a specified MED file.
8989  *  \param [in] fileName - the name of the MED file to read.
8990  *  \param [in] fieldName - the name of the field to read.
8991  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8992  *          is to delete this field using decrRef() as it is no more needed.
8993  *  \throw If reading the file fails.
8994  *  \throw If there is no field named \a fieldName in the file.
8995  */
8996 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
8997 {
8998   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,fieldName,loadAll);
8999   ret->contentNotNull();//to check that content type matches with \a this type.
9000   return ret.retn();
9001 }
9002
9003 /*!
9004  * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
9005  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
9006  *
9007  * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
9008  * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
9009  * \warning this is a shallow copy constructor
9010  *  \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
9011  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
9012  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
9013  *          is to delete this field using decrRef() as it is no more needed.
9014  */
9015 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
9016 {
9017   return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
9018 }
9019
9020 /*!
9021  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
9022  * following the given input policy.
9023  *
9024  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
9025  *                            By default (true) the globals are deeply copied.
9026  * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
9027  */
9028 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool isDeepCpyGlobs) const
9029 {
9030   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret;
9031   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9032   if(content)
9033     {
9034       const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
9035       if(!contc)
9036         throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
9037       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
9038       ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc,getFileName()));
9039     }
9040   else
9041     ret=MEDFileFieldMultiTS::New();
9042   if(isDeepCpyGlobs)
9043     ret->deepCpyGlobs(*this);
9044   else
9045     ret->shallowCpyGlobs(*this);
9046   return ret.retn();
9047 }
9048
9049 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const
9050 {
9051   return new MEDFileIntFieldMultiTS(*this);
9052 }
9053
9054 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
9055 {
9056   if(!f1ts)
9057     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
9058   const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
9059   if(!f1tsC)
9060     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
9061 }
9062
9063 /*!
9064  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9065  * mesh entities of a given dimension of the first mesh in MED file.
9066  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9067  *  \param [in] type - a spatial discretization of interest.
9068  *  \param [in] iteration - the iteration number of a required time step.
9069  *  \param [in] order - the iteration order number of required time step.
9070  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9071  *  \param [out] arrOut - the DataArrayInt containing values of field.
9072  *  \param [in] renumPol - specifies how to permute values of the result field according to
9073  *          the optional numbers of cells and nodes, if any. The valid values are
9074  *          - 0 - do not permute.
9075  *          - 1 - permute cells.
9076  *          - 2 - permute nodes.
9077  *          - 3 - permute cells and nodes.
9078  *
9079  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9080  *          caller is to delete this field using decrRef() as it is no more needed.
9081  *  \throw If the MED file is not readable.
9082  *  \throw If there is no mesh in the MED file.
9083  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9084  *  \throw If no field values of the required parameters are available.
9085  */
9086 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9087 {
9088   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9089   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9090   if(!myF1TSC)
9091     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
9092   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9093   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arr,*contentNotNullBase());
9094   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9095   return ret.retn();
9096 }
9097
9098 /*!
9099  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9100  * the top level cells of the first mesh in MED file.
9101  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9102  *  \param [in] type - a spatial discretization of interest.
9103  *  \param [in] iteration - the iteration number of a required time step.
9104  *  \param [in] order - the iteration order number of required time step.
9105  *  \param [out] arrOut - the DataArrayInt containing values of field.
9106  *  \param [in] renumPol - specifies how to permute values of the result field according to
9107  *          the optional numbers of cells and nodes, if any. The valid values are
9108  *          - 0 - do not permute.
9109  *          - 1 - permute cells.
9110  *          - 2 - permute nodes.
9111  *          - 3 - permute cells and nodes.
9112  *
9113  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9114  *          caller is to delete this field using decrRef() as it is no more needed.
9115  *  \throw If the MED file is not readable.
9116  *  \throw If there is no mesh in the MED file.
9117  *  \throw If no field values of the required parameters are available.
9118  */
9119 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, DataArrayInt* &arrOut, int renumPol) const
9120 {
9121   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9122   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9123   if(!myF1TSC)
9124     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
9125   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9126   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arr,*contentNotNullBase());
9127   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9128   return ret.retn();
9129 }
9130
9131 /*!
9132  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9133  * a given support.
9134  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9135  *  \param [in] type - a spatial discretization of interest.
9136  *  \param [in] iteration - the iteration number of a required time step.
9137  *  \param [in] order - the iteration order number of required time step.
9138  *  \param [out] arrOut - the DataArrayInt containing values of field.
9139  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9140  *  \param [in] mesh - the supporting mesh.
9141  *  \param [in] renumPol - specifies how to permute values of the result field according to
9142  *          the optional numbers of cells and nodes, if any. The valid values are
9143  *          - 0 - do not permute.
9144  *          - 1 - permute cells.
9145  *          - 2 - permute nodes.
9146  *          - 3 - permute cells and nodes.
9147  *
9148  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9149  *          caller is to delete this field using decrRef() as it is no more needed.
9150  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9151  *  \throw If no field of \a this is lying on \a mesh.
9152  *  \throw If no field values of the required parameters are available.
9153  */
9154 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9155 {
9156   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9157   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9158   if(!myF1TSC)
9159     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9160   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9161   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase());
9162   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9163   return ret.retn();
9164 }
9165
9166 /*!
9167  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
9168  * given support.
9169  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9170  *  \param [in] type - a spatial discretization of the new field.
9171  *  \param [in] iteration - the iteration number of a required time step.
9172  *  \param [in] order - the iteration order number of required time step.
9173  *  \param [in] mesh - the supporting mesh.
9174  *  \param [out] arrOut - the DataArrayInt containing values of field.
9175  *  \param [in] renumPol - specifies how to permute values of the result field according to
9176  *          the optional numbers of cells and nodes, if any. The valid values are
9177  *          - 0 - do not permute.
9178  *          - 1 - permute cells.
9179  *          - 2 - permute nodes.
9180  *          - 3 - permute cells and nodes.
9181  *
9182  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9183  *          caller is to delete this field using decrRef() as it is no more needed.
9184  *  \throw If no field of \a this is lying on \a mesh.
9185  *  \throw If no field values of the required parameters are available.
9186  */
9187 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9188 {
9189   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9190   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9191   if(!myF1TSC)
9192     throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9193   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9194   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase());
9195   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9196   return ret.retn();
9197 }
9198
9199 /*!
9200  * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
9201  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
9202  * This method is useful for MED2 file format when field on different mesh was autorized.
9203  */
9204 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const std::string& mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9205 {
9206   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9207   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9208   if(!myF1TSC)
9209     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9210   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9211   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase());
9212   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9213   return ret.retn();
9214 }
9215
9216 /*!
9217  * Returns values and a profile of the field of a given type, of a given time step,
9218  * lying on a given support.
9219  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9220  *  \param [in] type - a spatial discretization of the field.
9221  *  \param [in] iteration - the iteration number of a required time step.
9222  *  \param [in] order - the iteration order number of required time step.
9223  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9224  *  \param [in] mesh - the supporting mesh.
9225  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
9226  *          field of interest lies on. If the field lies on all entities of the given
9227  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
9228  *          using decrRef() as it is no more needed.
9229  *  \param [in] glob - the global data storing profiles and localization.
9230  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
9231  *          field. The caller is to delete this array using decrRef() as it is no more needed.
9232  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9233  *  \throw If no field of \a this is lying on \a mesh.
9234  *  \throw If no field values of the required parameters are available.
9235  */
9236 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
9237 {
9238   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9239   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9240   if(!myF1TSC)
9241     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
9242   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
9243   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(ret);
9244 }
9245
9246 /*!
9247  * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
9248  *  \param [in] pos - a time step id.
9249  *  \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
9250  *          delete this field using decrRef() as it is no more needed.
9251  *  \throw If \a pos is not a valid time step id.
9252  */
9253 MEDFileAnyTypeField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const
9254 {
9255   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
9256   if(!item)
9257     {
9258       std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
9259       throw INTERP_KERNEL::Exception(oss.str().c_str());
9260     }
9261   const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
9262   if(itemC)
9263     {
9264       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
9265       ret->shallowCpyGlobs(*this);
9266       return ret.retn();
9267     }
9268   std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
9269   throw INTERP_KERNEL::Exception(oss.str().c_str());
9270 }
9271
9272 /*!
9273  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
9274  * the given field is checked if its elements are sorted suitable for writing to MED file
9275  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
9276  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9277  *  \param [in] field - the field to add to \a this.
9278  *  \throw If the name of \a field is empty.
9279  *  \throw If the data array of \a field is not set.
9280  *  \throw If existing time steps have different name or number of components than \a field.
9281  *  \throw If the underlying mesh of \a field has no name.
9282  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
9283  */
9284 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
9285 {
9286   contentNotNull()->appendFieldNoProfileSBT(field,arrOfVals,*this);
9287 }
9288
9289 /*!
9290  * Adds a MEDCouplingFieldDouble to \a this as another time step.
9291  * The mesh support of input parameter \a field is ignored here, it can be NULL.
9292  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
9293  * and \a profile.
9294  *
9295  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
9296  * A new profile is added only if no equal profile is missing.
9297  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9298  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
9299  *  \param [in] arrOfVals - the values of the field \a field used.
9300  *  \param [in] mesh - the supporting mesh of \a field.
9301  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
9302  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
9303  *  \throw If either \a field or \a mesh or \a profile has an empty name.
9304  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9305  *  \throw If the data array of \a field is not set.
9306  *  \throw If the data array of \a this is already allocated but has different number of
9307  *         components than \a field.
9308  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
9309  *  \sa setFieldNoProfileSBT()
9310  */
9311 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
9312 {
9313   contentNotNull()->appendFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this);
9314 }
9315
9316 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const
9317 {
9318   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9319   if(!pt)
9320     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
9321   const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9322   if(!ret)
9323     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 !");
9324   return ret;
9325 }
9326
9327  MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull()
9328 {
9329   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9330   if(!pt)
9331     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
9332   MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9333   if(!ret)
9334     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 !");
9335   return ret;
9336 }
9337
9338 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
9339 {
9340   _content=new MEDFileIntFieldMultiTSWithoutSDA;
9341 }
9342
9343 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
9344 {
9345 }
9346
9347 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const std::string& fileName, bool loadAll)
9348 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
9349 {
9350 }
9351 catch(INTERP_KERNEL::Exception& e)
9352   { throw e; }
9353
9354 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const std::string& fileName, const std::string& fieldName, bool loadAll)
9355 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
9356 {
9357 }
9358 catch(INTERP_KERNEL::Exception& e)
9359   { throw e; }
9360
9361 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
9362 {
9363   return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
9364 }
9365
9366 //= MEDFileFields
9367
9368 MEDFileFields *MEDFileFields::New()
9369 {
9370   return new MEDFileFields;
9371 }
9372
9373 MEDFileFields *MEDFileFields::New(const std::string& fileName, bool loadAll)
9374 {
9375   return new MEDFileFields(fileName,loadAll);
9376 }
9377
9378 std::size_t MEDFileFields::getHeapMemorySizeWithoutChildren() const
9379 {
9380   std::size_t ret(MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren());
9381   ret+=_fields.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
9382   return ret;
9383 }
9384
9385 std::vector<const BigMemoryObject *> MEDFileFields::getDirectChildren() const
9386 {
9387   std::vector<const BigMemoryObject *> ret;
9388   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9389     {
9390       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9391       if(cur)
9392         ret.push_back(cur);
9393     }
9394   return ret;
9395 }
9396
9397 MEDFileFields *MEDFileFields::deepCpy() const
9398 {
9399   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9400   std::size_t i=0;
9401   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9402     {
9403       if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9404         ret->_fields[i]=(*it)->deepCpy();
9405     }
9406   ret->deepCpyGlobs(*this);
9407   return ret.retn();
9408 }
9409
9410 MEDFileFields *MEDFileFields::shallowCpy() const
9411 {
9412   return new MEDFileFields(*this);
9413 }
9414
9415 /*!
9416  * 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
9417  * 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.
9418  * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
9419  *
9420  * \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.
9421  * \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.
9422  *
9423  * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9424  */
9425 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const
9426 {
9427   std::set< std::pair<int,int> > s;
9428   bool firstShot=true;
9429   areThereSomeForgottenTS=false;
9430   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9431     {
9432       if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9433         continue;
9434       std::vector< std::pair<int,int> > v=(*it)->getIterations();
9435       std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
9436       if(firstShot)
9437         { s=s1; firstShot=false; }
9438       else
9439         {
9440           std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
9441           if(s!=s2)
9442             areThereSomeForgottenTS=true;
9443           s=s2;
9444         }
9445     }
9446   std::vector< std::pair<int,int> > ret;
9447   std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
9448   return ret;
9449 }
9450
9451 int MEDFileFields::getNumberOfFields() const
9452 {
9453   return _fields.size();
9454 }
9455
9456 std::vector<std::string> MEDFileFields::getFieldsNames() const
9457 {
9458   std::vector<std::string> ret(_fields.size());
9459   int i=0;
9460   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9461     {
9462       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
9463       if(f)
9464         {
9465           ret[i]=f->getName();
9466         }
9467       else
9468         {
9469           std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
9470           throw INTERP_KERNEL::Exception(oss.str().c_str());
9471         }
9472     }
9473   return ret;
9474 }
9475
9476 std::vector<std::string> MEDFileFields::getMeshesNames() const
9477 {
9478   std::vector<std::string> ret;
9479   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9480     {
9481       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9482       if(cur)
9483         ret.push_back(cur->getMeshName());
9484     }
9485   return ret;
9486 }
9487
9488 std::string MEDFileFields::simpleRepr() const
9489 {
9490   std::ostringstream oss;
9491   oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
9492   simpleRepr(0,oss);
9493   return oss.str();
9494 }
9495
9496 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
9497 {
9498   int nbOfFields=getNumberOfFields();
9499   std::string startLine(bkOffset,' ');
9500   oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
9501   int i=0;
9502   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9503     {
9504       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9505       if(cur)
9506         {
9507           oss << startLine << "  - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
9508         }
9509       else
9510         {
9511           oss << startLine << "  - not defined !" << std::endl;
9512         }
9513     }
9514   i=0;
9515   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9516     {
9517       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9518       std::string chapter(17,'0'+i);
9519       oss << startLine << chapter << std::endl;
9520       if(cur)
9521         {
9522           cur->simpleRepr(bkOffset+2,oss,i);
9523         }
9524       else
9525         {
9526           oss << startLine << "  - not defined !" << std::endl;
9527         }
9528       oss << startLine << chapter << std::endl;
9529     }
9530   simpleReprGlobs(oss);
9531 }
9532
9533 MEDFileFields::MEDFileFields()
9534 {
9535 }
9536
9537 MEDFileFields::MEDFileFields(const std::string& fileName, bool loadAll)
9538 try:MEDFileFieldGlobsReal(fileName)
9539   {
9540     MEDFileUtilities::CheckFileForRead(fileName);
9541     MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
9542     int nbFields=MEDnField(fid);
9543     _fields.resize(nbFields);
9544     med_field_type typcha;
9545     for(int i=0;i<nbFields;i++)
9546       {
9547         std::vector<std::string> infos;
9548         std::string fieldName,dtunit;
9549         int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,fileName,i,false,fieldName,typcha,infos,dtunit);
9550         switch(typcha)
9551           {
9552           case MED_FLOAT64:
9553             {
9554               _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9555               break;
9556             }
9557           case MED_INT32:
9558             {
9559               _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9560               break;
9561             }
9562           default:
9563             {
9564               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] !";
9565               throw INTERP_KERNEL::Exception(oss.str().c_str());
9566             }
9567           }
9568       }
9569     loadAllGlobals(fid);
9570   }
9571 catch(INTERP_KERNEL::Exception& e)
9572   {
9573     throw e;
9574   }
9575
9576 void MEDFileFields::writeLL(med_idt fid) const
9577 {
9578   int i=0;
9579   writeGlobals(fid,*this);
9580   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9581     {
9582       const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
9583       if(!elt)
9584         {
9585           std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
9586           throw INTERP_KERNEL::Exception(oss.str().c_str());
9587         }
9588       elt->writeLL(fid,*this);
9589     }
9590 }
9591
9592 void MEDFileFields::write(const std::string& fileName, int mode) const
9593 {
9594   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
9595   MEDFileUtilities::AutoFid fid(MEDfileOpen(fileName.c_str(),medmod));
9596   writeLL(fid);
9597 }
9598
9599 /*!
9600  * This method alloc the arrays and load potentially huge arrays contained in this field.
9601  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
9602  * This method can be also called to refresh or reinit values from a file.
9603  *
9604  * \throw If the fileName is not set or points to a non readable MED file.
9605  */
9606 void MEDFileFields::loadArrays()
9607 {
9608   if(getFileName().empty())
9609     throw INTERP_KERNEL::Exception("MEDFileFields::loadArrays : the structure does not come from a file !");
9610   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
9611   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9612     {
9613       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9614       if(elt)
9615         elt->loadBigArraysRecursively(fid,*elt);
9616     }
9617 }
9618
9619 /*!
9620  * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
9621  * But once data loaded once, this method does nothing.
9622  *
9623  * \throw If the fileName is not set or points to a non readable MED file.
9624  * \sa MEDFileFields::loadArrays, MEDFileFields::unloadArrays
9625  */
9626 void MEDFileFields::loadArraysIfNecessary()
9627 {
9628   if(!getFileName().empty())
9629     {
9630       MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
9631       for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9632         {
9633           MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9634           if(elt)
9635             elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
9636         }
9637     }
9638 }
9639
9640 /*!
9641  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
9642  * This method does not release arrays set outside the context of a MED file.
9643  *
9644  * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary
9645  */
9646 void MEDFileFields::unloadArrays()
9647 {
9648   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9649     {
9650       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9651       if(elt)
9652         elt->unloadArrays();
9653     }
9654 }
9655
9656 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
9657 {
9658   std::vector<std::string> ret;
9659   std::set<std::string> ret2;
9660   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9661     {
9662       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
9663       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9664         if(ret2.find(*it2)==ret2.end())
9665           {
9666             ret.push_back(*it2);
9667             ret2.insert(*it2);
9668           }
9669     }
9670   return ret;
9671 }
9672
9673 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
9674 {
9675   std::vector<std::string> ret;
9676   std::set<std::string> ret2;
9677   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9678     {
9679       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9680       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9681         if(ret2.find(*it2)==ret2.end())
9682           {
9683             ret.push_back(*it2);
9684             ret2.insert(*it2);
9685           }
9686     }
9687   return ret;
9688 }
9689
9690 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
9691 {
9692   std::vector<std::string> ret;
9693   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9694     {
9695       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
9696       ret.insert(ret.end(),tmp.begin(),tmp.end());
9697     }
9698   return ret;
9699 }
9700
9701 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
9702 {
9703   std::vector<std::string> ret;
9704   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9705     {
9706       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9707       ret.insert(ret.end(),tmp.begin(),tmp.end());
9708     }
9709   return ret;
9710 }
9711
9712 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9713 {
9714   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9715     (*it)->changePflsRefsNamesGen2(mapOfModif);
9716 }
9717
9718 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9719 {
9720   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9721     (*it)->changeLocsRefsNamesGen2(mapOfModif);
9722 }
9723
9724 void MEDFileFields::resize(int newSize)
9725 {
9726   _fields.resize(newSize);
9727 }
9728
9729 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields)
9730 {
9731   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
9732     pushField(*it);
9733 }
9734
9735 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field)
9736 {
9737   if(!field)
9738     throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
9739   _fields.push_back(field->getContent());
9740   appendGlobs(*field,1e-12);
9741 }
9742
9743 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field)
9744 {
9745   if(!field)
9746     throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
9747   if(i>=(int)_fields.size())
9748     _fields.resize(i+1);
9749   _fields[i]=field->getContent();
9750   appendGlobs(*field,1e-12);
9751 }
9752
9753 void MEDFileFields::destroyFieldAtPos(int i)
9754 {
9755   destroyFieldsAtPos(&i,&i+1);
9756 }
9757
9758 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds)
9759 {
9760   std::vector<bool> b(_fields.size(),true);
9761   for(const int *i=startIds;i!=endIds;i++)
9762     {
9763       if(*i<0 || *i>=(int)_fields.size())
9764         {
9765           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9766           throw INTERP_KERNEL::Exception(oss.str().c_str());
9767         }
9768       b[*i]=false;
9769     }
9770   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9771   std::size_t j=0;
9772   for(std::size_t i=0;i<_fields.size();i++)
9773     if(b[i])
9774       fields[j++]=_fields[i];
9775   _fields=fields;
9776 }
9777
9778 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step)
9779 {
9780   static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
9781   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
9782   std::vector<bool> b(_fields.size(),true);
9783   int k=bg;
9784   for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
9785     {
9786       if(k<0 || k>=(int)_fields.size())
9787         {
9788           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
9789           throw INTERP_KERNEL::Exception(oss.str().c_str());
9790         }
9791       b[k]=false;
9792     }
9793   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9794   std::size_t j=0;
9795   for(std::size_t i=0;i<_fields.size();i++)
9796     if(b[i])
9797       fields[j++]=_fields[i];
9798   _fields=fields;
9799 }
9800
9801 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
9802 {
9803   bool ret=false;
9804   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9805     {
9806       MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9807       if(cur)
9808         ret=cur->changeMeshNames(modifTab) || ret;
9809     }
9810   return ret;
9811 }
9812
9813 /*!
9814  * \param [in] meshName the name of the mesh that will be renumbered.
9815  * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
9816  *             This code corresponds to the distribution of types in the corresponding mesh.
9817  * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
9818  * \param [in] renumO2N the old to new renumber array.
9819  * \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
9820  *         field in \a this.
9821  */
9822 bool MEDFileFields::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N)
9823 {
9824   bool ret=false;
9825   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9826     {
9827       MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
9828       if(fmts)
9829         {
9830           ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
9831         }
9832     }
9833   return ret;
9834 }
9835
9836 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const
9837 {
9838   if(i<0 || i>=(int)_fields.size())
9839     {
9840       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
9841       throw INTERP_KERNEL::Exception(oss.str().c_str());
9842     }
9843   const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
9844   if(!fmts)
9845     return 0;
9846   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret;
9847   const MEDFileFieldMultiTSWithoutSDA *fmtsC=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts);
9848   const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts);
9849   if(fmtsC)
9850     ret=MEDFileFieldMultiTS::New(*fmtsC,false);
9851   else if(fmtsC2)
9852     ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
9853   else
9854     {
9855       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
9856       throw INTERP_KERNEL::Exception(oss.str().c_str());
9857     }
9858   ret->shallowCpyGlobs(*this);
9859   return ret.retn();
9860 }
9861
9862 /*!
9863  * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
9864  * This method is accessible in python using __getitem__ with a list in input.
9865  * \return a new object that the caller should deal with.
9866  */
9867 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const
9868 {
9869   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9870   std::size_t sz=std::distance(startIds,endIds);
9871   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
9872   int j=0;
9873   for(const int *i=startIds;i!=endIds;i++,j++)
9874     {
9875       if(*i<0 || *i>=(int)_fields.size())
9876         {
9877           std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9878           throw INTERP_KERNEL::Exception(oss.str().c_str());
9879         }
9880       fields[j]=_fields[*i];
9881     }
9882   ret->_fields=fields;
9883   return ret.retn();
9884 }
9885
9886 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const std::string& fieldName) const
9887 {
9888   return getFieldAtPos(getPosFromFieldName(fieldName));
9889 }
9890
9891 /*!
9892  * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
9893  * This method can be seen as a filter applied on \a this, that returns an object containing
9894  * 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
9895  * shallow copied from \a this.
9896  *
9897  * \param [in] meshName - the name of the mesh on w
9898  * \return a new object that the caller should deal with.
9899  */
9900 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const std::string& meshName) const
9901 {
9902   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9903   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9904     {
9905       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9906       if(!cur)
9907         continue;
9908       if(cur->getMeshName()==meshName)
9909         {
9910           cur->incrRef();
9911           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
9912           ret->_fields.push_back(cur2);
9913         }
9914     }
9915   ret->shallowCpyOnlyUsedGlobs(*this);
9916   return ret.retn();
9917 }
9918
9919 /*!
9920  * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
9921  * Input time steps are specified using a pair of integer (iteration, order).
9922  * 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,
9923  * but for each multitimestep only the time steps in \a timeSteps are kept.
9924  * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
9925  *
9926  * The returned object points to shallow copy of elements in \a this.
9927  *
9928  * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
9929  * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
9930  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9931  */
9932 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
9933 {
9934   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9935   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9936     {
9937       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9938       if(!cur)
9939         continue;
9940       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
9941       ret->_fields.push_back(elt);
9942     }
9943   ret->shallowCpyOnlyUsedGlobs(*this);
9944   return ret.retn();
9945 }
9946
9947 /*!
9948  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
9949  */
9950 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
9951 {
9952   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9953   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9954     {
9955       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9956       if(!cur)
9957         continue;
9958       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
9959       if(elt->getNumberOfTS()!=0)
9960         ret->_fields.push_back(elt);
9961     }
9962   ret->shallowCpyOnlyUsedGlobs(*this);
9963   return ret.retn();
9964 }
9965
9966 MEDFileFieldsIterator *MEDFileFields::iterator()
9967 {
9968   return new MEDFileFieldsIterator(this);
9969 }
9970
9971 int MEDFileFields::getPosFromFieldName(const std::string& fieldName) const
9972 {
9973   std::string tmp(fieldName);
9974   std::vector<std::string> poss;
9975   for(std::size_t i=0;i<_fields.size();i++)
9976     {
9977       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=_fields[i];
9978       if(f)
9979         {
9980           std::string fname(f->getName());
9981           if(tmp==fname)
9982             return i;
9983           else
9984             poss.push_back(fname);
9985         }
9986     }
9987   std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
9988   std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
9989   oss << " !";
9990   throw INTERP_KERNEL::Exception(oss.str().c_str());
9991 }
9992
9993 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
9994 {
9995   if(fs)
9996     {
9997       fs->incrRef();
9998       _nb_iter=fs->getNumberOfFields();
9999     }
10000 }
10001
10002 MEDFileFieldsIterator::~MEDFileFieldsIterator()
10003 {
10004 }
10005
10006 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
10007 {
10008   if(_iter_id<_nb_iter)
10009     {
10010       MEDFileFields *fs(_fs);
10011       if(fs)
10012         return fs->getFieldAtPos(_iter_id++);
10013       else
10014         return 0;
10015     }
10016   else
10017     return 0;
10018 }