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   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
5570   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
5571 }
5572
5573 /*!
5574  * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
5575  * But once data loaded once, this method does nothing.
5576  *
5577  * \throw If the fileName is not set or points to a non readable MED file.
5578  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::unloadArrays
5579  */
5580 void MEDFileAnyTypeField1TS::loadArraysIfNecessary()
5581 {
5582   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
5583   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
5584 }
5585
5586 /*!
5587  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
5588  * This method does not release arrays set outside the context of a MED file.
5589  *
5590  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary
5591  */
5592 void MEDFileAnyTypeField1TS::unloadArrays()
5593 {
5594   contentNotNullBase()->unloadArrays();
5595 }
5596
5597 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const
5598 {
5599   int nbComp=getNumberOfComponents();
5600   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5601   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5602   for(int i=0;i<nbComp;i++)
5603     {
5604       std::string info=getInfo()[i];
5605       std::string c,u;
5606       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
5607       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
5608       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
5609     }
5610   if(getName().empty())
5611     throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
5612   MEDfieldCr(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
5613   writeGlobals(fid,*this);
5614   contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
5615 }
5616
5617 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySizeWithoutChildren() const
5618 {
5619   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
5620 }
5621
5622 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TS::getDirectChildren() const
5623 {
5624   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
5625   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5626     ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)_content);
5627   return ret;
5628 }
5629
5630 /*!
5631  * Returns a string describing \a this field. This string is outputted
5632  * by \c print Python command.
5633  */
5634 std::string MEDFileAnyTypeField1TS::simpleRepr() const
5635 {
5636   std::ostringstream oss;
5637   contentNotNullBase()->simpleRepr(0,oss,-1);
5638   simpleReprGlobs(oss);
5639   return oss.str();
5640 }
5641
5642 /*!
5643  * This method returns all profiles whose name is non empty used.
5644  * \b WARNING If profile is used several times it will be reported \b only \b once.
5645  * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
5646  */
5647 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
5648 {
5649   return contentNotNullBase()->getPflsReallyUsed2();
5650 }
5651
5652 /*!
5653  * This method returns all localizations whose name is non empty used.
5654  * \b WARNING If localization is used several times it will be reported \b only \b once.
5655  */
5656 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
5657 {
5658   return contentNotNullBase()->getLocsReallyUsed2();
5659 }
5660
5661 /*!
5662  * This method returns all profiles whose name is non empty used.
5663  * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
5664  */
5665 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
5666 {
5667   return contentNotNullBase()->getPflsReallyUsedMulti2();
5668 }
5669
5670 /*!
5671  * This method returns all localizations whose name is non empty used.
5672  * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
5673  */
5674 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
5675 {
5676   return contentNotNullBase()->getLocsReallyUsedMulti2();
5677 }
5678
5679 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5680 {
5681   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
5682 }
5683
5684 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5685 {
5686   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
5687 }
5688
5689 int MEDFileAnyTypeField1TS::getDimension() const
5690 {
5691   return contentNotNullBase()->getDimension();
5692 }
5693
5694 int MEDFileAnyTypeField1TS::getIteration() const
5695 {
5696   return contentNotNullBase()->getIteration();
5697 }
5698
5699 int MEDFileAnyTypeField1TS::getOrder() const
5700 {
5701   return contentNotNullBase()->getOrder();
5702 }
5703
5704 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
5705 {
5706   return contentNotNullBase()->getTime(iteration,order);
5707 }
5708
5709 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
5710 {
5711   contentNotNullBase()->setTime(iteration,order,val);
5712 }
5713
5714 std::string MEDFileAnyTypeField1TS::getName() const
5715 {
5716   return contentNotNullBase()->getName();
5717 }
5718
5719 void MEDFileAnyTypeField1TS::setName(const std::string& name)
5720 {
5721   contentNotNullBase()->setName(name);
5722 }
5723
5724 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
5725 {
5726   contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
5727 }
5728
5729 std::string MEDFileAnyTypeField1TS::getDtUnit() const
5730 {
5731   return contentNotNullBase()->getDtUnit();
5732 }
5733
5734 void MEDFileAnyTypeField1TS::setDtUnit(const std::string& dtUnit)
5735 {
5736   contentNotNullBase()->setDtUnit(dtUnit);
5737 }
5738
5739 std::string MEDFileAnyTypeField1TS::getMeshName() const
5740 {
5741   return contentNotNullBase()->getMeshName();
5742 }
5743
5744 void MEDFileAnyTypeField1TS::setMeshName(const std::string& newMeshName)
5745 {
5746   contentNotNullBase()->setMeshName(newMeshName);
5747 }
5748
5749 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
5750 {
5751   return contentNotNullBase()->changeMeshNames(modifTab);
5752 }
5753
5754 int MEDFileAnyTypeField1TS::getMeshIteration() const
5755 {
5756   return contentNotNullBase()->getMeshIteration();
5757 }
5758
5759 int MEDFileAnyTypeField1TS::getMeshOrder() const
5760 {
5761   return contentNotNullBase()->getMeshOrder();
5762 }
5763
5764 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
5765 {
5766   return contentNotNullBase()->getNumberOfComponents();
5767 }
5768
5769 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
5770 {
5771   return contentNotNullBase()->isDealingTS(iteration,order);
5772 }
5773
5774 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
5775 {
5776   return contentNotNullBase()->getDtIt();
5777 }
5778
5779 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
5780 {
5781   contentNotNullBase()->fillIteration(p);
5782 }
5783
5784 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
5785 {
5786   contentNotNullBase()->fillTypesOfFieldAvailable(types);
5787 }
5788
5789 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos)
5790 {
5791   contentNotNullBase()->setInfo(infos);
5792 }
5793
5794 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
5795 {
5796   return contentNotNullBase()->getInfo();
5797 }
5798 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
5799 {
5800   return contentNotNullBase()->getInfo();
5801 }
5802
5803 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
5804 {
5805   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5806 }
5807
5808 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
5809 {
5810   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5811 }
5812
5813 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
5814 {
5815   return contentNotNullBase()->getNonEmptyLevels(mname,levs);
5816 }
5817
5818 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const
5819 {
5820   return contentNotNullBase()->getTypesOfFieldAvailable();
5821 }
5822
5823 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,
5824                                                                                        std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5825 {
5826   return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
5827 }
5828
5829 /*!
5830  * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
5831  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5832  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
5833  */
5834 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const
5835 {
5836   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5837   if(!content)
5838     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
5839   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
5840   std::size_t sz(contentsSplit.size());
5841   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5842   for(std::size_t i=0;i<sz;i++)
5843     {
5844       ret[i]=shallowCpy();
5845       ret[i]->_content=contentsSplit[i];
5846     }
5847   return ret;
5848 }
5849
5850 /*!
5851  * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
5852  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5853  */
5854 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const
5855 {
5856   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5857   if(!content)
5858     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
5859   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitDiscretizations();
5860   std::size_t sz(contentsSplit.size());
5861   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5862   for(std::size_t i=0;i<sz;i++)
5863     {
5864       ret[i]=shallowCpy();
5865       ret[i]->_content=contentsSplit[i];
5866     }
5867   return ret;
5868 }
5869
5870 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCpy() const
5871 {
5872   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=shallowCpy();
5873   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5874     ret->_content=_content->deepCpy();
5875   ret->deepCpyGlobs(*this);
5876   return ret.retn();
5877 }
5878
5879 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
5880 {
5881   return contentNotNullBase()->copyTinyInfoFrom(field,arr);
5882 }
5883
5884 //= MEDFileField1TS
5885
5886 /*!
5887  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5888  * the first field that has been read from a specified MED file.
5889  *  \param [in] fileName - the name of the MED file to read.
5890  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5891  *          is to delete this field using decrRef() as it is no more needed.
5892  *  \throw If reading the file fails.
5893  */
5894 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, bool loadAll)
5895 {
5896   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,loadAll);
5897   ret->contentNotNull();
5898   return ret.retn();
5899 }
5900
5901 /*!
5902  * Returns a new instance of MEDFileField1TS holding data of the first time step of
5903  * a given field that has been read from a specified MED file.
5904  *  \param [in] fileName - the name of the MED file to read.
5905  *  \param [in] fieldName - the name of the field to read.
5906  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5907  *          is to delete this field using decrRef() as it is no more needed.
5908  *  \throw If reading the file fails.
5909  *  \throw If there is no field named \a fieldName in the file.
5910  */
5911 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
5912 {
5913   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,loadAll);
5914   ret->contentNotNull();
5915   return ret.retn();
5916 }
5917
5918 /*!
5919  * Returns a new instance of MEDFileField1TS holding data of a given time step of
5920  * a given field that has been read from a specified MED file.
5921  *  \param [in] fileName - the name of the MED file to read.
5922  *  \param [in] fieldName - the name of the field to read.
5923  *  \param [in] iteration - the iteration number of a required time step.
5924  *  \param [in] order - the iteration order number of required time step.
5925  *  \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5926  *          is to delete this field using decrRef() as it is no more needed.
5927  *  \throw If reading the file fails.
5928  *  \throw If there is no field named \a fieldName in the file.
5929  *  \throw If the required time step is missing from the file.
5930  */
5931 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5932 {
5933   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,iteration,order,loadAll);
5934   ret->contentNotNull();
5935   return ret.retn();
5936 }
5937
5938 /*!
5939  * Returns a new instance of MEDFileField1TS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5940  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5941  *
5942  * Returns a new instance of MEDFileField1TS holding either a shallow copy
5943  * of a given MEDFileField1TSWithoutSDA ( \a other ) or \a other itself.
5944  * \warning this is a shallow copy constructor
5945  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
5946  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
5947  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5948  *          is to delete this field using decrRef() as it is no more needed.
5949  */
5950 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5951 {
5952   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(other,shallowCopyOfContent);
5953   ret->contentNotNull();
5954   return ret.retn();
5955 }
5956
5957 /*!
5958  * Returns a new empty instance of MEDFileField1TS.
5959  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5960  *          is to delete this field using decrRef() as it is no more needed.
5961  */
5962 MEDFileField1TS *MEDFileField1TS::New()
5963 {
5964   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS;
5965   ret->contentNotNull();
5966   return ret.retn();
5967 }
5968
5969 /*!
5970  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
5971  * following the given input policy.
5972  *
5973  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
5974  *                            By default (true) the globals are deeply copied.
5975  * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
5976  */
5977 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool isDeepCpyGlobs) const
5978 {
5979   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret;
5980   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5981   if(content)
5982     {
5983       const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
5984       if(!contc)
5985         throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
5986       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
5987       ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc,getFileName()));
5988     }
5989   else
5990     ret=MEDFileIntField1TS::New();
5991   if(isDeepCpyGlobs)
5992     ret->deepCpyGlobs(*this);
5993   else
5994     ret->shallowCpyGlobs(*this);
5995   return ret.retn();
5996 }
5997
5998 const MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() const
5999 {
6000   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6001   if(!pt)
6002     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is null !");
6003   const MEDFileField1TSWithoutSDA *ret=dynamic_cast<const MEDFileField1TSWithoutSDA *>(pt);
6004   if(!ret)
6005     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 !");
6006   return ret;
6007 }
6008
6009 MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull()
6010 {
6011   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6012   if(!pt)
6013     throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is null !");
6014   MEDFileField1TSWithoutSDA *ret=dynamic_cast<MEDFileField1TSWithoutSDA *>(pt);
6015   if(!ret)
6016     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 !");
6017   return ret;
6018 }
6019
6020 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6021 {
6022   if(!f)
6023     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
6024   if(!((DataArray*)arr))
6025     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
6026   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6027   if(!arrOutC)
6028     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6029   f->setArray(arrOutC);
6030 }
6031
6032 DataArrayDouble *MEDFileField1TS::ReturnSafelyDataArrayDouble(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6033 {
6034   if(!((DataArray*)arr))
6035     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : no array !");
6036   DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6037   if(!arrOutC)
6038     throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6039   arrOutC->incrRef();
6040   return arrOutC;
6041 }
6042
6043 MEDFileField1TS::MEDFileField1TS(const std::string& fileName, bool loadAll)
6044 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6045 {
6046 }
6047 catch(INTERP_KERNEL::Exception& e)
6048   { throw e; }
6049
6050 MEDFileField1TS::MEDFileField1TS(const std::string& fileName, const std::string& fieldName, bool loadAll)
6051 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6052 {
6053 }
6054 catch(INTERP_KERNEL::Exception& e)
6055   { throw e; }
6056
6057 MEDFileField1TS::MEDFileField1TS(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6058 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6059 {
6060 }
6061 catch(INTERP_KERNEL::Exception& e)
6062   { throw e; }
6063
6064 /*!
6065  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6066  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6067  *
6068  * \warning this is a shallow copy constructor
6069  */
6070 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
6071 try:MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6072 {
6073 }
6074 catch(INTERP_KERNEL::Exception& e)
6075   { throw e; }
6076
6077 MEDFileField1TS::MEDFileField1TS()
6078 {
6079   _content=new MEDFileField1TSWithoutSDA;
6080 }
6081
6082 /*!
6083  * Returns a new MEDCouplingFieldDouble of a given type lying on
6084  * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6085  * has not been constructed via file reading, an exception is thrown.
6086  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6087  *  \param [in] type - a spatial discretization of interest.
6088  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6089  *  \param [in] renumPol - specifies how to permute values of the result field according to
6090  *          the optional numbers of cells and nodes, if any. The valid values are
6091  *          - 0 - do not permute.
6092  *          - 1 - permute cells.
6093  *          - 2 - permute nodes.
6094  *          - 3 - permute cells and nodes.
6095  *
6096  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6097  *          caller is to delete this field using decrRef() as it is no more needed.
6098  *  \throw If \a this field has not been constructed via file reading.
6099  *  \throw If the MED file is not readable.
6100  *  \throw If there is no mesh in the MED file.
6101  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6102  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6103  *  \sa getFieldOnMeshAtLevel()
6104  */
6105 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const
6106 {
6107   if(getFileName2().empty())
6108     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6109   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6110   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNull());
6111   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6112   return ret.retn();
6113 }
6114
6115 /*!
6116  * Returns a new MEDCouplingFieldDouble of a given type lying on
6117  * the top level cells of the first mesh in MED file. If \a this field
6118  * has not been constructed via file reading, an exception is thrown.
6119  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6120  *  \param [in] type - a spatial discretization of interest.
6121  *  \param [in] renumPol - specifies how to permute values of the result field according to
6122  *          the optional numbers of cells and nodes, if any. The valid values are
6123  *          - 0 - do not permute.
6124  *          - 1 - permute cells.
6125  *          - 2 - permute nodes.
6126  *          - 3 - permute cells and nodes.
6127  *
6128  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6129  *          caller is to delete this field using decrRef() as it is no more needed.
6130  *  \throw If \a this field has not been constructed via file reading.
6131  *  \throw If the MED file is not readable.
6132  *  \throw If there is no mesh in the MED file.
6133  *  \throw If no field values of the given \a type.
6134  *  \throw If no field values lying on the top level support.
6135  *  \sa getFieldAtLevel()
6136  */
6137 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const
6138 {
6139   if(getFileName2().empty())
6140     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6141   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6142   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNull());
6143   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6144   return ret.retn();
6145 }
6146
6147 /*!
6148  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6149  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6150  *  \param [in] type - a spatial discretization of the new field.
6151  *  \param [in] mesh - the supporting mesh.
6152  *  \param [in] renumPol - specifies how to permute values of the result field according to
6153  *          the optional numbers of cells and nodes, if any. The valid values are
6154  *          - 0 - do not permute.
6155  *          - 1 - permute cells.
6156  *          - 2 - permute nodes.
6157  *          - 3 - permute cells and nodes.
6158  *
6159  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6160  *          caller is to delete this field using decrRef() as it is no more needed.
6161  *  \throw If no field of \a this is lying on \a mesh.
6162  *  \throw If the mesh is empty.
6163  *  \throw If no field values of the given \a type are available.
6164  *  \sa getFieldAtLevel()
6165  *  \sa getFieldOnMeshAtLevel()
6166  */
6167 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const
6168 {
6169   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6170   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull());
6171   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6172   return ret.retn();
6173 }
6174
6175 /*!
6176  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6177  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6178  *  \param [in] type - a spatial discretization of interest.
6179  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6180  *  \param [in] mesh - the supporting mesh.
6181  *  \param [in] renumPol - specifies how to permute values of the result field according to
6182  *          the optional numbers of cells and nodes, if any. The valid values are
6183  *          - 0 - do not permute.
6184  *          - 1 - permute cells.
6185  *          - 2 - permute nodes.
6186  *          - 3 - permute cells and nodes.
6187  *
6188  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6189  *          caller is to delete this field using decrRef() as it is no more needed.
6190  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6191  *  \throw If no field of \a this is lying on \a mesh.
6192  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6193  *  \sa getFieldAtLevel()
6194  *  \sa getFieldOnMeshAtLevel()
6195  */
6196 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
6197 {
6198   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6199   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull());
6200   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6201   return ret.retn();
6202 }
6203
6204 /*!
6205  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6206  * This method is called "Old" because in MED3 norm a field has only one meshName
6207  * attached, so this method is for readers of MED2 files. If \a this field
6208  * has not been constructed via file reading, an exception is thrown.
6209  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6210  *  \param [in] type - a spatial discretization of interest.
6211  *  \param [in] mName - a name of the supporting mesh.
6212  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6213  *  \param [in] renumPol - specifies how to permute values of the result field according to
6214  *          the optional numbers of cells and nodes, if any. The valid values are
6215  *          - 0 - do not permute.
6216  *          - 1 - permute cells.
6217  *          - 2 - permute nodes.
6218  *          - 3 - permute cells and nodes.
6219  *
6220  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6221  *          caller is to delete this field using decrRef() as it is no more needed.
6222  *  \throw If the MED file is not readable.
6223  *  \throw If there is no mesh named \a mName in the MED file.
6224  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6225  *  \throw If \a this field has not been constructed via file reading.
6226  *  \throw If no field of \a this is lying on the mesh named \a mName.
6227  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6228  *  \sa getFieldAtLevel()
6229  */
6230 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, int renumPol) const
6231 {
6232   if(getFileName2().empty())
6233     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6234   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6235   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
6236   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6237   return ret.retn();
6238 }
6239
6240 /*!
6241  * Returns values and a profile of the field of a given type lying on a given support.
6242  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6243  *  \param [in] type - a spatial discretization of the field.
6244  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6245  *  \param [in] mesh - the supporting mesh.
6246  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6247  *          field of interest lies on. If the field lies on all entities of the given
6248  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6249  *          using decrRef() as it is no more needed.
6250  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
6251  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6252  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6253  *  \throw If no field of \a this is lying on \a mesh.
6254  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6255  */
6256 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6257 {
6258   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6259   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
6260 }
6261
6262 /*!
6263  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6264  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6265  * "Sort By Type"), if not, an exception is thrown.
6266  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6267  *  \param [in] field - the field to add to \a this.
6268  *  \throw If the name of \a field is empty.
6269  *  \throw If the data array of \a field is not set.
6270  *  \throw If the data array is already allocated but has different number of components
6271  *         than \a field.
6272  *  \throw If the underlying mesh of \a field has no name.
6273  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6274  */
6275 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
6276 {
6277   setFileName("");
6278   contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
6279 }
6280
6281 /*!
6282  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6283  * can be an aggregation of several MEDCouplingFieldDouble instances.
6284  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6285  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6286  * and \a profile.
6287  *
6288  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6289  * A new profile is added only if no equal profile is missing.
6290  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6291  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
6292  *  \param [in] mesh - the supporting mesh of \a field.
6293  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6294  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6295  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6296  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6297  *  \throw If the data array of \a field is not set.
6298  *  \throw If the data array of \a this is already allocated but has different number of
6299  *         components than \a field.
6300  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6301  *  \sa setFieldNoProfileSBT()
6302  */
6303 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6304 {
6305   setFileName("");
6306   contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6307 }
6308
6309 MEDFileAnyTypeField1TS *MEDFileField1TS::shallowCpy() const
6310 {
6311   return new MEDFileField1TS(*this);
6312 }
6313
6314 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const
6315 {
6316   return contentNotNull()->getUndergroundDataArrayDouble();
6317 }
6318
6319 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6320 {
6321   return contentNotNull()->getUndergroundDataArrayDoubleExt(entries);
6322 }
6323
6324 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6325                                                                                       std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
6326 {
6327   return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
6328 }
6329
6330 //= MEDFileIntField1TS
6331
6332 MEDFileIntField1TS *MEDFileIntField1TS::New()
6333 {
6334   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS;
6335   ret->contentNotNull();
6336   return ret.retn();
6337 }
6338
6339 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, bool loadAll)
6340 {
6341   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,loadAll);
6342   ret->contentNotNull();
6343   return ret.retn();
6344 }
6345
6346 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
6347 {
6348   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,loadAll);
6349   ret->contentNotNull();
6350   return ret.retn();
6351 }
6352
6353 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6354 {
6355   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,iteration,order,loadAll);
6356   ret->contentNotNull();
6357   return ret.retn();
6358 }
6359
6360 MEDFileIntField1TS *MEDFileIntField1TS::New(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent)
6361 {
6362   MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(other,shallowCopyOfContent);
6363   ret->contentNotNull();
6364   return ret.retn();
6365 }
6366
6367 MEDFileIntField1TS::MEDFileIntField1TS()
6368 {
6369   _content=new MEDFileIntField1TSWithoutSDA;
6370 }
6371
6372 MEDFileIntField1TS::MEDFileIntField1TS(const std::string& fileName, bool loadAll)
6373 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6374 {
6375 }
6376 catch(INTERP_KERNEL::Exception& e)
6377   { throw e; }
6378
6379 MEDFileIntField1TS::MEDFileIntField1TS(const std::string& fileName, const std::string& fieldName, bool loadAll)
6380 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6381 {
6382 }
6383 catch(INTERP_KERNEL::Exception& e)
6384   { throw e; }
6385
6386 MEDFileIntField1TS::MEDFileIntField1TS(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6387 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6388 {
6389 }
6390 catch(INTERP_KERNEL::Exception& e)
6391   { throw e; }
6392
6393 /*!
6394  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6395  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6396  *
6397  * \warning this is a shallow copy constructor
6398  */
6399 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6400 {
6401 }
6402
6403 MEDFileAnyTypeField1TS *MEDFileIntField1TS::shallowCpy() const
6404 {
6405   return new MEDFileIntField1TS(*this);
6406 }
6407
6408 /*!
6409  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
6410  * following the given input policy.
6411  *
6412  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6413  *                            By default (true) the globals are deeply copied.
6414  * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
6415  */
6416 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool isDeepCpyGlobs) const
6417 {
6418   MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret;
6419   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6420   if(content)
6421     {
6422       const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
6423       if(!contc)
6424         throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
6425       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
6426       ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc,getFileName()));
6427     }
6428   else
6429     ret=MEDFileField1TS::New();
6430   if(isDeepCpyGlobs)
6431     ret->deepCpyGlobs(*this);
6432   else
6433     ret->shallowCpyGlobs(*this);
6434   return ret.retn();
6435 }
6436
6437 /*!
6438  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6439  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6440  * "Sort By Type"), if not, an exception is thrown.
6441  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6442  *  \param [in] field - the field to add to \a this. The field double values are ignored.
6443  *  \param [in] arrOfVals - the values of the field \a field used.
6444  *  \throw If the name of \a field is empty.
6445  *  \throw If the data array of \a field is not set.
6446  *  \throw If the data array is already allocated but has different number of components
6447  *         than \a field.
6448  *  \throw If the underlying mesh of \a field has no name.
6449  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6450  */
6451 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
6452 {
6453   setFileName("");
6454   contentNotNull()->setFieldNoProfileSBT(field,arrOfVals,*this,*contentNotNull());
6455 }
6456
6457 /*!
6458  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6459  * can be an aggregation of several MEDCouplingFieldDouble instances.
6460  * The mesh support of input parameter \a field is ignored here, it can be NULL.
6461  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6462  * and \a profile.
6463  *
6464  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6465  * A new profile is added only if no equal profile is missing.
6466  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6467  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
6468  *  \param [in] arrOfVals - the values of the field \a field used.
6469  *  \param [in] mesh - the supporting mesh of \a field.
6470  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6471  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
6472  *  \throw If either \a field or \a mesh or \a profile has an empty name.
6473  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6474  *  \throw If the data array of \a field is not set.
6475  *  \throw If the data array of \a this is already allocated but has different number of
6476  *         components than \a field.
6477  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6478  *  \sa setFieldNoProfileSBT()
6479  */
6480 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6481 {
6482   setFileName("");
6483   contentNotNull()->setFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6484 }
6485
6486 const MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() const
6487 {
6488   const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6489   if(!pt)
6490     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is null !");
6491   const MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(pt);
6492   if(!ret)
6493     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 !");
6494   return ret;
6495 }
6496
6497 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6498 {
6499   if(getFileName2().empty())
6500     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6501   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut2;
6502   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut2,*contentNotNull());
6503   DataArrayInt *arrOutC=dynamic_cast<DataArrayInt *>((DataArray *)arrOut2);
6504   if(!arrOutC)
6505     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : mismatch between dataArrays type and MEDFileIntField1TS ! Expected int32 !");
6506   arrOut=arrOutC;
6507   return ret.retn();
6508 }
6509
6510 DataArrayInt *MEDFileIntField1TS::ReturnSafelyDataArrayInt(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6511 {
6512   if(!((DataArray *)arr))
6513     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is NULL !");
6514   DataArrayInt *arrC=dynamic_cast<DataArrayInt *>((DataArray *)arr);
6515   if(!arrC)
6516     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is not of type INT32 !");
6517   arrC->incrRef();
6518   return arrC;
6519 }
6520
6521 /*!
6522  * Returns a new MEDCouplingFieldDouble of a given type lying on
6523  * the top level cells of the first mesh in MED file. If \a this field
6524  * has not been constructed via file reading, an exception is thrown.
6525  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6526  *  \param [in] type - a spatial discretization of interest.
6527  *  \param [out] arrOut - the DataArrayInt containing values of field.
6528  *  \param [in] renumPol - specifies how to permute values of the result field according to
6529  *          the optional numbers of cells and nodes, if any. The valid values are
6530  *          - 0 - do not permute.
6531  *          - 1 - permute cells.
6532  *          - 2 - permute nodes.
6533  *          - 3 - permute cells and nodes.
6534  *
6535  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6536  *          caller is to delete this field using decrRef() as it is no more needed.
6537  *  \throw If \a this field has not been constructed via file reading.
6538  *  \throw If the MED file is not readable.
6539  *  \throw If there is no mesh in the MED file.
6540  *  \throw If no field values of the given \a type.
6541  *  \throw If no field values lying on the top level support.
6542  *  \sa getFieldAtLevel()
6543  */
6544 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, DataArrayInt* &arrOut, int renumPol) const
6545 {
6546   if(getFileName2().empty())
6547     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6548   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6549   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arr,*contentNotNull());
6550   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6551   return ret.retn();
6552 }
6553
6554 /*!
6555  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6556  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6557  *  \param [in] type - a spatial discretization of the new field.
6558  *  \param [in] mesh - the supporting mesh.
6559  *  \param [out] arrOut - the DataArrayInt containing values of field.
6560  *  \param [in] renumPol - specifies how to permute values of the result field according to
6561  *          the optional numbers of cells and nodes, if any. The valid values are
6562  *          - 0 - do not permute.
6563  *          - 1 - permute cells.
6564  *          - 2 - permute nodes.
6565  *          - 3 - permute cells and nodes.
6566  *
6567  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6568  *          caller is to delete this field using decrRef() as it is no more needed.
6569  *  \throw If no field of \a this is lying on \a mesh.
6570  *  \throw If the mesh is empty.
6571  *  \throw If no field values of the given \a type are available.
6572  *  \sa getFieldAtLevel()
6573  *  \sa getFieldOnMeshAtLevel()
6574  */
6575 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6576 {
6577   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6578   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNull());
6579   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6580   return ret.retn();
6581 }
6582
6583 /*!
6584  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6585  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6586  *  \param [in] type - a spatial discretization of interest.
6587  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6588  *  \param [out] arrOut - the DataArrayInt containing values of field.
6589  *  \param [in] mesh - the supporting mesh.
6590  *  \param [in] renumPol - specifies how to permute values of the result field according to
6591  *          the optional numbers of cells and nodes, if any. The valid values are
6592  *          - 0 - do not permute.
6593  *          - 1 - permute cells.
6594  *          - 2 - permute nodes.
6595  *          - 3 - permute cells and nodes.
6596  *
6597  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6598  *          caller is to delete this field using decrRef() as it is no more needed.
6599  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6600  *  \throw If no field of \a this is lying on \a mesh.
6601  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6602  *  \sa getFieldAtLevel()
6603  *  \sa getFieldOnMeshAtLevel()
6604  */
6605 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6606 {
6607   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6608   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNull());
6609   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6610   return ret.retn();
6611 }
6612
6613 /*!
6614  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6615  * This method is called "Old" because in MED3 norm a field has only one meshName
6616  * attached, so this method is for readers of MED2 files. If \a this field
6617  * has not been constructed via file reading, an exception is thrown.
6618  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6619  *  \param [in] type - a spatial discretization of interest.
6620  *  \param [in] mName - a name of the supporting mesh.
6621  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6622  *  \param [out] arrOut - the DataArrayInt containing values of field.
6623  *  \param [in] renumPol - specifies how to permute values of the result field according to
6624  *          the optional numbers of cells and nodes, if any. The valid values are
6625  *          - 0 - do not permute.
6626  *          - 1 - permute cells.
6627  *          - 2 - permute nodes.
6628  *          - 3 - permute cells and nodes.
6629  *
6630  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6631  *          caller is to delete this field using decrRef() as it is no more needed.
6632  *  \throw If the MED file is not readable.
6633  *  \throw If there is no mesh named \a mName in the MED file.
6634  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6635  *  \throw If \a this field has not been constructed via file reading.
6636  *  \throw If no field of \a this is lying on the mesh named \a mName.
6637  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6638  *  \sa getFieldAtLevel()
6639  */
6640 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6641 {
6642   if(getFileName2().empty())
6643     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6644   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6645   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNull());
6646   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6647   return ret.retn();
6648 }
6649
6650 /*!
6651  * Returns values and a profile of the field of a given type lying on a given support.
6652  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6653  *  \param [in] type - a spatial discretization of the field.
6654  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6655  *  \param [in] mesh - the supporting mesh.
6656  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6657  *          field of interest lies on. If the field lies on all entities of the given
6658  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
6659  *          using decrRef() as it is no more needed.
6660  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
6661  *          field. The caller is to delete this array using decrRef() as it is no more needed.
6662  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6663  *  \throw If no field of \a this is lying on \a mesh.
6664  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6665  */
6666 DataArrayInt *MEDFileIntField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6667 {
6668   MEDCouplingAutoRefCountObjectPtr<DataArray> arr=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6669   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6670 }
6671
6672 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull()
6673 {
6674   MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6675   if(!pt)
6676     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is null !");
6677   MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<MEDFileIntField1TSWithoutSDA *>(pt);
6678   if(!ret)
6679     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 !");
6680   return ret;
6681 }
6682
6683 DataArrayInt *MEDFileIntField1TS::getUndergroundDataArray() const
6684 {
6685   return contentNotNull()->getUndergroundDataArrayInt();
6686 }
6687
6688 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
6689
6690 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
6691 {
6692 }
6693
6694 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileFieldNameScope(fieldName)
6695 {
6696 }
6697
6698 /*!
6699  * \param [in] fieldId field id in C mode
6700  */
6701 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
6702 {
6703   med_field_type typcha;
6704   std::string dtunitOut;
6705   int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,"",fieldId,false,_name,typcha,_infos,dtunitOut);
6706   setDtUnit(dtunitOut.c_str());
6707   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll);
6708 }
6709
6710 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)
6711 try:MEDFileFieldNameScope(fieldName),_infos(infos)
6712 {
6713   setDtUnit(dtunit.c_str());
6714   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll);
6715 }
6716 catch(INTERP_KERNEL::Exception& e)
6717 {
6718   throw e;
6719 }
6720
6721 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySizeWithoutChildren() const
6722 {
6723   std::size_t ret(_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA>));
6724   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6725     ret+=(*it).capacity();
6726   return ret;
6727 }
6728
6729 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTSWithoutSDA::getDirectChildren() const
6730 {
6731   std::vector<const BigMemoryObject *> ret;
6732   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6733     {
6734       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6735       if(cur)
6736         ret.push_back(cur);
6737     }
6738   return ret;
6739 }
6740
6741 /*!
6742  * 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
6743  * NULL.
6744  */
6745 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const
6746 {
6747   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6748   ret->setInfo(_infos);
6749   int sz=(int)_time_steps.size();
6750   for(const int *id=startIds;id!=endIds;id++)
6751     {
6752       if(*id>=0 && *id<sz)
6753         {
6754           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
6755           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6756           if(tse)
6757             {
6758               tse->incrRef();
6759               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6760             }
6761           ret->pushBackTimeStep(tse2);
6762         }
6763       else
6764         {
6765           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
6766           oss << " ! Should be in [0," << sz << ") !";
6767           throw INTERP_KERNEL::Exception(oss.str().c_str());
6768         }
6769     }
6770   if(ret->getNumberOfTS()>0)
6771     ret->synchronizeNameScope();
6772   ret->copyNameScope(*this);
6773   return ret.retn();
6774 }
6775
6776 /*!
6777  * 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
6778  * NULL.
6779  */
6780 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const
6781 {
6782   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
6783   int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
6784   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6785   ret->setInfo(_infos);
6786   int sz=(int)_time_steps.size();
6787   int j=bg;
6788   for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
6789     {
6790       if(j>=0 && j<sz)
6791         {
6792           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
6793           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6794           if(tse)
6795             {
6796               tse->incrRef();
6797               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6798             }
6799           ret->pushBackTimeStep(tse2);
6800         }
6801       else
6802         {
6803           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
6804           oss << " ! Should be in [0," << sz << ") !";
6805           throw INTERP_KERNEL::Exception(oss.str().c_str());
6806         }
6807     }
6808   if(ret->getNumberOfTS()>0)
6809     ret->synchronizeNameScope();
6810   ret->copyNameScope(*this);
6811   return ret.retn();
6812 }
6813
6814 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6815 {
6816   int id=0;
6817   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6818   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6819     {
6820       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6821       if(!cur)
6822         continue;
6823       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6824       if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
6825         ids->pushBackSilent(id);
6826     }
6827   return buildFromTimeStepIds(ids->begin(),ids->end());
6828 }
6829
6830 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6831 {
6832   int id=0;
6833   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6834   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6835     {
6836       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6837       if(!cur)
6838         continue;
6839       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6840       if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
6841         ids->pushBackSilent(id);
6842     }
6843   return buildFromTimeStepIds(ids->begin(),ids->end());
6844 }
6845
6846 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const
6847 {
6848   return _infos;
6849 }
6850
6851 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info)
6852 {
6853   _infos=info;
6854 }
6855
6856 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const
6857 {
6858   int ret=0;
6859   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
6860     {
6861       const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
6862       if(pt->isDealingTS(iteration,order))
6863         return ret;
6864     }
6865   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
6866   std::vector< std::pair<int,int> > vp=getIterations();
6867   for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
6868     oss << "(" << (*it2).first << "," << (*it2).second << ") ";
6869   throw INTERP_KERNEL::Exception(oss.str().c_str());
6870 }
6871
6872 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const
6873 {
6874   return *_time_steps[getTimeStepPos(iteration,order)];
6875 }
6876
6877 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order)
6878 {
6879   return *_time_steps[getTimeStepPos(iteration,order)];
6880 }
6881
6882 std::string MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshName() const
6883 {
6884   if(_time_steps.empty())
6885     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
6886   return _time_steps[0]->getMeshName();
6887 }
6888
6889 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setMeshName(const std::string& newMeshName)
6890 {
6891   std::string oldName(getMeshName());
6892   std::vector< std::pair<std::string,std::string> > v(1);
6893   v[0].first=oldName; v[0].second=newMeshName;
6894   changeMeshNames(v);
6895 }
6896
6897 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
6898 {
6899   bool ret=false;
6900   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6901     {
6902       MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6903       if(cur)
6904         ret=cur->changeMeshNames(modifTab) || ret;
6905     }
6906   return ret;
6907 }
6908
6909 /*!
6910  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
6911  */
6912 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const
6913 {
6914   return getTimeStepEntry(iteration,order).getUndergroundDataArray();
6915 }
6916
6917 /*!
6918  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
6919  */
6920 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6921 {
6922   return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
6923 }
6924
6925 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
6926                                                                 MEDFileFieldGlobsReal& glob)
6927 {
6928   bool ret=false;
6929   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6930     {
6931       MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
6932       if(f1ts)
6933         ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
6934     }
6935   return ret;
6936 }
6937
6938 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
6939 {
6940   std::string startLine(bkOffset,' ');
6941   oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
6942   if(fmtsId>=0)
6943     oss << " (" << fmtsId << ")";
6944   oss << " has the following name: \"" << _name << "\"." << std::endl;
6945   oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
6946   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6947     {
6948       oss << startLine << "  -  \"" << *it << "\"" << std::endl;
6949     }
6950   int i=0;
6951   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
6952     {
6953       std::string chapter(17,'0'+i);
6954       oss << startLine << chapter << std::endl;
6955       const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6956       if(cur)
6957         cur->simpleRepr(bkOffset+2,oss,i);
6958       else
6959         oss << startLine << "  Field on one time step #" << i << " is not defined !" << std::endl;
6960       oss << startLine << chapter << std::endl;
6961     }
6962 }
6963
6964 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const
6965 {
6966   std::size_t sz=_time_steps.size();
6967   std::vector< std::pair<int,int> > ret(sz);
6968   ret1.resize(sz);
6969   for(std::size_t i=0;i<sz;i++)
6970     {
6971       const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
6972       if(f1ts)
6973         {
6974           ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
6975         }
6976       else
6977         {
6978           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
6979           throw INTERP_KERNEL::Exception(oss.str().c_str());
6980         }
6981     }
6982   return ret;
6983 }
6984
6985 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>& tse)
6986 {
6987   MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
6988   if(!tse2)
6989     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
6990   checkCoherencyOfType(tse2);
6991   if(_time_steps.empty())
6992     {
6993       setName(tse2->getName().c_str());
6994       setInfo(tse2->getInfo());
6995     }
6996   checkThatComponentsMatch(tse2->getInfo());
6997   _time_steps.push_back(tse);
6998 }
6999
7000 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope()
7001 {
7002   std::size_t nbOfCompo=_infos.size();
7003   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7004     {
7005       MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
7006       if(cur)
7007         {
7008           if((cur->getInfo()).size()!=nbOfCompo)
7009             {
7010               std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
7011               oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
7012               throw INTERP_KERNEL::Exception(oss.str().c_str());
7013             }
7014           cur->copyNameScope(*this);
7015         }
7016     }
7017 }
7018
7019 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll)
7020 {
7021   _time_steps.resize(nbPdt);
7022   for(int i=0;i<nbPdt;i++)
7023     {
7024       std::vector< std::pair<int,int> > ts;
7025       med_int numdt=0,numo=0;
7026       med_int meshIt=0,meshOrder=0;
7027       med_float dt=0.0;
7028       MEDfieldComputingStepMeshInfo(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder);
7029       switch(fieldTyp)
7030         {
7031         case MED_FLOAT64:
7032           {
7033             _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7034             break;
7035           }
7036         case MED_INT32:
7037           {
7038             _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7039             break;
7040           }
7041         default:
7042           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
7043         }
7044       if(loadAll)
7045         _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this);
7046       else
7047         _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this);
7048     }
7049 }
7050
7051 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const
7052 {
7053   if(_time_steps.empty())
7054     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
7055   checkThatNbOfCompoOfTSMatchThis();
7056   std::vector<std::string> infos(getInfo());
7057   int nbComp=infos.size();
7058   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7059   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7060   for(int i=0;i<nbComp;i++)
7061     {
7062       std::string info=infos[i];
7063       std::string c,u;
7064       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
7065       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7066       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7067     }
7068   if(_name.empty())
7069     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
7070   MEDfieldCr(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
7071   int nbOfTS=_time_steps.size();
7072   for(int i=0;i<nbOfTS;i++)
7073     _time_steps[i]->writeLL(fid,opts,*this);
7074 }
7075
7076 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
7077 {
7078   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7079     {
7080       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7081       if(elt)
7082         elt->loadBigArraysRecursively(fid,nasc);
7083     }
7084 }
7085
7086 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
7087 {
7088   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7089     {
7090       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7091       if(elt)
7092         elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
7093     }
7094 }
7095
7096 void MEDFileAnyTypeFieldMultiTSWithoutSDA::unloadArrays()
7097 {
7098   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7099     {
7100       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7101       if(elt)
7102         elt->unloadArrays();
7103     }
7104 }
7105
7106 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
7107 {
7108   return _time_steps.size();
7109 }
7110
7111 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS()
7112 {
7113   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  > newTS;
7114   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7115     {
7116       const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
7117       if(tmp)
7118         newTS.push_back(*it);
7119     }
7120   _time_steps=newTS;
7121 }
7122
7123 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds)
7124 {
7125   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7126   int maxId=(int)_time_steps.size();
7127   int ii=0;
7128   std::set<int> idsToDel;
7129   for(const int *id=startIds;id!=endIds;id++,ii++)
7130     {
7131       if(*id>=0 && *id<maxId)
7132         {
7133           idsToDel.insert(*id);
7134         }
7135       else
7136         {
7137           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
7138           throw INTERP_KERNEL::Exception(oss.str().c_str());
7139         }
7140     }
7141   for(int iii=0;iii<maxId;iii++)
7142     if(idsToDel.find(iii)==idsToDel.end())
7143       newTS.push_back(_time_steps[iii]);
7144   _time_steps=newTS;
7145 }
7146
7147 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step)
7148 {
7149   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
7150   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7151   if(nbOfEntriesToKill==0)
7152     return ;
7153   std::size_t sz=_time_steps.size();
7154   std::vector<bool> b(sz,true);
7155   int j=bg;
7156   for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
7157     b[j]=false;
7158   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7159   for(std::size_t i=0;i<sz;i++)
7160     if(b[i])
7161       newTS.push_back(_time_steps[i]);
7162   _time_steps=newTS;
7163 }
7164
7165 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const
7166 {
7167   int ret=0;
7168   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
7169   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7170     {
7171       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7172       if(tmp)
7173         {
7174           int it2,ord;
7175           tmp->getTime(it2,ord);
7176           if(it2==iteration && order==ord)
7177             return ret;
7178           else
7179             oss << "(" << it2 << ","  << ord << "), ";
7180         }
7181     }
7182   throw INTERP_KERNEL::Exception(oss.str().c_str());
7183 }
7184
7185 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const
7186 {
7187   int ret=0;
7188   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
7189   oss.precision(15);
7190   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7191     {
7192       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7193       if(tmp)
7194         {
7195           int it2,ord;
7196           double ti=tmp->getTime(it2,ord);
7197           if(fabs(time-ti)<eps)
7198             return ret;
7199           else
7200             oss << ti << ", ";
7201         }
7202     }
7203   throw INTERP_KERNEL::Exception(oss.str().c_str());
7204 }
7205
7206 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
7207 {
7208   int lgth=_time_steps.size();
7209   std::vector< std::pair<int,int> > ret(lgth);
7210   for(int i=0;i<lgth;i++)
7211     _time_steps[i]->fillIteration(ret[i]);
7212   return ret;
7213 }
7214
7215 /*!
7216  * 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'
7217  * This method returns two things.
7218  * - The absolute dimension of 'this' in first parameter.
7219  * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
7220  *   to the first output parameter. The values in 'levs' will be returned in decreasing order.
7221  *
7222  * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
7223  * Only these 3 discretizations will be taken into account here.
7224  *
7225  * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
7226  * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
7227  * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
7228  *
7229  * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
7230  * 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'.
7231  *
7232  * Let's consider the typical following case :
7233  * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
7234  * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
7235  * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
7236  *   TETRA4 and SEG2
7237  * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
7238  *
7239  * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
7240  *
7241  * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
7242  * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
7243  * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
7244  * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
7245  */
7246 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
7247 {
7248   return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
7249 }
7250
7251 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const
7252 {
7253   if(pos<0 || pos>=(int)_time_steps.size())
7254     {
7255       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7256       throw INTERP_KERNEL::Exception(oss.str().c_str());
7257     }
7258   const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7259   if(item==0)
7260     {
7261       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7262       oss << "\nTry to use following method eraseEmptyTS !";
7263       throw INTERP_KERNEL::Exception(oss.str().c_str());
7264     }
7265   return item;
7266 }
7267
7268 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos)
7269 {
7270   if(pos<0 || pos>=(int)_time_steps.size())
7271     {
7272       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7273       throw INTERP_KERNEL::Exception(oss.str().c_str());
7274     }
7275   MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7276   if(item==0)
7277     {
7278       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7279       oss << "\nTry to use following method eraseEmptyTS !";
7280       throw INTERP_KERNEL::Exception(oss.str().c_str());
7281     }
7282   return item;
7283 }
7284
7285 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
7286 {
7287   std::vector<std::string> ret;
7288   std::set<std::string> ret2;
7289   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7290     {
7291       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
7292       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7293         if(ret2.find(*it2)==ret2.end())
7294           {
7295             ret.push_back(*it2);
7296             ret2.insert(*it2);
7297           }
7298     }
7299   return ret;
7300 }
7301
7302 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
7303 {
7304   std::vector<std::string> ret;
7305   std::set<std::string> ret2;
7306   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7307     {
7308       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
7309       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7310         if(ret2.find(*it2)==ret2.end())
7311           {
7312             ret.push_back(*it2);
7313             ret2.insert(*it2);
7314           }
7315     }
7316   return ret;
7317 }
7318
7319 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
7320 {
7321   std::vector<std::string> ret;
7322   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7323     {
7324       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
7325       ret.insert(ret.end(),tmp.begin(),tmp.end());
7326     }
7327   return ret;
7328 }
7329
7330 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
7331 {
7332   std::vector<std::string> ret;
7333   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7334     {
7335       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
7336       ret.insert(ret.end(),tmp.begin(),tmp.end());
7337     }
7338   return ret;
7339 }
7340
7341 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7342 {
7343   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7344     (*it)->changePflsRefsNamesGen2(mapOfModif);
7345 }
7346
7347 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7348 {
7349   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7350     (*it)->changeLocsRefsNamesGen2(mapOfModif);
7351 }
7352
7353 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const
7354 {
7355   int lgth=_time_steps.size();
7356   std::vector< std::vector<TypeOfField> > ret(lgth);
7357   for(int i=0;i<lgth;i++)
7358     _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
7359   return ret;
7360 }
7361
7362 /*!
7363  * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
7364  */
7365 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
7366 {
7367   return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
7368 }
7369
7370 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCpy() const
7371 {
7372   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
7373   std::size_t i=0;
7374   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7375     {
7376       if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
7377         ret->_time_steps[i]=(*it)->deepCpy();
7378     }
7379   return ret.retn();
7380 }
7381
7382 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const
7383 {
7384   std::size_t sz(_infos.size()),sz2(_time_steps.size());
7385   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
7386   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
7387   for(std::size_t i=0;i<sz;i++)
7388     {
7389       ret[i]=shallowCpy();
7390       ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
7391     }
7392   for(std::size_t i=0;i<sz2;i++)
7393     {
7394       std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
7395       if(ret1.size()!=sz)
7396         {
7397           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
7398           throw INTERP_KERNEL::Exception(oss.str().c_str());
7399         }
7400       ts[i]=ret1;
7401     }
7402   for(std::size_t i=0;i<sz;i++)
7403     for(std::size_t j=0;j<sz2;j++)
7404       ret[i]->_time_steps[j]=ts[j][i];
7405   return ret;
7406 }
7407
7408 /*!
7409  * This method splits into discretization each time steps in \a this.
7410  * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
7411  */
7412 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const
7413 {
7414   std::size_t sz(_time_steps.size());
7415   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7416   for(std::size_t i=0;i<sz;i++)
7417     {
7418       const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7419       if(!timeStep)
7420         {
7421           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
7422           throw INTERP_KERNEL::Exception(oss.str().c_str());
7423         }
7424       items[i]=timeStep->splitDiscretizations();
7425     }
7426   //
7427   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
7428   std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
7429   std::vector< TypeOfField > types;
7430   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7431     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7432       {
7433         std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
7434         if(ts.size()!=1)
7435           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
7436         std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
7437         if(it2==types.end())
7438           types.push_back(ts[0]);
7439       }
7440   ret.resize(types.size()); ret2.resize(types.size());
7441   for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7442     for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7443       {
7444         TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
7445         std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
7446         ret2[pos].push_back(*it1);
7447       }
7448   for(std::size_t i=0;i<types.size();i++)
7449     {
7450       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=createNew();
7451       for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
7452         elt->pushBackTimeStep(*it1);//also updates infos in elt
7453       ret[i]=elt;
7454       elt->MEDFileFieldNameScope::operator=(*this);
7455     }
7456   return ret;
7457 }
7458
7459 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
7460 {
7461   _name=field->getName();
7462   if(_name.empty())
7463     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
7464   if(!arr)
7465     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
7466   _infos=arr->getInfoOnComponents();
7467 }
7468
7469 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const
7470 {
7471   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
7472   if(_name!=field->getName())
7473     {
7474       std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
7475       oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
7476       throw INTERP_KERNEL::Exception(oss.str().c_str());
7477     }
7478   if(!arr)
7479     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
7480   checkThatComponentsMatch(arr->getInfoOnComponents());
7481 }
7482
7483 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const
7484 {
7485   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
7486   if(getInfo().size()!=compos.size())
7487     {
7488       std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
7489       oss << " number of components of element to append (" << compos.size() << ") !";
7490       throw INTERP_KERNEL::Exception(oss.str().c_str());
7491     }
7492   if(_infos!=compos)
7493     {
7494       std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
7495       std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
7496       oss << " But compo in input fields are : ";
7497       std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
7498       oss << " !";
7499       throw INTERP_KERNEL::Exception(oss.str().c_str());
7500     }
7501 }
7502
7503 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const
7504 {
7505   std::size_t sz=_infos.size();
7506   int j=0;
7507   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
7508     {
7509       const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7510       if(elt)
7511         if(elt->getInfo().size()!=sz)
7512           {
7513             std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
7514             oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
7515             throw INTERP_KERNEL::Exception(oss.str().c_str());
7516           }
7517     }
7518 }
7519
7520 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
7521 {
7522   if(!field)
7523     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7524   if(!_time_steps.empty())
7525     checkCoherencyOfTinyInfo(field,arr);
7526   MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
7527   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7528   objC->setFieldNoProfileSBT(field,arr,glob,*this);
7529   copyTinyInfoFrom(field,arr);
7530   _time_steps.push_back(obj);
7531 }
7532
7533 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob)
7534 {
7535   if(!field)
7536     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7537   if(!_time_steps.empty())
7538     checkCoherencyOfTinyInfo(field,arr);
7539   MEDFileField1TSWithoutSDA *objC=new MEDFileField1TSWithoutSDA;
7540   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7541   objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
7542   copyTinyInfoFrom(field,arr);
7543   _time_steps.push_back(obj);
7544 }
7545
7546 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ts)
7547 {
7548   int sz=(int)_time_steps.size();
7549   if(i<0 || i>=sz)
7550     {
7551       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
7552       throw INTERP_KERNEL::Exception(oss.str().c_str());
7553     }
7554   const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
7555   if(tsPtr)
7556     {
7557       if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
7558         {
7559           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() <<  " !";
7560           throw INTERP_KERNEL::Exception(oss.str().c_str());
7561         }
7562     }
7563   _time_steps[i]=ts;
7564 }
7565
7566 //= MEDFileFieldMultiTSWithoutSDA
7567
7568 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)
7569 {
7570   return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7571 }
7572
7573 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
7574 {
7575 }
7576
7577 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7578 {
7579 }
7580
7581 /*!
7582  * \param [in] fieldId field id in C mode
7583  */
7584 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7585 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7586 {
7587 }
7588 catch(INTERP_KERNEL::Exception& e)
7589   { throw e; }
7590
7591 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)
7592 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7593 {
7594 }
7595 catch(INTERP_KERNEL::Exception& e)
7596 { throw e; }
7597
7598 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7599 {
7600   return new MEDFileField1TSWithoutSDA;
7601 }
7602
7603 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7604 {
7605   if(!f1ts)
7606     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7607   const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
7608   if(!f1tsC)
7609     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
7610 }
7611
7612 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const
7613 {
7614   return MEDFileField1TSWithoutSDA::TYPE_STR;
7615 }
7616
7617 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const
7618 {
7619   return new MEDFileFieldMultiTSWithoutSDA(*this);
7620 }
7621
7622 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const
7623 {
7624   return new MEDFileFieldMultiTSWithoutSDA;
7625 }
7626
7627 /*!
7628  * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
7629  * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
7630  */
7631 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
7632 {
7633   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
7634   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
7635   if(!myF1TSC)
7636     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
7637   return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
7638 }
7639
7640 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const
7641 {
7642   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
7643   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7644   int i=0;
7645   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7646     {
7647       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7648       if(eltToConv)
7649         {
7650           const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
7651           if(!eltToConvC)
7652             throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
7653           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
7654           ret->setIteration(i,elt);
7655         }
7656     }
7657   return ret.retn();
7658 }
7659
7660 //= MEDFileAnyTypeFieldMultiTS
7661
7662 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
7663 {
7664 }
7665
7666 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const std::string& fileName, bool loadAll)
7667 try:MEDFileFieldGlobsReal(fileName)
7668 {
7669   MEDFileUtilities::CheckFileForRead(fileName);
7670   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7671   _content=BuildContentFrom(fid,fileName,loadAll);
7672   loadGlobals(fid);
7673 }
7674 catch(INTERP_KERNEL::Exception& e)
7675   {
7676     throw e;
7677   }
7678
7679 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const std::string& fileName, const std::string& fieldName, bool loadAll)
7680 {
7681   med_field_type typcha;
7682   std::vector<std::string> infos;
7683   std::string dtunit;
7684   int i=-1;
7685   MEDFileAnyTypeField1TS::LocateField(fid,fileName,fieldName,i,typcha,infos,dtunit);
7686   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7687   switch(typcha)
7688     {
7689     case MED_FLOAT64:
7690       {
7691         ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll);
7692         break;
7693       }
7694     case MED_INT32:
7695       {
7696         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll);
7697         break;
7698       }
7699     default:
7700       {
7701         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] !";
7702         throw INTERP_KERNEL::Exception(oss.str().c_str());
7703       }
7704     }
7705   ret->setDtUnit(dtunit.c_str());
7706   return ret.retn();
7707 }
7708
7709 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const std::string& fileName, bool loadAll)
7710 {
7711   med_field_type typcha;
7712   //
7713   std::vector<std::string> infos;
7714   std::string dtunit,fieldName;
7715   MEDFileAnyTypeField1TS::LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
7716   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7717   switch(typcha)
7718     {
7719     case MED_FLOAT64:
7720       {
7721         ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll);
7722         break;
7723       }
7724     case MED_INT32:
7725       {
7726         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll);
7727         break;
7728       }
7729     default:
7730       {
7731         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] !";
7732         throw INTERP_KERNEL::Exception(oss.str().c_str());
7733       }
7734     }
7735   ret->setDtUnit(dtunit.c_str());
7736   return ret.retn();
7737 }
7738
7739 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, const std::string& fileName)
7740 {
7741   if(!c)
7742     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
7743   if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
7744     {
7745       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=MEDFileFieldMultiTS::New();
7746       ret->setFileName(fileName);
7747       ret->_content=c;  c->incrRef();
7748       return ret.retn();
7749     }
7750   if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
7751     {
7752       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=MEDFileIntFieldMultiTS::New();
7753       ret->setFileName(fileName);
7754       ret->_content=c;  c->incrRef();
7755       return ret.retn();
7756     }
7757   throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
7758 }
7759
7760 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const std::string& fileName, const std::string& fieldName, bool loadAll)
7761 try:MEDFileFieldGlobsReal(fileName)
7762 {
7763   MEDFileUtilities::CheckFileForRead(fileName);
7764   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7765   _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
7766   loadGlobals(fid);
7767 }
7768 catch(INTERP_KERNEL::Exception& e)
7769   {
7770     throw e;
7771   }
7772
7773 //= MEDFileIntFieldMultiTSWithoutSDA
7774
7775 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)
7776 {
7777   return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7778 }
7779
7780 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
7781 {
7782 }
7783
7784 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7785 {
7786 }
7787
7788 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)
7789 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7790 {
7791 }
7792 catch(INTERP_KERNEL::Exception& e)
7793 { throw e; }
7794
7795 /*!
7796  * \param [in] fieldId field id in C mode
7797  */
7798 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7799 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7800 {
7801 }
7802 catch(INTERP_KERNEL::Exception& e)
7803   { throw e; }
7804
7805 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7806 {
7807   return new MEDFileIntField1TSWithoutSDA;
7808 }
7809
7810 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7811 {
7812   if(!f1ts)
7813     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7814   const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
7815   if(!f1tsC)
7816     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
7817 }
7818
7819 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const
7820 {
7821   return MEDFileIntField1TSWithoutSDA::TYPE_STR;
7822 }
7823
7824 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const
7825 {
7826   return new MEDFileIntFieldMultiTSWithoutSDA(*this);
7827 }
7828
7829 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const
7830 {
7831   return new MEDFileIntFieldMultiTSWithoutSDA;
7832 }
7833
7834 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const
7835 {
7836   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
7837   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7838   int i=0;
7839   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7840     {
7841       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7842       if(eltToConv)
7843         {
7844           const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
7845           if(!eltToConvC)
7846             throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
7847           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
7848           ret->setIteration(i,elt);
7849         }
7850     }
7851   return ret.retn();
7852 }
7853
7854 //= MEDFileAnyTypeFieldMultiTS
7855
7856 /*!
7857  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
7858  * that has been read from a specified MED file.
7859  *  \param [in] fileName - the name of the MED file to read.
7860  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7861  *          is to delete this field using decrRef() as it is no more needed.
7862  *  \throw If reading the file fails.
7863  */
7864 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, bool loadAll)
7865 {
7866   MEDFileUtilities::CheckFileForRead(fileName);
7867   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7868   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
7869   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7870   ret->loadGlobals(fid);
7871   return ret.retn();
7872 }
7873
7874 /*!
7875  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
7876  * that has been read from a specified MED file.
7877  *  \param [in] fileName - the name of the MED file to read.
7878  *  \param [in] fieldName - the name of the field to read.
7879  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7880  *          is to delete this field using decrRef() as it is no more needed.
7881  *  \throw If reading the file fails.
7882  *  \throw If there is no field named \a fieldName in the file.
7883  */
7884 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
7885 {
7886   MEDFileUtilities::CheckFileForRead(fileName);
7887   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7888   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
7889   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7890   ret->loadGlobals(fid);
7891   return ret.retn();
7892 }
7893
7894 /*!
7895  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
7896  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
7897  *
7898  * \warning this is a shallow copy constructor
7899  */
7900 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
7901 {
7902   if(!shallowCopyOfContent)
7903     {
7904       const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
7905       otherPtr->incrRef();
7906       _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
7907     }
7908   else
7909     {
7910       _content=other.shallowCpy();
7911     }
7912 }
7913
7914 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase()
7915 {
7916   MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7917   if(!ret)
7918     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
7919   return ret;
7920 }
7921
7922 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const
7923 {
7924   const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7925   if(!ret)
7926     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
7927   return ret;
7928 }
7929
7930 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
7931 {
7932   return contentNotNullBase()->getPflsReallyUsed2();
7933 }
7934
7935 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
7936 {
7937   return contentNotNullBase()->getLocsReallyUsed2();
7938 }
7939
7940 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
7941 {
7942   return contentNotNullBase()->getPflsReallyUsedMulti2();
7943 }
7944
7945 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
7946 {
7947   return contentNotNullBase()->getLocsReallyUsedMulti2();
7948 }
7949
7950 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7951 {
7952   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
7953 }
7954
7955 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7956 {
7957   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
7958 }
7959
7960 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
7961 {
7962   return contentNotNullBase()->getNumberOfTS();
7963 }
7964
7965 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS()
7966 {
7967   contentNotNullBase()->eraseEmptyTS();
7968 }
7969
7970 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
7971 {
7972   contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
7973 }
7974
7975 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step)
7976 {
7977   contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
7978 }
7979
7980 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const
7981 {
7982   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
7983   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7984   ret->_content=c;
7985   return ret.retn();
7986 }
7987
7988 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const
7989 {
7990   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
7991   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
7992   ret->_content=c;
7993   return ret.retn();
7994 }
7995
7996 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
7997 {
7998   return contentNotNullBase()->getIterations();
7999 }
8000
8001 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts)
8002 {
8003   for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
8004     pushBackTimeStep(*it);
8005 }
8006
8007 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts)
8008 {
8009   if(!f1ts)
8010     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
8011   checkCoherencyOfType(f1ts);
8012   f1ts->incrRef();
8013   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
8014   MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
8015   c->incrRef();
8016   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
8017   if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
8018     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
8019   _content->pushBackTimeStep(cSafe);
8020   appendGlobs(*f1ts,1e-12);
8021 }
8022
8023 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope()
8024 {
8025   contentNotNullBase()->synchronizeNameScope();
8026 }
8027
8028 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const
8029 {
8030   return contentNotNullBase()->getPosOfTimeStep(iteration,order);
8031 }
8032
8033 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const
8034 {
8035   return contentNotNullBase()->getPosGivenTime(time,eps);
8036 }
8037
8038 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
8039 {
8040   return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
8041 }
8042
8043 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const
8044 {
8045   return contentNotNullBase()->getTypesOfFieldAvailable();
8046 }
8047
8048 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
8049 {
8050   return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
8051 }
8052
8053 std::string MEDFileAnyTypeFieldMultiTS::getName() const
8054 {
8055   return contentNotNullBase()->getName();
8056 }
8057
8058 void MEDFileAnyTypeFieldMultiTS::setName(const std::string& name)
8059 {
8060   contentNotNullBase()->setName(name);
8061 }
8062
8063 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const
8064 {
8065   return contentNotNullBase()->getDtUnit();
8066 }
8067
8068 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const std::string& dtUnit)
8069 {
8070   contentNotNullBase()->setDtUnit(dtUnit);
8071 }
8072
8073 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
8074 {
8075   contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
8076 }
8077
8078 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const
8079 {
8080   return contentNotNullBase()->getTimeSteps(ret1);
8081 }
8082
8083 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const
8084 {
8085   return contentNotNullBase()->getMeshName();
8086 }
8087
8088 void MEDFileAnyTypeFieldMultiTS::setMeshName(const std::string& newMeshName)
8089 {
8090   contentNotNullBase()->setMeshName(newMeshName);
8091 }
8092
8093 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
8094 {
8095   return contentNotNullBase()->changeMeshNames(modifTab);
8096 }
8097
8098 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const
8099 {
8100   return contentNotNullBase()->getInfo();
8101 }
8102
8103 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info)
8104 {
8105   return contentNotNullBase()->setInfo(info);
8106 }
8107
8108 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const
8109 {
8110   const std::vector<std::string> ret=getInfo();
8111   return (int)ret.size();
8112 }
8113
8114 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const
8115 {
8116   writeGlobals(fid,*this);
8117   contentNotNullBase()->writeLL(fid,*this);
8118 }
8119
8120 /*!
8121  * Writes \a this field into a MED file specified by its name.
8122  *  \param [in] fileName - the MED file name.
8123  *  \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
8124  * - 2 - erase; an existing file is removed.
8125  * - 1 - append; same data should not be present in an existing file.
8126  * - 0 - overwrite; same data present in an existing file is overwritten.
8127  *  \throw If the field name is not set.
8128  *  \throw If no field data is set.
8129  *  \throw If \a mode == 1 and the same data is present in an existing file.
8130  */
8131 void MEDFileAnyTypeFieldMultiTS::write(const std::string& fileName, int mode) const
8132 {
8133   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
8134   MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
8135   writeLL(fid);
8136 }
8137
8138 /*!
8139  * This method alloc the arrays and load potentially huge arrays contained in this field.
8140  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
8141  * This method can be also called to refresh or reinit values from a file.
8142  *
8143  * \throw If the fileName is not set or points to a non readable MED file.
8144  */
8145 void MEDFileAnyTypeFieldMultiTS::loadArrays()
8146 {
8147   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
8148   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
8149 }
8150
8151 /*!
8152  * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
8153  * But once data loaded once, this method does nothing.
8154  *
8155  * \throw If the fileName is not set or points to a non readable MED file.
8156  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::unloadArrays
8157  */
8158 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary()
8159 {
8160   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
8161   contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
8162 }
8163
8164 /*!
8165  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
8166  * This method does not release arrays set outside the context of a MED file.
8167  *
8168  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
8169  */
8170 void MEDFileAnyTypeFieldMultiTS::unloadArrays()
8171 {
8172   contentNotNullBase()->unloadArrays();
8173 }
8174
8175 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
8176 {
8177   std::ostringstream oss;
8178   contentNotNullBase()->simpleRepr(0,oss,-1);
8179   simpleReprGlobs(oss);
8180   return oss.str();
8181 }
8182
8183 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySizeWithoutChildren() const
8184 {
8185   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
8186 }
8187
8188 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTS::getDirectChildren() const
8189 {
8190   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
8191   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8192     ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content);
8193   return ret;
8194 }
8195
8196 /*!
8197  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
8198  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8199  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
8200  */
8201 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const
8202 {
8203   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8204   if(!content)
8205     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
8206   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
8207   std::size_t sz(contentsSplit.size());
8208   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8209   for(std::size_t i=0;i<sz;i++)
8210     {
8211       ret[i]=shallowCpy();
8212       ret[i]->_content=contentsSplit[i];
8213     }
8214   return ret;
8215 }
8216
8217 /*!
8218  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
8219  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8220  */
8221 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const
8222 {
8223   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8224   if(!content)
8225     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
8226   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitDiscretizations();
8227   std::size_t sz(contentsSplit.size());
8228   std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8229   for(std::size_t i=0;i<sz;i++)
8230     {
8231       ret[i]=shallowCpy();
8232       ret[i]->_content=contentsSplit[i];
8233     }
8234   return ret;
8235 }
8236
8237 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCpy() const
8238 {
8239   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8240   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8241     ret->_content=_content->deepCpy();
8242   ret->deepCpyGlobs(*this);
8243   return ret.retn();
8244 }
8245
8246 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
8247 {
8248   return _content;
8249 }
8250
8251 /*!
8252  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8253  *  \param [in] iteration - the iteration number of a required time step.
8254  *  \param [in] order - the iteration order number of required time step.
8255  *  \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
8256  *          delete this field using decrRef() as it is no more needed.
8257  *  \throw If there is no required time step in \a this field.
8258  */
8259 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const
8260 {
8261   int pos=getPosOfTimeStep(iteration,order);
8262   return getTimeStepAtPos(pos);
8263 }
8264
8265 /*!
8266  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8267  *  \param [in] time - the time of the time step of interest.
8268  *  \param [in] eps - a precision used to compare time values.
8269  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8270  *          delete this field using decrRef() as it is no more needed.
8271  *  \throw If there is no required time step in \a this field.
8272  */
8273 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const
8274 {
8275   int pos=getPosGivenTime(time,eps);
8276   return getTimeStepAtPos(pos);
8277 }
8278
8279 /*!
8280  * 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.
8281  * The float64 value of time attached to the pair of integers are not considered here.
8282  * WARNING the returned pointers are not incremented. The caller is \b not responsible to deallocate them ! This method only reorganizes entries in \a vectFMTS.
8283  *
8284  * \param [in] vectFMTS - vector of not null fields defined on a same global data pointer.
8285  * \throw If there is a null pointer in \a vectFMTS.
8286  */
8287 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS)
8288 {
8289   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries : presence of null instance in input vector !";
8290   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8291   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8292   while(!lstFMTS.empty())
8293     {
8294       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8295       MEDFileAnyTypeFieldMultiTS *curIt(*it);
8296       if(!curIt)
8297         throw INTERP_KERNEL::Exception(msg);
8298       std::vector< std::pair<int,int> > refIts=curIt->getIterations();
8299       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8300       elt.push_back(curIt); it=lstFMTS.erase(it);
8301       while(it!=lstFMTS.end())
8302         {
8303           curIt=*it;
8304           if(!curIt)
8305             throw INTERP_KERNEL::Exception(msg);
8306           std::vector< std::pair<int,int> > curIts=curIt->getIterations();
8307           if(refIts==curIts)
8308             { elt.push_back(curIt); it=lstFMTS.erase(it); }
8309           else
8310             it++;
8311         }
8312       ret.push_back(elt);
8313     }
8314   return ret;
8315 }
8316
8317 /*!
8318  * This method splits the input list \a vectFMTS considering the aspect of the geometrical support over time.
8319  * All returned instances in a subvector can be safely loaded, rendered along time
8320  * All items must be defined on the same time step ids ( see MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries method ).
8321  * Each item in \a vectFMTS is expected to have one and exactly one spatial discretization along time.
8322  * 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).
8323  * All items in \a vectFMTS whose spatial discretization is not ON_NODES will appear once.
8324  * 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.
8325  *
8326  * \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().
8327  * \param [in] mesh - the mesh shared by all items in \a vectFMTS across time.
8328  * \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.
8329  * \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.
8330  *
8331  * \throw If an element in \a vectFMTS has not only one spatial discretization set.
8332  * \throw If an element in \a vectFMTS change of spatial discretization along time.
8333  * \throw If an element in \a vectFMTS lies on a mesh with meshname different from those in \a mesh.
8334  * \thorw If some elements in \a vectFMTS do not have the same times steps.
8335  * \throw If mesh is null.
8336  * \throw If an element in \a vectFMTS is null.
8337  * \sa MEDFileAnyTypeFieldMultiTS::AreOnSameSupportAcrossTime
8338  */
8339 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& fsc)
8340 {
8341   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : presence of a null instance in the input vector !";
8342   if(!mesh)
8343     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : input mesh is null !");
8344   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8345   if(vectFMTS.empty())
8346     return ret;
8347   std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it(vectFMTS.begin());
8348   MEDFileAnyTypeFieldMultiTS *frstElt(*it);
8349   if(!frstElt)
8350     throw INTERP_KERNEL::Exception(msg);
8351   std::size_t i=0;
8352   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNotNodes;
8353   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNodes;
8354   for(;it!=vectFMTS.end();it++,i++)
8355     {
8356       if(!(*it))
8357         throw INTERP_KERNEL::Exception(msg);
8358       TypeOfField tof0,tof1;
8359       if(CheckSupportAcrossTime(frstElt,*it,mesh,tof0,tof1)>0)
8360         {
8361           if(tof1!=ON_NODES)
8362             vectFMTSNotNodes.push_back(*it);
8363           else
8364             vectFMTSNodes.push_back(*it);
8365         }
8366       else
8367         vectFMTSNotNodes.push_back(*it);
8368     }
8369   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> > cmps;
8370   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > retCell=SplitPerCommonSupportNotNodesAlg(vectFMTSNotNodes,mesh,cmps);
8371   ret=retCell;
8372   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it2=vectFMTSNodes.begin();it2!=vectFMTSNodes.end();it2++)
8373     {
8374       i=0;
8375       bool isFetched(false);
8376       for(std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> >::const_iterator it0=retCell.begin();it0!=retCell.end();it0++,i++)
8377         {
8378           if((*it0).empty())
8379             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : internal error !");
8380           if(cmps[i]->isCompatibleWithNodesDiscr(*it2))
8381             { ret[i].push_back(*it2); isFetched=true; }
8382         }
8383       if(!isFetched)
8384         {
8385           std::vector<MEDFileAnyTypeFieldMultiTS *> tmp(1,*it2);
8386           MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> tmp2(MEDFileMeshStruct::New(mesh));
8387           ret.push_back(tmp); retCell.push_back(tmp); cmps.push_back(MEDFileFastCellSupportComparator::New(tmp2,*it2));
8388         }
8389     }
8390   fsc=cmps;
8391   return ret;
8392 }
8393
8394 /*!
8395  * 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.
8396  * \param [out] cmps - same size than the returned vector.
8397  */
8398 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupportNotNodesAlg(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& cmps)
8399 {
8400   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8401   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8402   while(!lstFMTS.empty())
8403     {
8404       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8405       MEDFileAnyTypeFieldMultiTS *ref(*it);
8406       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8407       elt.push_back(ref); it=lstFMTS.erase(it);
8408       MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(mesh));
8409       MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> cmp(MEDFileFastCellSupportComparator::New(mst,ref));
8410       while(it!=lstFMTS.end())
8411         {
8412           MEDFileAnyTypeFieldMultiTS *curIt(*it);
8413           if(cmp->isEqual(curIt))
8414             { elt.push_back(curIt); it=lstFMTS.erase(it); }
8415           else
8416             it++;
8417         }
8418       ret.push_back(elt); cmps.push_back(cmp);
8419     }
8420   return ret;
8421 }
8422
8423 /*!
8424  * 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.
8425  * \a f0 and \a f1 must be defined each only on a same spatial discretization even if this can be different each other.
8426  *
8427  * \throw If \a f0 or \a f1 has not only one spatial discretization set.
8428  * \throw If \a f0 or \a f1 change of spatial discretization along time.
8429  * \throw If \a f0 or \a f1 on a mesh with meshname different from those in \a mesh.
8430  * \thorw If \a f0 and \a f1 do not have the same times steps.
8431  * \throw If mesh is null.
8432  * \throw If \a f0 or \a f1 is null.
8433  * \sa MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport
8434  */
8435 int MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime(MEDFileAnyTypeFieldMultiTS *f0, MEDFileAnyTypeFieldMultiTS *f1, const MEDFileMesh *mesh, TypeOfField& tof0, TypeOfField& tof1)
8436 {
8437   if(!mesh)
8438     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : input mesh is null !");
8439   if(!f0 || !f1)
8440     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : presence of null instance in fields over time !");
8441   if(f0->getMeshName()!=mesh->getName())
8442     {
8443       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh \""<< f0->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8444       throw INTERP_KERNEL::Exception(oss.str().c_str());
8445     }
8446   if(f1->getMeshName()!=mesh->getName())
8447     {
8448       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh \""<< f1->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8449       throw INTERP_KERNEL::Exception(oss.str().c_str());
8450     }
8451   int nts=f0->getNumberOfTS();
8452   if(nts!=f1->getNumberOfTS())
8453     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : number of time steps are not the same !");
8454   if(nts==0)
8455     return nts;
8456   for(int i=0;i<nts;i++)
8457     {
8458       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f0cur=f0->getTimeStepAtPos(i);
8459       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1cur=f1->getTimeStepAtPos(i);
8460       std::vector<TypeOfField> tofs0(f0cur->getTypesOfFieldAvailable()),tofs1(f1cur->getTypesOfFieldAvailable());
8461       if(tofs0.size()!=1 || tofs1.size()!=1)
8462         throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : All time steps must be defined on only one spatial discretization !");
8463       if(i!=0)
8464         {
8465           if(tof0!=tofs0[0] || tof1!=tofs1[0])
8466             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : Across times steps MEDFileAnyTypeFieldMultiTS instances have to keep the same unique spatial discretization !");
8467         }
8468       else
8469         { tof0=tofs0[0]; tof1=tofs1[0]; }
8470       if(f0cur->getMeshIteration()!=mesh->getIteration() || f0cur->getMeshOrder()!=mesh->getOrder())
8471         {
8472           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() << ") !";
8473           throw INTERP_KERNEL::Exception(oss.str().c_str());
8474         }
8475       if(f1cur->getMeshIteration()!=mesh->getIteration() || f1cur->getMeshOrder()!=mesh->getOrder())
8476         {
8477           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() << ") !";
8478           throw INTERP_KERNEL::Exception(oss.str().c_str());
8479         }
8480       if(f0cur->getIteration()!=f1cur->getIteration() || f0cur->getOrder()!=f1cur->getOrder())
8481         {
8482           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() << ") !";
8483           throw INTERP_KERNEL::Exception(oss.str().c_str());
8484         }
8485     }
8486   return nts;
8487 }
8488
8489 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator()
8490 {
8491   return new MEDFileAnyTypeFieldMultiTSIterator(this);
8492 }
8493
8494 //= MEDFileFieldMultiTS
8495
8496 /*!
8497  * Returns a new empty instance of MEDFileFieldMultiTS.
8498  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8499  *          is to delete this field using decrRef() as it is no more needed.
8500  */
8501 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
8502 {
8503   return new MEDFileFieldMultiTS;
8504 }
8505
8506 /*!
8507  * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
8508  * that has been read from a specified MED file.
8509  *  \param [in] fileName - the name of the MED file to read.
8510  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8511  *          is to delete this field using decrRef() as it is no more needed.
8512  *  \throw If reading the file fails.
8513  */
8514 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, bool loadAll)
8515 {
8516   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,loadAll);
8517   ret->contentNotNull();//to check that content type matches with \a this type.
8518   return ret.retn();
8519 }
8520
8521 /*!
8522  * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
8523  * that has been read from a specified MED file.
8524  *  \param [in] fileName - the name of the MED file to read.
8525  *  \param [in] fieldName - the name of the field to read.
8526  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8527  *          is to delete this field using decrRef() as it is no more needed.
8528  *  \throw If reading the file fails.
8529  *  \throw If there is no field named \a fieldName in the file.
8530  */
8531 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
8532 {
8533   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,fieldName,loadAll);
8534   ret->contentNotNull();//to check that content type matches with \a this type.
8535   return ret.retn();
8536 }
8537
8538 /*!
8539  * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8540  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8541  *
8542  * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
8543  * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8544  * \warning this is a shallow copy constructor
8545  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
8546  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8547  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8548  *          is to delete this field using decrRef() as it is no more needed.
8549  */
8550 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8551 {
8552   return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
8553 }
8554
8555 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const
8556 {
8557   return new MEDFileFieldMultiTS(*this);
8558 }
8559
8560 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
8561 {
8562   if(!f1ts)
8563     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8564   const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
8565   if(!f1tsC)
8566     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8567 }
8568
8569 /*!
8570  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
8571  * following the given input policy.
8572  *
8573  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8574  *                            By default (true) the globals are deeply copied.
8575  * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
8576  */
8577 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool isDeepCpyGlobs) const
8578 {
8579   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret;
8580   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8581   if(content)
8582     {
8583       const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
8584       if(!contc)
8585         throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
8586       MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
8587       ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc,getFileName()));
8588     }
8589   else
8590     ret=MEDFileIntFieldMultiTS::New();
8591   if(isDeepCpyGlobs)
8592     ret->deepCpyGlobs(*this);
8593   else
8594     ret->shallowCpyGlobs(*this);
8595   return ret.retn();
8596 }
8597
8598 /*!
8599  * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
8600  *  \param [in] pos - a time step id.
8601  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8602  *          delete this field using decrRef() as it is no more needed.
8603  *  \throw If \a pos is not a valid time step id.
8604  */
8605 MEDFileAnyTypeField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const
8606 {
8607   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8608   if(!item)
8609     {
8610       std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8611       throw INTERP_KERNEL::Exception(oss.str().c_str());
8612     }
8613   const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
8614   if(itemC)
8615     {
8616       MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
8617       ret->shallowCpyGlobs(*this);
8618       return ret.retn();
8619     }
8620   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
8621   throw INTERP_KERNEL::Exception(oss.str().c_str());
8622 }
8623
8624 /*!
8625  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8626  * mesh entities of a given dimension of the first mesh in MED file.
8627  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8628  *  \param [in] type - a spatial discretization of interest.
8629  *  \param [in] iteration - the iteration number of a required time step.
8630  *  \param [in] order - the iteration order number of required time step.
8631  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8632  *  \param [in] renumPol - specifies how to permute values of the result field according to
8633  *          the optional numbers of cells and nodes, if any. The valid values are
8634  *          - 0 - do not permute.
8635  *          - 1 - permute cells.
8636  *          - 2 - permute nodes.
8637  *          - 3 - permute cells and nodes.
8638  *
8639  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8640  *          caller is to delete this field using decrRef() as it is no more needed.
8641  *  \throw If the MED file is not readable.
8642  *  \throw If there is no mesh in the MED file.
8643  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8644  *  \throw If no field values of the required parameters are available.
8645  */
8646 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const
8647 {
8648   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8649   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8650   if(!myF1TSC)
8651     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
8652   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8653   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNullBase());
8654   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8655   return ret.retn();
8656 }
8657
8658 /*!
8659  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8660  * the top level cells of the first mesh in MED file.
8661  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8662  *  \param [in] type - a spatial discretization of interest.
8663  *  \param [in] iteration - the iteration number of a required time step.
8664  *  \param [in] order - the iteration order number of required time step.
8665  *  \param [in] renumPol - specifies how to permute values of the result field according to
8666  *          the optional numbers of cells and nodes, if any. The valid values are
8667  *          - 0 - do not permute.
8668  *          - 1 - permute cells.
8669  *          - 2 - permute nodes.
8670  *          - 3 - permute cells and nodes.
8671  *
8672  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8673  *          caller is to delete this field using decrRef() as it is no more needed.
8674  *  \throw If the MED file is not readable.
8675  *  \throw If there is no mesh in the MED file.
8676  *  \throw If no field values of the required parameters are available.
8677  */
8678 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const
8679 {
8680   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8681   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8682   if(!myF1TSC)
8683     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
8684   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8685   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNullBase());
8686   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8687   return ret.retn();
8688 }
8689
8690 /*!
8691  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8692  * a given support.
8693  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8694  *  \param [in] type - a spatial discretization of interest.
8695  *  \param [in] iteration - the iteration number of a required time step.
8696  *  \param [in] order - the iteration order number of required time step.
8697  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8698  *  \param [in] mesh - the supporting mesh.
8699  *  \param [in] renumPol - specifies how to permute values of the result field according to
8700  *          the optional numbers of cells and nodes, if any. The valid values are
8701  *          - 0 - do not permute.
8702  *          - 1 - permute cells.
8703  *          - 2 - permute nodes.
8704  *          - 3 - permute cells and nodes.
8705  *
8706  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8707  *          caller is to delete this field using decrRef() as it is no more needed.
8708  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8709  *  \throw If no field of \a this is lying on \a mesh.
8710  *  \throw If no field values of the required parameters are available.
8711  */
8712 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
8713 {
8714   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8715   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8716   if(!myF1TSC)
8717     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8718   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8719   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
8720   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8721   return ret.retn();
8722 }
8723
8724 /*!
8725  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8726  * given support.
8727  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8728  *  \param [in] type - a spatial discretization of the new field.
8729  *  \param [in] iteration - the iteration number of a required time step.
8730  *  \param [in] order - the iteration order number of required time step.
8731  *  \param [in] mesh - the supporting mesh.
8732  *  \param [in] renumPol - specifies how to permute values of the result field according to
8733  *          the optional numbers of cells and nodes, if any. The valid values are
8734  *          - 0 - do not permute.
8735  *          - 1 - permute cells.
8736  *          - 2 - permute nodes.
8737  *          - 3 - permute cells and nodes.
8738  *
8739  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8740  *          caller is to delete this field using decrRef() as it is no more needed.
8741  *  \throw If no field of \a this is lying on \a mesh.
8742  *  \throw If no field values of the required parameters are available.
8743  */
8744 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const
8745 {
8746   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8747   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8748   if(!myF1TSC)
8749     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8750   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8751   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
8752   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8753   return ret.retn();
8754 }
8755
8756 /*!
8757  * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
8758  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8759  * This method is useful for MED2 file format when field on different mesh was autorized.
8760  */
8761 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int iteration, int order, int meshDimRelToMax, int renumPol) const
8762 {
8763   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8764   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8765   if(!myF1TSC)
8766     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
8767   MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8768   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
8769   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8770   return ret.retn();
8771 }
8772
8773 /*!
8774  * Returns values and a profile of the field of a given type, of a given time step,
8775  * lying on a given support.
8776  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8777  *  \param [in] type - a spatial discretization of the field.
8778  *  \param [in] iteration - the iteration number of a required time step.
8779  *  \param [in] order - the iteration order number of required time step.
8780  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8781  *  \param [in] mesh - the supporting mesh.
8782  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8783  *          field of interest lies on. If the field lies on all entities of the given
8784  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
8785  *          using decrRef() as it is no more needed.
8786  *  \param [in] glob - the global data storing profiles and localization.
8787  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
8788  *          field. The caller is to delete this array using decrRef() as it is no more needed.
8789  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8790  *  \throw If no field of \a this is lying on \a mesh.
8791  *  \throw If no field values of the required parameters are available.
8792  */
8793 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
8794 {
8795   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8796   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8797   if(!myF1TSC)
8798     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
8799   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8800   return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
8801 }
8802
8803 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const
8804 {
8805   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8806   if(!pt)
8807     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
8808   const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
8809   if(!ret)
8810     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 !");
8811   return ret;
8812 }
8813
8814  MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull()
8815 {
8816   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8817   if(!pt)
8818     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
8819   MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
8820   if(!ret)
8821     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 !");
8822   return ret;
8823 }
8824
8825 /*!
8826  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8827  * the given field is checked if its elements are sorted suitable for writing to MED file
8828  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8829  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8830  *  \param [in] field - the field to add to \a this.
8831  *  \throw If the name of \a field is empty.
8832  *  \throw If the data array of \a field is not set.
8833  *  \throw If existing time steps have different name or number of components than \a field.
8834  *  \throw If the underlying mesh of \a field has no name.
8835  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8836  */
8837 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
8838 {
8839   const DataArrayDouble *arr=0;
8840   if(field)
8841     arr=field->getArray();
8842   contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
8843 }
8844
8845 /*!
8846  * Adds a MEDCouplingFieldDouble to \a this as another time step.
8847  * The mesh support of input parameter \a field is ignored here, it can be NULL.
8848  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
8849  * and \a profile.
8850  *
8851  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
8852  * A new profile is added only if no equal profile is missing.
8853  * For more info, see \ref AdvMEDLoaderAPIFieldRW
8854  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
8855  *  \param [in] mesh - the supporting mesh of \a field.
8856  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
8857  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
8858  *  \throw If either \a field or \a mesh or \a profile has an empty name.
8859  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8860  *  \throw If the data array of \a field is not set.
8861  *  \throw If the data array of \a this is already allocated but has different number of
8862  *         components than \a field.
8863  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
8864  *  \sa setFieldNoProfileSBT()
8865  */
8866 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
8867 {
8868   const DataArrayDouble *arr=0;
8869   if(field)
8870     arr=field->getArray();
8871   contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
8872 }
8873
8874 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
8875 {
8876   _content=new MEDFileFieldMultiTSWithoutSDA;
8877 }
8878
8879 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const std::string& fileName, bool loadAll)
8880 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
8881 {
8882 }
8883 catch(INTERP_KERNEL::Exception& e)
8884   { throw e; }
8885
8886 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const std::string& fileName, const std::string& fieldName, bool loadAll)
8887 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
8888 {
8889 }
8890 catch(INTERP_KERNEL::Exception& e)
8891   { throw e; }
8892
8893 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
8894 {
8895 }
8896
8897 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
8898 {
8899   return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
8900 }
8901
8902 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
8903 {
8904   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
8905 }
8906
8907 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
8908 {
8909   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
8910 }
8911
8912 //= MEDFileAnyTypeFieldMultiTSIterator
8913
8914 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
8915 {
8916   if(fmts)
8917     {
8918       fmts->incrRef();
8919       _nb_iter=fmts->getNumberOfTS();
8920     }
8921 }
8922
8923 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
8924 {
8925 }
8926
8927 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt()
8928 {
8929   if(_iter_id<_nb_iter)
8930     {
8931       MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
8932       if(fmts)
8933         return fmts->getTimeStepAtPos(_iter_id++);
8934       else
8935         return 0;
8936     }
8937   else
8938     return 0;
8939 }
8940
8941 //= MEDFileIntFieldMultiTS
8942
8943 /*!
8944  * Returns a new empty instance of MEDFileFieldMultiTS.
8945  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8946  *          is to delete this field using decrRef() as it is no more needed.
8947  */
8948 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
8949 {
8950   return new MEDFileIntFieldMultiTS;
8951 }
8952
8953 /*!
8954  * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
8955  * that has been read from a specified MED file.
8956  *  \param [in] fileName - the name of the MED file to read.
8957  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8958  *          is to delete this field using decrRef() as it is no more needed.
8959  *  \throw If reading the file fails.
8960  */
8961 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, bool loadAll)
8962 {
8963   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,loadAll);
8964   ret->contentNotNull();//to check that content type matches with \a this type.
8965   return ret.retn();
8966 }
8967
8968 /*!
8969  * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
8970  * that has been read from a specified MED file.
8971  *  \param [in] fileName - the name of the MED file to read.
8972  *  \param [in] fieldName - the name of the field to read.
8973  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8974  *          is to delete this field using decrRef() as it is no more needed.
8975  *  \throw If reading the file fails.
8976  *  \throw If there is no field named \a fieldName in the file.
8977  */
8978 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
8979 {
8980   MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,fieldName,loadAll);
8981   ret->contentNotNull();//to check that content type matches with \a this type.
8982   return ret.retn();
8983 }
8984
8985 /*!
8986  * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8987  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8988  *
8989  * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
8990  * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8991  * \warning this is a shallow copy constructor
8992  *  \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
8993  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8994  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8995  *          is to delete this field using decrRef() as it is no more needed.
8996  */
8997 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8998 {
8999   return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
9000 }
9001
9002 /*!
9003  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
9004  * following the given input policy.
9005  *
9006  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
9007  *                            By default (true) the globals are deeply copied.
9008  * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
9009  */
9010 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool isDeepCpyGlobs) const
9011 {
9012   MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret;
9013   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9014   if(content)
9015     {
9016       const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
9017       if(!contc)
9018         throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
9019       MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
9020       ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc,getFileName()));
9021     }
9022   else
9023     ret=MEDFileFieldMultiTS::New();
9024   if(isDeepCpyGlobs)
9025     ret->deepCpyGlobs(*this);
9026   else
9027     ret->shallowCpyGlobs(*this);
9028   return ret.retn();
9029 }
9030
9031 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const
9032 {
9033   return new MEDFileIntFieldMultiTS(*this);
9034 }
9035
9036 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
9037 {
9038   if(!f1ts)
9039     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
9040   const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
9041   if(!f1tsC)
9042     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
9043 }
9044
9045 /*!
9046  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9047  * mesh entities of a given dimension of the first mesh in MED file.
9048  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9049  *  \param [in] type - a spatial discretization of interest.
9050  *  \param [in] iteration - the iteration number of a required time step.
9051  *  \param [in] order - the iteration order number of required time step.
9052  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9053  *  \param [out] arrOut - the DataArrayInt containing values of field.
9054  *  \param [in] renumPol - specifies how to permute values of the result field according to
9055  *          the optional numbers of cells and nodes, if any. The valid values are
9056  *          - 0 - do not permute.
9057  *          - 1 - permute cells.
9058  *          - 2 - permute nodes.
9059  *          - 3 - permute cells and nodes.
9060  *
9061  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9062  *          caller is to delete this field using decrRef() as it is no more needed.
9063  *  \throw If the MED file is not readable.
9064  *  \throw If there is no mesh in the MED file.
9065  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9066  *  \throw If no field values of the required parameters are available.
9067  */
9068 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9069 {
9070   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9071   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9072   if(!myF1TSC)
9073     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
9074   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9075   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arr,*contentNotNullBase());
9076   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9077   return ret.retn();
9078 }
9079
9080 /*!
9081  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9082  * the top level cells of the first mesh in MED file.
9083  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9084  *  \param [in] type - a spatial discretization of interest.
9085  *  \param [in] iteration - the iteration number of a required time step.
9086  *  \param [in] order - the iteration order number of required time step.
9087  *  \param [out] arrOut - the DataArrayInt containing values of field.
9088  *  \param [in] renumPol - specifies how to permute values of the result field according to
9089  *          the optional numbers of cells and nodes, if any. The valid values are
9090  *          - 0 - do not permute.
9091  *          - 1 - permute cells.
9092  *          - 2 - permute nodes.
9093  *          - 3 - permute cells and nodes.
9094  *
9095  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9096  *          caller is to delete this field using decrRef() as it is no more needed.
9097  *  \throw If the MED file is not readable.
9098  *  \throw If there is no mesh in the MED file.
9099  *  \throw If no field values of the required parameters are available.
9100  */
9101 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, DataArrayInt* &arrOut, int renumPol) const
9102 {
9103   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9104   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9105   if(!myF1TSC)
9106     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
9107   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9108   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arr,*contentNotNullBase());
9109   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9110   return ret.retn();
9111 }
9112
9113 /*!
9114  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9115  * a given support.
9116  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9117  *  \param [in] type - a spatial discretization of interest.
9118  *  \param [in] iteration - the iteration number of a required time step.
9119  *  \param [in] order - the iteration order number of required time step.
9120  *  \param [out] arrOut - the DataArrayInt containing values of field.
9121  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9122  *  \param [in] mesh - the supporting mesh.
9123  *  \param [in] renumPol - specifies how to permute values of the result field according to
9124  *          the optional numbers of cells and nodes, if any. The valid values are
9125  *          - 0 - do not permute.
9126  *          - 1 - permute cells.
9127  *          - 2 - permute nodes.
9128  *          - 3 - permute cells and nodes.
9129  *
9130  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9131  *          caller is to delete this field using decrRef() as it is no more needed.
9132  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9133  *  \throw If no field of \a this is lying on \a mesh.
9134  *  \throw If no field values of the required parameters are available.
9135  */
9136 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9137 {
9138   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9139   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9140   if(!myF1TSC)
9141     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9142   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9143   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase());
9144   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9145   return ret.retn();
9146 }
9147
9148 /*!
9149  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
9150  * given support.
9151  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9152  *  \param [in] type - a spatial discretization of the new field.
9153  *  \param [in] iteration - the iteration number of a required time step.
9154  *  \param [in] order - the iteration order number of required time step.
9155  *  \param [in] mesh - the supporting mesh.
9156  *  \param [out] arrOut - the DataArrayInt containing values of field.
9157  *  \param [in] renumPol - specifies how to permute values of the result field according to
9158  *          the optional numbers of cells and nodes, if any. The valid values are
9159  *          - 0 - do not permute.
9160  *          - 1 - permute cells.
9161  *          - 2 - permute nodes.
9162  *          - 3 - permute cells and nodes.
9163  *
9164  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9165  *          caller is to delete this field using decrRef() as it is no more needed.
9166  *  \throw If no field of \a this is lying on \a mesh.
9167  *  \throw If no field values of the required parameters are available.
9168  */
9169 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9170 {
9171   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9172   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9173   if(!myF1TSC)
9174     throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9175   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9176   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase());
9177   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9178   return ret.retn();
9179 }
9180
9181 /*!
9182  * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
9183  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
9184  * This method is useful for MED2 file format when field on different mesh was autorized.
9185  */
9186 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const std::string& mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9187 {
9188   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9189   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9190   if(!myF1TSC)
9191     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9192   MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9193   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase());
9194   arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9195   return ret.retn();
9196 }
9197
9198 /*!
9199  * Returns values and a profile of the field of a given type, of a given time step,
9200  * lying on a given support.
9201  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9202  *  \param [in] type - a spatial discretization of the field.
9203  *  \param [in] iteration - the iteration number of a required time step.
9204  *  \param [in] order - the iteration order number of required time step.
9205  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9206  *  \param [in] mesh - the supporting mesh.
9207  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
9208  *          field of interest lies on. If the field lies on all entities of the given
9209  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
9210  *          using decrRef() as it is no more needed.
9211  *  \param [in] glob - the global data storing profiles and localization.
9212  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
9213  *          field. The caller is to delete this array using decrRef() as it is no more needed.
9214  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9215  *  \throw If no field of \a this is lying on \a mesh.
9216  *  \throw If no field values of the required parameters are available.
9217  */
9218 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
9219 {
9220   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9221   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9222   if(!myF1TSC)
9223     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
9224   MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
9225   return MEDFileIntField1TS::ReturnSafelyDataArrayInt(ret);
9226 }
9227
9228 /*!
9229  * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
9230  *  \param [in] pos - a time step id.
9231  *  \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
9232  *          delete this field using decrRef() as it is no more needed.
9233  *  \throw If \a pos is not a valid time step id.
9234  */
9235 MEDFileAnyTypeField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const
9236 {
9237   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
9238   if(!item)
9239     {
9240       std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
9241       throw INTERP_KERNEL::Exception(oss.str().c_str());
9242     }
9243   const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
9244   if(itemC)
9245     {
9246       MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
9247       ret->shallowCpyGlobs(*this);
9248       return ret.retn();
9249     }
9250   std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
9251   throw INTERP_KERNEL::Exception(oss.str().c_str());
9252 }
9253
9254 /*!
9255  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
9256  * the given field is checked if its elements are sorted suitable for writing to MED file
9257  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
9258  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9259  *  \param [in] field - the field to add to \a this.
9260  *  \throw If the name of \a field is empty.
9261  *  \throw If the data array of \a field is not set.
9262  *  \throw If existing time steps have different name or number of components than \a field.
9263  *  \throw If the underlying mesh of \a field has no name.
9264  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
9265  */
9266 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
9267 {
9268   contentNotNull()->appendFieldNoProfileSBT(field,arrOfVals,*this);
9269 }
9270
9271 /*!
9272  * Adds a MEDCouplingFieldDouble to \a this as another time step.
9273  * The mesh support of input parameter \a field is ignored here, it can be NULL.
9274  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
9275  * and \a profile.
9276  *
9277  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
9278  * A new profile is added only if no equal profile is missing.
9279  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9280  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
9281  *  \param [in] arrOfVals - the values of the field \a field used.
9282  *  \param [in] mesh - the supporting mesh of \a field.
9283  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
9284  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
9285  *  \throw If either \a field or \a mesh or \a profile has an empty name.
9286  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9287  *  \throw If the data array of \a field is not set.
9288  *  \throw If the data array of \a this is already allocated but has different number of
9289  *         components than \a field.
9290  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
9291  *  \sa setFieldNoProfileSBT()
9292  */
9293 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
9294 {
9295   contentNotNull()->appendFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this);
9296 }
9297
9298 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const
9299 {
9300   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9301   if(!pt)
9302     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
9303   const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9304   if(!ret)
9305     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 !");
9306   return ret;
9307 }
9308
9309  MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull()
9310 {
9311   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9312   if(!pt)
9313     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
9314   MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9315   if(!ret)
9316     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 !");
9317   return ret;
9318 }
9319
9320 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
9321 {
9322   _content=new MEDFileIntFieldMultiTSWithoutSDA;
9323 }
9324
9325 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
9326 {
9327 }
9328
9329 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const std::string& fileName, bool loadAll)
9330 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
9331 {
9332 }
9333 catch(INTERP_KERNEL::Exception& e)
9334   { throw e; }
9335
9336 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const std::string& fileName, const std::string& fieldName, bool loadAll)
9337 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
9338 {
9339 }
9340 catch(INTERP_KERNEL::Exception& e)
9341   { throw e; }
9342
9343 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
9344 {
9345   return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
9346 }
9347
9348 //= MEDFileFields
9349
9350 MEDFileFields *MEDFileFields::New()
9351 {
9352   return new MEDFileFields;
9353 }
9354
9355 MEDFileFields *MEDFileFields::New(const std::string& fileName, bool loadAll)
9356 {
9357   return new MEDFileFields(fileName,loadAll);
9358 }
9359
9360 std::size_t MEDFileFields::getHeapMemorySizeWithoutChildren() const
9361 {
9362   std::size_t ret(MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren());
9363   ret+=_fields.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
9364   return ret;
9365 }
9366
9367 std::vector<const BigMemoryObject *> MEDFileFields::getDirectChildren() const
9368 {
9369   std::vector<const BigMemoryObject *> ret;
9370   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9371     {
9372       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9373       if(cur)
9374         ret.push_back(cur);
9375     }
9376   return ret;
9377 }
9378
9379 MEDFileFields *MEDFileFields::deepCpy() const
9380 {
9381   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9382   std::size_t i=0;
9383   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9384     {
9385       if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9386         ret->_fields[i]=(*it)->deepCpy();
9387     }
9388   ret->deepCpyGlobs(*this);
9389   return ret.retn();
9390 }
9391
9392 MEDFileFields *MEDFileFields::shallowCpy() const
9393 {
9394   return new MEDFileFields(*this);
9395 }
9396
9397 /*!
9398  * 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
9399  * 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.
9400  * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
9401  *
9402  * \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.
9403  * \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.
9404  *
9405  * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9406  */
9407 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const
9408 {
9409   std::set< std::pair<int,int> > s;
9410   bool firstShot=true;
9411   areThereSomeForgottenTS=false;
9412   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9413     {
9414       if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9415         continue;
9416       std::vector< std::pair<int,int> > v=(*it)->getIterations();
9417       std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
9418       if(firstShot)
9419         { s=s1; firstShot=false; }
9420       else
9421         {
9422           std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
9423           if(s!=s2)
9424             areThereSomeForgottenTS=true;
9425           s=s2;
9426         }
9427     }
9428   std::vector< std::pair<int,int> > ret;
9429   std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
9430   return ret;
9431 }
9432
9433 int MEDFileFields::getNumberOfFields() const
9434 {
9435   return _fields.size();
9436 }
9437
9438 std::vector<std::string> MEDFileFields::getFieldsNames() const
9439 {
9440   std::vector<std::string> ret(_fields.size());
9441   int i=0;
9442   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9443     {
9444       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
9445       if(f)
9446         {
9447           ret[i]=f->getName();
9448         }
9449       else
9450         {
9451           std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
9452           throw INTERP_KERNEL::Exception(oss.str().c_str());
9453         }
9454     }
9455   return ret;
9456 }
9457
9458 std::vector<std::string> MEDFileFields::getMeshesNames() const
9459 {
9460   std::vector<std::string> ret;
9461   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9462     {
9463       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9464       if(cur)
9465         ret.push_back(cur->getMeshName());
9466     }
9467   return ret;
9468 }
9469
9470 std::string MEDFileFields::simpleRepr() const
9471 {
9472   std::ostringstream oss;
9473   oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
9474   simpleRepr(0,oss);
9475   return oss.str();
9476 }
9477
9478 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
9479 {
9480   int nbOfFields=getNumberOfFields();
9481   std::string startLine(bkOffset,' ');
9482   oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
9483   int i=0;
9484   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9485     {
9486       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9487       if(cur)
9488         {
9489           oss << startLine << "  - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
9490         }
9491       else
9492         {
9493           oss << startLine << "  - not defined !" << std::endl;
9494         }
9495     }
9496   i=0;
9497   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9498     {
9499       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9500       std::string chapter(17,'0'+i);
9501       oss << startLine << chapter << std::endl;
9502       if(cur)
9503         {
9504           cur->simpleRepr(bkOffset+2,oss,i);
9505         }
9506       else
9507         {
9508           oss << startLine << "  - not defined !" << std::endl;
9509         }
9510       oss << startLine << chapter << std::endl;
9511     }
9512   simpleReprGlobs(oss);
9513 }
9514
9515 MEDFileFields::MEDFileFields()
9516 {
9517 }
9518
9519 MEDFileFields::MEDFileFields(const std::string& fileName, bool loadAll)
9520 try:MEDFileFieldGlobsReal(fileName)
9521   {
9522     MEDFileUtilities::CheckFileForRead(fileName);
9523     MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
9524     int nbFields=MEDnField(fid);
9525     _fields.resize(nbFields);
9526     med_field_type typcha;
9527     for(int i=0;i<nbFields;i++)
9528       {
9529         std::vector<std::string> infos;
9530         std::string fieldName,dtunit;
9531         int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,fileName,i,false,fieldName,typcha,infos,dtunit);
9532         switch(typcha)
9533           {
9534           case MED_FLOAT64:
9535             {
9536               _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9537               break;
9538             }
9539           case MED_INT32:
9540             {
9541               _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9542               break;
9543             }
9544           default:
9545             {
9546               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] !";
9547               throw INTERP_KERNEL::Exception(oss.str().c_str());
9548             }
9549           }
9550       }
9551     loadAllGlobals(fid);
9552   }
9553 catch(INTERP_KERNEL::Exception& e)
9554   {
9555     throw e;
9556   }
9557
9558 void MEDFileFields::writeLL(med_idt fid) const
9559 {
9560   int i=0;
9561   writeGlobals(fid,*this);
9562   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9563     {
9564       const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
9565       if(!elt)
9566         {
9567           std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
9568           throw INTERP_KERNEL::Exception(oss.str().c_str());
9569         }
9570       elt->writeLL(fid,*this);
9571     }
9572 }
9573
9574 void MEDFileFields::write(const std::string& fileName, int mode) const
9575 {
9576   med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
9577   MEDFileUtilities::AutoFid fid(MEDfileOpen(fileName.c_str(),medmod));
9578   writeLL(fid);
9579 }
9580
9581 /*!
9582  * This method alloc the arrays and load potentially huge arrays contained in this field.
9583  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
9584  * This method can be also called to refresh or reinit values from a file.
9585  *
9586  * \throw If the fileName is not set or points to a non readable MED file.
9587  */
9588 void MEDFileFields::loadArrays()
9589 {
9590   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
9591   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9592     {
9593       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9594       if(elt)
9595         elt->loadBigArraysRecursively(fid,*elt);
9596     }
9597 }
9598
9599 /*!
9600  * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
9601  * But once data loaded once, this method does nothing.
9602  *
9603  * \throw If the fileName is not set or points to a non readable MED file.
9604  * \sa MEDFileFields::loadArrays, MEDFileFields::unloadArrays
9605  */
9606 void MEDFileFields::loadArraysIfNecessary()
9607 {
9608   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
9609   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9610     {
9611       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9612       if(elt)
9613         elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
9614     }
9615 }
9616
9617 /*!
9618  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
9619  * This method does not release arrays set outside the context of a MED file.
9620  *
9621  * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary
9622  */
9623 void MEDFileFields::unloadArrays()
9624 {
9625   MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
9626   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9627     {
9628       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9629       if(elt)
9630         elt->unloadArrays();
9631     }
9632 }
9633
9634 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
9635 {
9636   std::vector<std::string> ret;
9637   std::set<std::string> ret2;
9638   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9639     {
9640       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
9641       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9642         if(ret2.find(*it2)==ret2.end())
9643           {
9644             ret.push_back(*it2);
9645             ret2.insert(*it2);
9646           }
9647     }
9648   return ret;
9649 }
9650
9651 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
9652 {
9653   std::vector<std::string> ret;
9654   std::set<std::string> ret2;
9655   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9656     {
9657       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9658       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9659         if(ret2.find(*it2)==ret2.end())
9660           {
9661             ret.push_back(*it2);
9662             ret2.insert(*it2);
9663           }
9664     }
9665   return ret;
9666 }
9667
9668 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
9669 {
9670   std::vector<std::string> ret;
9671   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9672     {
9673       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
9674       ret.insert(ret.end(),tmp.begin(),tmp.end());
9675     }
9676   return ret;
9677 }
9678
9679 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
9680 {
9681   std::vector<std::string> ret;
9682   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9683     {
9684       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9685       ret.insert(ret.end(),tmp.begin(),tmp.end());
9686     }
9687   return ret;
9688 }
9689
9690 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9691 {
9692   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9693     (*it)->changePflsRefsNamesGen2(mapOfModif);
9694 }
9695
9696 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9697 {
9698   for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9699     (*it)->changeLocsRefsNamesGen2(mapOfModif);
9700 }
9701
9702 void MEDFileFields::resize(int newSize)
9703 {
9704   _fields.resize(newSize);
9705 }
9706
9707 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields)
9708 {
9709   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
9710     pushField(*it);
9711 }
9712
9713 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field)
9714 {
9715   if(!field)
9716     throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
9717   _fields.push_back(field->getContent());
9718   appendGlobs(*field,1e-12);
9719 }
9720
9721 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field)
9722 {
9723   if(!field)
9724     throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
9725   if(i>=(int)_fields.size())
9726     _fields.resize(i+1);
9727   _fields[i]=field->getContent();
9728   appendGlobs(*field,1e-12);
9729 }
9730
9731 void MEDFileFields::destroyFieldAtPos(int i)
9732 {
9733   destroyFieldsAtPos(&i,&i+1);
9734 }
9735
9736 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds)
9737 {
9738   std::vector<bool> b(_fields.size(),true);
9739   for(const int *i=startIds;i!=endIds;i++)
9740     {
9741       if(*i<0 || *i>=(int)_fields.size())
9742         {
9743           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9744           throw INTERP_KERNEL::Exception(oss.str().c_str());
9745         }
9746       b[*i]=false;
9747     }
9748   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9749   std::size_t j=0;
9750   for(std::size_t i=0;i<_fields.size();i++)
9751     if(b[i])
9752       fields[j++]=_fields[i];
9753   _fields=fields;
9754 }
9755
9756 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step)
9757 {
9758   static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
9759   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
9760   std::vector<bool> b(_fields.size(),true);
9761   int k=bg;
9762   for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
9763     {
9764       if(k<0 || k>=(int)_fields.size())
9765         {
9766           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
9767           throw INTERP_KERNEL::Exception(oss.str().c_str());
9768         }
9769       b[k]=false;
9770     }
9771   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9772   std::size_t j=0;
9773   for(std::size_t i=0;i<_fields.size();i++)
9774     if(b[i])
9775       fields[j++]=_fields[i];
9776   _fields=fields;
9777 }
9778
9779 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
9780 {
9781   bool ret=false;
9782   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9783     {
9784       MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9785       if(cur)
9786         ret=cur->changeMeshNames(modifTab) || ret;
9787     }
9788   return ret;
9789 }
9790
9791 /*!
9792  * \param [in] meshName the name of the mesh that will be renumbered.
9793  * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
9794  *             This code corresponds to the distribution of types in the corresponding mesh.
9795  * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
9796  * \param [in] renumO2N the old to new renumber array.
9797  * \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
9798  *         field in \a this.
9799  */
9800 bool MEDFileFields::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N)
9801 {
9802   bool ret=false;
9803   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9804     {
9805       MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
9806       if(fmts)
9807         {
9808           ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
9809         }
9810     }
9811   return ret;
9812 }
9813
9814 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const
9815 {
9816   if(i<0 || i>=(int)_fields.size())
9817     {
9818       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
9819       throw INTERP_KERNEL::Exception(oss.str().c_str());
9820     }
9821   const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
9822   if(!fmts)
9823     return 0;
9824   MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret;
9825   const MEDFileFieldMultiTSWithoutSDA *fmtsC=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts);
9826   const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts);
9827   if(fmtsC)
9828     ret=MEDFileFieldMultiTS::New(*fmtsC,false);
9829   else if(fmtsC2)
9830     ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
9831   else
9832     {
9833       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
9834       throw INTERP_KERNEL::Exception(oss.str().c_str());
9835     }
9836   ret->shallowCpyGlobs(*this);
9837   return ret.retn();
9838 }
9839
9840 /*!
9841  * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
9842  * This method is accessible in python using __getitem__ with a list in input.
9843  * \return a new object that the caller should deal with.
9844  */
9845 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const
9846 {
9847   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9848   std::size_t sz=std::distance(startIds,endIds);
9849   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
9850   int j=0;
9851   for(const int *i=startIds;i!=endIds;i++,j++)
9852     {
9853       if(*i<0 || *i>=(int)_fields.size())
9854         {
9855           std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9856           throw INTERP_KERNEL::Exception(oss.str().c_str());
9857         }
9858       fields[j]=_fields[*i];
9859     }
9860   ret->_fields=fields;
9861   return ret.retn();
9862 }
9863
9864 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const std::string& fieldName) const
9865 {
9866   return getFieldAtPos(getPosFromFieldName(fieldName));
9867 }
9868
9869 /*!
9870  * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
9871  * This method can be seen as a filter applied on \a this, that returns an object containing
9872  * 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
9873  * shallow copied from \a this.
9874  *
9875  * \param [in] meshName - the name of the mesh on w
9876  * \return a new object that the caller should deal with.
9877  */
9878 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const std::string& meshName) const
9879 {
9880   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9881   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9882     {
9883       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9884       if(!cur)
9885         continue;
9886       if(cur->getMeshName()==meshName)
9887         {
9888           cur->incrRef();
9889           MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
9890           ret->_fields.push_back(cur2);
9891         }
9892     }
9893   ret->shallowCpyOnlyUsedGlobs(*this);
9894   return ret.retn();
9895 }
9896
9897 /*!
9898  * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
9899  * Input time steps are specified using a pair of integer (iteration, order).
9900  * 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,
9901  * but for each multitimestep only the time steps in \a timeSteps are kept.
9902  * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
9903  *
9904  * The returned object points to shallow copy of elements in \a this.
9905  *
9906  * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
9907  * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
9908  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9909  */
9910 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
9911 {
9912   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9913   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9914     {
9915       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9916       if(!cur)
9917         continue;
9918       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
9919       ret->_fields.push_back(elt);
9920     }
9921   ret->shallowCpyOnlyUsedGlobs(*this);
9922   return ret.retn();
9923 }
9924
9925 /*!
9926  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
9927  */
9928 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
9929 {
9930   MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9931   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9932     {
9933       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9934       if(!cur)
9935         continue;
9936       MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
9937       if(elt->getNumberOfTS()!=0)
9938         ret->_fields.push_back(elt);
9939     }
9940   ret->shallowCpyOnlyUsedGlobs(*this);
9941   return ret.retn();
9942 }
9943
9944 MEDFileFieldsIterator *MEDFileFields::iterator()
9945 {
9946   return new MEDFileFieldsIterator(this);
9947 }
9948
9949 int MEDFileFields::getPosFromFieldName(const std::string& fieldName) const
9950 {
9951   std::string tmp(fieldName);
9952   std::vector<std::string> poss;
9953   for(std::size_t i=0;i<_fields.size();i++)
9954     {
9955       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=_fields[i];
9956       if(f)
9957         {
9958           std::string fname(f->getName());
9959           if(tmp==fname)
9960             return i;
9961           else
9962             poss.push_back(fname);
9963         }
9964     }
9965   std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
9966   std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
9967   oss << " !";
9968   throw INTERP_KERNEL::Exception(oss.str().c_str());
9969 }
9970
9971 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
9972 {
9973   if(fs)
9974     {
9975       fs->incrRef();
9976       _nb_iter=fs->getNumberOfFields();
9977     }
9978 }
9979
9980 MEDFileFieldsIterator::~MEDFileFieldsIterator()
9981 {
9982 }
9983
9984 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
9985 {
9986   if(_iter_id<_nb_iter)
9987     {
9988       MEDFileFields *fs(_fs);
9989       if(fs)
9990         return fs->getFieldAtPos(_iter_id++);
9991       else
9992         return 0;
9993     }
9994   else
9995     return 0;
9996 }