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