src/MEDLoader/MEDFileField.cxx

   1 // Copyright (C) 2007-2016  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, or (at your option) any later version.
   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.txx"
  22 #include "MEDFileMesh.hxx"
  23 #include "MEDLoaderBase.hxx"
  24 #include "MEDLoaderTraits.hxx"
  25 #include "MEDFileSafeCaller.txx"
  26 #include "MEDFileFieldOverView.hxx"
  27 #include "MEDFileBlowStrEltUp.hxx"
  28 #include "MEDFileFieldVisitor.hxx"
  29
  30 #include "MEDCouplingFieldDouble.hxx"
  31 #include "MEDCouplingFieldTemplate.hxx"
  32 #include "MEDCouplingFieldDiscretization.hxx"
  33
  34 #include "InterpKernelAutoPtr.hxx"
  35 #include "CellModel.hxx"
  36
  37 #include <algorithm>
  38 #include <iterator>
  39
  40 extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
  41 extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
  42 extern med_geometry_type typmainoeud[1];
  43 extern med_geometry_type typmai3[34];
  44
  45 using namespace MEDCoupling;
  46
  47 template class MEDCoupling::MEDFileField1TSTemplateWithoutSDA<int>;
  48 template class MEDCoupling::MEDFileField1TSTemplateWithoutSDA<float>;
  49 template class MEDCoupling::MEDFileField1TSTemplateWithoutSDA<double>;
  50 template class MEDCoupling::MEDFileTemplateField1TS<int>;
  51 template class MEDCoupling::MEDFileTemplateField1TS<double>;
  52
  53 const char MEDFileField1TSWithoutSDA::TYPE_STR[]="FLOAT64";
  54 const char MEDFileIntField1TSWithoutSDA::TYPE_STR[]="INT32";
  55 const char MEDFileFloatField1TSWithoutSDA::TYPE_STR[]="FLOAT32";
  56
  57 MEDFileGTKeeper::~MEDFileGTKeeper()
  58 {
  59 }
  60
  61 MEDFileGTKeeper *MEDFileGTKeeperSta::deepCopy() const
  62 {
  63   return new MEDFileGTKeeperSta(_geo_type);
  64 }
  65
  66 INTERP_KERNEL::NormalizedCellType MEDFileGTKeeperSta::getGeoType() const
  67 {
  68   return _geo_type;
  69 }
  70
  71 std::string MEDFileGTKeeperSta::getRepr() const
  72 {
  73   return INTERP_KERNEL::CellModel::GetCellModel(_geo_type).getRepr();
  74 }
  75
  76 bool MEDFileGTKeeperSta::isEqual(const MEDFileGTKeeper *other) const
  77 {
  78   const MEDFileGTKeeperSta *otherC(dynamic_cast<const MEDFileGTKeeperSta *>(other));
  79   if(!otherC)
  80     return false;
  81   return _geo_type==otherC->_geo_type;
  82 }
  83
  84 MEDFileGTKeeperDyn::MEDFileGTKeeperDyn(const MEDFileUMesh *mesh, const MEDFileUMesh *section, const MEDFileStructureElement *se):_mesh(mesh),_section(section),_se(se)
  85 {
  86   if(mesh)
  87     mesh->incrRef();
  88   if(section)
  89     section->incrRef();
  90   if(se)
  91     se->incrRef();
  92   if(_mesh.isNull() || _section.isNull() || _se.isNull())
  93     throw INTERP_KERNEL::Exception("MEDFileGTKeeperDyn constructor : null pointer not allowed !");
  94 }
  95
  96 MEDFileGTKeeper *MEDFileGTKeeperDyn::deepCopy() const
  97 {
  98   return new MEDFileGTKeeperDyn(_mesh,_section,_se);
  99 }
 100
 101 INTERP_KERNEL::NormalizedCellType MEDFileGTKeeperDyn::getGeoType() const
 102 {
 103   throw INTERP_KERNEL::Exception("MEDFileGTKeeperDyn::getGeoType : not valid !");
 104 }
 105
 106 std::string MEDFileGTKeeperDyn::getRepr() const
 107 {
 108   std::ostringstream oss;
 109   oss << _se->getDynGT();
 110   return oss.str();
 111 }
 112
 113 bool MEDFileGTKeeperDyn::isEqual(const MEDFileGTKeeper *other) const
 114 {
 115   const MEDFileGTKeeperDyn *otherC(dynamic_cast<const MEDFileGTKeeperDyn *>(other));
 116   if(!otherC)
 117     return false;
 118   return this==otherC;
 119 }
 120
 121 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, const std::string& locName)
 122 {
 123   return new MEDFileFieldLoc(fid,locName);
 124 }
 125
 126 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, int id, const MEDFileEntities *entities)
 127 {
 128   return new MEDFileFieldLoc(fid,id,entities);
 129 }
 130
 131 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)
 132 {
 133   return new MEDFileFieldLoc(locName,geoType,refCoo,gsCoo,w);
 134 }
 135
 136 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, const std::string& locName):_name(locName)
 137 {
 138   med_geometry_type geotype;
 139   med_geometry_type sectiongeotype;
 140   int nsectionmeshcell;
 141   INTERP_KERNEL::AutoPtr<char> geointerpname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 142   INTERP_KERNEL::AutoPtr<char> sectionmeshname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 143   MEDlocalizationInfoByName(fid,locName.c_str(),&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
 144   _gt=new MEDFileGTKeeperSta((INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype))));
 145   const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(getGeoType()));
 146   _nb_node_per_cell=cm.getNumberOfNodes();
 147   _ref_coo.resize(_dim*_nb_node_per_cell);
 148   _gs_coo.resize(_dim*_nb_gauss_pt);
 149   _w.resize(_nb_gauss_pt);
 150   MEDlocalizationRd(fid,locName.c_str(),MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
 151 }
 152
 153 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, int id, const MEDFileEntities *entities)
 154 {
 155   med_geometry_type geotype;
 156   med_geometry_type sectiongeotype;
 157   int nsectionmeshcell;
 158   INTERP_KERNEL::AutoPtr<char> locName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 159   INTERP_KERNEL::AutoPtr<char> geointerpname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 160   INTERP_KERNEL::AutoPtr<char> sectionmeshname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 161   MEDlocalizationInfo(fid,id+1,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,&sectiongeotype);
 162   _name=locName;
 163   std::string sectionName(MEDLoaderBase::buildStringFromFortran(sectionmeshname,MED_NAME_SIZE));
 164   if(sectionName.empty())
 165     {
 166       _gt=new MEDFileGTKeeperSta((INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype))));
 167       const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(getGeoType()));
 168       _nb_node_per_cell=cm.getNumberOfNodes();
 169     }
 170   else
 171     {
 172       const MEDFileAllStaticEntitiesPlusDyn *entities2(dynamic_cast<const MEDFileAllStaticEntitiesPlusDyn *>(entities));
 173       if(!entities2)
 174         {
 175           std::ostringstream oss; oss << "MEDFileFieldLoc cstr : for loc \"" << _name << "\" presence of non static type ! Expect entities !";
 176           throw INTERP_KERNEL::Exception(oss.str());
 177         }
 178       const MEDFileStructureElement *se(entities2->getWithGT(geotype));
 179       const MEDFileUMesh *um(entities2->getSupMeshWithName(se->getMeshName()));
 180       const MEDFileUMesh *section(entities2->getSupMeshWithName(sectionName));
 181       _gt=new MEDFileGTKeeperDyn(um,section,se);
 182       {
 183         int dummy;
 184         MEDFILESAFECALLERWR0(MEDmeshGeotypeParameter,(fid,geotype,&dummy,&_nb_node_per_cell));
 185       }
 186     }
 187   _ref_coo.resize(_dim*_nb_node_per_cell);
 188   _gs_coo.resize(_dim*_nb_gauss_pt);
 189   _w.resize(_nb_gauss_pt);
 190   MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
 191 }
 192
 193 MEDFileFieldLoc::MEDFileFieldLoc(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType,
 194                                  const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w):_name(locName),_gt(new MEDFileGTKeeperSta(geoType)),_ref_coo(refCoo),_gs_coo(gsCoo),_w(w)
 195 {
 196   const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(getGeoType()));
 197   _dim=cm.getDimension();
 198   _nb_node_per_cell=cm.getNumberOfNodes();
 199   _nb_gauss_pt=_w.size();
 200 }
 201
 202
 203 MEDFileFieldLoc::MEDFileFieldLoc(const MEDFileFieldLoc& other):_dim(other._dim),_nb_gauss_pt(other._nb_gauss_pt),_gt(other._gt->deepCopy()),_nb_node_per_cell(other._nb_node_per_cell),_name(other._name),_ref_coo(other._ref_coo),_gs_coo(other._gs_coo),_w(other._w)
 204 {
 205 }
 206
 207 MEDFileFieldLoc *MEDFileFieldLoc::deepCopy() const
 208 {
 209   return new MEDFileFieldLoc(*this);
 210 }
 211
 212 bool MEDFileFieldLoc::isOnStructureElement() const
 213 {
 214   const MEDFileGTKeeper *gt(_gt);
 215   if(!gt)
 216     throw INTERP_KERNEL::Exception("MEDFileFieldLoc::isOnStructureElement : null pointer !");
 217   const MEDFileGTKeeperDyn *gt2(dynamic_cast<const MEDFileGTKeeperDyn *>(gt));
 218   return gt2!=NULL;
 219 }
 220
 221 std::size_t MEDFileFieldLoc::getHeapMemorySizeWithoutChildren() const
 222 {
 223   return (_ref_coo.capacity()+_gs_coo.capacity()+_w.capacity())*sizeof(double)+_name.capacity();
 224 }
 225
 226 std::vector<const BigMemoryObject *> MEDFileFieldLoc::getDirectChildrenWithNull() const
 227 {
 228   return std::vector<const BigMemoryObject *>();
 229 }
 230
 231 void MEDFileFieldLoc::simpleRepr(std::ostream& oss) const
 232 {
 233   static const char OFF7[]="\n    ";
 234   oss << "\"" << _name << "\"" << OFF7;
 235   oss << "GeoType=" << _gt->getRepr() << OFF7;
 236   oss << "Dimension=" << _dim << OFF7;
 237   oss << "Number of Gauss points=" << _nb_gauss_pt << OFF7;
 238   oss << "Number of nodes per cell=" << _nb_node_per_cell << OFF7;
 239   oss << "RefCoords="; std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 240   oss << "Weights="; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
 241   oss << "GaussPtsCoords="; std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," ")); oss << std::endl;
 242 }
 243
 244 void MEDFileFieldLoc::setName(const std::string& name)
 245 {
 246   _name=name;
 247 }
 248
 249 bool MEDFileFieldLoc::isEqual(const MEDFileFieldLoc& other, double eps) const
 250 {
 251   if(_name!=other._name)
 252     return false;
 253   if(_dim!=other._dim)
 254     return false;
 255   if(_nb_gauss_pt!=other._nb_gauss_pt)
 256     return false;
 257   if(_nb_node_per_cell!=other._nb_node_per_cell)
 258     return false;
 259   if(!_gt->isEqual(other._gt))
 260     return false;
 261   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_ref_coo,other._ref_coo,eps))
 262     return false;
 263   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_gs_coo,other._gs_coo,eps))
 264     return false;
 265   if(!MEDCouplingGaussLocalization::AreAlmostEqual(_w,other._w,eps))
 266     return false;
 267
 268   return true;
 269 }
 270
 271 void MEDFileFieldLoc::writeLL(med_idt fid) const
 272 {
 273   MEDlocalizationWr(fid,_name.c_str(),typmai3[(int)getGeoType()],_dim,&_ref_coo[0],MED_FULL_INTERLACE,_nb_gauss_pt,&_gs_coo[0],&_w[0],MED_NO_INTERPOLATION,MED_NO_MESH_SUPPORT);
 274 }
 275
 276 std::string MEDFileFieldLoc::repr() const
 277 {
 278   std::ostringstream oss; oss.precision(15);
 279   const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(getGeoType()));
 280   oss << "Localization \"" << _name << "\" :\n" << "  - Geometric Type : " << cm.getRepr();
 281   oss << "\n  - Dimension : " << _dim << "\n  - Number of gauss points : ";
 282   oss << _nb_gauss_pt << "\n  - Number of nodes in cell : " << _nb_node_per_cell;
 283   oss << "\n  - Ref coords are : ";
 284   int sz=_ref_coo.size();
 285   if(sz%_dim==0)
 286     {
 287       int nbOfTuples=sz/_dim;
 288       for(int i=0;i<nbOfTuples;i++)
 289         {
 290           oss << "(";
 291           for(int j=0;j<_dim;j++)
 292             { oss << _ref_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 293           oss << ") ";
 294         }
 295     }
 296   else
 297     std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," "));
 298   oss << "\n  - Gauss coords in reference element : ";
 299   sz=_gs_coo.size();
 300   if(sz%_dim==0)
 301     {
 302       int nbOfTuples=sz/_dim;
 303       for(int i=0;i<nbOfTuples;i++)
 304         {
 305           oss << "(";
 306           for(int j=0;j<_dim;j++)
 307             { oss << _gs_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
 308           oss << ") ";
 309         }
 310     }
 311   else
 312     std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," "));
 313   oss << "\n  - Weights of Gauss coords are : "; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," "));
 314   return oss.str();
 315 }
 316
 317 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
 318 {
 319   _type=field->getTypeOfField();
 320   _start=start;
 321   switch(_type)
 322   {
 323     case ON_CELLS:
 324       {
 325         getOrCreateAndGetArray()->setContigPartOfSelectedValuesSlice(_start,arrr,offset,offset+nbOfCells,1);
 326         _end=_start+nbOfCells;
 327         _nval=nbOfCells;
 328         break;
 329       }
 330     case ON_GAUSS_NE:
 331       {
 332         MCAuto<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(field->getMesh());
 333         const int *arrPtr=arr->getConstPointer();
 334         getOrCreateAndGetArray()->setContigPartOfSelectedValuesSlice(_start,arrr,arrPtr[offset],arrPtr[offset+nbOfCells],1);
 335         _end=_start+(arrPtr[offset+nbOfCells]-arrPtr[offset]);
 336         _nval=nbOfCells;
 337         break;
 338       }
 339     case ON_GAUSS_PT:
 340       {
 341         const MEDCouplingFieldDiscretization *disc(field->getDiscretization());
 342         const MEDCouplingGaussLocalization& gsLoc(field->getGaussLocalization(_loc_id));
 343         const MEDCouplingFieldDiscretizationGauss *disc2(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc));
 344         if(!disc2)
 345           throw INTERP_KERNEL::Exception("assignFieldNoProfile : invalid call to this method ! Internal Error !");
 346         const DataArrayInt *dai(disc2->getArrayOfDiscIds());
 347         MCAuto<DataArrayInt> dai2(disc2->getOffsetArr(field->getMesh()));
 348         const int *dai2Ptr(dai2->getConstPointer());
 349         int nbi(gsLoc.getWeights().size());
 350         MCAuto<DataArrayInt> da2(dai->selectByTupleIdSafeSlice(offset,offset+nbOfCells,1));
 351         MCAuto<DataArrayInt> da3(da2->findIdsEqual(_loc_id));
 352         const int *da3Ptr(da3->getConstPointer());
 353         if(da3->getNumberOfTuples()!=nbOfCells)
 354           {//profile : for gauss even in NoProfile !!!
 355             std::ostringstream oss; oss << "Pfl_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 356             _profile=oss.str();
 357             da3->setName(_profile.c_str());
 358             glob.appendProfile(da3);
 359           }
 360         MCAuto<DataArrayInt> da4(DataArrayInt::New());
 361         _nval=da3->getNbOfElems();
 362         da4->alloc(_nval*nbi,1);
 363         int *da4Ptr(da4->getPointer());
 364         for(int i=0;i<_nval;i++)
 365           {
 366             int ref=dai2Ptr[offset+da3Ptr[i]];
 367             for(int j=0;j<nbi;j++)
 368               *da4Ptr++=ref+j;
 369           }
 370         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 371         _localization=oss2.str();
 372         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,da4);
 373         _end=_start+_nval*nbi;
 374         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 375         break;
 376       }
 377     default:
 378       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile : not implemented yet for such discretization type of field !");
 379   }
 380   start=_end;
 381 }
 382
 383 /*!
 384  * Leaf method of field with profile assignement. This method is the most general one. No optimization is done here.
 385  * \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).
 386  * \param [in] multiTypePfl is the end user profile specified in high level API
 387  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
 388  * \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.
 389  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
 390  * \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.
 391  */
 392 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile(bool isPflAlone, 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)
 393 {
 394   _profile.clear();
 395   _type=field->getTypeOfField();
 396   std::string pflName(multiTypePfl->getName());
 397   std::ostringstream oss; oss << pflName;
 398   if(_type!=ON_NODES)
 399     {
 400       if(!isPflAlone)
 401         { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType()); oss << "_" <<  cm.getRepr(); }
 402     }
 403   else
 404     { oss << "_NODE"; }
 405   if(locIds)
 406     {
 407       if(pflName.empty())
 408         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : existing profile with empty name !");
 409       if(_type!=ON_GAUSS_PT)
 410         {
 411           locIds->setName(oss.str());
 412           glob.appendProfile(locIds);
 413           _profile=oss.str();
 414         }
 415     }
 416   _start=start;
 417   switch(_type)
 418   {
 419     case ON_NODES:
 420       {
 421         _nval=idsInPfl->getNumberOfTuples();
 422         getOrCreateAndGetArray()->setContigPartOfSelectedValuesSlice(_start,arrr,0,arrr->getNumberOfTuples(),1);
 423         _end=_start+_nval;
 424         break;
 425       }
 426     case ON_CELLS:
 427       {
 428         _nval=idsInPfl->getNumberOfTuples();
 429         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,idsInPfl);
 430         _end=_start+_nval;
 431         break;
 432       }
 433     case ON_GAUSS_NE:
 434       {
 435         MCAuto<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(mesh);
 436         MCAuto<DataArrayInt> arr2=arr->deltaShiftIndex();
 437         MCAuto<DataArrayInt> arr3=arr2->selectByTupleId(multiTypePfl->begin(),multiTypePfl->end());
 438         arr3->computeOffsetsFull();
 439         MCAuto<DataArrayInt> tmp=idsInPfl->buildExplicitArrByRanges(arr3);
 440         int trueNval=tmp->getNumberOfTuples();
 441         _nval=idsInPfl->getNumberOfTuples();
 442         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 443         _end=_start+trueNval;
 444         break;
 445       }
 446     case ON_GAUSS_PT:
 447       {
 448         const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
 449         if(!disc2)
 450           throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
 451         const DataArrayInt *da1=disc2->getArrayOfDiscIds();
 452         const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
 453         MCAuto<DataArrayInt> da2=da1->selectByTupleId(idsInPfl->begin(),idsInPfl->end());
 454         MCAuto<DataArrayInt> da3=da2->findIdsEqual(_loc_id);
 455         MCAuto<DataArrayInt> da4=idsInPfl->selectByTupleId(da3->begin(),da3->end());
 456         //
 457         MCAuto<MEDCouplingMesh> mesh2=mesh->buildPart(multiTypePfl->begin(),multiTypePfl->end());
 458         MCAuto<DataArrayInt> arr=disc2->getOffsetArr(mesh2);
 459         //
 460         MCAuto<DataArrayInt> tmp=DataArrayInt::New();
 461         int trueNval=0;
 462         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 463           trueNval+=arr->getIJ(*pt+1,0)-arr->getIJ(*pt,0);
 464         tmp->alloc(trueNval,1);
 465         int *tmpPtr=tmp->getPointer();
 466         for(const int *pt=da4->begin();pt!=da4->end();pt++)
 467           for(int j=arr->getIJ(*pt,0);j<arr->getIJ(*pt+1,0);j++)
 468             *tmpPtr++=j;
 469         //
 470         _nval=da4->getNumberOfTuples();
 471         getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
 472         _end=_start+trueNval;
 473         oss << "_loc_" << _loc_id;
 474         if(locIds)
 475           {
 476             MCAuto<DataArrayInt> da5=locIds->selectByTupleId(da3->begin(),da3->end());
 477             da5->setName(oss.str());
 478             glob.appendProfile(da5);
 479             _profile=oss.str();
 480           }
 481         else
 482           {
 483             if(!da3->isIota(nbOfEltsInWholeMesh))
 484               {
 485                 da3->setName(oss.str());
 486                 glob.appendProfile(da3);
 487                 _profile=oss.str();
 488               }
 489           }
 490         std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
 491         _localization=oss2.str();
 492         glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
 493         break;
 494       }
 495     default:
 496       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : not implemented yet for such discretization type of field !");
 497   }
 498   start=_end;
 499 }
 500
 501 void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob)
 502 {
 503   _start=start;
 504   _nval=arrr->getNumberOfTuples();
 505   getOrCreateAndGetArray()->setContigPartOfSelectedValuesSlice(_start,arrr,0,_nval,1);
 506   _end=_start+_nval;
 507   start=_end;
 508 }
 509
 510 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(MEDFileFieldPerMeshPerTypeCommon *fath, TypeOfField type, int profileIt, const PartDefinition *pd)
 511 {
 512   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,profileIt,pd);
 513 }
 514
 515 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(MEDFileFieldPerMeshPerTypeCommon *fath, TypeOfField type, int locId)
 516 {
 517   return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,locId,std::string());
 518 }
 519
 520 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(const MEDFileFieldPerMeshPerTypePerDisc& other)
 521 {
 522   return new MEDFileFieldPerMeshPerTypePerDisc(other);
 523 }
 524
 525 std::size_t MEDFileFieldPerMeshPerTypePerDisc::getHeapMemorySizeWithoutChildren() const
 526 {
 527   return _profile.capacity()+_localization.capacity()+sizeof(MEDFileFieldPerMeshPerTypePerDisc);
 528 }
 529
 530 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerTypePerDisc::getDirectChildrenWithNull() const
 531 {
 532   std::vector<const BigMemoryObject *> ret(1);
 533   ret[0]=(const PartDefinition*)_pd;
 534   return ret;
 535 }
 536
 537 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::deepCopy(MEDFileFieldPerMeshPerTypeCommon *father) const
 538 {
 539   MCAuto<MEDFileFieldPerMeshPerTypePerDisc> ret(new MEDFileFieldPerMeshPerTypePerDisc(*this));
 540   ret->_father=father;
 541   return ret.retn();
 542 }
 543
 544 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerTypeCommon *fath, TypeOfField atype, int profileIt, const PartDefinition *pd)
 545 try:_type(atype),_father(fath),_profile_it(profileIt),_pd(const_cast<PartDefinition *>(pd))
 546 {
 547   if(pd)
 548     pd->incrRef();
 549 }
 550 catch(INTERP_KERNEL::Exception& e)
 551 {
 552     throw e;
 553 }
 554
 555 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerTypeCommon *fath, TypeOfField type, int locId, const std::string& dummy):_type(type),_father(fath),_loc_id(locId)
 556 {
 557 }
 558
 559 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),_profile_it(other._profile_it),_pd(other._pd),_tmp_work1(other._tmp_work1)
 560 {
 561 }
 562
 563 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(0),_start(-std::numeric_limits<int>::max()),_end(-std::numeric_limits<int>::max()),
 564     _nval(-std::numeric_limits<int>::max()),_loc_id(-std::numeric_limits<int>::max())
 565 {
 566 }
 567
 568 void MEDFileFieldPerMeshPerTypePerDisc::goReadZeValuesInFile(med_idt fid, const std::string& fieldName, int nbOfCompo, int iteration, int order, med_entity_type menti, med_geometry_type mgeoti, unsigned char *startFeedingPtr)
 569 {
 570   const PartDefinition *pd(_pd);
 571   if(!pd)
 572     {
 573       INTERP_KERNEL::AutoPtr<char> locname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 574       int nbi,tmp1;
 575       med_int nbValsInFile(MEDfieldnValueWithProfileByName(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile.c_str(),MED_COMPACT_PFLMODE,&tmp1,locname,&nbi));
 576       if(_end-_start!=nbValsInFile*nbi)
 577         {
 578           std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::goReadZeValuesInFile : The number of tuples to read is " << nbValsInFile << "*" << nbi <<  " (nb integration points) ! But in data structure it values " << _end-_start << " is expected !";
 579           throw INTERP_KERNEL::Exception(oss.str());
 580         }
 581       MEDFILESAFECALLERRD0(MEDfieldValueWithProfileRd,(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,_profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,startFeedingPtr));
 582     }
 583   else
 584     {
 585       if(!_profile.empty())
 586         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::goReadZeValuesInFile : not implemented !");
 587       INTERP_KERNEL::AutoPtr<char> pflname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)),locname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 588       int profilesize,nbi;
 589       int overallNval(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile_it+1,MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
 590       const SlicePartDefinition *spd(dynamic_cast<const SlicePartDefinition *>(pd));
 591       if(spd)
 592         {
 593           int start,stop,step;
 594           spd->getSlice(start,stop,step);
 595           int nbOfEltsToLoad(DataArray::GetNumberOfItemGivenBES(start,stop,step,"MEDFileFieldPerMeshPerTypePerDisc::goReadZeValuesInFile"));
 596           med_filter filter=MED_FILTER_INIT;
 597           MEDfilterBlockOfEntityCr(fid,/*nentity*/overallNval,/*nvaluesperentity*/nbi,/*nconstituentpervalue*/nbOfCompo,
 598                                    MED_ALL_CONSTITUENT,MED_FULL_INTERLACE,MED_COMPACT_STMODE,MED_NO_PROFILE,
 599                                    /*start*/start+1,/*stride*/step,/*count*/1,/*blocksize*/nbOfEltsToLoad,
 600                                    /*lastblocksize=useless because count=1*/0,&filter);
 601           MEDFILESAFECALLERRD0(MEDfieldValueAdvancedRd,(fid,fieldName.c_str(),iteration,order,menti,mgeoti,&filter,startFeedingPtr));
 602           MEDfilterClose(&filter);
 603           return ;
 604         }
 605       const DataArrayPartDefinition *dpd(dynamic_cast<const DataArrayPartDefinition *>(pd));
 606       if(dpd)
 607         {
 608           dpd->checkConsistencyLight();
 609           MCAuto<DataArrayInt> myIds(dpd->toDAI());
 610           int a(myIds->getMinValueInArray()),b(myIds->getMaxValueInArray());
 611           myIds=myIds->deepCopy();// WARNING deep copy here because _pd is modified by applyLin !!!
 612           myIds->applyLin(1,-a);
 613           int nbOfEltsToLoad(b-a+1);
 614           med_filter filter=MED_FILTER_INIT;
 615           {//TODO : manage int32 !
 616             MCAuto<DataArrayDouble> tmp(DataArrayDouble::New());
 617             tmp->alloc(nbOfEltsToLoad,nbOfCompo);
 618             MEDfilterBlockOfEntityCr(fid,/*nentity*/overallNval,/*nvaluesperentity*/nbi,/*nconstituentpervalue*/nbOfCompo,
 619                                      MED_ALL_CONSTITUENT,MED_FULL_INTERLACE,MED_COMPACT_STMODE,MED_NO_PROFILE,
 620                                      /*start*/a+1,/*stride*/1,/*count*/1,/*blocksize*/nbOfEltsToLoad,
 621                                      /*lastblocksize=useless because count=1*/0,&filter);
 622             MEDFILESAFECALLERRD0(MEDfieldValueAdvancedRd,(fid,fieldName.c_str(),iteration,order,menti,mgeoti,&filter,reinterpret_cast<unsigned char *>(tmp->getPointer())));
 623             MCAuto<DataArrayDouble> feeder(DataArrayDouble::New());
 624             feeder->useExternalArrayWithRWAccess(reinterpret_cast<double *>(startFeedingPtr),_nval,nbOfCompo);
 625             feeder->setContigPartOfSelectedValues(0,tmp,myIds);
 626           }
 627           MEDfilterClose(&filter);
 628         }
 629       else
 630         throw INTERP_KERNEL::Exception("Not implemented yet for not slices!");
 631     }
 632 }
 633
 634 const MEDFileFieldPerMeshPerTypeCommon *MEDFileFieldPerMeshPerTypePerDisc::getFather() const
 635 {
 636   return _father;
 637 }
 638
 639 void MEDFileFieldPerMeshPerTypePerDisc::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
 640 {
 641   INTERP_KERNEL::AutoPtr<char> locname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 642   INTERP_KERNEL::AutoPtr<char> pflname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
 643   std::string fieldName(nasc.getName()),meshName(getMeshName());
 644   int iteration(getIteration()),order(getOrder()),profilesize,nbi;
 645   TypeOfField type(getType());
 646   med_geometry_type mgeoti;
 647   med_entity_type menti;
 648   _father->entriesForMEDfile(type,mgeoti,menti);
 649   int zeNVal(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile_it+1,MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
 650   _profile=MEDLoaderBase::buildStringFromFortran(pflname,MED_NAME_SIZE);
 651   _localization=MEDLoaderBase::buildStringFromFortran(locname,MED_NAME_SIZE);
 652   const PartDefinition *pd(_pd);
 653   if(!pd)
 654     {
 655       _nval=zeNVal;
 656     }
 657   else
 658     {
 659       if(!_profile.empty())
 660         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::loadOnlyStructureOfDataRecursively : profiles are not managed yet with part of def !");
 661       _nval=pd->getNumberOfElems();
 662     }
 663   _start=start;
 664   _end=start+_nval*nbi;
 665   start=_end;
 666   if(type==ON_CELLS && !_localization.empty())
 667     {
 668       if(_localization!="MED_GAUSS_ELNO")//For compatibily with MED2.3
 669         setType(ON_GAUSS_PT);
 670       else
 671         {
 672           setType(ON_GAUSS_NE);
 673           _localization.clear();
 674         }
 675     }
 676 }
 677
 678 void MEDFileFieldPerMeshPerTypePerDisc::loadBigArray(med_idt fid, const MEDFileFieldNameScope& nasc)
 679 {
 680   std::string fieldName(nasc.getName()),meshName(getMeshName());
 681   int iteration(getIteration()),order(getOrder());
 682   TypeOfField type(getType());
 683   med_geometry_type mgeoti;
 684   med_entity_type menti;
 685   _father->entriesForMEDfile(type,mgeoti,menti);
 686   if(_start>_end)
 687     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : internal error in range !");
 688   if(_start==_end)
 689     return ;
 690   DataArray *arr(getOrCreateAndGetArray());//arr is not null due to the spec of getOrCreateAndGetArray
 691   if(_start<0 || _start>=arr->getNumberOfTuples())
 692     {
 693       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << ") !";
 694       throw INTERP_KERNEL::Exception(oss.str());
 695     }
 696   if(_end<0 || _end>arr->getNumberOfTuples())
 697     {
 698       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << "] !";
 699       throw INTERP_KERNEL::Exception(oss.str());
 700     }
 701   int nbOfCompo(arr->getNumberOfComponents());
 702   DataArrayDouble *arrD(dynamic_cast<DataArrayDouble *>(arr));
 703   if(arrD)
 704     {
 705       double *startFeeding(arrD->getPointer()+_start*nbOfCompo);
 706       goReadZeValuesInFile(fid,fieldName,nbOfCompo,iteration,order,menti,mgeoti,reinterpret_cast<unsigned char*>(startFeeding));
 707       return ;
 708     }
 709   DataArrayInt *arrI(dynamic_cast<DataArrayInt *>(arr));
 710   if(arrI)
 711     {
 712       int *startFeeding(arrI->getPointer()+_start*nbOfCompo);
 713       goReadZeValuesInFile(fid,fieldName,nbOfCompo,iteration,order,menti,mgeoti,reinterpret_cast<unsigned char*>(startFeeding));
 714       return ;
 715     }
 716   throw INTERP_KERNEL::Exception("Error on array reading ! Unrecognized type of field ! Should be in FLOAT64 or INT32 !");
 717 }
 718
 719 /*!
 720  * Set a \c this->_start **and** \c this->_end keeping the same delta between the two.
 721  */
 722 void MEDFileFieldPerMeshPerTypePerDisc::setNewStart(int newValueOfStart)
 723 {
 724   int delta=_end-_start;
 725   _start=newValueOfStart;
 726   _end=_start+delta;
 727 }
 728
 729 int MEDFileFieldPerMeshPerTypePerDisc::getIteration() const
 730 {
 731   return _father->getIteration();
 732 }
 733
 734 int MEDFileFieldPerMeshPerTypePerDisc::getOrder() const
 735 {
 736   return _father->getOrder();
 737 }
 738
 739 double MEDFileFieldPerMeshPerTypePerDisc::getTime() const
 740 {
 741   return _father->getTime();
 742 }
 743
 744 std::string MEDFileFieldPerMeshPerTypePerDisc::getMeshName() const
 745 {
 746   return _father->getMeshName();
 747 }
 748
 749 void MEDFileFieldPerMeshPerTypePerDisc::simpleRepr(int bkOffset, std::ostream& oss, int id) const
 750 {
 751   const char startLine[]="    ## ";
 752   std::string startLine2(bkOffset,' ');
 753   startLine2+=startLine;
 754   INTERP_KERNEL::AutoCppPtr<MEDCouplingFieldDiscretization> tmp(MEDCouplingFieldDiscretization::New(_type));
 755   oss << startLine2 << "Localization #" << id << "." << std::endl;
 756   oss << startLine2 << "  Type=" << tmp->getRepr() << "." << std::endl;
 757   oss << startLine2 << "  This type discretization lies on profile : \"" << _profile << "\" and on the following localization : \"" << _localization << "\"." << std::endl;
 758   oss << startLine2 << "  This type discretization has " << _end-_start << " tuples (start=" << _start << ", end=" << _end << ")." << std::endl;
 759   oss << startLine2 << "  This type discretization has " << (_end-_start)/_nval << " integration points." << std::endl;
 760 }
 761
 762 TypeOfField MEDFileFieldPerMeshPerTypePerDisc::getType() const
 763 {
 764   return _type;
 765 }
 766
 767 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerTypePerDisc::getGeoType() const
 768 {
 769   return _father->getGeoType();
 770 }
 771
 772 void MEDFileFieldPerMeshPerTypePerDisc::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
 773 {
 774   types.insert(_type);
 775 }
 776
 777 void MEDFileFieldPerMeshPerTypePerDisc::setType(TypeOfField newType)
 778 {
 779   _type=newType;
 780 }
 781
 782 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfComponents() const
 783 {
 784   return _father->getNumberOfComponents();
 785 }
 786
 787 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfTuples() const
 788 {
 789   return _end-_start;
 790 }
 791
 792 DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray()
 793 {
 794   return _father->getOrCreateAndGetArray();
 795 }
 796
 797 const DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray() const
 798 {
 799   const MEDFileFieldPerMeshPerTypeCommon *fath=_father;
 800   return fath->getOrCreateAndGetArray();
 801 }
 802
 803 const std::vector<std::string>& MEDFileFieldPerMeshPerTypePerDisc::getInfo() const
 804 {
 805   return _father->getInfo();
 806 }
 807
 808 std::string MEDFileFieldPerMeshPerTypePerDisc::getProfile() const
 809 {
 810   return _profile;
 811 }
 812
 813 void MEDFileFieldPerMeshPerTypePerDisc::setProfile(const std::string& newPflName)
 814 {
 815   _profile=newPflName;
 816 }
 817
 818 std::string MEDFileFieldPerMeshPerTypePerDisc::getLocalization() const
 819 {
 820   return _localization;
 821 }
 822
 823 void MEDFileFieldPerMeshPerTypePerDisc::setLocalization(const std::string& newLocName)
 824 {
 825   _localization=newLocName;
 826 }
 827
 828 void MEDFileFieldPerMeshPerTypePerDisc::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
 829 {
 830   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 831     {
 832       if(std::find((*it2).first.begin(),(*it2).first.end(),_profile)!=(*it2).first.end())
 833         {
 834           _profile=(*it2).second;
 835           return;
 836         }
 837     }
 838 }
 839
 840 void MEDFileFieldPerMeshPerTypePerDisc::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
 841 {
 842   for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
 843     {
 844       if(std::find((*it2).first.begin(),(*it2).first.end(),_localization)!=(*it2).first.end())
 845         {
 846           _localization=(*it2).second;
 847           return;
 848         }
 849     }
 850 }
 851
 852 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
 853 {
 854   if(type!=_type)
 855     return ;
 856   dads.push_back(std::pair<int,int>(_start,_end));
 857   geoTypes.push_back(getGeoType());
 858   if(_profile.empty())
 859     pfls.push_back(0);
 860   else
 861     {
 862       pfls.push_back(glob->getProfile(_profile.c_str()));
 863     }
 864   if(_localization.empty())
 865     locs.push_back(-1);
 866   else
 867     {
 868       locs.push_back(glob->getLocalizationId(_localization.c_str()));
 869     }
 870 }
 871
 872 void MEDFileFieldPerMeshPerTypePerDisc::fillValues(int discId, int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
 873 {
 874   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));
 875   startEntryId++;
 876 }
 877
 878 void MEDFileFieldPerMeshPerTypePerDisc::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
 879 {
 880   TypeOfField type=getType();
 881   INTERP_KERNEL::NormalizedCellType geoType(getGeoType());
 882   med_geometry_type mgeoti;
 883   med_entity_type menti;
 884   _father->entriesForMEDfile(getType(),mgeoti,menti);
 885   const DataArray *arr(getOrCreateAndGetArray());
 886   if(!arr)
 887     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : no array set !");
 888   if(!arr->isAllocated())
 889     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : the array to be written is not allocated !");
 890   const DataArrayDouble *arrD=dynamic_cast<const DataArrayDouble *>(arr);
 891   const DataArrayInt *arrI=dynamic_cast<const DataArrayInt *>(arr);
 892   const unsigned char *locToWrite=0;
 893   if(arrD)
 894     locToWrite=reinterpret_cast<const unsigned char *>(arrD->getConstPointer()+_start*arr->getNumberOfComponents());
 895   else if(arrI)
 896     locToWrite=reinterpret_cast<const unsigned char *>(arrI->getConstPointer()+_start*arr->getNumberOfComponents());
 897   else
 898     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : not recognized type of values ! Supported are FLOAT64 and INT32 !");
 899   MEDFILESAFECALLERWR0(MEDfieldValueWithProfileWr,(fid,nasc.getName().c_str(),getIteration(),getOrder(),getTime(),menti,mgeoti,
 900                                                    MED_COMPACT_PFLMODE,_profile.c_str(),_localization.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,_nval,
 901                                                    locToWrite));
 902 }
 903
 904 void MEDFileFieldPerMeshPerTypePerDisc::getCoarseData(TypeOfField& type, std::pair<int,int>& dad, std::string& pfl, std::string& loc) const
 905 {
 906   type=_type;
 907   pfl=_profile;
 908   loc=_localization;
 909   dad.first=_start; dad.second=_end;
 910 }
 911
 912 /*!
 913  * \param [in] codeOfMesh is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
 914  *             This code corresponds to the distribution of types in the corresponding mesh.
 915  * \param [out] ptToFill memory zone where the output will be stored.
 916  * \return the size of data pushed into output param \a ptToFill
 917  */
 918 int MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode(int offset, const std::vector<int>& codeOfMesh, const MEDFileFieldGlobsReal& glob, int *ptToFill) const
 919 {
 920   _loc_id=offset;
 921   std::ostringstream oss;
 922   std::size_t nbOfType=codeOfMesh.size()/3;
 923   int found=-1;
 924   for(std::size_t i=0;i<nbOfType && found==-1;i++)
 925     if(getGeoType()==(INTERP_KERNEL::NormalizedCellType)codeOfMesh[3*i])
 926       found=(int)i;
 927   if(found==-1)
 928     {
 929       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 930       oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : not found geometric type " << cm.getRepr() << " in the referenced mesh of field !";
 931       throw INTERP_KERNEL::Exception(oss.str());
 932     }
 933   int *work=ptToFill;
 934   if(_profile.empty())
 935     {
 936       if(_nval!=codeOfMesh[3*found+1])
 937         {
 938           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 939           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << " number of elt ids in mesh is equal to " << _nval;
 940           oss << " whereas mesh has " << codeOfMesh[3*found+1] << " for this geometric type !";
 941           throw INTERP_KERNEL::Exception(oss.str());
 942         }
 943       for(int ii=codeOfMesh[3*found+2];ii<codeOfMesh[3*found+2]+_nval;ii++)
 944         *work++=ii;
 945     }
 946   else
 947     {
 948       const DataArrayInt *pfl=glob.getProfile(_profile.c_str());
 949       if(pfl->getNumberOfTuples()!=_nval)
 950         {
 951           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
 952           oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << ", field is defined on profile \"" << _profile << "\" and size of profile is ";
 953           oss << _nval;
 954           oss << pfl->getNumberOfTuples() << " whereas the number of ids is set to " << _nval << " for this geometric type !";
 955           throw INTERP_KERNEL::Exception(oss.str());
 956         }
 957       int offset2=codeOfMesh[3*found+2];
 958       for(const int *pflId=pfl->begin();pflId!=pfl->end();pflId++)
 959         {
 960           if(*pflId<codeOfMesh[3*found+1])
 961             *work++=offset2+*pflId;
 962         }
 963     }
 964   return _nval;
 965 }
 966
 967 int MEDFileFieldPerMeshPerTypePerDisc::fillTupleIds(int *ptToFill) const
 968 {
 969   for(int i=_start;i<_end;i++)
 970     *ptToFill++=i;
 971   return _end-_start;
 972 }
 973
 974 int MEDFileFieldPerMeshPerTypePerDisc::ConvertType(TypeOfField type, int locId)
 975 {
 976   switch(type)
 977   {
 978     case ON_CELLS:
 979       return -2;
 980     case ON_GAUSS_NE:
 981       return -1;
 982     case ON_GAUSS_PT:
 983       return locId;
 984     default:
 985       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::ConvertType : not managed type of field !");
 986   }
 987 }
 988
 989 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entries)
 990 {
 991   int id=0;
 992   std::map<std::pair<std::string,TypeOfField>,int> m;
 993   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > ret;
 994   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 995     if(m.find(std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType()))==m.end())
 996       m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]=id++;
 997   ret.resize(id);
 998   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
 999     ret[m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]].push_back(*it);
1000   return ret;
1001 }
1002
1003 /*!
1004  * - \c this->_loc_id mutable attribute is used for elt id in mesh offsets.
1005  *
1006  * \param [in] offset the offset id used to take into account that \a result is not compulsary empty in input
1007  * \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.
1008  * \param [in] explicitIdsInMesh ids in mesh of the considered chunk.
1009  * \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)
1010  * \param [in,out] glob if necessary by the method, new profiles can be added to it
1011  * \param [in,out] arr after the call of this method \a arr is renumbered to be compliant with added entries to \a result.
1012  * \param [out] result All new entries will be appended on it.
1013  * \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 !)
1014  */
1015 bool MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(int offset, const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
1016                                                        const DataArrayInt *explicitIdsInMesh,
1017                                                        const std::vector<int>& newCode,
1018                                                        MEDFileFieldGlobsReal& glob, DataArrayDouble *arr,
1019                                                        std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >& result)
1020 {
1021   if(entriesOnSameDisc.empty())
1022     return false;
1023   TypeOfField type=entriesOnSameDisc[0]->getType();
1024   int szEntities=0,szTuples=0;
1025   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++)
1026     { szEntities+=(*it)->_nval; szTuples+=(*it)->_end-(*it)->_start; }
1027   int nbi=szTuples/szEntities;
1028   if(szTuples%szEntities!=0)
1029     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks : internal error the splitting into same dicretization failed !");
1030   MCAuto<DataArrayInt> renumTuples=DataArrayInt::New(); renumTuples->alloc(szTuples,1);
1031   MCAuto<DataArrayInt> ranges=MEDCouplingUMesh::ComputeRangesFromTypeDistribution(newCode);
1032   std::vector< MCAuto<DataArrayInt> > newGeoTypesPerChunk(entriesOnSameDisc.size());
1033   std::vector< const DataArrayInt * > newGeoTypesPerChunk2(entriesOnSameDisc.size());
1034   std::vector< MCAuto<DataArrayInt> > newGeoTypesPerChunk_bis(entriesOnSameDisc.size());
1035   std::vector< const DataArrayInt * > newGeoTypesPerChunk3(entriesOnSameDisc.size());
1036   MCAuto<DataArrayInt> newGeoTypesPerChunk4=DataArrayInt::New(); newGeoTypesPerChunk4->alloc(szEntities,nbi);
1037   int id=0;
1038   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
1039     {
1040       int startOfEltIdOfChunk=(*it)->_start;
1041       MCAuto<DataArrayInt> newEltIds=explicitIdsInMesh->subArray(startOfEltIdOfChunk,startOfEltIdOfChunk+(*it)->_nval);
1042       MCAuto<DataArrayInt> rangeIdsForChunk=newEltIds->findRangeIdForEachTuple(ranges);
1043       MCAuto<DataArrayInt> idsInRrangeForChunk=newEltIds->findIdInRangeForEachTuple(ranges);
1044       //
1045       MCAuto<DataArrayInt> tmp=rangeIdsForChunk->duplicateEachTupleNTimes(nbi); rangeIdsForChunk->rearrange(nbi);
1046       newGeoTypesPerChunk4->setPartOfValues1(tmp,(*it)->_tmp_work1-offset,(*it)->_tmp_work1+(*it)->_nval*nbi-offset,1,0,nbi,1);
1047       //
1048       newGeoTypesPerChunk[id]=rangeIdsForChunk; newGeoTypesPerChunk2[id]=rangeIdsForChunk;
1049       newGeoTypesPerChunk_bis[id]=idsInRrangeForChunk; newGeoTypesPerChunk3[id]=idsInRrangeForChunk;
1050     }
1051   MCAuto<DataArrayInt> newGeoTypesEltIdsAllGather=DataArrayInt::Aggregate(newGeoTypesPerChunk2); newGeoTypesPerChunk.clear(); newGeoTypesPerChunk2.clear();
1052   MCAuto<DataArrayInt> newGeoTypesEltIdsAllGather2=DataArrayInt::Aggregate(newGeoTypesPerChunk3); newGeoTypesPerChunk_bis.clear(); newGeoTypesPerChunk3.clear();
1053   MCAuto<DataArrayInt> diffVals=newGeoTypesEltIdsAllGather->getDifferentValues();
1054   MCAuto<DataArrayInt> renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
1055   //
1056   MCAuto<DataArrayInt> renumTupleIds=newGeoTypesPerChunk4->buildPermArrPerLevel();
1057   //
1058   MCAuto<DataArrayDouble> arrPart=arr->subArray(offset,offset+szTuples);
1059   arrPart->renumberInPlace(renumTupleIds->begin());
1060   arr->setPartOfValues1(arrPart,offset,offset+szTuples,1,0,arrPart->getNumberOfComponents(),1);
1061   bool ret=false;
1062   const int *idIt=diffVals->begin();
1063   std::list<const MEDFileFieldPerMeshPerTypePerDisc *> li(entriesOnSameDisc.begin(),entriesOnSameDisc.end());
1064   int offset2=0;
1065   for(int i=0;i<diffVals->getNumberOfTuples();i++,idIt++)
1066     {
1067       MCAuto<DataArrayInt> ids=newGeoTypesEltIdsAllGather->findIdsEqual(*idIt);
1068       MCAuto<DataArrayInt> subIds=newGeoTypesEltIdsAllGather2->selectByTupleId(ids->begin(),ids->end());
1069       int nbEntityElts=subIds->getNumberOfTuples();
1070       bool ret2;
1071       MCAuto<MEDFileFieldPerMeshPerTypePerDisc> eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
1072           NewObjectOnSameDiscThanPool(type,(INTERP_KERNEL::NormalizedCellType)newCode[3*(*idIt)],subIds,!subIds->isIota(newCode[3*(*idIt)+1]),nbi,
1073                                       offset+offset2,
1074                                       li,glob,ret2);
1075       ret=ret || ret2;
1076       result.push_back(eltToAdd);
1077       offset2+=nbEntityElts*nbi;
1078     }
1079   ret=ret || li.empty();
1080   return ret;
1081 }
1082
1083 /*!
1084  * \param [in] typeF type of field of new chunk
1085  * \param [in] geoType the geometric type of the chunk
1086  * \param [in] idsOfMeshElt the entity ids of mesh (cells or nodes) of the new chunk.
1087  * \param [in] isPfl specifies if a profile is requested regarding size of \a idsOfMeshElt and the number of such entities regarding underlying mesh.
1088  * \param [in] nbi number of integration points
1089  * \param [in] offset The offset in the **global array of data**.
1090  * \param [in,out] entriesOnSameDisc the pool **on the same discretization** inside which it will be attempted to find an existing entry corresponding exactly
1091  *                 to the new chunk to create.
1092  * \param [in,out] glob the global shared info that will be requested for existing profiles or to append a new profile if needed.
1093  * \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
1094  *              and corresponding entry erased from \a entriesOnSameDisc.
1095  * \return a newly allocated chunk
1096  */
1097 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewObjectOnSameDiscThanPool(TypeOfField typeF, INTERP_KERNEL::NormalizedCellType geoType, DataArrayInt *idsOfMeshElt,
1098                                                                                                   bool isPfl, int nbi, int offset,
1099                                                                                                   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
1100                                                                                                   MEDFileFieldGlobsReal& glob,
1101                                                                                                   bool &notInExisting)
1102 {
1103   int nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
1104   std::list< const MEDFileFieldPerMeshPerTypePerDisc *>::iterator it=entriesOnSameDisc.begin();
1105   for(;it!=entriesOnSameDisc.end();it++)
1106     {
1107       if(((INTERP_KERNEL::NormalizedCellType)(*it)->_loc_id)==geoType && (*it)->_nval==nbMeshEntities)
1108         {
1109           if(!isPfl)
1110             {
1111               if((*it)->_profile.empty())
1112                 break;
1113               else
1114                 if(!(*it)->_profile.empty())
1115                   {
1116                     const DataArrayInt *pfl=glob.getProfile((*it)->_profile.c_str());
1117                     if(pfl->isEqualWithoutConsideringStr(*idsOfMeshElt))
1118                       break;
1119                   }
1120             }
1121         }
1122     }
1123   if(it==entriesOnSameDisc.end())
1124     {
1125       notInExisting=true;
1126       MEDFileFieldPerMeshPerTypePerDisc *ret=new MEDFileFieldPerMeshPerTypePerDisc;
1127       ret->_type=typeF;
1128       ret->_loc_id=(int)geoType;
1129       ret->_nval=nbMeshEntities;
1130       ret->_start=offset;
1131       ret->_end=ret->_start+ret->_nval*nbi;
1132       if(isPfl)
1133         {
1134           idsOfMeshElt->setName(glob.createNewNameOfPfl().c_str());
1135           glob.appendProfile(idsOfMeshElt);
1136           ret->_profile=idsOfMeshElt->getName();
1137         }
1138       //tony treatment of localization
1139       return ret;
1140     }
1141   else
1142     {
1143       notInExisting=false;
1144       MEDFileFieldPerMeshPerTypePerDisc *ret=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
1145       ret->_loc_id=(int)geoType;
1146       ret->setNewStart(offset);
1147       entriesOnSameDisc.erase(it);
1148       return ret;
1149     }
1150
1151 }
1152
1153 ////////////////////////////////////
1154
1155 MEDFileFieldPerMeshPerTypeCommon::~MEDFileFieldPerMeshPerTypeCommon()
1156 {
1157 }
1158
1159 void MEDFileFieldPerMeshPerTypeCommon::setFather(MEDFileFieldPerMesh *father)
1160 {
1161   _father=father;
1162 }
1163
1164 void MEDFileFieldPerMeshPerTypeCommon::accept(MEDFileFieldVisitor& visitor) const
1165 {
1166   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1167     if((*it).isNotNull())
1168       {
1169         visitor.newPerMeshPerTypePerDisc(*it);
1170       }
1171 }
1172
1173 void MEDFileFieldPerMeshPerTypeCommon::deepCopyElements()
1174 {
1175   std::size_t i=0;
1176   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1177     {
1178       if((const MEDFileFieldPerMeshPerTypePerDisc *)*it)
1179         _field_pm_pt_pd[i]=(*it)->deepCopy(this);
1180     }
1181 }
1182
1183 std::size_t MEDFileFieldPerMeshPerTypeCommon::getHeapMemorySizeWithoutChildren() const
1184 {
1185   return _field_pm_pt_pd.capacity()*sizeof(MCAuto<MEDFileFieldPerMeshPerTypePerDisc>);
1186 }
1187
1188 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerTypeCommon::getDirectChildrenWithNull() const
1189 {
1190   std::vector<const BigMemoryObject *> ret;
1191   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1192     ret.push_back((const MEDFileFieldPerMeshPerTypePerDisc *)*it);
1193   return ret;
1194 }
1195
1196 void MEDFileFieldPerMeshPerTypeCommon::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1197 {
1198   std::vector<int> pos=addNewEntryIfNecessary(field,offset,nbOfCells);
1199   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1200     _field_pm_pt_pd[*it]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1201 }
1202
1203 /*!
1204  * This method is the most general one. No optimization is done here.
1205  * \param [in] multiTypePfl is the end user profile specified in high level API
1206  * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
1207  * \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.
1208  *             \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
1209  * \param [in] nbOfEltsInWholeMesh nb of elts of type \a this->_geo_type in \b WHOLE mesh
1210  * \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.
1211  */
1212 void MEDFileFieldPerMeshPerTypeCommon::assignFieldProfile(bool isPflAlone, 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)
1213 {
1214   std::vector<int> pos=addNewEntryIfNecessary(field,idsInPfl);
1215   for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1216     _field_pm_pt_pd[*it]->assignFieldProfile(isPflAlone,start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,arr,mesh,glob,nasc);
1217 }
1218
1219 void MEDFileFieldPerMeshPerTypeCommon::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
1220 {
1221   _field_pm_pt_pd.resize(1);
1222   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1223   _field_pm_pt_pd[0]->assignNodeFieldNoProfile(start,field,arr,glob);
1224 }
1225
1226 void MEDFileFieldPerMeshPerTypeCommon::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1227 {
1228   MCAuto<DataArrayInt> pfl2=pfl->deepCopy();
1229   if(!arr || !arr->isAllocated())
1230     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypeCommon::assignNodeFieldProfile : input array is null, or not allocated !");
1231   _field_pm_pt_pd.resize(1);
1232   _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1233   _field_pm_pt_pd[0]->assignFieldProfile(true,start,pfl,pfl2,pfl2,-1,field,arr,0,glob,nasc);//mesh is not requested so 0 is send.
1234 }
1235
1236 std::vector<int> MEDFileFieldPerMeshPerTypeCommon::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1237 {
1238   TypeOfField type=field->getTypeOfField();
1239   if(type!=ON_GAUSS_PT)
1240     {
1241       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1242       int sz=_field_pm_pt_pd.size();
1243       bool found=false;
1244       for(int j=0;j<sz && !found;j++)
1245         {
1246           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1247             {
1248               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1249               found=true;
1250             }
1251         }
1252       if(!found)
1253         {
1254           _field_pm_pt_pd.resize(sz+1);
1255           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1256         }
1257       std::vector<int> ret(1,(int)sz);
1258       return ret;
1259     }
1260   else
1261     {
1262       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
1263       int sz2=ret2.size();
1264       std::vector<int> ret3(sz2);
1265       int k=0;
1266       for(int i=0;i<sz2;i++)
1267         {
1268           int sz=_field_pm_pt_pd.size();
1269           int locIdToFind=ret2[i];
1270           bool found=false;
1271           for(int j=0;j<sz && !found;j++)
1272             {
1273               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1274                 {
1275                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1276                   ret3[k++]=j;
1277                   found=true;
1278                 }
1279             }
1280           if(!found)
1281             {
1282               _field_pm_pt_pd.resize(sz+1);
1283               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1284               ret3[k++]=sz;
1285             }
1286         }
1287       return ret3;
1288     }
1289 }
1290
1291 std::vector<int> MEDFileFieldPerMeshPerTypeCommon::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1292 {
1293   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1294   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1295   if(!disc2)
1296     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1297   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1298   if(!da)
1299     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss (no profile) : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1300   MCAuto<DataArrayInt> da2=da->selectByTupleIdSafeSlice(offset,offset+nbOfCells,1);
1301   MCAuto<DataArrayInt> retTmp=da2->getDifferentValues();
1302   if(retTmp->presenceOfValue(-1))
1303     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1304   std::vector<int> ret(retTmp->begin(),retTmp->end());
1305   return ret;
1306 }
1307
1308 std::vector<int> MEDFileFieldPerMeshPerTypeCommon::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1309 {
1310   TypeOfField type=field->getTypeOfField();
1311   if(type!=ON_GAUSS_PT)
1312     {
1313       int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1314       int sz=_field_pm_pt_pd.size();
1315       bool found=false;
1316       for(int j=0;j<sz && !found;j++)
1317         {
1318           if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1319             {
1320               _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1321               found=true;
1322             }
1323         }
1324       if(!found)
1325         {
1326           _field_pm_pt_pd.resize(sz+1);
1327           _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1328         }
1329       std::vector<int> ret(1,0);
1330       return ret;
1331     }
1332   else
1333     {
1334       std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,subCells);
1335       int sz2=ret2.size();
1336       std::vector<int> ret3(sz2);
1337       int k=0;
1338       for(int i=0;i<sz2;i++)
1339         {
1340           int sz=_field_pm_pt_pd.size();
1341           int locIdToFind=ret2[i];
1342           bool found=false;
1343           for(int j=0;j<sz && !found;j++)
1344             {
1345               if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1346                 {
1347                   _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1348                   ret3[k++]=j;
1349                   found=true;
1350                 }
1351             }
1352           if(!found)
1353             {
1354               _field_pm_pt_pd.resize(sz+1);
1355               _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1356               ret3[k++]=sz;
1357             }
1358         }
1359       return ret3;
1360     }
1361 }
1362
1363 std::vector<int> MEDFileFieldPerMeshPerTypeCommon::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1364 {
1365   const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1366   const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1367   if(!disc2)
1368     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1369   const DataArrayInt *da=disc2->getArrayOfDiscIds();
1370   if(!da)
1371     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1372   MCAuto<DataArrayInt> da2=da->selectByTupleIdSafe(subCells->getConstPointer(),subCells->getConstPointer()+subCells->getNumberOfTuples());
1373   MCAuto<DataArrayInt> retTmp=da2->getDifferentValues();
1374   if(retTmp->presenceOfValue(-1))
1375     throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1376   std::vector<int> ret(retTmp->begin(),retTmp->end());
1377   return ret;
1378 }
1379
1380 const MEDFileFieldPerMesh *MEDFileFieldPerMeshPerTypeCommon::getFather() const
1381 {
1382   return _father;
1383 }
1384
1385 bool MEDFileFieldPerMeshPerTypeCommon::isUniqueLevel(int& dim) const
1386 {
1387   const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(getGeoType()));
1388   int curDim((int)cm.getDimension());
1389   if(dim!=std::numeric_limits<int>::max())
1390     {
1391       if(dim!=curDim)
1392         return false;
1393     }
1394   else
1395     dim=curDim;
1396   return true;
1397 }
1398
1399 void MEDFileFieldPerMeshPerTypeCommon::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
1400 {
1401   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1402     {
1403       (*it)->fillTypesOfFieldAvailable(types);
1404     }
1405 }
1406
1407 void MEDFileFieldPerMeshPerTypeCommon::fillFieldSplitedByType(std::vector< std::pair<int,int> >& dads, std::vector<TypeOfField>& types, std::vector<std::string>& pfls, std::vector<std::string>& locs) const
1408 {
1409   int sz=_field_pm_pt_pd.size();
1410   dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
1411   for(int i=0;i<sz;i++)
1412     {
1413       _field_pm_pt_pd[i]->getCoarseData(types[i],dads[i],pfls[i],locs[i]);
1414     }
1415 }
1416
1417 int MEDFileFieldPerMeshPerTypeCommon::getIteration() const
1418 {
1419   return _father->getIteration();
1420 }
1421
1422 int MEDFileFieldPerMeshPerTypeCommon::getOrder() const
1423 {
1424   return _father->getOrder();
1425 }
1426
1427 double MEDFileFieldPerMeshPerTypeCommon::getTime() const
1428 {
1429   return _father->getTime();
1430 }
1431
1432 std::string MEDFileFieldPerMeshPerTypeCommon::getMeshName() const
1433 {
1434   return _father->getMeshName();
1435 }
1436
1437 void MEDFileFieldPerMeshPerTypeCommon::getSizes(int& globalSz, int& nbOfEntries) const
1438 {
1439   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1440     {
1441       globalSz+=(*it)->getNumberOfTuples();
1442     }
1443   nbOfEntries+=(int)_field_pm_pt_pd.size();
1444 }
1445
1446 int MEDFileFieldPerMeshPerTypeCommon::getNumberOfComponents() const
1447 {
1448   return _father->getNumberOfComponents();
1449 }
1450
1451 bool MEDFileFieldPerMeshPerTypeCommon::presenceOfMultiDiscPerGeoType() const
1452 {
1453   std::size_t nb(0);
1454   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1455     {
1456       const MEDFileFieldPerMeshPerTypePerDisc *fmtd(*it);
1457       if(fmtd)
1458         nb++;
1459     }
1460   return nb>1;
1461 }
1462
1463 void MEDFileFieldPerMeshPerTypeCommon::pushDiscretization(MEDFileFieldPerMeshPerTypePerDisc *disc)
1464 {
1465   MCAuto<MEDFileFieldPerMeshPerTypePerDisc> elt;
1466   elt.takeRef(disc);
1467   _field_pm_pt_pd.push_back(elt);
1468 }
1469
1470 DataArray *MEDFileFieldPerMeshPerTypeCommon::getOrCreateAndGetArray()
1471 {
1472   return _father->getOrCreateAndGetArray();
1473 }
1474
1475 const DataArray *MEDFileFieldPerMeshPerTypeCommon::getOrCreateAndGetArray() const
1476 {
1477   const MEDFileFieldPerMesh *fath=_father;
1478   return fath->getOrCreateAndGetArray();
1479 }
1480
1481 const std::vector<std::string>& MEDFileFieldPerMeshPerTypeCommon::getInfo() const
1482 {
1483   return _father->getInfo();
1484 }
1485
1486 std::vector<std::string> MEDFileFieldPerMeshPerTypeCommon::getPflsReallyUsed() const
1487 {
1488   std::vector<std::string> ret;
1489   std::set<std::string> ret2;
1490   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1491     {
1492       std::string tmp=(*it1)->getProfile();
1493       if(!tmp.empty())
1494         if(ret2.find(tmp)==ret2.end())
1495           {
1496             ret.push_back(tmp);
1497             ret2.insert(tmp);
1498           }
1499     }
1500   return ret;
1501 }
1502
1503 std::vector<std::string> MEDFileFieldPerMeshPerTypeCommon::getLocsReallyUsed() const
1504 {
1505   std::vector<std::string> ret;
1506   std::set<std::string> ret2;
1507   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1508     {
1509       std::string tmp=(*it1)->getLocalization();
1510       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1511         if(ret2.find(tmp)==ret2.end())
1512           {
1513             ret.push_back(tmp);
1514             ret2.insert(tmp);
1515           }
1516     }
1517   return ret;
1518 }
1519
1520 std::vector<std::string> MEDFileFieldPerMeshPerTypeCommon::getPflsReallyUsedMulti() const
1521 {
1522   std::vector<std::string> ret;
1523   std::set<std::string> ret2;
1524   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1525     {
1526       std::string tmp=(*it1)->getProfile();
1527       if(!tmp.empty())
1528         ret.push_back(tmp);
1529     }
1530   return ret;
1531 }
1532
1533 std::vector<std::string> MEDFileFieldPerMeshPerTypeCommon::getLocsReallyUsedMulti() const
1534 {
1535   std::vector<std::string> ret;
1536   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1537     {
1538       std::string tmp=(*it1)->getLocalization();
1539       if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1540         ret.push_back(tmp);
1541     }
1542   return ret;
1543 }
1544
1545 void MEDFileFieldPerMeshPerTypeCommon::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1546 {
1547   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1548     (*it1)->changePflsRefsNamesGen(mapOfModif);
1549 }
1550
1551 void MEDFileFieldPerMeshPerTypeCommon::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1552 {
1553   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1554     (*it1)->changeLocsRefsNamesGen(mapOfModif);
1555 }
1556
1557 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId(int locId)
1558 {
1559   if(_field_pm_pt_pd.empty())
1560     {
1561       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId : no localizations for geotype \"" << getGeoTypeRepr() << "\" !";
1562       throw INTERP_KERNEL::Exception(oss.str());
1563     }
1564   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1565     return _field_pm_pt_pd[locId];
1566   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId : no such locId available (" << locId;
1567   oss2 << ") for geometric type \"" << getGeoTypeRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1568   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1569   return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
1570 }
1571
1572 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId(int locId) const
1573 {
1574   if(_field_pm_pt_pd.empty())
1575     {
1576       std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId : no localizations for geotype \"" << getGeoTypeRepr() << "\" !";
1577       throw INTERP_KERNEL::Exception(oss.str());
1578     }
1579   if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1580     return _field_pm_pt_pd[locId];
1581   std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerTypeCommon::getLeafGivenLocId : no such locId available (" << locId;
1582   oss2 << ") for geometric type \"" << getGeoTypeRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1583   throw INTERP_KERNEL::Exception(oss2.str().c_str());
1584   return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
1585 }
1586
1587 void MEDFileFieldPerMeshPerTypeCommon::fillValues(int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
1588 {
1589   int i=0;
1590   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1591     {
1592       (*it)->fillValues(i,startEntryId,entries);
1593     }
1594 }
1595
1596 void MEDFileFieldPerMeshPerTypeCommon::setLeaves(const std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
1597 {
1598   _field_pm_pt_pd=leaves;
1599   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1600     (*it)->setFather(this);
1601 }
1602
1603 /*!
1604  *  \param [in,out] globalNum a global numbering counter for the renumbering.
1605  *  \param [out] its - list of pair (start,stop) kept
1606  *  \return bool - false if the type of field \a tof is not contained in \a this.
1607  */
1608 bool MEDFileFieldPerMeshPerTypeCommon::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
1609 {
1610   bool ret(false);
1611   std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd;
1612   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1613     if((*it)->getType()==tof)
1614       {
1615         newPmPtPd.push_back(*it);
1616         std::pair<int,int> bgEnd; bgEnd.first=(*it)->getStart(); bgEnd.second=(*it)->getEnd();
1617         (*it)->setNewStart(globalNum);
1618         globalNum=(*it)->getEnd();
1619         its.push_back(bgEnd);
1620         ret=true;
1621       }
1622   if(ret)
1623     _field_pm_pt_pd=newPmPtPd;
1624   return ret;
1625 }
1626
1627 /*!
1628  *  \param [in,out] globalNum a global numbering counter for the renumbering.
1629  *  \param [out] its - list of pair (start,stop) kept
1630  *  \return bool - false if the type of field \a tof is not contained in \a this.
1631  */
1632 bool MEDFileFieldPerMeshPerTypeCommon::keepOnlyGaussDiscretization(std::size_t idOfDisc, int &globalNum, std::vector< std::pair<int,int> >& its)
1633 {
1634   if(_field_pm_pt_pd.size()<=idOfDisc)
1635     return false;
1636   MCAuto<MEDFileFieldPerMeshPerTypePerDisc> elt(_field_pm_pt_pd[idOfDisc]);
1637   std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd(1,elt);
1638   std::pair<int,int> bgEnd; bgEnd.first=_field_pm_pt_pd[idOfDisc]->getStart(); bgEnd.second=_field_pm_pt_pd[idOfDisc]->getEnd();
1639   elt->setNewStart(globalNum);
1640   globalNum=elt->getEnd();
1641   its.push_back(bgEnd);
1642   _field_pm_pt_pd=newPmPtPd;
1643   return true;
1644 }
1645
1646 void MEDFileFieldPerMeshPerTypeCommon::loadOnlyStructureOfDataRecursively(med_idt fid, int &start, const MEDFileFieldNameScope& nasc)
1647 {
1648   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1649     (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1650 }
1651
1652 void MEDFileFieldPerMeshPerTypeCommon::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
1653 {
1654   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1655     (*it)->loadBigArray(fid,nasc);
1656 }
1657
1658 void MEDFileFieldPerMeshPerTypeCommon::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
1659 {
1660   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1661     {
1662       (*it)->copyOptionsFrom(*this);
1663       (*it)->writeLL(fid,nasc);
1664     }
1665 }
1666
1667 med_entity_type MEDFileFieldPerMeshPerTypeCommon::ConvertIntoMEDFileType(TypeOfField ikType, INTERP_KERNEL::NormalizedCellType ikGeoType, med_geometry_type& medfGeoType)
1668 {
1669   switch(ikType)
1670   {
1671     case ON_CELLS:
1672       medfGeoType=typmai3[(int)ikGeoType];
1673       return MED_CELL;
1674     case ON_NODES:
1675       medfGeoType=MED_NONE;
1676       return MED_NODE;
1677     case ON_GAUSS_NE:
1678       medfGeoType=typmai3[(int)ikGeoType];
1679       return MED_NODE_ELEMENT;
1680     case ON_GAUSS_PT:
1681       medfGeoType=typmai3[(int)ikGeoType];
1682       return MED_CELL;
1683     default:
1684       throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypeCommon::ConvertIntoMEDFileType : unexpected entity type ! internal error");
1685   }
1686   return MED_UNDEF_ENTITY_TYPE;
1687 }
1688
1689 //////////////////////////////////////////////////
1690
1691 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc, const PartDefinition *pd)
1692 {
1693   return new MEDFileFieldPerMeshPerType(fid,fath,type,geoType,nasc,pd);
1694 }
1695
1696 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::New(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType)
1697 {
1698   return new MEDFileFieldPerMeshPerType(fath,geoType);
1699 }
1700
1701 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::deepCopy(MEDFileFieldPerMesh *father) const
1702 {
1703   MCAuto<MEDFileFieldPerMeshPerType> ret=new MEDFileFieldPerMeshPerType(*this);
1704   ret->setFather(father);
1705   ret->deepCopyElements();
1706   return ret.retn();
1707 }
1708
1709 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
1710 {
1711   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1712     {
1713       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1714       if(meshDim!=(int)cm.getDimension())
1715         return ;
1716     }
1717   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1718     (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
1719 }
1720
1721 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
1722 {
1723   return _geo_type;
1724 }
1725
1726 void MEDFileFieldPerMeshPerType::entriesForMEDfile(TypeOfField mct, med_geometry_type& gt, med_entity_type& ent) const
1727 {
1728   ent=MEDFileFieldPerMeshPerTypeCommon::ConvertIntoMEDFileType(mct,_geo_type,gt);
1729 }
1730
1731 void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
1732 {
1733   const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_geo_type));
1734   int curDim((int)cm.getDimension());
1735   dim=std::max(dim,curDim);
1736 }
1737
1738 void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1739 {
1740   const char startLine[]="  ## ";
1741   std::string startLine2(bkOffset,' ');
1742   std::string startLine3(startLine2);
1743   startLine3+=startLine;
1744   if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1745     {
1746       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1747       oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry types " << cm.getRepr() << "." << std::endl;
1748     }
1749   else
1750     oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
1751   oss << startLine3 << "Entry is defined on " <<  _field_pm_pt_pd.size() << " localizations." << std::endl;
1752   int i=0;
1753   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1754     {
1755       const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
1756       if(cur)
1757         cur->simpleRepr(bkOffset,oss,i);
1758       else
1759         {
1760           oss << startLine2 << "    ## " << "Localization #" << i << " is empty !" << std::endl;
1761         }
1762     }
1763 }
1764
1765 std::string MEDFileFieldPerMeshPerType::getGeoTypeRepr() const
1766 {
1767   const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_geo_type));
1768   return std::string(cm.getRepr());
1769 }
1770
1771 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(MEDFileFieldPerMesh *father, INTERP_KERNEL::NormalizedCellType gt):MEDFileFieldPerMeshPerTypeCommon(father),_geo_type(gt)
1772 {
1773 }
1774
1775 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc, const PartDefinition *pd):MEDFileFieldPerMeshPerTypeCommon(fath),_geo_type(geoType)
1776 {
1777   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1778   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1779   med_geometry_type mgeoti;
1780   med_entity_type menti(ConvertIntoMEDFileType(type,geoType,mgeoti));
1781   int nbProfiles(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),menti,mgeoti,pflName,locName));
1782   _field_pm_pt_pd.resize(nbProfiles);
1783   for(int i=0;i<nbProfiles;i++)
1784     {
1785       _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,type,i,pd);
1786     }
1787   if(type==ON_CELLS)
1788     {
1789       int nbProfiles2(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,mgeoti,pflName,locName));
1790       for(int i=0;i<nbProfiles2;i++)
1791         _field_pm_pt_pd.push_back(MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,ON_GAUSS_NE,i,pd));
1792     }
1793 }
1794
1795 MCAuto<MEDFileFieldPerMeshPerType> MEDFileFieldPerMeshPerType::Aggregate(int &start, const std::vector<std::pair<int,const MEDFileFieldPerMeshPerType *> >& pms, const std::vector< std::vector< std::pair<int,int> > >& dts, INTERP_KERNEL::NormalizedCellType gt, MEDFileFieldPerMesh *father, std::vector<std::pair< int, std::pair<int,int> > >& extractInfo)
1796 {
1797   MCAuto<MEDFileFieldPerMeshPerType> ret(MEDFileFieldPerMeshPerType::New(father,gt));
1798   std::map<TypeOfField, std::vector< std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * > > > m;
1799   for(std::vector<std::pair<int,const MEDFileFieldPerMeshPerType *> >::const_iterator it=pms.begin();it!=pms.end();it++)
1800     {
1801       for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it2=(*it).second->_field_pm_pt_pd.begin();it2!=(*it).second->_field_pm_pt_pd.end();it2++)
1802         m[(*it2)->getType()].push_back(std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * >((*it).first,*it2));
1803     }
1804   for(std::map<TypeOfField, std::vector< std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * > > >::const_iterator it=m.begin();it!=m.end();it++)
1805     {
1806       MCAuto<MEDFileFieldPerMeshPerTypePerDisc> agg(MEDFileFieldPerMeshPerTypePerDisc::Aggregate(start,(*it).second,dts,(*it).first,ret,extractInfo));
1807       ret->_field_pm_pt_pd.push_back(agg);
1808     }
1809   return ret;
1810 }
1811
1812 //////////////////////////////////////////////////
1813
1814 MEDFileFieldPerMeshPerTypeDyn *MEDFileFieldPerMeshPerTypeDyn::NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, const MEDFileEntities *entities, int idGT, const MEDFileFieldNameScope& nasc)
1815 {
1816   if(!entities)
1817     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypeDyn::NewOnRead : null pointer !");
1818   const MEDFileAllStaticEntitiesPlusDyn *entities2(dynamic_cast<const MEDFileAllStaticEntitiesPlusDyn *>(entities));
1819   if(!entities2)
1820     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypeDyn::NewOnRead : invalid type of entities !");
1821   const MEDFileStructureElement *se(entities2->getWithGT(idGT));
1822   return new MEDFileFieldPerMeshPerTypeDyn(fid,fath,se,nasc);
1823 }
1824
1825 MEDFileFieldPerMeshPerTypeDyn::MEDFileFieldPerMeshPerTypeDyn(med_idt fid, MEDFileFieldPerMesh *fath, const MEDFileStructureElement *se, const MEDFileFieldNameScope& nasc):MEDFileFieldPerMeshPerTypeCommon(fath)
1826 {
1827   _se.takeRef(se);
1828   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1829   INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1830   int nbProfiles(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_STRUCT_ELEMENT,_se->getDynGT(),pflName,locName));
1831   _field_pm_pt_pd.resize(nbProfiles);
1832   for(int i=0;i<nbProfiles;i++)
1833     {
1834       _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,_se->getEntity(),i,NULL);
1835     }
1836 }
1837
1838 int MEDFileFieldPerMeshPerTypeDyn::getDynGT() const
1839 {
1840   return _se->getDynGT();
1841 }
1842
1843 std::string MEDFileFieldPerMeshPerTypeDyn::getModelName() const
1844 {
1845   return _se->getName();
1846 }
1847
1848 void MEDFileFieldPerMeshPerTypeDyn::getDimension(int& dim) const
1849 {
1850   throw INTERP_KERNEL::Exception("not implemented yet !");
1851 }
1852
1853 void MEDFileFieldPerMeshPerTypeDyn::entriesForMEDfile(TypeOfField mct, med_geometry_type& gt, med_entity_type& ent) const
1854 {
1855   gt=getDynGT();
1856   ent=MED_STRUCT_ELEMENT;
1857 }
1858
1859 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerTypeDyn::getGeoType() const
1860 {
1861   throw INTERP_KERNEL::Exception("not implemented yet !");
1862 }
1863
1864 void MEDFileFieldPerMeshPerTypeDyn::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1865 {
1866   const char startLine[]="  ## ";
1867   std::string startLine2(bkOffset,' ');
1868   std::string startLine3(startLine2);
1869   startLine3+=startLine;
1870   oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry STRUCTURE_ELEMENT type " << getDynGT() << "." << std::endl;
1871   oss << startLine3 << "Entry is defined on " <<  _field_pm_pt_pd.size() << " localizations." << std::endl;
1872   int i=0;
1873   for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1874     {
1875       if((*it).isNotNull())
1876         (*it)->simpleRepr(bkOffset,oss,i);
1877       else
1878         {
1879           oss << startLine2 << "    ## " << "Localization #" << i << " is empty !" << std::endl;
1880         }
1881     }
1882 }
1883
1884 std::string MEDFileFieldPerMeshPerTypeDyn::getGeoTypeRepr() const
1885 {
1886   throw INTERP_KERNEL::Exception("not implemented yet !");
1887 }
1888
1889 MEDFileFieldPerMeshPerTypeDyn *MEDFileFieldPerMeshPerTypeDyn::deepCopy(MEDFileFieldPerMesh *father) const
1890 {
1891   MCAuto<MEDFileFieldPerMeshPerTypeDyn> ret(new MEDFileFieldPerMeshPerTypeDyn(*this));
1892   ret->setFather(father);
1893   ret->deepCopyElements();
1894   return ret.retn();
1895 }
1896
1897 void MEDFileFieldPerMeshPerTypeDyn::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
1898 {
1899   throw INTERP_KERNEL::Exception("not implemented yet !");
1900 }
1901
1902 //////////////////////////////////////////////////
1903
1904 MEDFileFieldPerMesh *MEDFileFieldPerMesh::NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc, const MEDFileMesh *mm, const MEDFileEntities *entities)
1905 {
1906   return new MEDFileFieldPerMesh(fid,fath,meshCsit,meshIteration,meshOrder,nasc,mm,entities);
1907 }
1908
1909 MEDFileFieldPerMesh *MEDFileFieldPerMesh::New(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh)
1910 {
1911   return new MEDFileFieldPerMesh(fath,mesh);
1912 }
1913
1914 std::size_t MEDFileFieldPerMesh::getHeapMemorySizeWithoutChildren() const
1915 {
1916   return _field_pm_pt.capacity()*sizeof(MCAuto< MEDFileFieldPerMeshPerType >);
1917 }
1918
1919 std::vector<const BigMemoryObject *> MEDFileFieldPerMesh::getDirectChildrenWithNull() const
1920 {
1921   std::vector<const BigMemoryObject *> ret;
1922   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1923     ret.push_back(*it);
1924   return ret;
1925 }
1926
1927 MEDFileFieldPerMesh *MEDFileFieldPerMesh::deepCopy(MEDFileAnyTypeField1TSWithoutSDA *father) const
1928 {
1929   MCAuto< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
1930   ret->_father=father;
1931   std::size_t i=0;
1932   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1933     {
1934       if((*it).isNotNull())
1935         ret->_field_pm_pt[i]=(*it)->deepCopy((MEDFileFieldPerMesh *)(ret));
1936     }
1937   return ret.retn();
1938 }
1939
1940 void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1941 {
1942   std::string startLine(bkOffset,' ');
1943   oss << startLine << "## Field part (" << id << ") lying on mesh \"" << getMeshName() << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
1944   oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
1945   int i=0;
1946   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1947     {
1948       if((*it).isNotNull())
1949         (*it)->simpleRepr(bkOffset,oss,i);
1950       else
1951         {
1952           oss << startLine << "  ## Entry geometry type #" << i << " is empty !" << std::endl;
1953         }
1954     }
1955 }
1956
1957 void MEDFileFieldPerMesh::copyTinyInfoFrom(const MEDCouplingMesh *mesh)
1958 {
1959   mesh->getTime(_mesh_iteration,_mesh_order);
1960 }
1961
1962 void MEDFileFieldPerMesh::assignFieldNoProfileNoRenum(int& start, const std::vector<int>& code, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1963 {
1964   int nbOfTypes=code.size()/3;
1965   int offset=0;
1966   for(int i=0;i<nbOfTypes;i++)
1967     {
1968       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1969       int nbOfCells=code[3*i+1];
1970       int pos=addNewEntryIfNecessary(type);
1971       _field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1972       offset+=nbOfCells;
1973     }
1974 }
1975
1976 /*!
1977  * This method is the most general one. No optimization is done here.
1978  * \param [in] multiTypePfl is the end user profile specified in high level API
1979  * \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].
1980  * \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.
1981  * \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.
1982  * \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.
1983  * \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.
1984  */
1985 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)
1986 {
1987   int nbOfTypes(code.size()/3);
1988   for(int i=0;i<nbOfTypes;i++)
1989     {
1990       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1991       int pos=addNewEntryIfNecessary(type);
1992       DataArrayInt *pfl=0;
1993       if(code[3*i+2]!=-1)
1994         pfl=idsPerType[code[3*i+2]];
1995       int nbOfTupes2=code2.size()/3;
1996       int found=0;
1997       for(;found<nbOfTupes2;found++)
1998         if(code[3*i]==code2[3*found])
1999           break;
2000       if(found==nbOfTupes2)
2001         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::assignFieldProfile : internal problem ! Should never happen ! Please report bug to anthony.geay@cea.fr !");
2002       _field_pm_pt[pos]->assignFieldProfile(nbOfTypes==1,start,multiTypePfl,idsInPflPerType[i],pfl,code2[3*found+1],field,arr,mesh,glob,nasc);
2003     }
2004 }
2005
2006 void MEDFileFieldPerMesh::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
2007 {
2008   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
2009   _field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
2010 }
2011
2012 void MEDFileFieldPerMesh::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
2013 {
2014   int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
2015   _field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,arr,glob,nasc);
2016 }
2017
2018 void MEDFileFieldPerMesh::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
2019 {
2020   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2021     (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
2022 }
2023
2024 void MEDFileFieldPerMesh::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
2025 {
2026   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2027     (*it)->loadBigArraysRecursively(fid,nasc);
2028 }
2029
2030 void MEDFileFieldPerMesh::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
2031 {
2032   int nbOfTypes=_field_pm_pt.size();
2033   for(int i=0;i<nbOfTypes;i++)
2034     {
2035       _field_pm_pt[i]->copyOptionsFrom(*this);
2036       _field_pm_pt[i]->writeLL(fid,nasc);
2037     }
2038 }
2039
2040 void MEDFileFieldPerMesh::getDimension(int& dim) const
2041 {
2042   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2043     (*it)->getDimension(dim);
2044 }
2045
2046 bool MEDFileFieldPerMesh::isUniqueLevel(int& dim) const
2047 {
2048   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2049     if(!(*it)->isUniqueLevel(dim))
2050       return false;
2051   return true;
2052 }
2053
2054 void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
2055 {
2056   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2057     (*it)->fillTypesOfFieldAvailable(types);
2058 }
2059
2060 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
2061 {
2062   int sz=_field_pm_pt.size();
2063   std::vector< std::vector<std::pair<int,int> > > ret(sz);
2064   types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
2065   for(int i=0;i<sz;i++)
2066     {
2067       types[i]=_field_pm_pt[i]->getGeoType();
2068       _field_pm_pt[i]->fillFieldSplitedByType(ret[i],typesF[i],pfls[i],locs[i]);
2069     }
2070   return ret;
2071 }
2072
2073 double MEDFileFieldPerMesh::getTime() const
2074 {
2075   int tmp1,tmp2;
2076   return _father->getTime(tmp1,tmp2);
2077 }
2078
2079 int MEDFileFieldPerMesh::getIteration() const
2080 {
2081   return _father->getIteration();
2082 }
2083
2084 int MEDFileFieldPerMesh::getOrder() const
2085 {
2086   return _father->getOrder();
2087 }
2088
2089 int MEDFileFieldPerMesh::getNumberOfComponents() const
2090 {
2091   return _father->getNumberOfComponents();
2092 }
2093
2094 std::string MEDFileFieldPerMesh::getMeshName() const
2095 {
2096   return _father->getMeshName();
2097 }
2098
2099 void MEDFileFieldPerMesh::setMeshName(const std::string& meshName)
2100 {
2101   _father->setMeshName(meshName);
2102 }
2103
2104 bool MEDFileFieldPerMesh::presenceOfMultiDiscPerGeoType() const
2105 {
2106   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2107     {
2108       if((*it).isNull())
2109         continue;
2110       if((*it)->presenceOfMultiDiscPerGeoType())
2111         return true;
2112     }
2113   return false;
2114 }
2115
2116 bool MEDFileFieldPerMesh::presenceOfStructureElements() const
2117 {
2118   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2119     if((*it).isNotNull())
2120       {
2121         const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
2122         if(pt)
2123           return true;
2124       }
2125   return false;
2126 }
2127
2128 bool MEDFileFieldPerMesh::onlyStructureElements() const
2129 {
2130   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2131     if((*it).isNotNull())
2132       {
2133         const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
2134         if(!pt)
2135           return false;
2136       }
2137   return true;
2138 }
2139
2140 void MEDFileFieldPerMesh::killStructureElements()
2141 {
2142   std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > res;
2143   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2144     {
2145       if((*it).isNotNull())
2146         {
2147           const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
2148           if(!pt)
2149             res.push_back(*it);
2150         }
2151     }
2152   _field_pm_pt=res;
2153 }
2154
2155 void MEDFileFieldPerMesh::keepOnlyStructureElements()
2156 {
2157   std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > res;
2158   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2159     {
2160       if((*it).isNotNull())
2161         {
2162           const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
2163           if(pt)
2164             res.push_back(*it);
2165         }
2166     }
2167   _field_pm_pt=res;
2168 }
2169
2170 void MEDFileFieldPerMesh::keepOnlyOnSE(const std::string& seName)
2171 {
2172   std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > res;
2173   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2174     {
2175       if((*it).isNotNull())
2176         {
2177           const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
2178           if(!pt)
2179             throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::keepOnlyOnSE : presence of non SE !");
2180           if(pt->getModelName()==seName)
2181             res.push_back(*it);
2182         }
2183     }
2184   _field_pm_pt=res;
2185 }
2186
2187 void MEDFileFieldPerMesh::getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const
2188 {
2189   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2190     {
2191       if((*it).isNotNull())
2192         {
2193           const MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<const MEDFileFieldPerMeshPerTypeDyn *>((const MEDFileFieldPerMeshPerTypeCommon *)*it));
2194           if(pt)
2195             {
2196               ps.push_back(std::pair<std::string,std::string>(getMeshName(),pt->getModelName()));
2197             }
2198           else
2199             throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getMeshSENames : presence of a non structure element part !");
2200         }
2201     }
2202 }
2203
2204 DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray()
2205 {
2206   if(!_father)
2207     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
2208   return _father->getOrCreateAndGetArray();
2209 }
2210
2211 const DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray() const
2212 {
2213   if(!_father)
2214     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
2215   return _father->getOrCreateAndGetArray();
2216 }
2217
2218 const std::vector<std::string>& MEDFileFieldPerMesh::getInfo() const
2219 {
2220   return _father->getInfo();
2221 }
2222
2223 /*!
2224  * type,geoTypes,dads,pfls,locs are input parameters. They should have the same size.
2225  * 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.
2226  * It returns 2 output vectors :
2227  * - 'code' of size 3*sz where sz is the number of different values into 'geoTypes'
2228  * - 'notNullPfls' contains sz2 values that are extracted from 'pfls' in which null profiles have been removed.
2229  * 'code' and 'notNullPfls' are in MEDCouplingUMesh::checkTypeConsistencyAndContig format.
2230  */
2231 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)
2232 {
2233   int notNullPflsSz=0;
2234   int nbOfArrs=geoTypes.size();
2235   for(int i=0;i<nbOfArrs;i++)
2236     if(pfls[i])
2237       notNullPflsSz++;
2238   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
2239   int nbOfDiffGeoTypes=geoTypes3.size();
2240   code.resize(3*nbOfDiffGeoTypes);
2241   notNullPfls.resize(notNullPflsSz);
2242   notNullPflsSz=0;
2243   int j=0;
2244   for(int i=0;i<nbOfDiffGeoTypes;i++)
2245     {
2246       int startZone=j;
2247       INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
2248       std::vector<const DataArrayInt *> notNullTmp;
2249       if(pfls[j])
2250         notNullTmp.push_back(pfls[j]);
2251       j++;
2252       for(;j<nbOfArrs;j++)
2253         if(geoTypes[j]==refType)
2254           {
2255             if(pfls[j])
2256               notNullTmp.push_back(pfls[j]);
2257           }
2258         else
2259           break;
2260       std::vector< std::pair<int,int> > tmpDads(dads.begin()+startZone,dads.begin()+j);
2261       std::vector<const DataArrayInt *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
2262       std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
2263       code[3*i]=(int)refType;
2264       std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
2265       code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
2266       if(notNullTmp.empty())
2267         code[3*i+2]=-1;
2268       else
2269         {
2270           notNullPfls[notNullPflsSz]=DataArrayInt::Aggregate(notNullTmp);
2271           code[3*i+2]=notNullPflsSz++;
2272         }
2273     }
2274 }
2275
2276 /*!
2277  * 'dads' 'geoTypes' and 'locs' are input parameters that should have same size sz. sz should be >=1.
2278  */
2279 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)
2280 {
2281   int sz=dads.size();
2282   int ret=0;
2283   for(int i=0;i<sz;i++)
2284     {
2285       if(locs[i]==-1)
2286         {
2287           if(type!=ON_GAUSS_NE)
2288             ret+=dads[i].second-dads[i].first;
2289           else
2290             {
2291               const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(geoTypes[i]);
2292               ret+=(dads[i].second-dads[i].first)/cm.getNumberOfNodes();
2293             }
2294         }
2295       else
2296         {
2297           int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
2298           ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
2299         }
2300     }
2301   return ret;
2302 }
2303
2304 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsed() const
2305 {
2306   std::vector<std::string> ret;
2307   std::set<std::string> ret2;
2308   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2309     {
2310       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
2311       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
2312         if(ret2.find(*it2)==ret2.end())
2313           {
2314             ret.push_back(*it2);
2315             ret2.insert(*it2);
2316           }
2317     }
2318   return ret;
2319 }
2320
2321 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
2322 {
2323   std::vector<std::string> ret;
2324   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2325     {
2326       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
2327       ret.insert(ret.end(),tmp.begin(),tmp.end());
2328     }
2329   return ret;
2330 }
2331
2332 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsed() const
2333 {
2334   std::vector<std::string> ret;
2335   std::set<std::string> ret2;
2336   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2337     {
2338       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
2339       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
2340         if(ret2.find(*it2)==ret2.end())
2341           {
2342             ret.push_back(*it2);
2343             ret2.insert(*it2);
2344           }
2345     }
2346   return ret;
2347 }
2348
2349 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
2350 {
2351   std::vector<std::string> ret;
2352   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2353     {
2354       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
2355       ret.insert(ret.end(),tmp.begin(),tmp.end());
2356     }
2357   return ret;
2358 }
2359
2360 bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
2361 {
2362   for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
2363     {
2364       if((*it).first==getMeshName())
2365         {
2366           setMeshName((*it).second);
2367           return true;
2368         }
2369     }
2370   return false;
2371 }
2372
2373 void MEDFileFieldPerMesh::convertMedBallIntoClassic()
2374 {
2375   if(_field_pm_pt.size()!=1)
2376     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::convertMedBallIntoClassic : Only managed for single mesh !");
2377   if(_field_pm_pt[0].isNull())
2378     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::convertMedBallIntoClassic : null pointer !");
2379   MEDFileFieldPerMeshPerTypeDyn *pt(dynamic_cast<MEDFileFieldPerMeshPerTypeDyn *>((MEDFileFieldPerMeshPerTypeCommon *)_field_pm_pt[0]));
2380   if(!pt)
2381     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::convertMedBallIntoClassic : this is expected to be marked as structure element !");
2382   if(pt->getNumberOfLoc()!=1)
2383     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::convertMedBallIntoClassic : only one loc managed !");
2384   const MEDFileFieldPerMeshPerTypePerDisc *disc(pt->getLeafGivenLocId(0));
2385   if(!disc)
2386     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::convertMedBallIntoClassic : internal error !");
2387   MCAuto<MEDFileFieldPerMeshPerTypePerDisc> disc2(MEDFileFieldPerMeshPerTypePerDisc::New(*disc));
2388   disc2->setType(ON_NODES);
2389   MCAuto<MEDFileFieldPerMeshPerType> pt2(MEDFileFieldPerMeshPerType::New(this,INTERP_KERNEL::NORM_ERROR));
2390   disc2->setFather(pt2);
2391   pt2->setFather(this);
2392   pt2->pushDiscretization(disc2);
2393   _field_pm_pt[0]=DynamicCast<MEDFileFieldPerMeshPerType,MEDFileFieldPerMeshPerTypeCommon>(pt2);
2394 }
2395
2396 bool MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
2397                                                       MEDFileFieldGlobsReal& glob)
2398 {
2399   if(getMeshName()!=meshName)
2400     return false;
2401   std::set<INTERP_KERNEL::NormalizedCellType> typesToKeep;
2402   for(std::size_t i=0;i<oldCode.size()/3;i++) typesToKeep.insert((INTERP_KERNEL::NormalizedCellType)oldCode[3*i]);
2403   std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > > entries;
2404   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKept;
2405   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> otherEntries;
2406   getUndergroundDataArrayExt(entries);
2407   DataArray *arr0(getOrCreateAndGetArray());//tony
2408   if(!arr0)
2409     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values of field is null !");
2410   DataArrayDouble *arr(dynamic_cast<DataArrayDouble *>(arr0));//tony
2411   if(!arr0)
2412     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values is double ! Not managed for the moment !");
2413   int sz=0;
2414   if(!arr)
2415     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
2416   for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >::const_iterator it=entries.begin();it!=entries.end();it++)
2417     {
2418       if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
2419         {
2420           entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
2421           sz+=(*it).second.second-(*it).second.first;
2422         }
2423       else
2424         otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
2425     }
2426   MCAuto<DataArrayInt> renumDefrag=DataArrayInt::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
2427   ////////////////////
2428   MCAuto<DataArrayInt> explicitIdsOldInMesh=DataArrayInt::New(); explicitIdsOldInMesh->alloc(sz,1);//sz is a majorant of the real size. A realloc will be done after
2429   int *workI2=explicitIdsOldInMesh->getPointer();
2430   int sz1=0,sz2=0,sid=1;
2431   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptML=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKept);
2432   // std::vector<int> tupleIdOfStartOfNewChuncksV(entriesKeptML.size());
2433   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator itL1=entriesKeptML.begin();itL1!=entriesKeptML.end();itL1++,sid++)
2434     {
2435       //  tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
2436       MCAuto<DataArrayInt> explicitIdsOldInArr=DataArrayInt::New(); explicitIdsOldInArr->alloc(sz,1);
2437       int *workI=explicitIdsOldInArr->getPointer();
2438       for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
2439         {
2440           int delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
2441           (*itL2)->setLocId(sz2);
2442           (*itL2)->_tmp_work1=(*itL2)->getStart();
2443           int delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
2444         }
2445       renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
2446     }
2447   explicitIdsOldInMesh->reAlloc(sz2);
2448   int tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
2449   ////////////////////
2450   MCAuto<DataArrayInt> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
2451   // perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
2452   std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
2453   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
2454     {
2455       otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
2456       otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
2457       otherEntriesNew.back()->setLocId((*it)->getGeoType());
2458     }
2459   std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
2460   std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
2461   for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
2462     {
2463       MCAuto<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
2464       int newStart=elt->getLocId();
2465       elt->setLocId((*it)->getGeoType());
2466       elt->setNewStart(newStart);
2467       elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
2468       entriesKeptNew.push_back(elt);
2469       entriesKeptNew2.push_back(elt);
2470     }
2471   MCAuto<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
2472   // perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
2473   MCAuto<DataArrayInt> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
2474   std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
2475   bool ret=false;
2476   for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
2477     {
2478       sid=0;
2479       /*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
2480         {
2481           MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
2482           curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
2483           }*/
2484       ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
2485                                                             glob,arr2,otherEntriesNew) || ret;
2486     }
2487   if(!ret)
2488     return false;
2489   // Assign new dispatching
2490   assignNewLeaves(otherEntriesNew);
2491   arr->deepCopyFrom(*arr2);
2492   return true;
2493 }
2494
2495 /*!
2496  * \param [in,out] globalNum a global numbering counter for the renumbering.
2497  * \param [out] its - list of pair (start,stop) kept
2498  */
2499 void MEDFileFieldPerMesh::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
2500 {
2501   std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > ret;
2502   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2503     {
2504       std::vector< std::pair<int,int> > its2;
2505       if((*it)->keepOnlySpatialDiscretization(tof,globalNum,its2))
2506         {
2507           ret.push_back(*it);
2508           its.insert(its.end(),its2.begin(),its2.end());
2509         }
2510     }
2511   _field_pm_pt=ret;
2512 }
2513
2514 /*!
2515  * \param [in,out] globalNum a global numbering counter for the renumbering.
2516  * \param [out] its - list of pair (start,stop) kept
2517  */
2518 void MEDFileFieldPerMesh::keepOnlyGaussDiscretization(std::size_t idOfDisc, int &globalNum, std::vector< std::pair<int,int> >& its)
2519 {
2520   std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > ret;
2521   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2522     {
2523       std::vector< std::pair<int,int> > its2;
2524       if((*it)->keepOnlyGaussDiscretization(idOfDisc,globalNum,its2))
2525         {
2526           ret.push_back(*it);
2527           its.insert(its.end(),its2.begin(),its2.end());
2528         }
2529     }
2530   _field_pm_pt=ret;
2531 }
2532
2533 void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
2534 {
2535   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc> > > types;
2536   for( std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
2537     types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
2538   //
2539   std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > > fieldPmPt(types.size());
2540   std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
2541   std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it2=fieldPmPt.begin();
2542   for(;it1!=types.end();it1++,it2++)
2543     {
2544       MCAuto<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
2545       elt->setLeaves((*it1).second);
2546       MCAuto<MEDFileFieldPerMeshPerTypeCommon> elt2(DynamicCast<MEDFileFieldPerMeshPerType,MEDFileFieldPerMeshPerTypeCommon>(elt));
2547       *it2=elt2;
2548     }
2549   _field_pm_pt=fieldPmPt;
2550 }
2551
2552 void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2553 {
2554   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2555     (*it)->changePflsRefsNamesGen(mapOfModif);
2556 }
2557
2558 void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2559 {
2560   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2561     (*it)->changeLocsRefsNamesGen(mapOfModif);
2562 }
2563
2564 /*!
2565  * \param [in] mesh is the whole mesh
2566  */
2567 MEDCouplingFieldDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, bool& isPfl, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2568 {
2569   if(_field_pm_pt.empty())
2570     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2571   //
2572   std::vector< std::pair<int,int> > dads;
2573   std::vector<const DataArrayInt *> pfls;
2574   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2575   std::vector<int> locs,code;
2576   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2577   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2578     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2579   // Sort by types
2580   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2581   if(code.empty())
2582     {
2583       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2584       throw INTERP_KERNEL::Exception(oss.str());
2585     }
2586   //
2587   std::vector< MCAuto<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2588   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2589   if(type!=ON_NODES)
2590     {
2591       DataArrayInt *arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2592       if(!arr)
2593         return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2594       else
2595         {
2596           MCAuto<DataArrayInt> arr2(arr);
2597           return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl,arrOut,nasc);
2598         }
2599     }
2600   else
2601     {
2602       if(code.size()!=3)
2603         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2604       int nb=code[1];
2605       if(code[2]==-1)
2606         {
2607           if(nb!=mesh->getNumberOfNodes())
2608             {
2609               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2610               oss << " nodes in mesh !";
2611               throw INTERP_KERNEL::Exception(oss.str());
2612             }
2613           return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2614         }
2615       else
2616         return finishFieldNode2(glob,dads,locs,mesh,notNullPflsPerGeoType3[0],isPfl,arrOut,nasc);
2617     }
2618 }
2619
2620 DataArray *MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
2621 {
2622   if(_field_pm_pt.empty())
2623     throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2624   //
2625   std::vector<std::pair<int,int> > dads;
2626   std::vector<const DataArrayInt *> pfls;
2627   std::vector<DataArrayInt *> notNullPflsPerGeoType;
2628   std::vector<int> locs,code;
2629   std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2630   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2631     (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2632   // Sort by types
2633   SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2634   if(code.empty())
2635     {
2636       std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2637       throw INTERP_KERNEL::Exception(oss.str());
2638     }
2639   std::vector< MCAuto<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2640   std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2641   if(type!=ON_NODES)
2642     {
2643       MCAuto<DataArrayInt> arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2644       return finishField4(dads,arr,mesh->getNumberOfCells(),pfl);
2645     }
2646   else
2647     {
2648       if(code.size()!=3)
2649         throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2650       int nb=code[1];
2651       if(code[2]==-1)
2652         {
2653           if(nb!=mesh->getNumberOfNodes())
2654             {
2655               std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2656               oss << " nodes in mesh !";
2657               throw INTERP_KERNEL::Exception(oss.str());
2658             }
2659         }
2660       return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
2661     }
2662   //
2663   return 0;
2664 }
2665
2666 void MEDFileFieldPerMesh::accept(MEDFileFieldVisitor& visitor) const
2667 {
2668   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2669     if((*it).isNotNull())
2670       {
2671         visitor.newPerMeshPerTypeEntry(*it);
2672         (*it)->accept(visitor);
2673         visitor.endPerMeshPerTypeEntry(*it);
2674       }
2675 }
2676
2677 void MEDFileFieldPerMesh::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
2678 {
2679   int globalSz=0;
2680   int nbOfEntries=0;
2681   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2682     {
2683       (*it)->getSizes(globalSz,nbOfEntries);
2684     }
2685   entries.resize(nbOfEntries);
2686   nbOfEntries=0;
2687   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2688     {
2689       (*it)->fillValues(nbOfEntries,entries);
2690     }
2691 }
2692
2693 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId)
2694 {
2695   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2696     {
2697       if((*it)->getGeoType()==typ)
2698         return (*it)->getLeafGivenLocId(locId);
2699     }
2700   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2701   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2702   oss << "Possiblities are : ";
2703   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2704     {
2705       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2706       oss << "\"" << cm2.getRepr() << "\", ";
2707     }
2708   throw INTERP_KERNEL::Exception(oss.str());
2709 }
2710
2711 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) const
2712 {
2713   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2714     {
2715       if((*it)->getGeoType()==typ)
2716         return (*it)->getLeafGivenLocId(locId);
2717     }
2718   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2719   std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2720   oss << "Possiblities are : ";
2721   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2722     {
2723       const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2724       oss << "\"" << cm2.getRepr() << "\", ";
2725     }
2726   throw INTERP_KERNEL::Exception(oss.str());
2727 }
2728
2729 /*!
2730  * \param [in,out] start - Integer that gives the current position in the final aggregated array
2731  * \param [in] pms - list of elements to aggregate. integer gives the mesh id
2732  * \param [in] dts - (Distribution of types) = level 1 : meshes to aggregate. Level 2 : all geo type. Level 3 pair specifying geo type and number of elem in geotype.
2733  * \param [out] extractInfo - Gives information about the where the data comes from. It is a vector of triplet. First element in the triplet the mesh pos. The 2nd one the start pos. The 3rd the end pos.
2734  */
2735 MCAuto<MEDFileFieldPerMeshPerTypePerDisc> MEDFileFieldPerMeshPerTypePerDisc::Aggregate(int &start, const std::vector< std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc *> >& pms, const std::vector< std::vector< std::pair<int,int> > >& dts, TypeOfField tof, MEDFileFieldPerMeshPerType *father, std::vector<std::pair< int, std::pair<int,int> > >& extractInfo)
2736 {
2737   MCAuto<MEDFileFieldPerMeshPerTypePerDisc> ret(new MEDFileFieldPerMeshPerTypePerDisc(father,tof));
2738   if(pms.empty())
2739     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : empty input vector !");
2740   for(std::vector<std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it=pms.begin();it!=pms.end();it++)
2741     {
2742       if(!(*it).second)
2743         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : presence of null pointer !");
2744       if(!(*it).second->getProfile().empty())
2745         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for profiles !");
2746       if(!(*it).second->getLocalization().empty())
2747         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for gauss pts !");
2748     }
2749   INTERP_KERNEL::NormalizedCellType gt(pms[0].second->getGeoType());
2750   std::size_t i(0);
2751   std::vector< std::pair<int,int> > filteredDTS;
2752   for(std::vector< std::vector< std::pair<int,int> > >::const_iterator it=dts.begin();it!=dts.end();it++,i++)
2753     for(std::vector< std::pair<int,int> >::const_iterator it2=(*it).begin();it2!=(*it).end();it2++)
2754       if((*it2).first==gt)
2755         filteredDTS.push_back(std::pair<int,int>(i,(*it2).second));
2756   if(pms.size()!=filteredDTS.size())
2757     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for generated profiles !");
2758   std::vector<std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it1(pms.begin());
2759   std::vector< std::pair<int,int> >::const_iterator it2(filteredDTS.begin());
2760   int zeStart(start),nval(0);
2761   for(;it1!=pms.end();it1++,it2++)
2762     {
2763       if((*it1).first!=(*it2).first)
2764         throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for generated profiles 2 !");
2765       int s1((*it1).second->getStart()),e1((*it1).second->getEnd());
2766       extractInfo.push_back(std::pair<int, std::pair<int,int> >((*it1).first,std::pair<int,int>(s1,e1)));
2767       start+=e1-s1;
2768       nval+=((*it1).second)->getNumberOfVals();
2769     }
2770   ret->_start=zeStart; ret->_end=start; ret->_nval=nval;
2771   return ret;
2772 }
2773
2774 MCAuto<MEDFileFieldPerMesh> MEDFileFieldPerMesh::Aggregate(int &start, const std::vector<const MEDFileFieldPerMesh *>& pms, const std::vector< std::vector< std::pair<int,int> > >& dts, MEDFileAnyTypeField1TSWithoutSDA *father, std::vector<std::pair< int, std::pair<int,int> > >& extractInfo)
2775 {
2776   MCAuto<MEDFileFieldPerMesh> ret(new MEDFileFieldPerMesh(father,pms[0]->getMeshName(),pms[0]->getMeshIteration(),pms[0]->getMeshOrder()));
2777   std::map<INTERP_KERNEL::NormalizedCellType, std::vector< std::pair<int,const MEDFileFieldPerMeshPerType *> > > m;
2778   std::size_t i(0);
2779   for(std::vector<const MEDFileFieldPerMesh *>::const_iterator it=pms.begin();it!=pms.end();it++,i++)
2780     {
2781       const std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >& v((*it)->_field_pm_pt);
2782       for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::const_iterator it2=v.begin();it2!=v.end();it2++)
2783         {
2784           INTERP_KERNEL::NormalizedCellType gt((*it2)->getGeoType());
2785           const MEDFileFieldPerMeshPerType *elt(dynamic_cast<const MEDFileFieldPerMeshPerType *>((const MEDFileFieldPerMeshPerTypeCommon *)(*it2)));
2786           if(!elt)
2787             throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::Aggregate : not managed for structelement !");
2788           m[gt].push_back(std::pair<int,const MEDFileFieldPerMeshPerType *>(i,elt));
2789         }
2790     }
2791   for(std::map<INTERP_KERNEL::NormalizedCellType, std::vector< std::pair<int,const MEDFileFieldPerMeshPerType *> > >::const_iterator it=m.begin();it!=m.end();it++)
2792     {
2793       MCAuto<MEDFileFieldPerMeshPerType> agg(MEDFileFieldPerMeshPerType::Aggregate(start,(*it).second,dts,(*it).first,ret,extractInfo));
2794       MCAuto<MEDFileFieldPerMeshPerTypeCommon> agg2(DynamicCast<MEDFileFieldPerMeshPerType,MEDFileFieldPerMeshPerTypeCommon>(agg));
2795       ret->_field_pm_pt.push_back(agg2);
2796     }
2797   return ret;
2798 }
2799
2800 int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
2801 {
2802   int i=0;
2803   int pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
2804   std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it2=_field_pm_pt.begin();
2805   for(std::vector< MCAuto< MEDFileFieldPerMeshPerTypeCommon > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
2806     {
2807       INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
2808       if(type==curType)
2809         return i;
2810       else
2811         {
2812           int pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
2813           if(pos>pos2)
2814             it2=it+1;
2815         }
2816     }
2817   int ret=std::distance(_field_pm_pt.begin(),it2);
2818   _field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
2819   return ret;
2820 }
2821
2822 /*!
2823  * 'dads' and 'locs' input parameters have the same number of elements
2824  * \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
2825  */
2826 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2827                                                          const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs,
2828                                                          const MEDCouplingMesh *mesh, bool& isPfl, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2829 {
2830   isPfl=false;
2831   MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(type,ONE_TIME);
2832   ret->setMesh(mesh); ret->setName(nasc.getName().c_str()); ret->setTime(getTime(),getIteration(),getOrder()); ret->setTimeUnit(nasc.getDtUnit().c_str());
2833   MCAuto<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2834   const std::vector<std::string>& infos=getInfo();
2835   da->setInfoOnComponents(infos);
2836   da->setName("");
2837   if(type==ON_GAUSS_PT)
2838     {
2839       int offset=0;
2840       int nbOfArrs=dads.size();
2841       for(int i=0;i<nbOfArrs;i++)
2842         {
2843           std::vector<std::pair<int,int> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
2844           const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
2845           int nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
2846           MCAuto<DataArrayInt> di=DataArrayInt::New();
2847           di->alloc(nbOfElems,1);
2848           di->iota(offset);
2849           const MEDFileFieldLoc& fl=glob->getLocalizationFromId(locs[i]);
2850           ret->setGaussLocalizationOnCells(di->getConstPointer(),di->getConstPointer()+nbOfElems,fl.getRefCoords(),fl.getGaussCoords(),fl.getGaussWeights());
2851           offset+=nbOfElems;
2852         }
2853     }
2854   arrOut=da;
2855   return ret.retn();
2856 }
2857
2858 /*!
2859  * 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.
2860  * 'dads', 'locs' and 'geoTypes' input parameters have the same number of elements.
2861  * No check of this is performed. 'da' array contains an array in old2New style to be applyied to mesh to obtain the right support.
2862  * The order of cells in the returned field is those imposed by the profile.
2863  * \param [in] mesh is the global mesh.
2864  */
2865 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2866                                                           const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2867                                                           const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
2868                                                           const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2869 {
2870   if(da->isIota(mesh->getNumberOfCells()))
2871     return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2872   MCAuto<MEDCouplingMesh> m2=mesh->buildPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2873   m2->setName(mesh->getName().c_str());
2874   MCAuto<MEDCouplingFieldDouble> ret=finishField(type,glob,dads,locs,m2,isPfl,arrOut,nasc);
2875   isPfl=true;
2876   return ret.retn();
2877 }
2878
2879 /*!
2880  * This method is the complement of MEDFileFieldPerMesh::finishField2 method except that this method works for node profiles.
2881  */
2882 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishFieldNode2(const MEDFileFieldGlobsReal *glob,
2883                                                               const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2884                                                               const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2885 {
2886   if(da->isIota(mesh->getNumberOfNodes()))
2887     return finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2888   // Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
2889   const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
2890   if(meshu)
2891     {
2892       if(meshu->getNodalConnectivity()==0)
2893         {
2894           MCAuto<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2895           int nb=da->getNbOfElems();
2896           const int *ptr=da->getConstPointer();
2897           MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
2898           meshuc->allocateCells(nb);
2899           for(int i=0;i<nb;i++)
2900             meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
2901           meshuc->finishInsertingCells();
2902           ret->setMesh(meshuc);
2903           const MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
2904           if(!disc) throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::finishFieldNode2 : internal error, no discretization on field !");
2905           disc->checkCoherencyBetween(meshuc,arrOut);
2906           return ret.retn();
2907         }
2908     }
2909   //
2910   MCAuto<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2911   isPfl=true;
2912   DataArrayInt *arr2=0;
2913   MCAuto<DataArrayInt> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2914   MCAuto<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
2915   MCAuto<DataArrayInt> arr3(arr2);
2916   int nnodes=mesh2->getNumberOfNodes();
2917   if(nnodes==(int)da->getNbOfElems())
2918     {
2919       MCAuto<DataArrayInt> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
2920       arrOut->renumberInPlace(da3->getConstPointer());
2921       mesh2->setName(mesh->getName().c_str());
2922       ret->setMesh(mesh2);
2923       return ret.retn();
2924     }
2925   else
2926     {
2927       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 !!!";
2928       oss << "So it is impossible to return a well definied MEDCouplingFieldDouble instance on specified mesh on a specified meshDim !" << std::endl;
2929       oss << "To retrieve correctly such a field you have 3 possibilities :" << std::endl;
2930       oss << " - use an another meshDim compatible with the field on nodes (MED file does not have such information)" << std::endl;
2931       oss << " - use an another a meshDimRelToMax equal to 1 -> it will return a mesh with artificial cell POINT1 containing the profile !" << std::endl;
2932       oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
2933       throw INTERP_KERNEL::Exception(oss.str());
2934     }
2935   return 0;
2936 }
2937
2938 /*!
2939  * This method is the most light method of field retrieving.
2940  */
2941 DataArray *MEDFileFieldPerMesh::finishField4(const std::vector<std::pair<int,int> >& dads, const DataArrayInt *pflIn, int nbOfElems, DataArrayInt *&pflOut) const
2942 {
2943   if(!pflIn)
2944     {
2945       pflOut=DataArrayInt::New();
2946       pflOut->alloc(nbOfElems,1);
2947       pflOut->iota(0);
2948     }
2949   else
2950     {
2951       pflOut=const_cast<DataArrayInt*>(pflIn);
2952       pflOut->incrRef();
2953     }
2954   MCAuto<DataArrayInt> safePfl(pflOut);
2955   MCAuto<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2956   const std::vector<std::string>& infos=getInfo();
2957   int nbOfComp=infos.size();
2958   for(int i=0;i<nbOfComp;i++)
2959     da->setInfoOnComponent(i,infos[i].c_str());
2960   safePfl->incrRef();
2961   return da.retn();
2962 }
2963
2964
2965 /// @cond INTERNAL
2966
2967 class MFFPMIter
2968 {
2969 public:
2970   static MFFPMIter *NewCell(const MEDFileEntities *entities);
2971   static bool IsPresenceOfNode(const MEDFileEntities *entities);
2972   virtual ~MFFPMIter() { }
2973   virtual void begin() = 0;
2974   virtual bool finished() const = 0;
2975   virtual void next() = 0;
2976   virtual int current() const = 0;
2977 };
2978
2979 class MFFPMIterSimple : public MFFPMIter
2980 {
2981 public:
2982   MFFPMIterSimple():_pos(0) { }
2983   void begin() { _pos=0; }
2984   bool finished() const { return _pos>=MED_N_CELL_FIXED_GEO; }
2985   void next() { _pos++; }
2986   int current() const { return _pos; }
2987 private:
2988   int _pos;
2989 };
2990
2991 class MFFPMIter2 : public MFFPMIter
2992 {
2993 public:
2994   MFFPMIter2(const std::vector<INTERP_KERNEL::NormalizedCellType>& cts);
2995   void begin() { _it=_ids.begin(); }
2996   bool finished() const { return _it==_ids.end(); }
2997   void next() { _it++; }
2998   int current() const { return *_it; }
2999 private:
3000   std::vector<int> _ids;
3001   std::vector<int>::const_iterator _it;
3002 };
3003
3004 MFFPMIter *MFFPMIter::NewCell(const MEDFileEntities *entities)
3005 {
3006   if(!entities)
3007     return new MFFPMIterSimple;
3008   else
3009     {
3010       const MEDFileStaticEntities *entities2(dynamic_cast<const MEDFileStaticEntities *>(entities));
3011       if(entities2)
3012         {
3013           std::vector<INTERP_KERNEL::NormalizedCellType> tmp;
3014           const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& myEnt(entities2->getEntries());
3015           for(std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >::const_iterator it=myEnt.begin();it!=myEnt.end();it++)
3016             {
3017               if((*it).first==ON_CELLS || (*it).first==ON_GAUSS_NE || (*it).first==ON_GAUSS_PT)
3018                 tmp.push_back((*it).second);
3019             }
3020           return new MFFPMIter2(tmp);
3021         }
3022       return new MFFPMIterSimple;// for MEDFileAllStaticEntites and MEDFileAllStaticEntitiesPlusDyn cells are in
3023     }
3024 }
3025
3026 bool MFFPMIter::IsPresenceOfNode(const MEDFileEntities *entities)
3027 {
3028   if(!entities)
3029     return true;
3030   else
3031     {
3032       const MEDFileStaticEntities *entities2(dynamic_cast<const MEDFileStaticEntities *>(entities));
3033       if(entities2)
3034         {
3035           const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& myEnt(entities2->getEntries());
3036           for(std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >::const_iterator it=myEnt.begin();it!=myEnt.end();it++)
3037             if((*it).first==ON_NODES)
3038               return true;
3039           return false;
3040         }
3041       return true;// for MEDFileAllStaticEntites and MEDFileAllStaticEntitiesPlusDyn nodes are in
3042     }
3043 }
3044
3045 MFFPMIter2::MFFPMIter2(const std::vector<INTERP_KERNEL::NormalizedCellType>& cts)
3046 {
3047   std::size_t sz(cts.size());
3048   _ids.resize(sz);
3049   for(std::size_t i=0;i<sz;i++)
3050     {
3051       INTERP_KERNEL::NormalizedCellType *loc(std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,cts[i]));
3052       if(loc!=typmai2+MED_N_CELL_FIXED_GEO)
3053         _ids[i]=(int)std::distance(typmai2,loc);
3054       else
3055         throw INTERP_KERNEL::Exception("MFFPMIter2 : The specified geo type does not exists !");
3056     }
3057 }
3058
3059 /// @endcond
3060
3061 MEDFileFieldPerMesh::MEDFileFieldPerMesh(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc, const MEDFileMesh *mm, const MEDFileEntities *entities):_mesh_iteration(meshIteration),_mesh_order(meshOrder),
3062     _father(fath)
3063 {
3064   INTERP_KERNEL::AutoPtr<char> meshName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
3065   INTERP_KERNEL::AutoPtr<char> pflName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
3066   INTERP_KERNEL::AutoPtr<char> locName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
3067   const MEDFileUMesh *mmu(dynamic_cast<const MEDFileUMesh *>(mm));
3068   INTERP_KERNEL::AutoCppPtr<MFFPMIter> iter0(MFFPMIter::NewCell(entities));
3069   for(iter0->begin();!iter0->finished();iter0->next())
3070     {
3071       int nbProfile (MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL        ,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
3072       std::string name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
3073       int nbProfile2(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
3074       std::string name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
3075       if(nbProfile>0 || nbProfile2>0)
3076         {
3077           const PartDefinition *pd(0);
3078           if(mmu)
3079             pd=mmu->getPartDefAtLevel(mmu->getRelativeLevOnGeoType(typmai2[iter0->current()]),typmai2[iter0->current()]);
3080           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[iter0->current()],nasc,pd));
3081           if(nbProfile>0)
3082             setMeshName(name0);
3083           else
3084             setMeshName(name1);
3085         }
3086     }
3087   if(MFFPMIter::IsPresenceOfNode(entities))
3088     {
3089       int nbProfile(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,meshCsit+1,meshName,pflName,locName));
3090       if(nbProfile>0)
3091         {
3092           const PartDefinition *pd(0);
3093           if(mmu)
3094             pd=mmu->getPartDefAtLevel(1,INTERP_KERNEL::NORM_ERROR);
3095           _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc,pd));
3096           setMeshName(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE));
3097         }
3098     }
3099   if(!entities)
3100     return ;
3101   std::vector<int> dynGT(entities->getDynGTAvail());
3102   for(std::vector<int>::const_iterator it=dynGT.begin();it!=dynGT.end();it++)
3103     {
3104       int nbPfl(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_STRUCT_ELEMENT,*it,pflName,locName));
3105       if(nbPfl>0)
3106         {
3107           _field_pm_pt.push_back(MEDFileFieldPerMeshPerTypeDyn::NewOnRead(fid,this,entities,*it,nasc));
3108           setMeshName(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE));
3109         }
3110     }
3111 }
3112
3113 MEDFileFieldPerMesh::MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh):_father(fath)
3114 {
3115   copyTinyInfoFrom(mesh);
3116 }
3117
3118 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int id, const std::string& pflName)
3119 {
3120   if(id>=(int)_pfls.size())
3121     _pfls.resize(id+1);
3122   _pfls[id]=DataArrayInt::New();
3123   int lgth(MEDprofileSizeByName(fid,pflName.c_str()));
3124   _pfls[id]->setName(pflName);
3125   _pfls[id]->alloc(lgth,1);
3126   MEDFILESAFECALLERRD0(MEDprofileRd,(fid,pflName.c_str(),_pfls[id]->getPointer()));
3127   _pfls[id]->applyLin(1,-1,0);//Converting into C format
3128 }
3129
3130 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int i)
3131 {
3132   INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
3133   int sz;
3134   MEDFILESAFECALLERRD0(MEDprofileInfo,(fid,i+1,pflName,&sz));
3135   std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
3136   if(i>=(int)_pfls.size())
3137     _pfls.resize(i+1);
3138   _pfls[i]=DataArrayInt::New();
3139   _pfls[i]->alloc(sz,1);
3140   _pfls[i]->setName(pflCpp.c_str());
3141   MEDFILESAFECALLERRD0(MEDprofileRd,(fid,pflName,_pfls[i]->getPointer()));
3142   _pfls[i]->applyLin(1,-1,0);//Converting into C format
3143 }
3144
3145 void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
3146 {
3147   int nbOfPfls=_pfls.size();
3148   for(int i=0;i<nbOfPfls;i++)
3149     {
3150       MCAuto<DataArrayInt> cpy=_pfls[i]->deepCopy();
3151       cpy->applyLin(1,1,0);
3152       INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
3153       MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
3154       MEDFILESAFECALLERWR0(MEDprofileWr,(fid,pflName,_pfls[i]->getNumberOfTuples(),cpy->getConstPointer()));
3155     }
3156   //
3157   int nbOfLocs=_locs.size();
3158   for(int i=0;i<nbOfLocs;i++)
3159     _locs[i]->writeLL(fid);
3160 }
3161
3162 void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps)
3163 {
3164   std::vector<std::string> pfls=getPfls();
3165   for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
3166     {
3167       std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
3168       if(it2==pfls.end())
3169         {
3170           _pfls.push_back(*it);
3171         }
3172       else
3173         {
3174           int id=std::distance(pfls.begin(),it2);
3175           if(!(*it)->isEqual(*_pfls[id]))
3176             {
3177               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
3178               throw INTERP_KERNEL::Exception(oss.str());
3179             }
3180         }
3181     }
3182   std::vector<std::string> locs=getLocs();
3183   for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=other._locs.begin();it!=other._locs.end();it++)
3184     {
3185       std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
3186       if(it2==locs.end())
3187         {
3188           _locs.push_back(*it);
3189         }
3190       else
3191         {
3192           int id=std::distance(locs.begin(),it2);
3193           if(!(*it)->isEqual(*_locs[id],eps))
3194             {
3195               std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
3196               throw INTERP_KERNEL::Exception(oss.str());
3197             }
3198         }
3199     }
3200 }
3201
3202 void MEDFileFieldGlobs::checkGlobsPflsPartCoherency(const std::vector<std::string>& pflsUsed) const
3203 {
3204   for(std::vector<std::string>::const_iterator it=pflsUsed.begin();it!=pflsUsed.end();it++)
3205     getProfile((*it).c_str());
3206 }
3207
3208 void MEDFileFieldGlobs::checkGlobsLocsPartCoherency(const std::vector<std::string>& locsUsed) const
3209 {
3210   for(std::vector<std::string>::const_iterator it=locsUsed.begin();it!=locsUsed.end();it++)
3211     getLocalization((*it).c_str());
3212 }
3213
3214 void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real)
3215 {
3216   std::vector<std::string> profiles=real.getPflsReallyUsed();
3217   int sz=profiles.size();
3218   _pfls.resize(sz);
3219   for(int i=0;i<sz;i++)
3220     loadProfileInFile(fid,i,profiles[i].c_str());
3221   //
3222   std::vector<std::string> locs=real.getLocsReallyUsed();
3223   sz=locs.size();
3224   _locs.resize(sz);
3225   for(int i=0;i<sz;i++)
3226     _locs[i]=MEDFileFieldLoc::New(fid,locs[i].c_str());
3227 }
3228
3229 void MEDFileFieldGlobs::loadAllGlobals(med_idt fid, const MEDFileEntities *entities)
3230 {
3231   int nProfil=MEDnProfile(fid);
3232   for(int i=0;i<nProfil;i++)
3233     loadProfileInFile(fid,i);
3234   int sz=MEDnLocalization(fid);
3235   _locs.resize(sz);
3236   for(int i=0;i<sz;i++)
3237     {
3238       _locs[i]=MEDFileFieldLoc::New(fid,i,entities);
3239     }
3240 }
3241
3242 MEDFileFieldGlobs *MEDFileFieldGlobs::New(med_idt fid)
3243 {
3244   return new MEDFileFieldGlobs(fid);
3245 }
3246
3247 MEDFileFieldGlobs *MEDFileFieldGlobs::New()
3248 {
3249   return new MEDFileFieldGlobs;
3250 }
3251
3252 std::size_t MEDFileFieldGlobs::getHeapMemorySizeWithoutChildren() const
3253 {
3254   return _file_name.capacity()+_pfls.capacity()*sizeof(MCAuto<DataArrayInt>)+_locs.capacity()*sizeof(MCAuto<MEDFileFieldLoc>);
3255 }
3256
3257 std::vector<const BigMemoryObject *> MEDFileFieldGlobs::getDirectChildrenWithNull() const
3258 {
3259   std::vector<const BigMemoryObject *> ret;
3260   for(std::vector< MCAuto< DataArrayInt > >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
3261     ret.push_back((const DataArrayInt *)*it);
3262   for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
3263     ret.push_back((const MEDFileFieldLoc *)*it);
3264   return ret;
3265 }
3266
3267 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCopy() const
3268 {
3269   MCAuto<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
3270   std::size_t i=0;
3271   for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
3272     {
3273       if((const DataArrayInt *)*it)
3274         ret->_pfls[i]=(*it)->deepCopy();
3275     }
3276   i=0;
3277   for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
3278     {
3279       if((const MEDFileFieldLoc*)*it)
3280         ret->_locs[i]=(*it)->deepCopy();
3281     }
3282   return ret.retn();
3283 }
3284
3285 /*!
3286  * \throw if a profile in \a pfls in not in \a this.
3287  * \throw if a localization in \a locs in not in \a this.
3288  * \sa MEDFileFieldGlobs::deepCpyPart
3289  */
3290 MEDFileFieldGlobs *MEDFileFieldGlobs::shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
3291 {
3292   MCAuto<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
3293   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
3294     {
3295       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
3296       if(!pfl)
3297         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! pfl null !");
3298       pfl->incrRef();
3299       MCAuto<DataArrayInt> pfl2(pfl);
3300       ret->_pfls.push_back(pfl2);
3301     }
3302   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
3303     {
3304       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
3305       if(!loc)
3306         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! loc null !");
3307       loc->incrRef();
3308       MCAuto<MEDFileFieldLoc> loc2(loc);
3309       ret->_locs.push_back(loc2);
3310     }
3311   ret->setFileName(getFileName());
3312   return ret.retn();
3313 }
3314
3315 /*!
3316  * \throw if a profile in \a pfls in not in \a this.
3317  * \throw if a localization in \a locs in not in \a this.
3318  * \sa MEDFileFieldGlobs::shallowCpyPart
3319  */
3320 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
3321 {
3322   MCAuto<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
3323   for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
3324     {
3325       DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
3326       if(!pfl)
3327         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! pfl null !");
3328       ret->_pfls.push_back(pfl->deepCopy());
3329     }
3330   for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
3331     {
3332       MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
3333       if(!loc)
3334         throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! loc null !");
3335       ret->_locs.push_back(loc->deepCopy());
3336     }
3337   ret->setFileName(getFileName());
3338   return ret.retn();
3339 }
3340
3341 MEDFileFieldGlobs::MEDFileFieldGlobs(med_idt fid):_file_name(MEDFileWritable::FileNameFromFID(fid))
3342 {
3343 }
3344
3345 MEDFileFieldGlobs::MEDFileFieldGlobs()
3346 {
3347 }
3348
3349 MEDFileFieldGlobs::~MEDFileFieldGlobs()
3350 {
3351 }
3352
3353 void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
3354 {
3355   oss << "Profiles :\n";
3356   std::size_t n=_pfls.size();
3357   for(std::size_t i=0;i<n;i++)
3358     {
3359       oss << "  - #" << i << " ";
3360       const DataArrayInt *pfl=_pfls[i];
3361       if(pfl)
3362         oss << "\"" << pfl->getName() << "\"\n";
3363       else
3364         oss << "EMPTY !\n";
3365     }
3366   n=_locs.size();
3367   oss << "Localizations :\n";
3368   for(std::size_t i=0;i<n;i++)
3369     {
3370       oss << "  - #" << i << " ";
3371       const MEDFileFieldLoc *loc=_locs[i];
3372       if(loc)
3373         loc->simpleRepr(oss);
3374       else
3375         oss<< "EMPTY !\n";
3376     }
3377 }
3378
3379 void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3380 {
3381   for(std::vector< MCAuto<DataArrayInt> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
3382     {
3383       DataArrayInt *elt(*it);
3384       if(elt)
3385         {
3386           std::string name(elt->getName());
3387           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
3388             {
3389               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
3390                 {
3391                   elt->setName((*it2).second.c_str());
3392                   return;
3393                 }
3394             }
3395         }
3396     }
3397 }
3398
3399 void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3400 {
3401   for(std::vector< MCAuto<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
3402     {
3403       MEDFileFieldLoc *elt(*it);
3404       if(elt)
3405         {
3406           std::string name(elt->getName());
3407           for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
3408             {
3409               if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
3410                 {
3411                   elt->setName((*it2).second.c_str());
3412                   return;
3413                 }
3414             }
3415         }
3416     }
3417 }
3418
3419 int MEDFileFieldGlobs::getNbOfGaussPtPerCell(int locId) const
3420 {
3421   if(locId<0 || locId>=(int)_locs.size())
3422     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getNbOfGaussPtPerCell : Invalid localization id !");
3423   return _locs[locId]->getNbOfGaussPtPerCell();
3424 }
3425
3426 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const std::string& locName) const
3427 {
3428   return getLocalizationFromId(getLocalizationId(locName));
3429 }
3430
3431 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) const
3432 {
3433   if(locId<0 || locId>=(int)_locs.size())
3434     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
3435   return *_locs[locId];
3436 }
3437
3438 /// @cond INTERNAL
3439 namespace MEDCouplingImpl
3440 {
3441   class LocFinder
3442   {
3443   public:
3444     LocFinder(const std::string& loc):_loc(loc) { }
3445     bool operator() (const MCAuto<MEDFileFieldLoc>& loc) { return loc->isName(_loc); }
3446   private:
3447     const std::string &_loc;
3448   };
3449
3450   class PflFinder
3451   {
3452   public:
3453     PflFinder(const std::string& pfl):_pfl(pfl) { }
3454     bool operator() (const MCAuto<DataArrayInt>& pfl) { return _pfl==pfl->getName(); }
3455   private:
3456     const std::string& _pfl;
3457   };
3458 }
3459 /// @endcond
3460
3461 int MEDFileFieldGlobs::getLocalizationId(const std::string& loc) const
3462 {
3463   std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),MEDCouplingImpl::LocFinder(loc));
3464   if(it==_locs.end())
3465     {
3466       std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
3467       for(it=_locs.begin();it!=_locs.end();it++)
3468         oss << "\"" << (*it)->getName() << "\", ";
3469       throw INTERP_KERNEL::Exception(oss.str());
3470     }
3471   return std::distance(_locs.begin(),it);
3472 }
3473
3474 /*!
3475  * The returned value is never null.
3476  */
3477 const DataArrayInt *MEDFileFieldGlobs::getProfile(const std::string& pflName) const
3478 {
3479   std::string pflNameCpp(pflName);
3480   std::vector< MCAuto<DataArrayInt> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),MEDCouplingImpl::PflFinder(pflNameCpp));
3481   if(it==_pfls.end())
3482     {
3483       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
3484       for(it=_pfls.begin();it!=_pfls.end();it++)
3485         oss << "\"" << (*it)->getName() << "\", ";
3486       throw INTERP_KERNEL::Exception(oss.str());
3487     }
3488   return *it;
3489 }
3490
3491 const DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) const
3492 {
3493   if(pflId<0 || pflId>=(int)_pfls.size())
3494     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
3495   return _pfls[pflId];
3496 }
3497
3498 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId)
3499 {
3500   if(locId<0 || locId>=(int)_locs.size())
3501     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
3502   return *_locs[locId];
3503 }
3504
3505 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const std::string& locName)
3506 {
3507   return getLocalizationFromId(getLocalizationId(locName));
3508 }
3509
3510 /*!
3511  * The returned value is never null.
3512  */
3513 DataArrayInt *MEDFileFieldGlobs::getProfile(const std::string& pflName)
3514 {
3515   std::string pflNameCpp(pflName);
3516   std::vector< MCAuto<DataArrayInt> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),MEDCouplingImpl::PflFinder(pflNameCpp));
3517   if(it==_pfls.end())
3518     {
3519       std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
3520       for(it=_pfls.begin();it!=_pfls.end();it++)
3521         oss << "\"" << (*it)->getName() << "\", ";
3522       throw INTERP_KERNEL::Exception(oss.str());
3523     }
3524   return *it;
3525 }
3526
3527 DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId)
3528 {
3529   if(pflId<0 || pflId>=(int)_pfls.size())
3530     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
3531   return _pfls[pflId];
3532 }
3533
3534 void MEDFileFieldGlobs::killProfileIds(const std::vector<int>& pflIds)
3535 {
3536   std::vector< MCAuto<DataArrayInt> > newPfls;
3537   int i=0;
3538   for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
3539     {
3540       if(std::find(pflIds.begin(),pflIds.end(),i)==pflIds.end())
3541         newPfls.push_back(*it);
3542     }
3543   _pfls=newPfls;
3544 }
3545
3546 void MEDFileFieldGlobs::killLocalizationIds(const std::vector<int>& locIds)
3547 {
3548   std::vector< MCAuto<MEDFileFieldLoc> > newLocs;
3549   int i=0;
3550   for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
3551     {
3552       if(std::find(locIds.begin(),locIds.end(),i)==locIds.end())
3553         newLocs.push_back(*it);
3554     }
3555   _locs=newLocs;
3556 }
3557
3558 void MEDFileFieldGlobs::killStructureElementsInGlobs()
3559 {
3560   std::vector< MCAuto<MEDFileFieldLoc> > newLocs;
3561   for(std::vector< MCAuto<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
3562     {
3563       if((*it).isNull())
3564         continue;
3565       if(!(*it)->isOnStructureElement())
3566         newLocs.push_back(*it);
3567     }
3568   _locs=newLocs;
3569 }
3570
3571 std::vector<std::string> MEDFileFieldGlobs::getPfls() const
3572 {
3573   int sz=_pfls.size();
3574   std::vector<std::string> ret(sz);
3575   for(int i=0;i<sz;i++)
3576     ret[i]=_pfls[i]->getName();
3577   return ret;
3578 }
3579
3580 std::vector<std::string> MEDFileFieldGlobs::getLocs() const
3581 {
3582   int sz=_locs.size();
3583   std::vector<std::string> ret(sz);
3584   for(int i=0;i<sz;i++)
3585     ret[i]=_locs[i]->getName();
3586   return ret;
3587 }
3588
3589 bool MEDFileFieldGlobs::existsPfl(const std::string& pflName) const
3590 {
3591   std::vector<std::string> v=getPfls();
3592   std::string s(pflName);
3593   return std::find(v.begin(),v.end(),s)!=v.end();
3594 }
3595
3596 bool MEDFileFieldGlobs::existsLoc(const std::string& locName) const
3597 {
3598   std::vector<std::string> v=getLocs();
3599   std::string s(locName);
3600   return std::find(v.begin(),v.end(),s)!=v.end();
3601 }
3602
3603 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualProfiles() const
3604 {
3605   std::map<int,std::vector<int> > m;
3606   int i=0;
3607   for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
3608     {
3609       const DataArrayInt *tmp=(*it);
3610       if(tmp)
3611         {
3612           m[tmp->getHashCode()].push_back(i);
3613         }
3614     }
3615   std::vector< std::vector<int> > ret;
3616   for(std::map<int,std::vector<int> >::const_iterator it2=m.begin();it2!=m.end();it2++)
3617     {
3618       if((*it2).second.size()>1)
3619         {
3620           std::vector<int> ret0;
3621           bool equalityOrNot=false;
3622           for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
3623             {
3624               std::vector<int>::const_iterator it4=it3; it4++;
3625               for(;it4!=(*it2).second.end();it4++)
3626                 {
3627                   if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
3628                     {
3629                       if(!equalityOrNot)
3630                         ret0.push_back(*it3);
3631                       ret0.push_back(*it4);
3632                       equalityOrNot=true;
3633                     }
3634                 }
3635             }
3636           if(!ret0.empty())
3637             ret.push_back(ret0);
3638         }
3639     }
3640   return ret;
3641 }
3642
3643 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
3644 {
3645   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
3646 }
3647
3648 void MEDFileFieldGlobs::appendProfile(DataArrayInt *pfl)
3649 {
3650   std::string name(pfl->getName());
3651   if(name.empty())
3652     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
3653   for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
3654     if(name==(*it)->getName())
3655       {
3656         if(!pfl->isEqual(*(*it)))
3657           {
3658             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
3659             throw INTERP_KERNEL::Exception(oss.str());
3660           }
3661       }
3662   pfl->incrRef();
3663   _pfls.push_back(pfl);
3664 }
3665
3666 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)
3667 {
3668   std::string name(locName);
3669   if(name.empty())
3670     throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
3671   MCAuto<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
3672   for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
3673     if((*it)->isName(locName))
3674       {
3675         if(!(*it)->isEqual(*obj,1e-12))
3676           {
3677             std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
3678             throw INTERP_KERNEL::Exception(oss.str());
3679           }
3680       }
3681   _locs.push_back(obj);
3682 }
3683
3684 std::string MEDFileFieldGlobs::createNewNameOfPfl() const
3685 {
3686   std::vector<std::string> names=getPfls();
3687   return CreateNewNameNotIn("NewPfl_",names);
3688 }
3689
3690 std::string MEDFileFieldGlobs::createNewNameOfLoc() const
3691 {
3692   std::vector<std::string> names=getLocs();
3693   return CreateNewNameNotIn("NewLoc_",names);
3694 }
3695
3696 std::string MEDFileFieldGlobs::CreateNewNameNotIn(const std::string& prefix, const std::vector<std::string>& namesToAvoid)
3697 {
3698   for(std::size_t sz=0;sz<100000;sz++)
3699     {
3700       std::ostringstream tryName;
3701       tryName << prefix << sz;
3702       if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tryName.str())==namesToAvoid.end())
3703         return tryName.str();
3704     }
3705   throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::CreateNewNameNotIn : impossible to create an additional profile limit of 100000 profiles reached !");
3706 }
3707
3708 /*!
3709  * Creates a MEDFileFieldGlobsReal on a given file name. Nothing is read here.
3710  *  \param [in] fname - the file name.
3711  */
3712 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal(med_idt fid):_globals(MEDFileFieldGlobs::New(fid))
3713 {
3714 }
3715
3716 /*!
3717  * Creates an empty MEDFileFieldGlobsReal.
3718  */
3719 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal():_globals(MEDFileFieldGlobs::New())
3720 {
3721 }
3722
3723 std::size_t MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren() const
3724 {
3725   return 0;
3726 }
3727
3728 std::vector<const BigMemoryObject *> MEDFileFieldGlobsReal::getDirectChildrenWithNull() const
3729 {
3730   std::vector<const BigMemoryObject *> ret;
3731   ret.push_back((const MEDFileFieldGlobs *)_globals);
3732   return ret;
3733 }
3734
3735 /*!
3736  * Returns a string describing profiles and Gauss points held in \a this.
3737  *  \return std::string - the description string.
3738  */
3739 void MEDFileFieldGlobsReal::simpleReprGlobs(std::ostream& oss) const
3740 {
3741   const MEDFileFieldGlobs *glob=_globals;
3742   std::ostringstream oss2; oss2 << glob;
3743   std::string stars(oss2.str().length(),'*');
3744   oss << "Globals information on fields (at " << oss2.str() << "):" << "\n************************************" << stars  << "\n\n";
3745   if(glob)
3746     glob->simpleRepr(oss);
3747   else
3748     oss << "NO GLOBAL INFORMATION !\n";
3749 }
3750
3751 void MEDFileFieldGlobsReal::resetContent()
3752 {
3753   _globals=MEDFileFieldGlobs::New();
3754 }
3755
3756 void MEDFileFieldGlobsReal::killStructureElementsInGlobs()
3757 {
3758   contentNotNull()->killStructureElementsInGlobs();
3759 }
3760
3761 MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
3762 {
3763 }
3764
3765 /*!
3766  * Copies references to profiles and Gauss points from another MEDFileFieldGlobsReal.
3767  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3768  */
3769 void MEDFileFieldGlobsReal::shallowCpyGlobs(const MEDFileFieldGlobsReal& other)
3770 {
3771   _globals=other._globals;
3772 }
3773
3774 /*!
3775  * Copies references to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3776  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3777  */
3778 void MEDFileFieldGlobsReal::shallowCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3779 {
3780   const MEDFileFieldGlobs *otherg(other._globals);
3781   if(!otherg)
3782     return ;
3783   _globals=otherg->shallowCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3784 }
3785
3786 /*!
3787  * Copies deeply to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3788  *  \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3789  */
3790 void MEDFileFieldGlobsReal::deepCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3791 {
3792   const MEDFileFieldGlobs *otherg(other._globals);
3793   if(!otherg)
3794     return ;
3795   _globals=otherg->deepCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3796 }
3797
3798 void MEDFileFieldGlobsReal::deepCpyGlobs(const MEDFileFieldGlobsReal& other)
3799 {
3800   _globals=other._globals;
3801   if((const MEDFileFieldGlobs *)_globals)
3802     _globals=other._globals->deepCopy();
3803 }
3804
3805 /*!
3806  * Adds profiles and Gauss points held by another MEDFileFieldGlobsReal to \a this one.
3807  *  \param [in] other - the MEDFileFieldGlobsReal to copy data from.
3808  *  \param [in] eps - a precision used to compare Gauss points with same name held by
3809  *         \a this and \a other MEDFileFieldGlobsReal.
3810  *  \throw If \a this and \a other hold profiles with equal names but different ids.
3811  *  \throw If  \a this and \a other hold different Gauss points with equal names.
3812  */
3813 void MEDFileFieldGlobsReal::appendGlobs(const MEDFileFieldGlobsReal& other, double eps)
3814 {
3815   const MEDFileFieldGlobs *thisGlobals(_globals),*otherGlobals(other._globals);
3816   if(thisGlobals==otherGlobals)
3817     return ;
3818   if(!thisGlobals)
3819     {
3820       _globals=other._globals;
3821       return ;
3822     }
3823   _globals->appendGlobs(*other._globals,eps);
3824 }
3825
3826 void MEDFileFieldGlobsReal::checkGlobsCoherency() const
3827 {
3828   checkGlobsPflsPartCoherency();
3829   checkGlobsLocsPartCoherency();
3830 }
3831
3832 void MEDFileFieldGlobsReal::checkGlobsPflsPartCoherency() const
3833 {
3834   contentNotNull()->checkGlobsPflsPartCoherency(getPflsReallyUsed());
3835 }
3836
3837 void MEDFileFieldGlobsReal::checkGlobsLocsPartCoherency() const
3838 {
3839   contentNotNull()->checkGlobsLocsPartCoherency(getLocsReallyUsed());
3840 }
3841
3842 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id, const std::string& pflName)
3843 {
3844   contentNotNull()->loadProfileInFile(fid,id,pflName);
3845 }
3846
3847 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id)
3848 {
3849   contentNotNull()->loadProfileInFile(fid,id);
3850 }
3851
3852 void MEDFileFieldGlobsReal::loadGlobals(med_idt fid)
3853 {
3854   contentNotNull()->loadGlobals(fid,*this);
3855 }
3856
3857 void MEDFileFieldGlobsReal::loadAllGlobals(med_idt fid, const MEDFileEntities *entities)
3858 {
3859   contentNotNull()->loadAllGlobals(fid,entities);
3860 }
3861
3862 void MEDFileFieldGlobsReal::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
3863 {
3864   contentNotNull()->writeGlobals(fid,opt);
3865 }
3866
3867 /*!
3868  * Returns names of all profiles. To get only used profiles call getPflsReallyUsed()
3869  * or getPflsReallyUsedMulti().
3870  *  \return std::vector<std::string> - a sequence of names of all profiles.
3871  */
3872 std::vector<std::string> MEDFileFieldGlobsReal::getPfls() const
3873 {
3874   return contentNotNull()->getPfls();
3875 }
3876
3877 /*!
3878  * Returns names of all localizations. To get only used localizations call getLocsReallyUsed()
3879  * or getLocsReallyUsedMulti().
3880  *  \return std::vector<std::string> - a sequence of names of all localizations.
3881  */
3882 std::vector<std::string> MEDFileFieldGlobsReal::getLocs() const
3883 {
3884   return contentNotNull()->getLocs();
3885 }
3886
3887 /*!
3888  * Checks if the profile with a given name exists.
3889  *  \param [in] pflName - the profile name of interest.
3890  *  \return bool - \c true if the profile named \a pflName exists.
3891  */
3892 bool MEDFileFieldGlobsReal::existsPfl(const std::string& pflName) const
3893 {
3894   return contentNotNull()->existsPfl(pflName);
3895 }
3896
3897 /*!
3898  * Checks if the localization with a given name exists.
3899  *  \param [in] locName - the localization name of interest.
3900  *  \return bool - \c true if the localization named \a locName exists.
3901  */
3902 bool MEDFileFieldGlobsReal::existsLoc(const std::string& locName) const
3903 {
3904   return contentNotNull()->existsLoc(locName);
3905 }
3906
3907 std::string MEDFileFieldGlobsReal::createNewNameOfPfl() const
3908 {
3909   return contentNotNull()->createNewNameOfPfl();
3910 }
3911
3912 std::string MEDFileFieldGlobsReal::createNewNameOfLoc() const
3913 {
3914   return contentNotNull()->createNewNameOfLoc();
3915 }
3916
3917 /*!
3918  * Sets the name of a MED file.
3919  *  \param [inout] fileName - the file name.
3920  */
3921 void MEDFileFieldGlobsReal::setFileName(const std::string& fileName)
3922 {
3923   contentNotNull()->setFileName(fileName);
3924 }
3925
3926 /*!
3927  * Finds equal profiles. Two profiles are considered equal if they contain the same ids
3928  * in the same order.
3929  *  \return std::vector< std::vector<int> > - a sequence of groups of equal profiles.
3930  *          Each item of this sequence is a vector containing ids of equal profiles.
3931  */
3932 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualProfiles() const
3933 {
3934   return contentNotNull()->whichAreEqualProfiles();
3935 }
3936
3937 /*!
3938  * Finds equal localizations.
3939  *  \param [in] eps - a precision used to compare real values of the localizations.
3940  *  \return std::vector< std::vector<int> > - a sequence of groups of equal localizations.
3941  *          Each item of this sequence is a vector containing ids of equal localizations.
3942  */
3943 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualLocs(double eps) const
3944 {
3945   return contentNotNull()->whichAreEqualLocs(eps);
3946 }
3947
3948 /*!
3949  * Renames the profiles. References to profiles (a reference is a profile name) are not changed.
3950  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3951  *        this sequence is a pair whose
3952  *        - the first item is a vector of profile names to replace by the second item,
3953  *        - the second item is a profile name to replace every profile name of the first item.
3954  */
3955 void MEDFileFieldGlobsReal::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3956 {
3957   contentNotNull()->changePflsNamesInStruct(mapOfModif);
3958 }
3959
3960 /*!
3961  * Renames the localizations. References to localizations (a reference is a localization name) are not changed.
3962  * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3963  *        this sequence is a pair whose
3964  *        - the first item is a vector of localization names to replace by the second item,
3965  *        - the second item is a localization name to replace every localization name of the first item.
3966  */
3967 void MEDFileFieldGlobsReal::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3968 {
3969   contentNotNull()->changeLocsNamesInStruct(mapOfModif);
3970 }
3971
3972 /*!
3973  * Replaces references to some profiles (a reference is a profile name) by references
3974  * to other profiles and, contrary to changePflsRefsNamesGen(), renames the profiles
3975  * them-selves accordingly. <br>
3976  * This method is a generalization of changePflName().
3977  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3978  *        this sequence is a pair whose
3979  *        - the first item is a vector of profile names to replace by the second item,
3980  *        - the second item is a profile name to replace every profile of the first item.
3981  * \sa changePflsRefsNamesGen()
3982  * \sa changePflName()
3983  */
3984 void MEDFileFieldGlobsReal::changePflsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3985 {
3986   changePflsRefsNamesGen(mapOfModif);
3987   changePflsNamesInStruct(mapOfModif);
3988 }
3989
3990 /*!
3991  * Replaces references to some localizations (a reference is a localization name) by references
3992  * to other localizations and, contrary to changeLocsRefsNamesGen(), renames the localizations
3993  * them-selves accordingly. <br>
3994  * This method is a generalization of changeLocName().
3995  * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3996  *        this sequence is a pair whose
3997  *        - the first item is a vector of localization names to replace by the second item,
3998  *        - the second item is a localization name to replace every localization of the first item.
3999  * \sa changeLocsRefsNamesGen()
4000  * \sa changeLocName()
4001  */
4002 void MEDFileFieldGlobsReal::changeLocsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
4003 {
4004   changeLocsRefsNamesGen(mapOfModif);
4005   changeLocsNamesInStruct(mapOfModif);
4006 }
4007
4008 /*!
4009  * Renames the profile having a given name and updates references to this profile.
4010  *  \param [in] oldName - the name of the profile to rename.
4011  *  \param [in] newName - a new name of the profile.
4012  * \sa changePflsNames().
4013  */
4014 void MEDFileFieldGlobsReal::changePflName(const std::string& oldName, const std::string& newName)
4015 {
4016   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
4017   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
4018   mapOfModif[0]=p;
4019   changePflsNames(mapOfModif);
4020 }
4021
4022 /*!
4023  * Renames the localization having a given name and updates references to this localization.
4024  *  \param [in] oldName - the name of the localization to rename.
4025  *  \param [in] newName - a new name of the localization.
4026  * \sa changeLocsNames().
4027  */
4028 void MEDFileFieldGlobsReal::changeLocName(const std::string& oldName, const std::string& newName)
4029 {
4030   std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
4031   std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
4032   mapOfModif[0]=p;
4033   changeLocsNames(mapOfModif);
4034 }
4035
4036 /*!
4037  * Removes duplicated profiles. Returns a map used to update references to removed
4038  * profiles via changePflsRefsNamesGen().
4039  * Equal profiles are found using whichAreEqualProfiles().
4040  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
4041  *          a sequence describing the performed replacements of profiles. Each element of
4042  *          this sequence is a pair whose
4043  *          - the first item is a vector of profile names replaced by the second item,
4044  *          - the second item is a profile name replacing every profile of the first item.
4045  */
4046 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipPflsNames()
4047 {
4048   std::vector< std::vector<int> > pseudoRet=whichAreEqualProfiles();
4049   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
4050   int i=0;
4051   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
4052     {
4053       std::vector< std::string > tmp((*it).size());
4054       int j=0;
4055       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
4056         tmp[j]=std::string(getProfileFromId(*it2)->getName());
4057       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
4058       ret[i]=p;
4059       std::vector<int> tmp2((*it).begin()+1,(*it).end());
4060       killProfileIds(tmp2);
4061     }
4062   changePflsRefsNamesGen(ret);
4063   return ret;
4064 }
4065
4066 /*!
4067  * Removes duplicated localizations. Returns a map used to update references to removed
4068  * localizations via changeLocsRefsNamesGen().
4069  * Equal localizations are found using whichAreEqualLocs().
4070  *  \param [in] eps - a precision used to compare real values of the localizations.
4071  *  \return std::vector< std::pair<std::vector<std::string>, std::string > > -
4072  *          a sequence describing the performed replacements of localizations. Each element of
4073  *          this sequence is a pair whose
4074  *          - the first item is a vector of localization names replaced by the second item,
4075  *          - the second item is a localization name replacing every localization of the first item.
4076  */
4077 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipLocsNames(double eps)
4078 {
4079   std::vector< std::vector<int> > pseudoRet=whichAreEqualLocs(eps);
4080   std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
4081   int i=0;
4082   for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
4083     {
4084       std::vector< std::string > tmp((*it).size());
4085       int j=0;
4086       for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
4087         tmp[j]=std::string(getLocalizationFromId(*it2).getName());
4088       std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
4089       ret[i]=p;
4090       std::vector<int> tmp2((*it).begin()+1,(*it).end());
4091       killLocalizationIds(tmp2);
4092     }
4093   changeLocsRefsNamesGen(ret);
4094   return ret;
4095 }
4096
4097 /*!
4098  * Returns number of Gauss points per cell in a given localization.
4099  *  \param [in] locId - an id of the localization of interest.
4100  *  \return int - the number of the Gauss points per cell.
4101  */
4102 int MEDFileFieldGlobsReal::getNbOfGaussPtPerCell(int locId) const
4103 {
4104   return contentNotNull()->getNbOfGaussPtPerCell(locId);
4105 }
4106
4107 /*!
4108  * Returns an id of a localization by its name.
4109  *  \param [in] loc - the localization name of interest.
4110  *  \return int - the id of the localization.
4111  *  \throw If there is no a localization named \a loc.
4112  */
4113 int MEDFileFieldGlobsReal::getLocalizationId(const std::string& loc) const
4114 {
4115   return contentNotNull()->getLocalizationId(loc);
4116 }
4117
4118 /*!
4119  * Returns the name of the MED file.
4120  *  \return const std::string&  - the MED file name.
4121  */
4122 std::string MEDFileFieldGlobsReal::getFileName() const
4123 {
4124   return contentNotNull()->getFileName();
4125 }
4126
4127 /*!
4128  * Returns a localization object by its name.
4129  *  \param [in] locName - the name of the localization of interest.
4130  *  \return const MEDFileFieldLoc& - the localization object having the name \a locName.
4131  *  \throw If there is no a localization named \a locName.
4132  */
4133 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const std::string& locName) const
4134 {
4135   return contentNotNull()->getLocalization(locName);
4136 }
4137
4138 /*!
4139  * Returns a localization object by its id.
4140  *  \param [in] locId - the id of the localization of interest.
4141  *  \return const MEDFileFieldLoc& - the localization object having the id \a locId.
4142  *  \throw If there is no a localization with id \a locId.
4143  */
4144 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) const
4145 {
4146   return contentNotNull()->getLocalizationFromId(locId);
4147 }
4148
4149 /*!
4150  * Returns a profile array by its name.
4151  *  \param [in] pflName - the name of the profile of interest.
4152  *  \return const DataArrayInt * - the profile array having the name \a pflName.
4153  *  \throw If there is no a profile named \a pflName.
4154  */
4155 const DataArrayInt *MEDFileFieldGlobsReal::getProfile(const std::string& pflName) const
4156 {
4157   return contentNotNull()->getProfile(pflName);
4158 }
4159
4160 /*!
4161  * Returns a profile array by its id.
4162  *  \param [in] pflId - the id of the profile of interest.
4163  *  \return const DataArrayInt * - the profile array having the id \a pflId.
4164  *  \throw If there is no a profile with id \a pflId.
4165  */
4166 const DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) const
4167 {
4168   return contentNotNull()->getProfileFromId(pflId);
4169 }
4170
4171 /*!
4172  * Returns a localization object, apt for modification, by its id.
4173  *  \param [in] locId - the id of the localization of interest.
4174  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
4175  *          having the id \a locId.
4176  *  \throw If there is no a localization with id \a locId.
4177  */
4178 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId)
4179 {
4180   return contentNotNull()->getLocalizationFromId(locId);
4181 }
4182
4183 /*!
4184  * Returns a localization object, apt for modification, by its name.
4185  *  \param [in] locName - the name of the localization of interest.
4186  *  \return MEDFileFieldLoc& - a non-const reference to the localization object
4187  *          having the name \a locName.
4188  *  \throw If there is no a localization named \a locName.
4189  */
4190 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const std::string& locName)
4191 {
4192   return contentNotNull()->getLocalization(locName);
4193 }
4194
4195 /*!
4196  * Returns a profile array, apt for modification, by its name.
4197  *  \param [in] pflName - the name of the profile of interest.
4198  *  \return DataArrayInt * - a non-const pointer to the profile array having the name \a pflName.
4199  *  \throw If there is no a profile named \a pflName.
4200  */
4201 DataArrayInt *MEDFileFieldGlobsReal::getProfile(const std::string& pflName)
4202 {
4203   return contentNotNull()->getProfile(pflName);
4204 }
4205
4206 /*!
4207  * Returns a profile array, apt for modification, by its id.
4208  *  \param [in] pflId - the id of the profile of interest.
4209  *  \return DataArrayInt * - a non-const pointer to the profile array having the id \a pflId.
4210  *  \throw If there is no a profile with id \a pflId.
4211  */
4212 DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId)
4213 {
4214   return contentNotNull()->getProfileFromId(pflId);
4215 }
4216
4217 /*!
4218  * Removes profiles given by their ids. No data is updated to track this removal.
4219  *  \param [in] pflIds - a sequence of ids of the profiles to remove.
4220  */
4221 void MEDFileFieldGlobsReal::killProfileIds(const std::vector<int>& pflIds)
4222 {
4223   contentNotNull()->killProfileIds(pflIds);
4224 }
4225
4226 /*!
4227  * Removes localizations given by their ids. No data is updated to track this removal.
4228  *  \param [in] locIds - a sequence of ids of the localizations to remove.
4229  */
4230 void MEDFileFieldGlobsReal::killLocalizationIds(const std::vector<int>& locIds)
4231 {
4232   contentNotNull()->killLocalizationIds(locIds);
4233 }
4234
4235 /*!
4236  * Stores a profile array.
4237  *  \param [in] pfl - the profile array to store.
4238  *  \throw If the name of \a pfl is empty.
4239  *  \throw If a profile with the same name as that of \a pfl already exists but contains
4240  *         different ids.
4241  */
4242 void MEDFileFieldGlobsReal::appendProfile(DataArrayInt *pfl)
4243 {
4244   contentNotNull()->appendProfile(pfl);
4245 }
4246
4247 /*!
4248  * Adds a new localization of Gauss points.
4249  *  \param [in] locName - the name of the new localization.
4250  *  \param [in] geoType - a geometrical type of the reference cell.
4251  *  \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
4252  *         must be \c nbOfNodesPerCell * \c dimOfType.
4253  *  \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
4254  *         must be  _wg_.size() * \c dimOfType.
4255  *  \param [in] w - the weights of Gauss points.
4256  *  \throw If \a locName is empty.
4257  *  \throw If a localization with the name \a locName already exists but is
4258  *         different form the new one.
4259  */
4260 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)
4261 {
4262   contentNotNull()->appendLoc(locName,geoType,refCoo,gsCoo,w);
4263 }
4264
4265 MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull()
4266 {
4267   MEDFileFieldGlobs *g(_globals);
4268   if(!g)
4269     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in not const !");
4270   return g;
4271 }
4272
4273 const MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() const
4274 {
4275   const MEDFileFieldGlobs *g(_globals);
4276   if(!g)
4277     throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in const !");
4278   return g;
4279 }
4280
4281 //= MEDFileFieldNameScope
4282
4283 MEDFileFieldNameScope::MEDFileFieldNameScope()
4284 {
4285 }
4286
4287 MEDFileFieldNameScope::MEDFileFieldNameScope(const std::string& fieldName, const std::string& meshName):_name(fieldName),_mesh_name(meshName)
4288 {
4289 }
4290
4291 /*!
4292  * Returns the name of \a this field.
4293  *  \return std::string - a string containing the field name.
4294  */
4295 std::string MEDFileFieldNameScope::getName() const
4296 {
4297   return _name;
4298 }
4299
4300 /*!
4301  * Sets name of \a this field
4302  *  \param [in] name - the new field name.
4303  */
4304 void MEDFileFieldNameScope::setName(const std::string& fieldName)
4305 {
4306   _name=fieldName;
4307 }
4308
4309 std::string MEDFileFieldNameScope::getDtUnit() const
4310 {
4311   return _dt_unit;
4312 }
4313
4314 void MEDFileFieldNameScope::setDtUnit(const std::string& dtUnit)
4315 {
4316   _dt_unit=dtUnit;
4317 }
4318
4319 void MEDFileFieldNameScope::copyNameScope(const MEDFileFieldNameScope& other)
4320 {
4321   _name=other._name;
4322   _mesh_name=other._mesh_name;
4323   _dt_unit=other._dt_unit;
4324 }
4325
4326 /*!
4327  * Returns the mesh name.
4328  *  \return std::string - a string holding the mesh name.
4329  *  \throw If \c _field_per_mesh.empty()
4330  */
4331 std::string MEDFileFieldNameScope::getMeshName() const
4332 {
4333   return _mesh_name;
4334 }
4335
4336 void MEDFileFieldNameScope::setMeshName(const std::string& meshName)
4337 {
4338   _mesh_name=meshName;
4339 }
4340
4341 //= MEDFileAnyTypeField1TSWithoutSDA
4342
4343 void MEDFileAnyTypeField1TSWithoutSDA::deepCpyLeavesFrom(const MEDFileAnyTypeField1TSWithoutSDA& other)
4344 {
4345   _field_per_mesh.resize(other._field_per_mesh.size());
4346   std::size_t i=0;
4347   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
4348     {
4349       if((const MEDFileFieldPerMesh *)*it)
4350         _field_per_mesh[i]=(*it)->deepCopy(this);
4351     }
4352 }
4353
4354 void MEDFileAnyTypeField1TSWithoutSDA::accept(MEDFileFieldVisitor& visitor) const
4355 {
4356   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4357     if((*it).isNotNull())
4358       {
4359         visitor.newMeshEntry(*it);
4360         (*it)->accept(visitor);
4361         visitor.endMeshEntry(*it);
4362       }
4363 }
4364
4365 /*!
4366  * Prints a string describing \a this field into a stream. This string is outputted
4367  * by \c print Python command.
4368  *  \param [in] bkOffset - number of white spaces printed at the beginning of each line.
4369  *  \param [in,out] oss - the out stream.
4370  *  \param [in] f1tsId - the field index within a MED file. If \a f1tsId < 0, the tiny
4371  *          info id printed, else, not.
4372  */
4373 void MEDFileAnyTypeField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
4374 {
4375   std::string startOfLine(bkOffset,' ');
4376   oss << startOfLine << "Field ";
4377   if(bkOffset==0)
4378     oss << "[Type=" << getTypeStr() << "] with name \"" << getName() << "\" ";
4379   oss << "on one time Step ";
4380   if(f1tsId>=0)
4381     oss << "(" << f1tsId << ") ";
4382   oss << "on iteration=" << _iteration << " order=" << _order << "." << std::endl;
4383   oss << startOfLine << "Time attached is : " << _dt << " [" << _dt_unit << "]." << std::endl;
4384   const DataArray *arr=getUndergroundDataArray();
4385   if(arr)
4386     {
4387       const std::vector<std::string> &comps=arr->getInfoOnComponents();
4388       if(f1tsId<0)
4389         {
4390           oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
4391           for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
4392             oss << startOfLine << "  -  \"" << (*it) << "\"" << std::endl;
4393         }
4394       if(arr->isAllocated())
4395         {
4396           oss << startOfLine << "Whole field contains " << arr->getNumberOfTuples() << " tuples." << std::endl;
4397         }
4398       else
4399         oss << startOfLine << "The array of the current field has not allocated yet !" << std::endl;
4400     }
4401   else
4402     {
4403       oss << startOfLine << "Field infos are empty ! Not defined yet !" << std::endl;
4404     }
4405   oss << startOfLine << "----------------------" << std::endl;
4406   if(!_field_per_mesh.empty())
4407     {
4408       int i=0;
4409       for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
4410         {
4411           const MEDFileFieldPerMesh *cur=(*it2);
4412           if(cur)
4413             cur->simpleRepr(bkOffset,oss,i);
4414           else
4415             oss << startOfLine << "Field per mesh #" << i << " is not defined !" << std::endl;
4416         }
4417     }
4418   else
4419     {
4420       oss << startOfLine << "Field is not defined on any meshes !" << std::endl;
4421     }
4422   oss << startOfLine << "----------------------" << std::endl;
4423 }
4424
4425 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitComponents() const
4426 {
4427   const DataArray *arr(getUndergroundDataArray());
4428   if(!arr)
4429     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitComponents : no array defined !");
4430   int nbOfCompo=arr->getNumberOfComponents();
4431   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfCompo);
4432   for(int i=0;i<nbOfCompo;i++)
4433     {
4434       ret[i]=deepCopy();
4435       std::vector<int> v(1,i);
4436       MCAuto<DataArray> arr2=arr->keepSelectedComponents(v);
4437       ret[i]->setArray(arr2);
4438     }
4439   return ret;
4440 }
4441
4442 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order):MEDFileFieldNameScope(fieldName,meshName),_iteration(iteration),_order(order),_csit(csit),_nb_of_tuples_to_be_allocated(-2)
4443 {
4444 }
4445
4446 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA():_iteration(-1),_order(-1),_dt(0.),_csit(-1),_nb_of_tuples_to_be_allocated(-1)
4447 {
4448 }
4449
4450 /*!
4451  * Returns the maximal dimension of supporting elements. Returns -2 if \a this is
4452  * empty. Returns -1 if this in on nodes.
4453  *  \return int - the dimension of \a this.
4454  */
4455 int MEDFileAnyTypeField1TSWithoutSDA::getDimension() const
4456 {
4457   int ret=-2;
4458   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4459     (*it)->getDimension(ret);
4460   return ret;
4461 }
4462
4463 bool MEDFileAnyTypeField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
4464 {
4465   bool ret=false;
4466   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4467     {
4468       MEDFileFieldPerMesh *cur(*it);
4469       if(cur)
4470         ret=cur->changeMeshNames(modifTab) || ret;
4471     }
4472   return ret;
4473 }
4474
4475 /*!
4476  * Returns the number of iteration of the state of underlying mesh.
4477  *  \return int - the iteration number.
4478  *  \throw If \c _field_per_mesh.empty()
4479  */
4480 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIteration() const
4481 {
4482   if(_field_per_mesh.empty())
4483     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshIteration : No field set !");
4484   return _field_per_mesh[0]->getMeshIteration();
4485 }
4486
4487 /*!
4488  * Returns the order number of iteration of the state of underlying mesh.
4489  *  \return int - the order number.
4490  *  \throw If \c _field_per_mesh.empty()
4491  */
4492 int MEDFileAnyTypeField1TSWithoutSDA::getMeshOrder() const
4493 {
4494   if(_field_per_mesh.empty())
4495     throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshOrder : No field set !");
4496   return _field_per_mesh[0]->getMeshOrder();
4497 }
4498
4499 /*!
4500  * Checks if \a this field is tagged by a given iteration number and a given
4501  * iteration order number.
4502  *  \param [in] iteration - the iteration number of interest.
4503  *  \param [in] order - the iteration order number of interest.
4504  *  \return bool - \c true if \a this->getIteration() == \a iteration &&
4505  *          \a this->getOrder() == \a order.
4506  */
4507 bool MEDFileAnyTypeField1TSWithoutSDA::isDealingTS(int iteration, int order) const
4508 {
4509   return iteration==_iteration && order==_order;
4510 }
4511
4512 /*!
4513  * Returns number of iteration and order number of iteration when
4514  * \a this field has been calculated.
4515  *  \return std::pair<int,int> - a pair of the iteration number and the iteration
4516  *          order number.
4517  */
4518 std::pair<int,int> MEDFileAnyTypeField1TSWithoutSDA::getDtIt() const
4519 {
4520   std::pair<int,int> p;
4521   fillIteration(p);
4522   return p;
4523 }
4524
4525 /*!
4526  * Returns number of iteration and order number of iteration when
4527  * \a this field has been calculated.
4528  *  \param [in,out] p - a pair returning the iteration number and the iteration
4529  *          order number.
4530  */
4531 void MEDFileAnyTypeField1TSWithoutSDA::fillIteration(std::pair<int,int>& p) const
4532 {
4533   p.first=_iteration;
4534   p.second=_order;
4535 }
4536
4537 /*!
4538  * Returns all types of spatial discretization of \a this field.
4539  *  \param [in,out] types - a sequence of types of \a this field.
4540  */
4541 void MEDFileAnyTypeField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
4542 {
4543   std::set<TypeOfField> types2;
4544   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4545     {
4546       (*it)->fillTypesOfFieldAvailable(types2);
4547     }
4548   std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
4549   std::copy(types2.begin(),types2.end(),bi);
4550 }
4551
4552 /*!
4553  * Returns all types of spatial discretization of \a this field.
4554  *  \return std::vector<TypeOfField> - a sequence of types of spatial discretization
4555  *          of \a this field.
4556  */
4557 std::vector<TypeOfField> MEDFileAnyTypeField1TSWithoutSDA::getTypesOfFieldAvailable() const
4558 {
4559   std::vector<TypeOfField> ret;
4560   fillTypesOfFieldAvailable(ret);
4561   return ret;
4562 }
4563
4564 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsed2() const
4565 {
4566   std::vector<std::string> ret;
4567   std::set<std::string> ret2;
4568   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4569     {
4570       std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
4571       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
4572         if(ret2.find(*it2)==ret2.end())
4573           {
4574             ret.push_back(*it2);
4575             ret2.insert(*it2);
4576           }
4577     }
4578   return ret;
4579 }
4580
4581 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsed2() const
4582 {
4583   std::vector<std::string> ret;
4584   std::set<std::string> ret2;
4585   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4586     {
4587       std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
4588       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
4589         if(ret2.find(*it2)==ret2.end())
4590           {
4591             ret.push_back(*it2);
4592             ret2.insert(*it2);
4593           }
4594     }
4595   return ret;
4596 }
4597
4598 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsedMulti2() const
4599 {
4600   std::vector<std::string> ret;
4601   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4602     {
4603       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
4604       ret.insert(ret.end(),tmp.begin(),tmp.end());
4605     }
4606   return ret;
4607 }
4608
4609 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsedMulti2() const
4610 {
4611   std::vector<std::string> ret;
4612   std::set<std::string> ret2;
4613   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4614     {
4615       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
4616       ret.insert(ret.end(),tmp.begin(),tmp.end());
4617     }
4618   return ret;
4619 }
4620
4621 void MEDFileAnyTypeField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
4622 {
4623   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4624     (*it)->changePflsRefsNamesGen(mapOfModif);
4625 }
4626
4627 void MEDFileAnyTypeField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
4628 {
4629   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4630     (*it)->changeLocsRefsNamesGen(mapOfModif);
4631 }
4632
4633 /*!
4634  * Returns all attributes of parts of \a this field lying on a given mesh.
4635  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
4636  * item of every of returned sequences refers to the _i_-th part of \a this field.
4637  * Thus all sequences returned by this method are of the same length equal to number
4638  * of different types of supporting entities.<br>
4639  * A field part can include sub-parts with several different spatial discretizations,
4640  * \ref MEDCoupling::ON_CELLS "ON_CELLS" and \ref MEDCoupling::ON_GAUSS_PT "ON_GAUSS_PT"
4641  * for example. Hence, some of the returned sequences contains nested sequences, and an item
4642  * of a nested sequence corresponds to a type of spatial discretization.<br>
4643  * This method allows for iteration over MEDFile DataStructure without any overhead.
4644  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4645  *          for the case with only one underlying mesh. (Actually, the number of meshes is
4646  *          not checked if \a mname == \c NULL).
4647  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
4648  *          a field part is returned.
4649  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
4650  *          This sequence is of the same length as \a types.
4651  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
4652  *          discretization. A profile name can be empty.
4653  *          Length of this and of nested sequences is the same as that of \a typesF.
4654  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
4655  *          discretization. A localization name can be empty.
4656  *          Length of this and of nested sequences is the same as that of \a typesF.
4657  *  \return std::vector< std::vector< std::pair<int,int> > > - a sequence holding a range
4658  *          of ids of tuples within the data array, per each type of spatial
4659  *          discretization within one mesh entity type.
4660  *          Length of this and of nested sequences is the same as that of \a typesF.
4661  *  \throw If no field is lying on \a mname.
4662  */
4663 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
4664 {
4665   if(_field_per_mesh.empty())
4666     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
4667   return _field_per_mesh[0]->getFieldSplitedByType(types,typesF,pfls,locs);
4668 }
4669
4670 /*!
4671  * Returns dimensions of mesh elements \a this field lies on. The returned value is a
4672  * maximal absolute dimension and values returned via the out parameter \a levs are
4673  * dimensions relative to the maximal absolute dimension. <br>
4674  * This method is designed for MEDFileField1TS instances that have a discretization
4675  * \ref MEDCoupling::ON_CELLS "ON_CELLS",
4676  * \ref MEDCoupling::ON_GAUSS_PT "ON_GAUSS_PT",
4677  * \ref MEDCoupling::ON_GAUSS_NE "ON_GAUSS_NE".
4678  * Only these 3 discretizations will be taken into account here. If \a this is
4679  * \ref MEDCoupling::ON_NODES "ON_NODES", -1 is returned and \a levs are empty.<br>
4680  * This method is useful to make the link between the dimension of the underlying mesh
4681  * and the levels of \a this, because it is possible that the highest dimension of \a this
4682  * field is not equal to the dimension of the underlying mesh.
4683  *
4684  * Let's consider the following case:
4685  * - mesh \a m1 has a meshDimension 3 and has non empty levels [0,-1,-2] with elements
4686  * TETRA4, HEXA8, TRI3 and SEG2.
4687  * - field \a f1 lies on \a m1 and is defined on 3D and 1D elements TETRA4 and SEG2.
4688  * - field \a f2 lies on \a m1 and is defined on 2D and 1D elements TRI3 and SEG2.
4689  *
4690  * In this case \a f1->getNonEmptyLevels() returns (3,[0,-2]) and \a
4691  * f2->getNonEmptyLevels() returns (2,[0,-1]). <br>
4692  * The returned values can be used for example to retrieve a MEDCouplingFieldDouble lying
4693  * on elements of a certain relative level by calling getFieldAtLevel(). \a meshDimRelToMax
4694  * parameter of getFieldAtLevel() is computed basing on the returned values as this:
4695  * <em> meshDimRelToMax = absDim - meshDim + relativeLev </em>.
4696  * For example<br>
4697  * to retrieve the highest level of
4698  * \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+0 ); // absDim - meshDim + relativeLev</em><br>
4699  * to retrieve the lowest level of \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+(-2) );</em><br>
4700  * to retrieve the highest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+0 );</em><br>
4701  * to retrieve the lowest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+(-1) )</em>.
4702  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4703  *          for the case with only one underlying mesh. (Actually, the number of meshes is
4704  *          not checked if \a mname == \c NULL).
4705  *  \param [in,out] levs - a sequence returning the dimensions relative to the maximal
4706  *          absolute one. They are in decreasing order. This sequence is cleared before
4707  *          filling it in.
4708  *  \return int - the maximal absolute dimension of elements \a this fields lies on.
4709  *  \throw If no field is lying on \a mname.
4710  */
4711 int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
4712 {
4713   levs.clear();
4714   std::vector<INTERP_KERNEL::NormalizedCellType> types;
4715   std::vector< std::vector<TypeOfField> > typesF;
4716   std::vector< std::vector<std::string> > pfls, locs;
4717   if(_field_per_mesh.empty())
4718     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels : This is empty !");
4719   _field_per_mesh[0]->getFieldSplitedByType(types,typesF,pfls,locs);
4720   if(types.empty())
4721     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getNonEmptyLevels : 'this' is empty !");
4722   std::set<INTERP_KERNEL::NormalizedCellType> st(types.begin(),types.end());
4723   if(st.size()==1 && (*st.begin())==INTERP_KERNEL::NORM_ERROR)
4724     return -1;
4725   st.erase(INTERP_KERNEL::NORM_ERROR);
4726   std::set<int> ret1;
4727   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
4728     {
4729       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
4730       ret1.insert((int)cm.getDimension());
4731     }
4732   int ret=*std::max_element(ret1.begin(),ret1.end());
4733   std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
4734   std::transform(levs.begin(),levs.end(),levs.begin(),std::bind2nd(std::plus<int>(),-ret));
4735   return ret;
4736 }
4737
4738 void MEDFileAnyTypeField1TSWithoutSDA::convertMedBallIntoClassic()
4739 {
4740   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it<_field_per_mesh.end();it++)
4741     if((*it).isNotNull())
4742       (*it)->convertMedBallIntoClassic();
4743 }
4744
4745 void MEDFileAnyTypeField1TSWithoutSDA::makeReduction(INTERP_KERNEL::NormalizedCellType ct, TypeOfField tof, const DataArrayInt *pfl)
4746 {
4747   if(!pfl)
4748     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::makeReduction : null pfl !");
4749   std::string name(pfl->getName());
4750   pfl->checkAllocated();
4751   if(pfl->getNumberOfComponents()!=1)
4752     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::makeReduction : non mono compo array !");
4753   if(name.empty())
4754     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::makeReduction : empty pfl name !");
4755   if(_field_per_mesh.size()!=1)
4756     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::makeReduction : only single mesh supported !");
4757   MCAuto<MEDFileFieldPerMesh> fpm(_field_per_mesh[0]);
4758   if(fpm.isNull())
4759     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::makeReduction : only single not null mesh supported !");
4760   MEDFileFieldPerMeshPerTypePerDisc *disc(fpm->getLeafGivenTypeAndLocId(ct,0));
4761   if(disc->getType()!=tof)
4762     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::makeReduction : error !");
4763   int s(disc->getStart()),e(disc->getEnd()),nt(pfl->getNumberOfTuples());
4764   DataArray *arr(getUndergroundDataArray());
4765   int nt2(arr->getNumberOfTuples()),delta((e-s)-nt);
4766   if(delta<0)
4767     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::makeReduction : internal error !");
4768   MCAuto<DataArray> arr0(arr->selectByTupleIdSafeSlice(0,s,1)),arr1(arr->selectByTupleIdSafeSlice(s,e,1)),arr2(arr->selectByTupleIdSafeSlice(e,nt2,1));
4769   MCAuto<DataArray> arr11(arr1->selectByTupleIdSafe(pfl->begin(),pfl->end()));
4770   MCAuto<DataArray> arrOut(arr->buildNewEmptyInstance());
4771   arrOut->alloc(nt2-delta,arr->getNumberOfComponents());
4772   arrOut->copyStringInfoFrom(*arr);
4773   arrOut->setContigPartOfSelectedValuesSlice(0,arr0,0,s,1);
4774   arrOut->setContigPartOfSelectedValuesSlice(s,arr11,0,nt,1);
4775   arrOut->setContigPartOfSelectedValuesSlice(e-delta,arr2,0,nt2-e,1);
4776   setArray(arrOut);
4777   disc->setEnd(e-delta);
4778   disc->setProfile(name);
4779 }
4780
4781 /*!
4782  * \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.
4783  * \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.
4784  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4785  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4786  */
4787 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
4788 {
4789   if(_field_per_mesh.empty())
4790     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId : This is empty !");
4791   return _field_per_mesh[0]->getLeafGivenTypeAndLocId(typ,locId);
4792 }
4793
4794 /*!
4795  * \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.
4796  * \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.
4797  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4798  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4799  */
4800 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
4801 {
4802   if(_field_per_mesh.empty())
4803     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId : This is empty !");
4804   return _field_per_mesh[0]->getLeafGivenTypeAndLocId(typ,locId);
4805 }
4806
4807 /*!
4808  * \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.
4809  */
4810 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIdFromMeshName(const std::string& mName) const
4811 {
4812   if(_field_per_mesh.empty())
4813     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
4814   if(mName.empty())
4815     return 0;
4816   std::string mName2(mName);
4817   int ret=0;
4818   std::vector<std::string> msg;
4819   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
4820     if(mName2==(*it)->getMeshName())
4821       return ret;
4822     else
4823       msg.push_back((*it)->getMeshName());
4824   std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
4825   oss << "Possible meshes are : ";
4826   for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
4827     oss << "\"" << (*it2) << "\" ";
4828   throw INTERP_KERNEL::Exception(oss.str());
4829 }
4830
4831 int MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary(const MEDCouplingMesh *mesh)
4832 {
4833   if(!mesh)
4834     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary : input mesh is NULL !");
4835   std::string tmp(mesh->getName());
4836   if(tmp.empty())
4837     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
4838   setMeshName(tmp);
4839   std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();
4840   int i=0;
4841   for(;it!=_field_per_mesh.end();it++,i++)
4842     {
4843       if((*it)->getMeshName()==tmp)
4844         return i;
4845     }
4846   int sz=_field_per_mesh.size();
4847   _field_per_mesh.resize(sz+1);
4848   _field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
4849   return sz;
4850 }
4851
4852 bool MEDFileAnyTypeField1TSWithoutSDA::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
4853                                                                    MEDFileFieldGlobsReal& glob)
4854 {
4855   bool ret=false;
4856   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4857     {
4858       MEDFileFieldPerMesh *fpm(*it);
4859       if(fpm)
4860         ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
4861     }
4862   return ret;
4863 }
4864
4865 /*!
4866  * This method splits \a this into several sub-parts so that each sub parts have exactly one spatial discretization. This method implements the minimal
4867  * splitting that leads to single spatial discretization of this.
4868  *
4869  * \sa splitMultiDiscrPerGeoTypes
4870  */
4871 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations() const
4872 {
4873   std::vector<INTERP_KERNEL::NormalizedCellType> types;
4874   std::vector< std::vector<TypeOfField> > typesF;
4875   std::vector< std::vector<std::string> > pfls,locs;
4876   std::vector< std::vector<std::pair<int,int> > > bgEnd(getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs));
4877   std::set<TypeOfField> allEnt;
4878   for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++)
4879     for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4880       allEnt.insert(*it2);
4881   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret(allEnt.size());
4882   std::set<TypeOfField>::const_iterator it3(allEnt.begin());
4883   for(std::size_t i=0;i<allEnt.size();i++,it3++)
4884     {
4885       std::vector< std::pair<int,int> > its;
4886       ret[i]=shallowCpy();
4887       int newLgth(ret[i]->keepOnlySpatialDiscretization(*it3,its));
4888       ret[i]->updateData(newLgth,its);
4889     }
4890   return ret;
4891 }
4892
4893 /*!
4894  * This method performs a sub splitting as splitDiscretizations does but finer. This is the finest spliting level that can be done.
4895  * This method implements the minimal splitting so that each returned elements are mono Gauss discretization per geometric type.
4896  *
4897  * \sa splitDiscretizations
4898  */
4899 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitMultiDiscrPerGeoTypes() const
4900 {
4901   std::vector<INTERP_KERNEL::NormalizedCellType> types;
4902   std::vector< std::vector<TypeOfField> > typesF;
4903   std::vector< std::vector<std::string> > pfls,locs;
4904   std::vector< std::vector<std::pair<int,int> > > bgEnd(getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs));
4905   std::set<TypeOfField> allEnt;
4906   std::size_t nbOfMDPGT(0),ii(0);
4907   for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++,ii++)
4908     {
4909       nbOfMDPGT=std::max(nbOfMDPGT,locs[ii].size());
4910       for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4911         allEnt.insert(*it2);
4912     }
4913   if(allEnt.size()!=1)
4914     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitMultiDiscrPerGeoTypes : this field is expected to be defined only on one spatial discretization !");
4915   if(nbOfMDPGT==0)
4916     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitMultiDiscrPerGeoTypes : empty field !");
4917   if(nbOfMDPGT==1)
4918     {
4919       std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret0(1);
4920       ret0[0]=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(this); this->incrRef();
4921       return ret0;
4922     }
4923   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfMDPGT);
4924   for(std::size_t i=0;i<nbOfMDPGT;i++)
4925     {
4926       std::vector< std::pair<int,int> > its;
4927       ret[i]=shallowCpy();
4928       int newLgth(ret[i]->keepOnlyGaussDiscretization(i,its));
4929       ret[i]->updateData(newLgth,its);
4930     }
4931   return ret;
4932 }
4933
4934 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlySpatialDiscretization(TypeOfField tof, std::vector< std::pair<int,int> >& its)
4935 {
4936   int globalCounter(0);
4937   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4938     (*it)->keepOnlySpatialDiscretization(tof,globalCounter,its);
4939   return globalCounter;
4940 }
4941
4942 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlyGaussDiscretization(std::size_t idOfDisc, std::vector< std::pair<int,int> >& its)
4943 {
4944   int globalCounter(0);
4945   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4946     (*it)->keepOnlyGaussDiscretization(idOfDisc,globalCounter,its);
4947   return globalCounter;
4948 }
4949
4950 void MEDFileAnyTypeField1TSWithoutSDA::updateData(int newLgth, const std::vector< std::pair<int,int> >& oldStartStops)
4951 {
4952   if(_nb_of_tuples_to_be_allocated>=0)
4953     {
4954       _nb_of_tuples_to_be_allocated=newLgth;
4955       const DataArray *oldArr(getUndergroundDataArray());
4956       if(oldArr)
4957         {
4958           MCAuto<DataArray> newArr(createNewEmptyDataArrayInstance());
4959           newArr->setInfoAndChangeNbOfCompo(oldArr->getInfoOnComponents());
4960           setArray(newArr);
4961           _nb_of_tuples_to_be_allocated=newLgth;//force the _nb_of_tuples_to_be_allocated because setArray has been used specialy
4962         }
4963       return ;
4964     }
4965   if(_nb_of_tuples_to_be_allocated==-1)
4966     return ;
4967   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4968     {
4969       const DataArray *oldArr(getUndergroundDataArray());
4970       if(!oldArr || !oldArr->isAllocated())
4971         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 1 !");
4972       MCAuto<DataArray> newArr(createNewEmptyDataArrayInstance());
4973       newArr->alloc(newLgth,getNumberOfComponents());
4974       if(oldArr)
4975         newArr->copyStringInfoFrom(*oldArr);
4976       int pos=0;
4977       for(std::vector< std::pair<int,int> >::const_iterator it=oldStartStops.begin();it!=oldStartStops.end();it++)
4978         {
4979           if((*it).second<(*it).first)
4980             throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : the range in the leaves was invalid !");
4981           newArr->setContigPartOfSelectedValuesSlice(pos,oldArr,(*it).first,(*it).second,1);
4982           pos+=(*it).second-(*it).first;
4983         }
4984       setArray(newArr);
4985       return ;
4986     }
4987   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 2 !");
4988 }
4989
4990 void MEDFileAnyTypeField1TSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts, const MEDFileFieldNameScope& nasc) const
4991 {
4992   if(_field_per_mesh.empty())
4993     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : empty field !");
4994   if(_field_per_mesh.size()>1)
4995     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : In MED3.0 mode in writting mode only ONE underlying mesh supported !");
4996   _field_per_mesh[0]->copyOptionsFrom(opts);
4997   _field_per_mesh[0]->writeLL(fid,nasc);
4998 }
4999
5000 /*!
5001  * 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.
5002  * If false is returned the memory allocation is not required.
5003  */
5004 bool MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile()
5005 {
5006   if(_nb_of_tuples_to_be_allocated>=0)
5007     {
5008       getOrCreateAndGetArray()->alloc(_nb_of_tuples_to_be_allocated,getNumberOfComponents());
5009       _nb_of_tuples_to_be_allocated=-2;
5010       return true;
5011     }
5012   if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
5013     return false;
5014   if(_nb_of_tuples_to_be_allocated==-1)
5015     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : trying to read from a file an empty instance ! Need to prepare the structure before !");
5016   if(_nb_of_tuples_to_be_allocated<-3)
5017     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
5018   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
5019 }
5020
5021 void MEDFileAnyTypeField1TSWithoutSDA::loadOnlyStructureOfDataRecursively(med_idt fid, const MEDFileFieldNameScope& nasc, const MEDFileMeshes *ms, const MEDFileEntities *entities)
5022 {
5023   med_int numdt,numit;
5024   med_float dt;
5025   med_int meshnumdt,meshnumit;
5026   MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&_dt));
5027   {
5028     med_bool localMesh;
5029     med_int nmesh;
5030     INTERP_KERNEL::AutoPtr<char> meshName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
5031     MEDFILESAFECALLERRD0(MEDfield23ComputingStepMeshInfo,(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&dt,&nmesh,meshName,&localMesh,&meshnumdt,&meshnumit)); // to check with Adrien for legacy MED files
5032   }
5033   //MEDFILESAFECALLERRD0(MEDfieldComputingStepMeshInfo,(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&_dt,&meshnumdt,&meshnumit));
5034   if(_iteration!=numdt || _order!=numit)
5035     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively : unexpected exception internal error !");
5036   _field_per_mesh.resize(1);
5037   //
5038   MEDFileMesh *mm(0);
5039   if(ms)
5040     {
5041       mm=ms->getMeshWithName(getMeshName());
5042     }
5043   //
5044   _field_per_mesh[0]=MEDFileFieldPerMesh::NewOnRead(fid,this,0,meshnumdt,meshnumit,nasc,mm,entities);
5045   _nb_of_tuples_to_be_allocated=0;
5046   _field_per_mesh[0]->loadOnlyStructureOfDataRecursively(fid,_nb_of_tuples_to_be_allocated,nasc);
5047 }
5048
5049 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
5050 {
5051   allocIfNecessaryTheArrayToReceiveDataFromFile();
5052   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5053     (*it)->loadBigArraysRecursively(fid,nasc);
5054 }
5055
5056 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
5057 {
5058   if(allocIfNecessaryTheArrayToReceiveDataFromFile())
5059     for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5060       (*it)->loadBigArraysRecursively(fid,nasc);
5061 }
5062
5063 void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc, const MEDFileMeshes *ms, const MEDFileEntities *entities)
5064 {
5065   loadOnlyStructureOfDataRecursively(fid,nasc,ms,entities);
5066   loadBigArraysRecursively(fid,nasc);
5067 }
5068
5069 void MEDFileAnyTypeField1TSWithoutSDA::unloadArrays()
5070 {
5071   DataArray *thisArr(getUndergroundDataArray());
5072   if(thisArr && thisArr->isAllocated())
5073     {
5074       _nb_of_tuples_to_be_allocated=thisArr->getNumberOfTuples();
5075       thisArr->desallocate();
5076     }
5077 }
5078
5079 std::size_t MEDFileAnyTypeField1TSWithoutSDA::getHeapMemorySizeWithoutChildren() const
5080 {
5081   return _mesh_name.capacity()+_dt_unit.capacity()+_field_per_mesh.capacity()*sizeof(MCAuto< MEDFileFieldPerMesh >);
5082 }
5083
5084 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TSWithoutSDA::getDirectChildrenWithNull() const
5085 {
5086   std::vector<const BigMemoryObject *> ret;
5087   if(getUndergroundDataArray())
5088     ret.push_back(getUndergroundDataArray());
5089   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5090     ret.push_back((const MEDFileFieldPerMesh *)*it);
5091   return ret;
5092 }
5093
5094 /*!
5095  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
5096  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
5097  * "Sort By Type"), if not, an exception is thrown.
5098  *  \param [in] field - the field to add to \a this. The array of field \a field is ignored
5099  *  \param [in] arr - the array of values.
5100  *  \param [in,out] glob - the global data where profiles and localization present in
5101  *          \a field, if any, are added.
5102  *  \throw If the name of \a field is empty.
5103  *  \throw If the data array of \a field is not set.
5104  *  \throw If \a this->_arr is already allocated but has different number of components
5105  *         than \a field.
5106  *  \throw If the underlying mesh of \a field has no name.
5107  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
5108  */
5109 void MEDFileAnyTypeField1TSWithoutSDA::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
5110 {
5111   const MEDCouplingMesh *mesh=field->getMesh();
5112   //
5113   TypeOfField type=field->getTypeOfField();
5114   std::vector<DataArrayInt *> dummy;
5115   if(mesh)
5116     setMeshName(mesh->getName());
5117   int start=copyTinyInfoFrom(field,arr);
5118   int pos=addNewEntryIfNecessary(mesh);
5119   if(type!=ON_NODES)
5120     {
5121       std::vector<int> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
5122       _field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,arr,glob,nasc);
5123     }
5124   else
5125     _field_per_mesh[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
5126 }
5127
5128 /*!
5129  * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
5130  * of a given mesh are used as the support of the given field (a real support is not used).
5131  * Elements of the given mesh must be sorted suitable for writing to MED file.
5132  * Order of underlying mesh entities of the given field specified by \a profile parameter
5133  * is not prescribed; this method permutes field values to have them sorted by element
5134  * type as required for writing to MED file. A new profile is added only if no equal
5135  * profile is missing.
5136  *  \param [in] field - the field to add to \a this. The field double values are ignored.
5137  *  \param [in] arrOfVals - the values of the field \a field used.
5138  *  \param [in] mesh - the supporting mesh of \a field.
5139  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
5140  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
5141  *  \param [in,out] glob - the global data where profiles and localization present in
5142  *          \a field, if any, are added.
5143  *  \throw If either \a field or \a mesh or \a profile has an empty name.
5144  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
5145  *  \throw If the data array of \a field is not set.
5146  *  \throw If \a this->_arr is already allocated but has different number of components
5147  *         than \a field.
5148  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
5149  *  \sa setFieldNoProfileSBT()
5150  */
5151 void MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
5152 {
5153   if(!field)
5154     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input field is null !");
5155   if(!arrOfVals || !arrOfVals->isAllocated())
5156     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input array is null or not allocated !");
5157   TypeOfField type=field->getTypeOfField();
5158   std::vector<DataArrayInt *> idsInPflPerType;
5159   std::vector<DataArrayInt *> idsPerType;
5160   std::vector<int> code,code2;
5161   MCAuto<MEDCouplingMesh> m(mesh->getMeshAtLevel(meshDimRelToMax));
5162   if(type!=ON_NODES)
5163     {
5164       m->splitProfilePerType(profile,code,idsInPflPerType,idsPerType);
5165       std::vector< MCAuto<DataArrayInt> > idsInPflPerType2(idsInPflPerType.size()); std::copy(idsInPflPerType.begin(),idsInPflPerType.end(),idsInPflPerType2.begin());
5166       std::vector< MCAuto<DataArrayInt> > idsPerType2(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType2.begin());
5167       std::vector<const DataArrayInt *> idsPerType3(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType3.begin());
5168       // start of check
5169       MCAuto<MEDCouplingFieldDouble> field2=field->clone(false);
5170       int nbOfTuplesExp=field2->getNumberOfTuplesExpectedRegardingCode(code,idsPerType3);
5171       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
5172         {
5173           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : The array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
5174           throw INTERP_KERNEL::Exception(oss.str());
5175         }
5176       // end of check
5177       int start=copyTinyInfoFrom(field,arrOfVals);
5178       code2=m->getDistributionOfTypes();
5179       //
5180       int pos=addNewEntryIfNecessary(m);
5181       _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
5182     }
5183   else
5184     {
5185       if(!profile || !profile->isAllocated() || profile->getNumberOfComponents()!=1)
5186         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input profile is null, not allocated or with number of components != 1 !");
5187       std::vector<int> v(3); v[0]=-1; v[1]=profile->getNumberOfTuples(); v[2]=0;
5188       std::vector<const DataArrayInt *> idsPerType3(1); idsPerType3[0]=profile;
5189       int nbOfTuplesExp=field->getNumberOfTuplesExpectedRegardingCode(v,idsPerType3);
5190       if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
5191         {
5192           std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : For node field, the array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
5193           throw INTERP_KERNEL::Exception(oss.str());
5194         }
5195       int start=copyTinyInfoFrom(field,arrOfVals);
5196       int pos=addNewEntryIfNecessary(m);
5197       _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
5198     }
5199 }
5200
5201 /*!
5202  * \param [in] newNbOfTuples - The new nb of tuples to be allocated.
5203  */
5204 void MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile(int newNbOfTuples)
5205 {
5206   if(_nb_of_tuples_to_be_allocated>=0)
5207     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 !");
5208   DataArray *arr(getOrCreateAndGetArray());
5209   arr->alloc(newNbOfTuples,arr->getNumberOfComponents());
5210   _nb_of_tuples_to_be_allocated=-3;
5211 }
5212
5213 /*!
5214  * Copies tiny info and allocates \a this->_arr instance of DataArrayDouble to
5215  * append data of a given MEDCouplingFieldDouble. So that the size of \a this->_arr becomes
5216  * larger by the size of \a field. Returns an id of the first not filled
5217  * tuple of \a this->_arr.
5218  *  \param [in] field - the field to copy the info on components and the name from.
5219  *  \return int - the id of first not initialized tuple of \a this->_arr.
5220  *  \throw If the name of \a field is empty.
5221  *  \throw If the data array of \a field is not set.
5222  *  \throw If \a this->_arr is already allocated but has different number of components
5223  *         than \a field.
5224  */
5225 int MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
5226 {
5227   if(!field)
5228     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
5229   std::string name(field->getName());
5230   setName(name.c_str());
5231   if(field->getMesh())
5232     setMeshName(field->getMesh()->getName());
5233   setDtUnit(field->getTimeUnit());
5234   if(name.empty())
5235     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
5236   if(!arr)
5237     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
5238   if(!arr->isAllocated())
5239     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : array is not allocated !");
5240   _dt=field->getTime(_iteration,_order);
5241   getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
5242   if(!getOrCreateAndGetArray()->isAllocated())
5243     {
5244       allocNotFromFile(arr->getNumberOfTuples());
5245       return 0;
5246     }
5247   else
5248     {
5249       int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
5250       int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
5251       getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
5252       _nb_of_tuples_to_be_allocated=-3;
5253       return oldNbOfTuples;
5254     }
5255 }
5256
5257 /*!
5258  * Returns number of components in \a this field
5259  *  \return int - the number of components.
5260  */
5261 int MEDFileAnyTypeField1TSWithoutSDA::getNumberOfComponents() const
5262 {
5263   return getOrCreateAndGetArray()->getNumberOfComponents();
5264 }
5265
5266 /*!
5267  * Change info on components in \a this.
5268  * \throw If size of \a infos is not equal to the number of components already in \a this.
5269  */
5270 void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos)
5271 {
5272   DataArray *arr=getOrCreateAndGetArray();
5273   arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
5274 }
5275
5276 /*!
5277  * Returns info on components of \a this field.
5278  *  \return const std::vector<std::string>& - a sequence of strings each being an
5279  *          information on _i_-th component.
5280  */
5281 const std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo() const
5282 {
5283   const DataArray *arr=getOrCreateAndGetArray();
5284   return arr->getInfoOnComponents();
5285 }
5286
5287 /*!
5288  * Returns a mutable info on components of \a this field.
5289  *  \return std::vector<std::string>& - a sequence of strings each being an
5290  *          information on _i_-th component.
5291  */
5292 std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo()
5293 {
5294   DataArray *arr=getOrCreateAndGetArray();
5295   return arr->getInfoOnComponents();
5296 }
5297
5298 bool MEDFileAnyTypeField1TSWithoutSDA::presenceOfMultiDiscPerGeoType() const
5299 {
5300   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5301     {
5302       const MEDFileFieldPerMesh *fpm(*it);
5303       if(!fpm)
5304         continue;
5305       if(fpm->presenceOfMultiDiscPerGeoType())
5306         return true;
5307     }
5308   return false;
5309 }
5310
5311 bool MEDFileAnyTypeField1TSWithoutSDA::presenceOfStructureElements() const
5312 {
5313   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5314     if((*it).isNotNull())
5315       if((*it)->presenceOfStructureElements())
5316         return true;
5317   return false;
5318 }
5319
5320 bool MEDFileAnyTypeField1TSWithoutSDA::onlyStructureElements() const
5321 {
5322   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5323     if((*it).isNotNull())
5324       if(!(*it)->onlyStructureElements())
5325         return false;
5326   return true;
5327 }
5328
5329 void MEDFileAnyTypeField1TSWithoutSDA::killStructureElements()
5330 {
5331   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5332     if((*it).isNotNull())
5333       (*it)->killStructureElements();
5334 }
5335
5336 void MEDFileAnyTypeField1TSWithoutSDA::keepOnlyStructureElements()
5337 {
5338   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5339     if((*it).isNotNull())
5340       (*it)->keepOnlyStructureElements();
5341 }
5342
5343 void MEDFileAnyTypeField1TSWithoutSDA::keepOnlyOnSE(const std::string& seName)
5344 {
5345   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5346     if((*it).isNotNull())
5347       (*it)->keepOnlyOnSE(seName);
5348 }
5349
5350 void MEDFileAnyTypeField1TSWithoutSDA::getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const
5351 {
5352   for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
5353     if((*it).isNotNull())
5354       (*it)->getMeshSENames(ps);
5355 }
5356
5357 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh(const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
5358 {
5359   static const char MSG0[]="MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh : the field is too complex to be able to be extracted with  \"field\" method ! Call getFieldOnMeshAtLevel method instead to deal with complexity !";
5360   if(_field_per_mesh.empty())
5361     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh : the field is empty ! Nothing to extract !");
5362   if(_field_per_mesh.size()>1)
5363     throw INTERP_KERNEL::Exception(MSG0);
5364   if(_field_per_mesh[0].isNull())
5365     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh : the field is inconsistent !");
5366   const MEDFileFieldPerMesh *pm(_field_per_mesh[0]);
5367   std::set<TypeOfField> types;
5368   pm->fillTypesOfFieldAvailable(types);
5369   if(types.size()!=1)
5370     throw INTERP_KERNEL::Exception(MSG0);
5371   TypeOfField type(*types.begin());
5372   int meshDimRelToMax(0);
5373   if(type==ON_NODES)
5374     meshDimRelToMax=0;
5375   else
5376     {
5377       int myDim(std::numeric_limits<int>::max());
5378       bool isUnique(pm->isUniqueLevel(myDim));
5379       if(!isUnique)
5380         throw INTERP_KERNEL::Exception(MSG0);
5381       meshDimRelToMax=myDim-mesh->getMeshDimension();
5382       if(meshDimRelToMax>0)
5383         throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh : the mesh attached to field is not compatible with the field !");
5384     }
5385   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,0/*renumPol*/,glob,mesh,arrOut,nasc);
5386 }
5387
5388 /*!
5389  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
5390  *  \param [in] type - a spatial discretization of the new field.
5391  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
5392  *  \param [in] mName - a name of the supporting mesh.
5393  *  \param [in] renumPol - specifies how to permute values of the result field according to
5394  *          the optional numbers of cells and nodes, if any. The valid values are
5395  *          - 0 - do not permute.
5396  *          - 1 - permute cells.
5397  *          - 2 - permute nodes.
5398  *          - 3 - permute cells and nodes.
5399  *
5400  *  \param [in] glob - the global data storing profiles and localization.
5401  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
5402  *          caller is to delete this field using decrRef() as it is no more needed.
5403  *  \throw If the MED file is not readable.
5404  *  \throw If there is no mesh named \a mName in the MED file.
5405  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
5406  *  \throw If no field of \a this is lying on the mesh \a mName.
5407  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
5408  */
5409 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, const std::string& mName, int renumPol, const MEDFileFieldGlobsReal *glob, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
5410 {
5411   MCAuto<MEDFileMesh> mm;
5412   if(mName.empty())
5413     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
5414   else
5415     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
5416   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
5417 }
5418
5419 /*!
5420  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
5421  *  \param [in] type - a spatial discretization of the new field.
5422  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
5423  *  \param [in] renumPol - specifies how to permute values of the result field according to
5424  *          the optional numbers of cells and nodes, if any. The valid values are
5425  *          - 0 - do not permute.
5426  *          - 1 - permute cells.
5427  *          - 2 - permute nodes.
5428  *          - 3 - permute cells and nodes.
5429  *
5430  *  \param [in] glob - the global data storing profiles and localization.
5431  *  \param [in] mesh - the supporting mesh.
5432  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
5433  *          caller is to delete this field using decrRef() as it is no more needed.
5434  *  \throw If the MED file is not readable.
5435  *  \throw If no field of \a this is lying on \a mesh.
5436  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
5437  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
5438  */
5439 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
5440 {
5441   MCAuto<MEDCouplingMesh> m(mesh->getMeshAtLevel(meshDimRelToMax,false));
5442   const DataArrayInt *d(mesh->getNumberFieldAtLevel(meshDimRelToMax)),*e(mesh->getNumberFieldAtLevel(1));
5443   if(meshDimRelToMax==1)
5444     (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
5445   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e,arrOut,nasc);
5446 }
5447
5448 /*!
5449  * Returns a new MEDCouplingFieldDouble of a given type lying on the top level cells of a
5450  * given mesh.
5451  *  \param [in] type - a spatial discretization of the new field.
5452  *  \param [in] mName - a name of the supporting mesh.
5453  *  \param [in] renumPol - specifies how to permute values of the result field according to
5454  *          the optional numbers of cells and nodes, if any. The valid values are
5455  *          - 0 - do not permute.
5456  *          - 1 - permute cells.
5457  *          - 2 - permute nodes.
5458  *          - 3 - permute cells and nodes.
5459  *
5460  *  \param [in] glob - the global data storing profiles and localization.
5461  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
5462  *          caller is to delete this field using decrRef() as it is no more needed.
5463  *  \throw If the MED file is not readable.
5464  *  \throw If there is no mesh named \a mName in the MED file.
5465  *  \throw If there are no mesh entities in the mesh.
5466  *  \throw If no field values of the given \a type are available.
5467  */
5468 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const std::string& mName, int renumPol, const MEDFileFieldGlobsReal *glob, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
5469 {
5470   MCAuto<MEDFileMesh> mm;
5471   if(mName.empty())
5472     mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
5473   else
5474     mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
5475   int absDim=getDimension();
5476   int meshDimRelToMax=absDim-mm->getMeshDimension();
5477   return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
5478 }
5479
5480 /*!
5481  * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
5482  *  \param [in] type - a spatial discretization of the new field.
5483  *  \param [in] renumPol - specifies how to permute values of the result field according to
5484  *          the optional numbers of cells and nodes, if any. The valid values are
5485  *          - 0 - do not permute.
5486  *          - 1 - permute cells.
5487  *          - 2 - permute nodes.
5488  *          - 3 - permute cells and nodes.
5489  *
5490  *  \param [in] glob - the global data storing profiles and localization.
5491  *  \param [in] mesh - the supporting mesh.
5492  *  \param [in] cellRenum - the cell numbers array used for permutation of the result
5493  *         field according to \a renumPol.
5494  *  \param [in] nodeRenum - the node numbers array used for permutation of the result
5495  *         field according to \a renumPol.
5496  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
5497  *          caller is to delete this field using decrRef() as it is no more needed.
5498  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
5499  *  \throw If no field of \a this is lying on \a mesh.
5500  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
5501  */
5502 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, const DataArrayInt *cellRenum, const DataArrayInt *nodeRenum, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
5503 {
5504   static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
5505   bool isPfl=false;
5506   MCAuto<MEDCouplingFieldDouble> ret=_field_per_mesh[0]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl,arrOut,nasc);
5507   switch(renumPol)
5508   {
5509     case 0:
5510       {
5511         //no need to test _field_per_mesh.empty() because geMeshName has already done it
5512         return ret.retn();
5513       }
5514     case 3:
5515     case 1:
5516       {
5517         if(isPfl)
5518           throw INTERP_KERNEL::Exception(msg1);
5519         //no need to test _field_per_mesh.empty() because geMeshName has already done it
5520         if(cellRenum)
5521           {
5522             if((int)cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
5523               {
5524                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
5525                 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
5526                 throw INTERP_KERNEL::Exception(oss.str());
5527               }
5528             MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
5529             if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
5530             std::vector<DataArray *> arrOut2(1,arrOut);
5531             // 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
5532             disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
5533             (const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
5534           }
5535         if(renumPol==1)
5536           return ret.retn();
5537       }
5538     case 2:
5539       {
5540         //no need to test _field_per_mesh.empty() because geMeshName has already done it
5541         if(isPfl)
5542           throw INTERP_KERNEL::Exception(msg1);
5543         if(nodeRenum)
5544           {
5545             if((int)nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
5546               {
5547                 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
5548                 oss << "\"" << nasc.getName() << "\" not defined on all nodes !";
5549                 throw INTERP_KERNEL::Exception(oss.str());
5550               }
5551             MCAuto<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
5552             if(!dynamic_cast<DataArrayDouble *>((DataArray *)arrOut))
5553               throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : node renumbering not implemented for not double DataArrays !");
5554             ret->renumberNodes(nodeRenumSafe->getConstPointer());
5555           }
5556         return ret.retn();
5557       }
5558     default:
5559       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
5560   }
5561 }
5562
5563 /*!
5564  * Returns values and a profile of the field of a given type lying on a given support.
5565  *  \param [in] type - a spatial discretization of the field.
5566  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
5567  *  \param [in] mesh - the supporting mesh.
5568  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
5569  *          field of interest lies on. If the field lies on all entities of the given
5570  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
5571  *          using decrRef() as it is no more needed.
5572  *  \param [in] glob - the global data storing profiles and localization.
5573  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
5574  *          field. The caller is to delete this array using decrRef() as it is no more needed.
5575  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
5576  *  \throw If no field of \a this is lying on \a mesh.
5577  *  \throw If no field values of the given \a type are available.
5578  */
5579 DataArray *MEDFileAnyTypeField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
5580 {
5581   MCAuto<MEDCouplingMesh> m(mesh->getMeshAtLevel(meshDimRelToMax));
5582   MCAuto<DataArray> ret=_field_per_mesh[0]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob,nasc);
5583   ret->setName(nasc.getName().c_str());
5584   return ret.retn();
5585 }
5586
5587 //= MEDFileField1TSWithoutSDA
5588
5589 /*!
5590  * Throws if a given value is not a valid (non-extended) relative dimension.
5591  *  \param [in] meshDimRelToMax - the relative dimension value.
5592  *  \throw If \a meshDimRelToMax > 0.
5593  */
5594 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax)
5595 {
5596   if(meshDimRelToMax>0)
5597     throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
5598 }
5599
5600 /*!
5601  * Checks if elements of a given mesh are in the order suitable for writing
5602  * to the MED file. If this is not so, an exception is thrown. In a case of success, returns a
5603  * vector describing types of elements and their number.
5604  *  \param [in] mesh - the mesh to check.
5605  *  \return std::vector<int> - a vector holding for each element type (1) item of
5606  *          INTERP_KERNEL::NormalizedCellType, (2) number of elements, (3) -1.
5607  *          These values are in full-interlace mode.
5608  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
5609  */
5610 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh)
5611 {
5612   if(!mesh)
5613     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
5614   std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
5615   int nbOfTypes=geoTypes.size();
5616   std::vector<int> code(3*nbOfTypes);
5617   MCAuto<DataArrayInt> arr1=DataArrayInt::New();
5618   arr1->alloc(nbOfTypes,1);
5619   int *arrPtr=arr1->getPointer();
5620   std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
5621   for(int i=0;i<nbOfTypes;i++,it++)
5622     arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
5623   MCAuto<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
5624   const int *arrPtr2=arr2->getConstPointer();
5625   int i=0;
5626   for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
5627     {
5628       int pos=arrPtr2[i];
5629       int nbCells=mesh->getNumberOfCellsWithType(*it);
5630       code[3*pos]=(int)(*it);
5631       code[3*pos+1]=nbCells;
5632       code[3*pos+2]=-1;//no profiles
5633     }
5634   std::vector<const DataArrayInt *> idsPerType;//no profiles
5635   DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
5636   if(da)
5637     {
5638       da->decrRef();
5639       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
5640     }
5641   return code;
5642 }
5643
5644 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos)
5645 {
5646   return new MEDFileField1TSWithoutSDA(fieldName,meshName,csit,iteration,order,infos);
5647 }
5648
5649 /*!
5650  * Returns all attributes and values of parts of \a this field lying on a given mesh.
5651  * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
5652  * item of every of returned sequences refers to the _i_-th part of \a this field.
5653  * Thus all sequences returned by this method are of the same length equal to number
5654  * of different types of supporting entities.<br>
5655  * A field part can include sub-parts with several different spatial discretizations,
5656  * \ref MEDCoupling::ON_CELLS "ON_CELLS" and \ref MEDCoupling::ON_GAUSS_PT "ON_GAUSS_PT"
5657  * for example. Hence, some of the returned sequences contains nested sequences, and an item
5658  * of a nested sequence corresponds to a type of spatial discretization.<br>
5659  * This method allows for iteration over MEDFile DataStructure with a reduced overhead.
5660  * The overhead is due to selecting values into new instances of DataArrayDouble.
5661  *  \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
5662  *          for the case with only one underlying mesh. (Actually, the number of meshes is
5663  *          not checked if \a mname == \c NULL).
5664  *  \param [in,out] types - a sequence of types of underlying mesh entities. A type per
5665  *          a field part is returned.
5666  *  \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
5667  *          A field part can include sub-parts with several different spatial discretizations,
5668  *          \ref MEDCoupling::ON_CELLS "ON_CELLS" and
5669  *          \ref MEDCoupling::ON_GAUSS_PT "ON_GAUSS_PT" for example.
5670  *          This sequence is of the same length as \a types.
5671  *  \param [in,out] pfls - a sequence returning a profile name per each type of spatial
5672  *          discretization. A profile name can be empty.
5673  *          Length of this and of nested sequences is the same as that of \a typesF.
5674  *  \param [in,out] locs - a sequence returning a localization name per each type of spatial
5675  *          discretization. A localization name can be empty.
5676  *          Length of this and of nested sequences is the same as that of \a typesF.
5677  *  \return std::vector< std::vector<DataArrayDouble *> > - a sequence holding arrays of values
5678  *          per each type of spatial discretization within one mesh entity type.
5679  *          The caller is to delete each DataArrayDouble using decrRef() as it is no more needed.
5680  *          Length of this and of nested sequences is the same as that of \a typesF.
5681  *  \throw If no field is lying on \a mname.
5682  */
5683 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
5684 {
5685   if(mname.empty())
5686     if(_field_per_mesh.empty())
5687       throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
5688   std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[0]->getFieldSplitedByType(types,typesF,pfls,locs);
5689   int nbOfRet=ret0.size();
5690   std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
5691   for(int i=0;i<nbOfRet;i++)
5692     {
5693       const std::vector< std::pair<int,int> >& p=ret0[i];
5694       int nbOfRet1=p.size();
5695       ret[i].resize(nbOfRet1);
5696       for(int j=0;j<nbOfRet1;j++)
5697         {
5698           DataArrayDouble *tmp=_arr->selectByTupleIdSafeSlice(p[j].first,p[j].second,1);
5699           ret[i][j]=tmp;
5700         }
5701     }
5702   return ret;
5703 }
5704
5705 const char *MEDFileField1TSWithoutSDA::getTypeStr() const
5706 {
5707   return TYPE_STR;
5708 }
5709
5710 MEDFileIntField1TSWithoutSDA *MEDFileField1TSWithoutSDA::convertToInt() const
5711 {
5712   MCAuto<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA);
5713   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
5714   ret->deepCpyLeavesFrom(*this);
5715   const DataArrayDouble *arr(_arr);
5716   if(arr)
5717     {
5718       MCAuto<DataArrayInt> arr2(arr->convertToIntArr());
5719       ret->setArray(arr2);
5720     }
5721   return ret.retn();
5722 }
5723
5724 /*!
5725  * Returns a pointer to the underground DataArrayDouble instance and a
5726  * sequence describing parameters of a support of each part of \a this field. The
5727  * caller should not decrRef() the returned DataArrayDouble. This method allows for a
5728  * direct access to the field values. This method is intended for the field lying on one
5729  * mesh only.
5730  *  \param [in,out] entries - the sequence describing parameters of a support of each
5731  *         part of \a this field. Each item of this sequence consists of two parts. The
5732  *         first part describes a type of mesh entity and an id of discretization of a
5733  *         current field part. The second part describes a range of values [begin,end)
5734  *         within the returned array relating to the current field part.
5735  *  \return DataArrayDouble * - the pointer to the field values array.
5736  *  \throw If the number of underlying meshes is not equal to 1.
5737  *  \throw If no field values are available.
5738  *  \sa getUndergroundDataArray()
5739  */
5740 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5741 {
5742   return getUndergroundDataArrayTemplateExt(entries);
5743 }
5744
5745 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos):MEDFileField1TSTemplateWithoutSDA<double>(fieldName,meshName,csit,iteration,order)
5746 {
5747   DataArrayDouble *arr(getOrCreateAndGetArrayTemplate());
5748   arr->setInfoAndChangeNbOfCompo(infos);
5749 }
5750
5751 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():MEDFileField1TSTemplateWithoutSDA<double>()
5752 {
5753 }
5754
5755 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::shallowCpy() const
5756 {
5757   MCAuto<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA(*this));
5758   ret->deepCpyLeavesFrom(*this);
5759   return ret.retn();
5760 }
5761
5762 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCopy() const
5763 {
5764   MCAuto<MEDFileField1TSWithoutSDA> ret(shallowCpy());
5765   if(_arr.isNotNull())
5766     ret->_arr=_arr->deepCopy();
5767   return ret.retn();
5768 }
5769
5770 //= MEDFileIntField1TSWithoutSDA
5771
5772 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::New(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos)
5773 {
5774   return new MEDFileIntField1TSWithoutSDA(fieldName,meshName,csit,iteration,order,infos);
5775 }
5776
5777 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA()
5778 {
5779 }
5780
5781 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order,
5782                                                            const std::vector<std::string>& infos):MEDFileField1TSTemplateWithoutSDA<int>(fieldName,meshName,csit,iteration,order)
5783 {
5784   DataArrayInt *arr(getOrCreateAndGetArrayTemplate());
5785   arr->setInfoAndChangeNbOfCompo(infos);
5786 }
5787
5788 const char *MEDFileIntField1TSWithoutSDA::getTypeStr() const
5789 {
5790   return TYPE_STR;
5791 }
5792
5793 MEDFileField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::convertToDouble() const
5794 {
5795   MCAuto<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
5796   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
5797   ret->deepCpyLeavesFrom(*this);
5798   if(_arr.isNotNull())
5799     {
5800       MCAuto<DataArrayDouble> arr2(_arr->convertToDblArr());
5801       ret->setArray(arr2);
5802     }
5803   return ret.retn();
5804 }
5805
5806 /*!
5807  * Returns a pointer to the underground DataArrayInt instance and a
5808  * sequence describing parameters of a support of each part of \a this field. The
5809  * caller should not decrRef() the returned DataArrayInt. This method allows for a
5810  * direct access to the field values. This method is intended for the field lying on one
5811  * mesh only.
5812  *  \param [in,out] entries - the sequence describing parameters of a support of each
5813  *         part of \a this field. Each item of this sequence consists of two parts. The
5814  *         first part describes a type of mesh entity and an id of discretization of a
5815  *         current field part. The second part describes a range of values [begin,end)
5816  *         within the returned array relating to the current field part.
5817  *  \return DataArrayInt * - the pointer to the field values array.
5818  *  \throw If the number of underlying meshes is not equal to 1.
5819  *  \throw If no field values are available.
5820  *  \sa getUndergroundDataArray()
5821  */
5822 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5823 {
5824   return getUndergroundDataArrayIntExt(entries);
5825 }
5826
5827 /*!
5828  * Returns a pointer to the underground DataArrayInt instance and a
5829  * sequence describing parameters of a support of each part of \a this field. The
5830  * caller should not decrRef() the returned DataArrayInt. This method allows for a
5831  * direct access to the field values. This method is intended for the field lying on one
5832  * mesh only.
5833  *  \param [in,out] entries - the sequence describing parameters of a support of each
5834  *         part of \a this field. Each item of this sequence consists of two parts. The
5835  *         first part describes a type of mesh entity and an id of discretization of a
5836  *         current field part. The second part describes a range of values [begin,end)
5837  *         within the returned array relating to the current field part.
5838  *  \return DataArrayInt * - the pointer to the field values array.
5839  *  \throw If the number of underlying meshes is not equal to 1.
5840  *  \throw If no field values are available.
5841  *  \sa getUndergroundDataArray()
5842  */
5843 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5844 {
5845   if(_field_per_mesh.size()!=1)
5846     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
5847   if(_field_per_mesh[0]==0)
5848     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
5849   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
5850   return getUndergroundDataArrayTemplate();
5851 }
5852
5853 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::shallowCpy() const
5854 {
5855   MCAuto<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA(*this));
5856   ret->deepCpyLeavesFrom(*this);
5857   return ret.retn();
5858 }
5859
5860 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::deepCopy() const
5861 {
5862   MCAuto<MEDFileIntField1TSWithoutSDA> ret(shallowCpy());
5863   if(_arr.isNotNull())
5864     ret->_arr=_arr->deepCopy();
5865   return ret.retn();
5866 }
5867
5868 //= MEDFileFloatField1TSWithoutSDA
5869
5870 MEDFileFloatField1TSWithoutSDA *MEDFileFloatField1TSWithoutSDA::New(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order, const std::vector<std::string>& infos)
5871 {
5872   return new MEDFileFloatField1TSWithoutSDA(fieldName,meshName,csit,iteration,order,infos);
5873 }
5874
5875 MEDFileFloatField1TSWithoutSDA::MEDFileFloatField1TSWithoutSDA()
5876 {
5877 }
5878
5879 MEDFileFloatField1TSWithoutSDA::MEDFileFloatField1TSWithoutSDA(const std::string& fieldName, const std::string& meshName, int csit, int iteration, int order,
5880                                                                const std::vector<std::string>& infos):MEDFileField1TSTemplateWithoutSDA<float>(fieldName,meshName,csit,iteration,order)
5881 {
5882   DataArrayFloat *arr(getOrCreateAndGetArrayTemplate());
5883   arr->setInfoAndChangeNbOfCompo(infos);
5884 }
5885
5886 const char *MEDFileFloatField1TSWithoutSDA::getTypeStr() const
5887 {
5888   return TYPE_STR;
5889 }
5890
5891 MEDFileField1TSWithoutSDA *MEDFileFloatField1TSWithoutSDA::convertToDouble() const
5892 {
5893   MCAuto<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
5894   ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
5895   ret->deepCpyLeavesFrom(*this);
5896   if(_arr.isNotNull())
5897     {
5898       MCAuto<DataArrayDouble> arr2(_arr->convertToDblArr());
5899       ret->setArray(arr2);
5900     }
5901   return ret.retn();
5902 }
5903
5904 /*!
5905  * Returns a pointer to the underground DataArrayFloat instance and a
5906  * sequence describing parameters of a support of each part of \a this field. The
5907  * caller should not decrRef() the returned DataArrayFloat. This method allows for a
5908  * direct access to the field values. This method is intended for the field lying on one
5909  * mesh only.
5910  *  \param [in,out] entries - the sequence describing parameters of a support of each
5911  *         part of \a this field. Each item of this sequence consists of two parts. The
5912  *         first part describes a type of mesh entity and an id of discretization of a
5913  *         current field part. The second part describes a range of values [begin,end)
5914  *         within the returned array relating to the current field part.
5915  *  \return DataArrayFloat * - the pointer to the field values array.
5916  *  \throw If the number of underlying meshes is not equal to 1.
5917  *  \throw If no field values are available.
5918  *  \sa getUndergroundDataArray()
5919  */
5920 DataArray *MEDFileFloatField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5921 {
5922   return getUndergroundDataArrayFloatExt(entries);
5923 }
5924
5925 /*!
5926  * Returns a pointer to the underground DataArrayFloat instance and a
5927  * sequence describing parameters of a support of each part of \a this field. The
5928  * caller should not decrRef() the returned DataArrayFloat. This method allows for a
5929  * direct access to the field values. This method is intended for the field lying on one
5930  * mesh only.
5931  *  \param [in,out] entries - the sequence describing parameters of a support of each
5932  *         part of \a this field. Each item of this sequence consists of two parts. The
5933  *         first part describes a type of mesh entity and an id of discretization of a
5934  *         current field part. The second part describes a range of values [begin,end)
5935  *         within the returned array relating to the current field part.
5936  *  \return DataArrayFloat * - the pointer to the field values array.
5937  *  \throw If the number of underlying meshes is not equal to 1.
5938  *  \throw If no field values are available.
5939  *  \sa getUndergroundDataArray()
5940  */
5941 DataArrayFloat *MEDFileFloatField1TSWithoutSDA::getUndergroundDataArrayFloatExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5942 {
5943   if(_field_per_mesh.size()!=1)
5944     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
5945   if(_field_per_mesh[0]==0)
5946     throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
5947   _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
5948   return getUndergroundDataArrayTemplate();
5949 }
5950
5951 MEDFileFloatField1TSWithoutSDA *MEDFileFloatField1TSWithoutSDA::shallowCpy() const
5952 {
5953   MCAuto<MEDFileFloatField1TSWithoutSDA> ret(new MEDFileFloatField1TSWithoutSDA(*this));
5954   ret->deepCpyLeavesFrom(*this);
5955   return ret.retn();
5956 }
5957
5958 MEDFileFloatField1TSWithoutSDA *MEDFileFloatField1TSWithoutSDA::deepCopy() const
5959 {
5960   MCAuto<MEDFileFloatField1TSWithoutSDA> ret(shallowCpy());
5961   if(_arr.isNotNull())
5962     ret->_arr=_arr->deepCopy();
5963   return ret.retn();
5964 }
5965
5966 //= MEDFileAnyTypeField1TS
5967
5968 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
5969 {
5970 }
5971
5972 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
5973 {
5974   med_field_type typcha;
5975   //
5976   std::vector<std::string> infos;
5977   std::string dtunit,fieldName,meshName;
5978   LocateField2(fid,0,true,fieldName,typcha,infos,dtunit,meshName);
5979   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ret;
5980   switch(typcha)
5981   {
5982     case MED_FLOAT64:
5983       {
5984         ret=MEDFileField1TSWithoutSDA::New(fieldName,meshName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5985         break;
5986       }
5987     case MED_INT32:
5988       {
5989         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,meshName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5990         break;
5991       }
5992     case MED_NODE://6432
5993       {
5994         ret=MEDFileFloatField1TSWithoutSDA::New(fieldName,meshName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5995         break;
5996       }
5997     default:
5998       {
5999         std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fid) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
6000         throw INTERP_KERNEL::Exception(oss.str());
6001       }
6002   }
6003   ret->setDtUnit(dtunit.c_str());
6004   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
6005   //
6006   med_int numdt,numit;
6007   med_float dt;
6008   MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,fieldName.c_str(),1,&numdt,&numit,&dt));
6009   ret->setTime(numdt,numit,dt);
6010   ret->_csit=1;
6011   if(loadAll)
6012     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,entities);
6013   else
6014     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,entities);
6015   return ret.retn();
6016 }
6017
6018 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
6019 try:MEDFileFieldGlobsReal(fid)
6020 {
6021   _content=BuildContentFrom(fid,loadAll,ms,entities);
6022   loadGlobals(fid);
6023 }
6024 catch(INTERP_KERNEL::Exception& e)
6025 {
6026     throw e;
6027 }
6028
6029 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
6030 {
6031   med_field_type typcha;
6032   std::vector<std::string> infos;
6033   std::string dtunit,meshName;
6034   int nbSteps(0);
6035   {
6036     int iii=-1;
6037     nbSteps=LocateField(fid,fieldName,iii,typcha,infos,dtunit,meshName);
6038   }
6039   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ret;
6040   switch(typcha)
6041   {
6042     case MED_FLOAT64:
6043       {
6044         ret=MEDFileField1TSWithoutSDA::New(fieldName,meshName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
6045         break;
6046       }
6047     case MED_INT32:
6048       {
6049         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,meshName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
6050         break;
6051       }
6052     case MED_NODE://6432
6053       {
6054         ret=MEDFileFloatField1TSWithoutSDA::New(fieldName,meshName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
6055         break;
6056       }
6057     default:
6058       {
6059         std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fid,fieldName) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
6060         throw INTERP_KERNEL::Exception(oss.str());
6061       }
6062   }
6063   ret->setMeshName(meshName);
6064   ret->setDtUnit(dtunit.c_str());
6065   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
6066   //
6067   if(nbSteps<1)
6068     {
6069       std::ostringstream oss; oss << "MEDFileField1TS(fid,fieldName) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but there is no time steps on it !";
6070       throw INTERP_KERNEL::Exception(oss.str());
6071     }
6072   //
6073   med_int numdt,numit;
6074   med_float dt;
6075   MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,fieldName.c_str(),1,&numdt,&numit,&dt));
6076   ret->setTime(numdt,numit,dt);
6077   ret->_csit=1;
6078   if(loadAll)
6079     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,entities);
6080   else
6081     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,entities);
6082   return ret.retn();
6083 }
6084
6085 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
6086 try:MEDFileFieldGlobsReal(fid)
6087 {
6088   _content=BuildContentFrom(fid,fieldName,loadAll,ms,entities);
6089   loadGlobals(fid);
6090 }
6091 catch(INTERP_KERNEL::Exception& e)
6092 {
6093     throw e;
6094 }
6095
6096 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c)
6097 {
6098   if(!c)
6099     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
6100   if(dynamic_cast<const MEDFileField1TSWithoutSDA *>(c))
6101     {
6102       MCAuto<MEDFileField1TS> ret(MEDFileField1TS::New());
6103       ret->_content=c; c->incrRef();
6104       return ret.retn();
6105     }
6106   if(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(c))
6107     {
6108       MCAuto<MEDFileIntField1TS> ret(MEDFileIntField1TS::New());
6109       ret->_content=c; c->incrRef();
6110       return ret.retn();
6111     }
6112   throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
6113 }
6114
6115 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c, med_idt fid)
6116 {
6117   MEDFileAnyTypeField1TS *ret(BuildNewInstanceFromContent(c));
6118   ret->setFileName(FileNameFromFID(fid));
6119   return ret;
6120 }
6121
6122 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, bool loadAll)
6123 {
6124   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6125   return New(fid,loadAll);
6126 }
6127
6128 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(med_idt fid, bool loadAll)
6129 {
6130   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,loadAll,0,0));
6131   MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
6132   ret->loadGlobals(fid);
6133   return ret.retn();
6134 }
6135
6136 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
6137 {
6138   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6139   return New(fid,fieldName,loadAll);
6140 }
6141
6142 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(med_idt fid, const std::string& fieldName, bool loadAll)
6143 {
6144   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,loadAll,0,0));
6145   MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
6146   ret->loadGlobals(fid);
6147   return ret.retn();
6148 }
6149
6150 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6151 {
6152   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6153   return New(fid,fieldName,iteration,order,loadAll);
6154 }
6155
6156 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll)
6157 {
6158   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,iteration,order,loadAll,0,0));
6159   MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
6160   ret->loadGlobals(fid);
6161   return ret.retn();
6162 }
6163
6164 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::NewAdv(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileEntities *entities)
6165 {
6166   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6167   return NewAdv(fid,fieldName,iteration,order,loadAll,entities);
6168 }
6169
6170 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::NewAdv(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileEntities *entities)
6171 {
6172   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,iteration,order,loadAll,0,entities));
6173   MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
6174   ret->loadGlobals(fid);
6175   return ret.retn();
6176 }
6177
6178 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
6179 {
6180   med_field_type typcha;
6181   std::vector<std::string> infos;
6182   std::string dtunit,meshName;
6183   int iii(-1);
6184   int nbOfStep2(LocateField(fid,fieldName,iii,typcha,infos,dtunit,meshName));
6185   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ret;
6186   switch(typcha)
6187   {
6188     case MED_FLOAT64:
6189       {
6190         ret=MEDFileField1TSWithoutSDA::New(fieldName,meshName,-1,iteration,order,std::vector<std::string>());
6191         break;
6192       }
6193     case MED_INT32:
6194       {
6195         ret=MEDFileIntField1TSWithoutSDA::New(fieldName,meshName,-1,iteration,order,std::vector<std::string>());
6196         break;
6197       }
6198     default:
6199       {
6200         std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fid,fieldName,iteration,order) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
6201         throw INTERP_KERNEL::Exception(oss.str());
6202       }
6203   }
6204   ret->setDtUnit(dtunit.c_str());
6205   ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
6206   //
6207   bool found=false;
6208   std::vector< std::pair<int,int> > dtits(nbOfStep2);
6209   for(int i=0;i<nbOfStep2 && !found;i++)
6210     {
6211       med_int numdt,numit;
6212       med_float dt;
6213       MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,fieldName.c_str(),i+1,&numdt,&numit,&dt));
6214       if(numdt==iteration && numit==order)
6215         {
6216           found=true;
6217           ret->_csit=i+1;
6218         }
6219       else
6220         dtits[i]=std::pair<int,int>(numdt,numit);
6221     }
6222   if(!found)
6223     {
6224       std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << FileNameFromFID(fid) << "' ! Available iterations are : ";
6225       for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
6226         oss << "(" << (*iter).first << "," << (*iter).second << "), ";
6227       throw INTERP_KERNEL::Exception(oss.str());
6228     }
6229   if(loadAll)
6230     ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,entities);
6231   else
6232     ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,entities);
6233   return ret.retn();
6234 }
6235
6236 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
6237 try:MEDFileFieldGlobsReal(fid)
6238 {
6239   _content=BuildContentFrom(fid,fieldName,iteration,order,loadAll,ms,entities);
6240   loadGlobals(fid);
6241 }
6242 catch(INTERP_KERNEL::Exception& e)
6243 {
6244     throw e;
6245 }
6246
6247 /*!
6248  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6249  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6250  *
6251  * \warning this is a shallow copy constructor
6252  */
6253 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent)
6254 {
6255   if(!shallowCopyOfContent)
6256     {
6257       const MEDFileAnyTypeField1TSWithoutSDA *otherPtr(&other);
6258       otherPtr->incrRef();
6259       _content=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(otherPtr);
6260     }
6261   else
6262     {
6263       _content=other.shallowCpy();
6264     }
6265 }
6266
6267 int MEDFileAnyTypeField1TS::LocateField2(med_idt fid, int fieldIdCFormat, bool checkFieldId, std::string& fieldName, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut, std::string& meshName)
6268 {
6269   if(checkFieldId)
6270     {
6271       int nbFields=MEDnField(fid);
6272       if(fieldIdCFormat>=nbFields)
6273         {
6274           std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << FileNameFromFID(fid) << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
6275           throw INTERP_KERNEL::Exception(oss.str());
6276         }
6277     }
6278   int ncomp(MEDfieldnComponent(fid,fieldIdCFormat+1));
6279   INTERP_KERNEL::AutoPtr<char> comp(MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE));
6280   INTERP_KERNEL::AutoPtr<char> unit(MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE));
6281   INTERP_KERNEL::AutoPtr<char> dtunit(MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE));
6282   INTERP_KERNEL::AutoPtr<char> nomcha(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
6283   INTERP_KERNEL::AutoPtr<char> nomMaa(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
6284   med_bool localMesh;
6285   int nbOfStep;
6286   MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,fieldIdCFormat+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep));
6287   fieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
6288   dtunitOut=MEDLoaderBase::buildStringFromFortran(dtunit,MED_LNAME_SIZE);
6289   meshName=MEDLoaderBase::buildStringFromFortran(nomMaa,MED_NAME_SIZE);
6290   infos.clear(); infos.resize(ncomp);
6291   for(int j=0;j<ncomp;j++)
6292     infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
6293   return nbOfStep;
6294 }
6295
6296 /*!
6297  * This method throws an INTERP_KERNEL::Exception if \a fieldName field is not in file pointed by \a fid and with name \a fileName.
6298  *
6299  * \param [out]
6300  * \return in case of success the number of time steps available for the field with name \a fieldName.
6301  */
6302 int MEDFileAnyTypeField1TS::LocateField(med_idt fid, const std::string& fieldName, int& posCFormat, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut, std::string& meshName)
6303 {
6304   int nbFields=MEDnField(fid);
6305   bool found=false;
6306   std::vector<std::string> fns(nbFields);
6307   int nbOfStep2(-1);
6308   for(int i=0;i<nbFields && !found;i++)
6309     {
6310       std::string tmp,tmp2;
6311       nbOfStep2=LocateField2(fid,i,false,tmp,typcha,infos,dtunitOut,tmp2);
6312       fns[i]=tmp;
6313       found=(tmp==fieldName);
6314       if(found)
6315         {
6316           posCFormat=i;
6317           meshName=tmp2;
6318         }
6319     }
6320   if(!found)
6321     {
6322       std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << FileNameFromFID(fid) << "' ! Available fields are : ";
6323       for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
6324         oss << "\"" << *it << "\" ";
6325       throw INTERP_KERNEL::Exception(oss.str());
6326     }
6327   return nbOfStep2;
6328 }
6329
6330 /*!
6331  * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
6332  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
6333  * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
6334  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
6335  * to keep a valid instance.
6336  * 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.
6337  * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
6338  * 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.
6339  *
6340  * \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.
6341  * \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.
6342  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
6343  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
6344  * \param [in] newLocName is the new localization name.
6345  * \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.
6346  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
6347  */
6348 void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newPflName, bool forceRenameOnGlob)
6349 {
6350   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
6351   std::string oldPflName=disc->getProfile();
6352   std::vector<std::string> vv=getPflsReallyUsedMulti();
6353   int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
6354   if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
6355     {
6356       disc->setProfile(newPflName);
6357       DataArrayInt *pfl=getProfile(oldPflName.c_str());
6358       pfl->setName(newPflName);
6359     }
6360   else
6361     {
6362       std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
6363       throw INTERP_KERNEL::Exception(oss.str());
6364     }
6365 }
6366
6367 /*!
6368  * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
6369  * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
6370  * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
6371  * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
6372  * to keep a valid instance.
6373  * 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.
6374  * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
6375  * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
6376  * 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.
6377  *
6378  * \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.
6379  * \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.
6380  * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
6381  *             \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
6382  * \param [in] newLocName is the new localization name.
6383  * \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.
6384  *             If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
6385  */
6386 void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newLocName, bool forceRenameOnGlob)
6387 {
6388   MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
6389   std::string oldLocName=disc->getLocalization();
6390   std::vector<std::string> vv=getLocsReallyUsedMulti();
6391   int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
6392   if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
6393     {
6394       disc->setLocalization(newLocName);
6395       MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
6396       loc.setName(newLocName);
6397     }
6398   else
6399     {
6400       std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
6401       throw INTERP_KERNEL::Exception(oss.str());
6402     }
6403 }
6404
6405 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase()
6406 {
6407   MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
6408   if(!ret)
6409     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : content is expected to be not null !");
6410   return ret;
6411 }
6412
6413 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() const
6414 {
6415   const MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
6416   if(!ret)
6417     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : const content is expected to be not null !");
6418   return ret;
6419 }
6420
6421 /*!
6422  * This method alloc the arrays and load potentially huge arrays contained in this field.
6423  * This method should be called when a MEDFileAnyTypeField1TS::New constructor has been with false as the last parameter.
6424  * This method can be also called to refresh or reinit values from a file.
6425  *
6426  * \throw If the fileName is not set or points to a non readable MED file.
6427  * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
6428  */
6429 void MEDFileAnyTypeField1TS::loadArrays()
6430 {
6431   if(getFileName().empty())
6432     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::loadArrays : the structure does not come from a file !");
6433   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
6434   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
6435 }
6436
6437 /*!
6438  * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
6439  * But once data loaded once, this method does nothing. Contrary to MEDFileAnyTypeField1TS::loadArrays and MEDFileAnyTypeField1TS::unloadArrays
6440  * this method does not throw if \a this does not come from file read.
6441  *
6442  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::unloadArrays
6443  */
6444 void MEDFileAnyTypeField1TS::loadArraysIfNecessary()
6445 {
6446   if(!getFileName().empty())
6447     {
6448       MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
6449       contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
6450     }
6451 }
6452
6453 /*!
6454  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
6455  * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
6456  * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileAnyTypeField1TS::unloadArraysWithoutDataLoss instead.
6457  *
6458  * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary, MEDFileAnyTypeField1TS::unloadArraysWithoutDataLoss
6459  */
6460 void MEDFileAnyTypeField1TS::unloadArrays()
6461 {
6462   contentNotNullBase()->unloadArrays();
6463 }
6464
6465 /*!
6466  * This method potentially releases big data arrays if \a this is coming from a file. If \a this has been built from scratch this method will have no effect.
6467  * This method is the symetrical method of MEDFileAnyTypeField1TS::loadArraysIfNecessary.
6468  * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
6469  *
6470  * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
6471  */
6472 void MEDFileAnyTypeField1TS::unloadArraysWithoutDataLoss()
6473 {
6474   if(!getFileName().empty())
6475     contentNotNullBase()->unloadArrays();
6476 }
6477
6478 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const
6479 {
6480   int nbComp(getNumberOfComponents());
6481   INTERP_KERNEL::AutoPtr<char> comp(MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE));
6482   INTERP_KERNEL::AutoPtr<char> unit(MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE));
6483   for(int i=0;i<nbComp;i++)
6484     {
6485       std::string info=getInfo()[i];
6486       std::string c,u;
6487       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
6488       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
6489       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
6490     }
6491   if(getName().empty())
6492     throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
6493   MEDFILESAFECALLERWR0(MEDfieldCr,(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str()));
6494   writeGlobals(fid,*this);
6495   contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
6496 }
6497
6498 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySizeWithoutChildren() const
6499 {
6500   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
6501 }
6502
6503 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TS::getDirectChildrenWithNull() const
6504 {
6505   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildrenWithNull());
6506   ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)_content);
6507   return ret;
6508 }
6509
6510 /*!
6511  * Returns a string describing \a this field. This string is outputted
6512  * by \c print Python command.
6513  */
6514 std::string MEDFileAnyTypeField1TS::simpleRepr() const
6515 {
6516   std::ostringstream oss;
6517   contentNotNullBase()->simpleRepr(0,oss,-1);
6518   simpleReprGlobs(oss);
6519   return oss.str();
6520 }
6521
6522 /*!
6523  * This method returns all profiles whose name is non empty used.
6524  * \b WARNING If profile is used several times it will be reported \b only \b once.
6525  * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
6526  */
6527 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
6528 {
6529   return contentNotNullBase()->getPflsReallyUsed2();
6530 }
6531
6532 /*!
6533  * This method returns all localizations whose name is non empty used.
6534  * \b WARNING If localization is used several times it will be reported \b only \b once.
6535  */
6536 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
6537 {
6538   return contentNotNullBase()->getLocsReallyUsed2();
6539 }
6540
6541 /*!
6542  * This method returns all profiles whose name is non empty used.
6543  * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
6544  */
6545 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
6546 {
6547   return contentNotNullBase()->getPflsReallyUsedMulti2();
6548 }
6549
6550 /*!
6551  * This method returns all localizations whose name is non empty used.
6552  * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
6553  */
6554 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
6555 {
6556   return contentNotNullBase()->getLocsReallyUsedMulti2();
6557 }
6558
6559 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
6560 {
6561   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
6562 }
6563
6564 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
6565 {
6566   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
6567 }
6568
6569 int MEDFileAnyTypeField1TS::getDimension() const
6570 {
6571   return contentNotNullBase()->getDimension();
6572 }
6573
6574 int MEDFileAnyTypeField1TS::getIteration() const
6575 {
6576   return contentNotNullBase()->getIteration();
6577 }
6578
6579 int MEDFileAnyTypeField1TS::getOrder() const
6580 {
6581   return contentNotNullBase()->getOrder();
6582 }
6583
6584 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
6585 {
6586   return contentNotNullBase()->getTime(iteration,order);
6587 }
6588
6589 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
6590 {
6591   contentNotNullBase()->setTime(iteration,order,val);
6592 }
6593
6594 std::string MEDFileAnyTypeField1TS::getName() const
6595 {
6596   return contentNotNullBase()->getName();
6597 }
6598
6599 void MEDFileAnyTypeField1TS::setName(const std::string& name)
6600 {
6601   contentNotNullBase()->setName(name);
6602 }
6603
6604 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
6605 {
6606   contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
6607 }
6608
6609 std::string MEDFileAnyTypeField1TS::getDtUnit() const
6610 {
6611   return contentNotNullBase()->getDtUnit();
6612 }
6613
6614 void MEDFileAnyTypeField1TS::setDtUnit(const std::string& dtUnit)
6615 {
6616   contentNotNullBase()->setDtUnit(dtUnit);
6617 }
6618
6619 std::string MEDFileAnyTypeField1TS::getMeshName() const
6620 {
6621   return contentNotNullBase()->getMeshName();
6622 }
6623
6624 void MEDFileAnyTypeField1TS::setMeshName(const std::string& newMeshName)
6625 {
6626   contentNotNullBase()->setMeshName(newMeshName);
6627 }
6628
6629 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
6630 {
6631   return contentNotNullBase()->changeMeshNames(modifTab);
6632 }
6633
6634 int MEDFileAnyTypeField1TS::getMeshIteration() const
6635 {
6636   return contentNotNullBase()->getMeshIteration();
6637 }
6638
6639 int MEDFileAnyTypeField1TS::getMeshOrder() const
6640 {
6641   return contentNotNullBase()->getMeshOrder();
6642 }
6643
6644 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
6645 {
6646   return contentNotNullBase()->getNumberOfComponents();
6647 }
6648
6649 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
6650 {
6651   return contentNotNullBase()->isDealingTS(iteration,order);
6652 }
6653
6654 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
6655 {
6656   return contentNotNullBase()->getDtIt();
6657 }
6658
6659 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
6660 {
6661   contentNotNullBase()->fillIteration(p);
6662 }
6663
6664 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
6665 {
6666   contentNotNullBase()->fillTypesOfFieldAvailable(types);
6667 }
6668
6669 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos)
6670 {
6671   contentNotNullBase()->setInfo(infos);
6672 }
6673
6674 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
6675 {
6676   return contentNotNullBase()->getInfo();
6677 }
6678 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
6679 {
6680   return contentNotNullBase()->getInfo();
6681 }
6682
6683 bool MEDFileAnyTypeField1TS::presenceOfMultiDiscPerGeoType() const
6684 {
6685   return contentNotNullBase()->presenceOfMultiDiscPerGeoType();
6686 }
6687
6688 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
6689 {
6690   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
6691 }
6692
6693 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
6694 {
6695   return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
6696 }
6697
6698 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
6699 {
6700   return contentNotNullBase()->getNonEmptyLevels(mname,levs);
6701 }
6702
6703 void MEDFileAnyTypeField1TS::convertMedBallIntoClassic()
6704 {
6705   return contentNotNullBase()->convertMedBallIntoClassic();
6706 }
6707
6708 void MEDFileAnyTypeField1TS::makeReduction(INTERP_KERNEL::NormalizedCellType ct, TypeOfField tof, const DataArrayInt *pfl)
6709 {
6710   return contentNotNullBase()->makeReduction(ct,tof,pfl);
6711 }
6712
6713 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const
6714 {
6715   return contentNotNullBase()->getTypesOfFieldAvailable();
6716 }
6717
6718 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,
6719                                                                                               std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const
6720 {
6721   return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
6722 }
6723
6724 /*!
6725  * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
6726  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
6727  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
6728  */
6729 std::vector< MCAuto< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const
6730 {
6731   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6732   if(!content)
6733     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
6734   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
6735   std::size_t sz(contentsSplit.size());
6736   std::vector< MCAuto< MEDFileAnyTypeField1TS > > ret(sz);
6737   for(std::size_t i=0;i<sz;i++)
6738     {
6739       ret[i]=shallowCpy();
6740       ret[i]->_content=contentsSplit[i];
6741     }
6742   return ret;
6743 }
6744
6745 /*!
6746  * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
6747  * The returned instances are shallowed copied of \a this except that for globals that are share with those contained in \a this.
6748  */
6749 std::vector< MCAuto< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const
6750 {
6751   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6752   if(!content)
6753     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
6754   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit(content->splitDiscretizations());
6755   std::size_t sz(contentsSplit.size());
6756   std::vector< MCAuto< MEDFileAnyTypeField1TS > > ret(sz);
6757   for(std::size_t i=0;i<sz;i++)
6758     {
6759       ret[i]=shallowCpy();
6760       ret[i]->_content=contentsSplit[i];
6761     }
6762   return ret;
6763 }
6764
6765 /*!
6766  * This method returns as MEDFileAnyTypeField1TS new instances as number of maximal number of discretization in \a this.
6767  * The returned instances are shallowed copied of \a this except that for globals that are share with those contained in \a this.
6768  */
6769 std::vector< MCAuto< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitMultiDiscrPerGeoTypes() const
6770 {
6771   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6772   if(!content)
6773     throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitMultiDiscrPerGeoTypes : no content in this ! Unable to split discretization !");
6774   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit(content->splitMultiDiscrPerGeoTypes());
6775   std::size_t sz(contentsSplit.size());
6776   std::vector< MCAuto< MEDFileAnyTypeField1TS > > ret(sz);
6777   for(std::size_t i=0;i<sz;i++)
6778     {
6779       ret[i]=shallowCpy();
6780       ret[i]->_content=contentsSplit[i];
6781     }
6782   return ret;
6783 }
6784
6785 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCopy() const
6786 {
6787   MCAuto<MEDFileAnyTypeField1TS> ret=shallowCpy();
6788   if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
6789     ret->_content=_content->deepCopy();
6790   ret->deepCpyGlobs(*this);
6791   return ret.retn();
6792 }
6793
6794 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
6795 {
6796   return contentNotNullBase()->copyTinyInfoFrom(field,arr);
6797 }
6798
6799 //= MEDFileField1TS
6800
6801 /*!
6802  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
6803  * following the given input policy.
6804  *
6805  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6806  *                            By default (true) the globals are deeply copied.
6807  * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
6808  */
6809 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool isDeepCpyGlobs) const
6810 {
6811   MCAuto<MEDFileIntField1TS> ret;
6812   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6813   if(content)
6814     {
6815       const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
6816       if(!contc)
6817         throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
6818       MCAuto<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
6819       ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc));
6820     }
6821   else
6822     ret=MEDFileIntField1TS::New();
6823   if(isDeepCpyGlobs)
6824     ret->deepCpyGlobs(*this);
6825   else
6826     ret->shallowCpyGlobs(*this);
6827   return ret.retn();
6828 }
6829
6830 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MCAuto<DataArray>& arr)
6831 {
6832   if(!f)
6833     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
6834   if(arr.isNull())
6835     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
6836   DataArrayDouble *arrOutC(dynamic_cast<DataArrayDouble *>((DataArray*)arr));
6837   if(!arrOutC)
6838     throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6839   f->setArray(arrOutC);
6840 }
6841
6842 /*!
6843  * Return an extraction of \a this using \a extractDef map to specify the extraction.
6844  * The keys of \a extractDef is level relative to max ext of \a mm mesh.
6845  *
6846  * \return A new object that the caller is responsible to deallocate.
6847  * \sa MEDFileUMesh::deduceNodeSubPartFromCellSubPart , MEDFileUMesh::extractPart
6848  */
6849 MEDFileField1TS *MEDFileField1TS::extractPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef, MEDFileMesh *mm) const
6850 {
6851   if(!mm)
6852     throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : input mesh is NULL !");
6853   MCAuto<MEDFileField1TS> ret(MEDFileField1TS::New());
6854   std::vector<TypeOfField> tof(getTypesOfFieldAvailable());
6855   for(std::vector<TypeOfField>::const_iterator it0=tof.begin();it0!=tof.end();it0++)
6856     {
6857       if((*it0)!=ON_NODES)
6858         {
6859           std::vector<int> levs;
6860           getNonEmptyLevels(mm->getName(),levs);
6861           for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
6862             {
6863               std::map<int, MCAuto<DataArrayInt> >::const_iterator it2(extractDef.find(*lev));
6864               if(it2!=extractDef.end())
6865                 {
6866                   MCAuto<DataArrayInt> t((*it2).second);
6867                   if(t.isNull())
6868                     throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : presence of a value with null pointer 1 !");
6869                   MCAuto<MEDCouplingFieldDouble> f(getFieldOnMeshAtLevel(ON_CELLS,(*lev),mm));
6870                   MCAuto<MEDCouplingFieldDouble> fOut(f->buildSubPart(t));
6871                   ret->setFieldNoProfileSBT(fOut);
6872                 }
6873             }
6874         }
6875       else
6876         {
6877           std::map<int, MCAuto<DataArrayInt> >::const_iterator it2(extractDef.find(1));
6878           if(it2==extractDef.end())
6879             throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : presence of a NODE field and no extract array available for NODE !");
6880           MCAuto<DataArrayInt> t((*it2).second);
6881           if(t.isNull())
6882             throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : presence of a value with null pointer 1 !");
6883           MCAuto<MEDCouplingFieldDouble> f(getFieldOnMeshAtLevel(ON_NODES,0,mm));
6884           MCAuto<MEDCouplingFieldDouble> fOut(f->deepCopy());
6885           DataArrayDouble *arr(f->getArray());
6886           MCAuto<DataArrayDouble> newArr(arr->selectByTupleIdSafe(t->begin(),t->end()));
6887           fOut->setArray(newArr);
6888           ret->setFieldNoProfileSBT(fOut);
6889         }
6890     }
6891   return ret.retn();
6892 }
6893
6894 MEDFileField1TS::MEDFileField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
6895 try:MEDFileTemplateField1TS<double>(fid,loadAll,ms)
6896 {
6897 }
6898 catch(INTERP_KERNEL::Exception& e)
6899 { throw e; }
6900
6901 MEDFileField1TS::MEDFileField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms)
6902 try:MEDFileTemplateField1TS<double>(fid,fieldName,loadAll,ms)
6903 {
6904 }
6905 catch(INTERP_KERNEL::Exception& e)
6906 { throw e; }
6907
6908 MEDFileField1TS::MEDFileField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms)
6909 try:MEDFileTemplateField1TS<double>(fid,fieldName,iteration,order,loadAll,ms)
6910 {
6911 }
6912 catch(INTERP_KERNEL::Exception& e)
6913 { throw e; }
6914
6915 /*!
6916  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6917  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6918  *
6919  * \warning this is a shallow copy constructor
6920  */
6921 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
6922 try:MEDFileTemplateField1TS<double>(other,shallowCopyOfContent)
6923 {
6924 }
6925 catch(INTERP_KERNEL::Exception& e)
6926 { throw e; }
6927
6928 /*!
6929  * This is the simplest version to fetch a field for MED structure. One drawback : if \a this is a complex field (multi spatial discretization inside a same field) this method will throw exception and more advance
6930  * method should be called (getFieldOnMeshAtLevel for example).
6931  * But for normal usage of field in MED file world this method is the most efficient to fetch data.
6932  *
6933  * \param [in] mesh - the mesh the field is lying on
6934  * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6935  *          caller is to delete this field using decrRef() as it is no more needed.
6936  */
6937 MEDCouplingFieldDouble *MEDFileField1TS::field(const MEDFileMesh *mesh) const
6938 {
6939   MCAuto<DataArray> arrOut;
6940   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->fieldOnMesh(this,mesh,arrOut,*contentNotNull()));
6941   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6942   return ret.retn();
6943 }
6944
6945 /*!
6946  * Returns a new MEDCouplingFieldDouble of a given type lying on
6947  * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6948  * has not been constructed via file reading, an exception is thrown.
6949  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6950  *  \param [in] type - a spatial discretization of interest.
6951  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6952  *  \param [in] renumPol - specifies how to permute values of the result field according to
6953  *          the optional numbers of cells and nodes, if any. The valid values are
6954  *          - 0 - do not permute.
6955  *          - 1 - permute cells.
6956  *          - 2 - permute nodes.
6957  *          - 3 - permute cells and nodes.
6958  *
6959  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6960  *          caller is to delete this field using decrRef() as it is no more needed.
6961  *  \throw If \a this field has not been constructed via file reading.
6962  *  \throw If the MED file is not readable.
6963  *  \throw If there is no mesh in the MED file.
6964  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6965  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6966  *  \sa getFieldOnMeshAtLevel()
6967  */
6968 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const
6969 {
6970   if(getFileName().empty())
6971     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6972   MCAuto<DataArray> arrOut;
6973   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNull()));
6974   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6975   return ret.retn();
6976 }
6977
6978 /*!
6979  * Returns a new MEDCouplingFieldDouble of a given type lying on
6980  * the top level cells of the first mesh in MED file. If \a this field
6981  * has not been constructed via file reading, an exception is thrown.
6982  * For more info, see \ref AdvMEDLoaderAPIFieldRW
6983  *  \param [in] type - a spatial discretization of interest.
6984  *  \param [in] renumPol - specifies how to permute values of the result field according to
6985  *          the optional numbers of cells and nodes, if any. The valid values are
6986  *          - 0 - do not permute.
6987  *          - 1 - permute cells.
6988  *          - 2 - permute nodes.
6989  *          - 3 - permute cells and nodes.
6990  *
6991  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6992  *          caller is to delete this field using decrRef() as it is no more needed.
6993  *  \throw If \a this field has not been constructed via file reading.
6994  *  \throw If the MED file is not readable.
6995  *  \throw If there is no mesh in the MED file.
6996  *  \throw If no field values of the given \a type.
6997  *  \throw If no field values lying on the top level support.
6998  *  \sa getFieldAtLevel()
6999  */
7000 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const
7001 {
7002   if(getFileName().empty())
7003     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
7004   MCAuto<DataArray> arrOut;
7005   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNull()));
7006   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
7007   return ret.retn();
7008 }
7009
7010 /*!
7011  * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
7012  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7013  *  \param [in] type - a spatial discretization of the new field.
7014  *  \param [in] mesh - the supporting mesh.
7015  *  \param [in] renumPol - specifies how to permute values of the result field according to
7016  *          the optional numbers of cells and nodes, if any. The valid values are
7017  *          - 0 - do not permute.
7018  *          - 1 - permute cells.
7019  *          - 2 - permute nodes.
7020  *          - 3 - permute cells and nodes.
7021  *
7022  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
7023  *          caller is to delete this field using decrRef() as it is no more needed.
7024  *  \throw If no field of \a this is lying on \a mesh.
7025  *  \throw If the mesh is empty.
7026  *  \throw If no field values of the given \a type are available.
7027  *  \sa getFieldAtLevel()
7028  *  \sa getFieldOnMeshAtLevel()
7029  */
7030 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const
7031 {
7032   MCAuto<DataArray> arrOut;
7033   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull()));
7034   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
7035   return ret.retn();
7036 }
7037
7038 /*!
7039  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
7040  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7041  *  \param [in] type - a spatial discretization of interest.
7042  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
7043  *  \param [in] mesh - the supporting mesh.
7044  *  \param [in] renumPol - specifies how to permute values of the result field according to
7045  *          the optional numbers of cells and nodes, if any. The valid values are
7046  *          - 0 - do not permute.
7047  *          - 1 - permute cells.
7048  *          - 2 - permute nodes.
7049  *          - 3 - permute cells and nodes.
7050  *
7051  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
7052  *          caller is to delete this field using decrRef() as it is no more needed.
7053  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
7054  *  \throw If no field of \a this is lying on \a mesh.
7055  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
7056  *  \sa getFieldAtLevel()
7057  *  \sa getFieldOnMeshAtLevel()
7058  */
7059 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
7060 {
7061   MCAuto<DataArray> arrOut;
7062   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull()));
7063   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
7064   return ret.retn();
7065 }
7066
7067 /*!
7068  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
7069  * This method is called "Old" because in MED3 norm a field has only one meshName
7070  * attached, so this method is for readers of MED2 files. If \a this field
7071  * has not been constructed via file reading, an exception is thrown.
7072  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7073  *  \param [in] type - a spatial discretization of interest.
7074  *  \param [in] mName - a name of the supporting mesh.
7075  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
7076  *  \param [in] renumPol - specifies how to permute values of the result field according to
7077  *          the optional numbers of cells and nodes, if any. The valid values are
7078  *          - 0 - do not permute.
7079  *          - 1 - permute cells.
7080  *          - 2 - permute nodes.
7081  *          - 3 - permute cells and nodes.
7082  *
7083  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
7084  *          caller is to delete this field using decrRef() as it is no more needed.
7085  *  \throw If the MED file is not readable.
7086  *  \throw If there is no mesh named \a mName in the MED file.
7087  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
7088  *  \throw If \a this field has not been constructed via file reading.
7089  *  \throw If no field of \a this is lying on the mesh named \a mName.
7090  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
7091  *  \sa getFieldAtLevel()
7092  */
7093 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, int renumPol) const
7094 {
7095   if(getFileName().empty())
7096     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
7097   MCAuto<DataArray> arrOut;
7098   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull()));
7099   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
7100   return ret.retn();
7101 }
7102
7103 /*!
7104  * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
7105  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
7106  * "Sort By Type"), if not, an exception is thrown.
7107  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7108  *  \param [in] field - the field to add to \a this.
7109  *  \throw If the name of \a field is empty.
7110  *  \throw If the data array of \a field is not set.
7111  *  \throw If the data array is already allocated but has different number of components
7112  *         than \a field.
7113  *  \throw If the underlying mesh of \a field has no name.
7114  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
7115  */
7116 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
7117 {
7118   setFileName("");
7119   contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
7120 }
7121
7122 /*!
7123  * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
7124  * can be an aggregation of several MEDCouplingFieldDouble instances.
7125  * The mesh support of input parameter \a field is ignored here, it can be NULL.
7126  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
7127  * and \a profile.
7128  *
7129  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
7130  * A new profile is added only if no equal profile is missing.
7131  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7132  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
7133  *  \param [in] mesh - the supporting mesh of \a field.
7134  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
7135  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
7136  *  \throw If either \a field or \a mesh or \a profile has an empty name.
7137  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
7138  *  \throw If the data array of \a field is not set.
7139  *  \throw If the data array of \a this is already allocated but has different number of
7140  *         components than \a field.
7141  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
7142  *  \sa setFieldNoProfileSBT()
7143  */
7144 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
7145 {
7146   setFileName("");
7147   contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
7148 }
7149
7150 MEDFileField1TS *MEDFileField1TS::shallowCpy() const
7151 {
7152   return new MEDFileField1TS(*this);
7153 }
7154
7155 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
7156                                                                                       std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const
7157 {
7158   return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
7159 }
7160
7161 //= MEDFileIntField1TS
7162
7163 MEDFileIntField1TS::MEDFileIntField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
7164 try:MEDFileTemplateField1TS<int>(fid,loadAll,ms)
7165 {
7166 }
7167 catch(INTERP_KERNEL::Exception& e)
7168 { throw e; }
7169
7170 MEDFileIntField1TS::MEDFileIntField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms)
7171 try:MEDFileTemplateField1TS<int>(fid,fieldName,loadAll,ms)
7172 {
7173 }
7174 catch(INTERP_KERNEL::Exception& e)
7175 { throw e; }
7176
7177 MEDFileIntField1TS::MEDFileIntField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms)
7178 try:MEDFileTemplateField1TS<int>(fid,fieldName,iteration,order,loadAll,ms)
7179 {
7180 }
7181 catch(INTERP_KERNEL::Exception& e)
7182 { throw e; }
7183
7184 /*!
7185  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
7186  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
7187  *
7188  * \warning this is a shallow copy constructor
7189  */
7190 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileTemplateField1TS<int>(other,shallowCopyOfContent)
7191 {
7192 }
7193
7194 MEDFileIntField1TS *MEDFileIntField1TS::shallowCpy() const
7195 {
7196   return new MEDFileIntField1TS(*this);
7197 }
7198
7199 /*!
7200  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
7201  * following the given input policy.
7202  *
7203  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
7204  *                            By default (true) the globals are deeply copied.
7205  * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
7206  */
7207 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool isDeepCpyGlobs) const
7208 {
7209   MCAuto<MEDFileField1TS> ret;
7210   const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
7211   if(content)
7212     {
7213       const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
7214       if(!contc)
7215         throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
7216       MCAuto<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
7217       ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc));
7218     }
7219   else
7220     ret=MEDFileField1TS::New();
7221   if(isDeepCpyGlobs)
7222     ret->deepCpyGlobs(*this);
7223   else
7224     ret->shallowCpyGlobs(*this);
7225   return ret.retn();
7226 }
7227
7228 /*!
7229  * Adds a MEDCouplingFieldInt to \a this. The underlying mesh of the given field is
7230  * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
7231  * "Sort By Type"), if not, an exception is thrown.
7232  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7233  *  \param [in] field - the field to add to \a this.
7234  *  \throw If the name of \a field is empty.
7235  *  \throw If the data array of \a field is not set.
7236  *  \throw If the data array is already allocated but has different number of components
7237  *         than \a field.
7238  *  \throw If the underlying mesh of \a field has no name.
7239  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
7240  */
7241 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldInt *field)
7242 {
7243   MCAuto<MEDCouplingFieldDouble> field2(ConvertFieldIntToFieldDouble(field));
7244   setFileName("");
7245   contentNotNull()->setFieldNoProfileSBT(field2,field->getArray(),*this,*contentNotNull());
7246 }
7247
7248 /*!
7249  * Adds a MEDCouplingFieldInt to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
7250  * can be an aggregation of several MEDCouplingFieldDouble instances.
7251  * The mesh support of input parameter \a field is ignored here, it can be NULL.
7252  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
7253  * and \a profile.
7254  *
7255  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
7256  * A new profile is added only if no equal profile is missing.
7257  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7258  *  \param [in] field - the field to add to \a this.
7259  *  \param [in] mesh - the supporting mesh of \a field.
7260  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
7261  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
7262  *  \throw If either \a field or \a mesh or \a profile has an empty name.
7263  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
7264  *  \throw If the data array of \a field is not set.
7265  *  \throw If the data array of \a this is already allocated but has different number of
7266  *         components than \a field.
7267  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
7268  *  \sa setFieldNoProfileSBT()
7269  */
7270 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldInt *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
7271 {
7272   MCAuto<MEDCouplingFieldDouble> field2(ConvertFieldIntToFieldDouble(field));
7273   setFileName("");
7274   contentNotNull()->setFieldProfile(field2,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
7275 }
7276
7277 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const
7278 {
7279   if(getFileName().empty())
7280     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
7281   MCAuto<DataArray> arrOut;
7282   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNull()));
7283   MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
7284   return ret2.retn();
7285 }
7286
7287 MCAuto<MEDCouplingFieldInt> MEDFileIntField1TS::SetDataArrayDoubleInIntField(MEDCouplingFieldDouble *f, MCAuto<DataArray>& arr)
7288 {
7289   int t1,t2;
7290   double t0(f->getTime(t1,t2));
7291   MCAuto<DataArrayInt> arr2(DynamicCastSafe<DataArray,DataArrayInt>(arr));
7292   MCAuto<MEDCouplingFieldTemplate> ft(MEDCouplingFieldTemplate::New(*f));
7293   MCAuto<MEDCouplingFieldInt> ret(MEDCouplingFieldInt::New(*ft));
7294   ret->setTime(t0,t1,t2); ret->setArray(arr2);
7295   return ret.retn();
7296 }
7297
7298 MCAuto<MEDCouplingFieldDouble> MEDFileIntField1TS::ConvertFieldIntToFieldDouble(const MEDCouplingFieldInt *f)
7299 {
7300   if(!f)
7301     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ConvertFieldIntToFieldDouble : null input field !");
7302   int t1,t2;
7303   double t0(f->getTime(t1,t2));
7304   MCAuto<MEDCouplingFieldTemplate> ft(MEDCouplingFieldTemplate::New(*f));
7305   MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(*ft));
7306   ret->setTime(t0,t1,t2);
7307   return ret;
7308 }
7309
7310 MEDFileIntField1TS *MEDFileIntField1TS::extractPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef, MEDFileMesh *mm) const
7311 {
7312   throw INTERP_KERNEL::Exception("MEDFileIntField1TS::extractPart : not implemented yet !");
7313 }
7314
7315 /*!
7316  * This is the simplest version to fetch a field for MED structure. One drawback : if \a this is a complex field (multi spatial discretization inside a same field) this method will throw exception and more advance
7317  * method should be called (getFieldOnMeshAtLevel for example).
7318  * But for normal usage of field in MED file world this method is the most efficient to fetch data.
7319  *
7320  * \param [in] mesh - the mesh the field is lying on
7321  * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldInt. The
7322  *          caller is to delete this field using decrRef() as it is no more needed.
7323  */
7324 MEDCouplingFieldInt *MEDFileIntField1TS::field(const MEDFileMesh *mesh) const
7325 {
7326   MCAuto<DataArray> arrOut;
7327   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->fieldOnMesh(this,mesh,arrOut,*contentNotNull()));
7328   MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
7329   return ret2.retn();
7330 }
7331
7332 /*!
7333  * Returns a new MEDCouplingFieldInt of a given type lying on
7334  * the top level cells of the first mesh in MED file. If \a this field
7335  * has not been constructed via file reading, an exception is thrown.
7336  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7337  *  \param [in] type - a spatial discretization of interest.
7338  *  \param [in] renumPol - specifies how to permute values of the result field according to
7339  *          the optional numbers of cells and nodes, if any. The valid values are
7340  *          - 0 - do not permute.
7341  *          - 1 - permute cells.
7342  *          - 2 - permute nodes.
7343  *          - 3 - permute cells and nodes.
7344  *
7345  *  \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
7346  *          caller is to delete this field using decrRef() as it is no more needed.
7347  *  \throw If \a this field has not been constructed via file reading.
7348  *  \throw If the MED file is not readable.
7349  *  \throw If there is no mesh in the MED file.
7350  *  \throw If no field values of the given \a type.
7351  *  \throw If no field values lying on the top level support.
7352  *  \sa getFieldAtLevel()
7353  */
7354 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const
7355 {
7356   if(getFileName().empty())
7357     throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
7358   MCAuto<DataArray> arrOut;
7359   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNull()));
7360   MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
7361   return ret2.retn();
7362 }
7363
7364 /*!
7365  * Returns a new MEDCouplingFieldInt of given type lying on a given mesh.
7366  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7367  *  \param [in] type - a spatial discretization of the new field.
7368  *  \param [in] mesh - the supporting mesh.
7369  *  \param [in] renumPol - specifies how to permute values of the result field according to
7370  *          the optional numbers of cells and nodes, if any. The valid values are
7371  *          - 0 - do not permute.
7372  *          - 1 - permute cells.
7373  *          - 2 - permute nodes.
7374  *          - 3 - permute cells and nodes.
7375  *
7376  *  \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
7377  *          caller is to delete this field using decrRef() as it is no more needed.
7378  *  \throw If no field of \a this is lying on \a mesh.
7379  *  \throw If the mesh is empty.
7380  *  \throw If no field values of the given \a type are available.
7381  *  \sa getFieldAtLevel()
7382  *  \sa getFieldOnMeshAtLevel()
7383  */
7384 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const
7385 {
7386   MCAuto<DataArray> arrOut;
7387   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull()));
7388   MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
7389   return ret2.retn();
7390 }
7391
7392 /*!
7393  * Returns a new MEDCouplingFieldInt of a given type lying on a given support.
7394  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7395  *  \param [in] type - a spatial discretization of interest.
7396  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
7397  *  \param [in] mesh - the supporting mesh.
7398  *  \param [in] renumPol - specifies how to permute values of the result field according to
7399  *          the optional numbers of cells and nodes, if any. The valid values are
7400  *          - 0 - do not permute.
7401  *          - 1 - permute cells.
7402  *          - 2 - permute nodes.
7403  *          - 3 - permute cells and nodes.
7404  *
7405  *  \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
7406  *          caller is to delete this field using decrRef() as it is no more needed.
7407  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
7408  *  \throw If no field of \a this is lying on \a mesh.
7409  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
7410  *  \sa getFieldAtLevel()
7411  *  \sa getFieldOnMeshAtLevel()
7412  */
7413 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
7414 {
7415   MCAuto<DataArray> arrOut;
7416   MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull()));
7417   MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
7418   return ret2.retn();
7419 }
7420
7421 /*!
7422  * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
7423  * This method is called "Old" because in MED3 norm a field has only one meshName
7424  * attached, so this method is for readers of MED2 files. If \a this field
7425  * has not been constructed via file reading, an exception is thrown.
7426  * For more info, see \ref AdvMEDLoaderAPIFieldRW
7427  *  \param [in] type - a spatial discretization of interest.
7428  *  \param [in] mName - a name of the supporting mesh.
7429  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
7430  *  \param [in] renumPol - specifies how to permute values of the result field according to
7431  *          the optional numbers of cells and nodes, if any. The valid values are
7432  *          - 0 - do not permute.
7433  *          - 1 - permute cells.
7434  *          - 2 - permute nodes.
7435  *          - 3 - permute cells and nodes.
7436  *
7437  *  \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
7438  *          caller is to delete this field using decrRef() as it is no more needed.
7439  *  \throw If the MED file is not readable.
7440  *  \throw If there is no mesh named \a mName in the MED file.
7441  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
7442  *  \throw If \a this field has not been constructed via file reading.
7443  *  \throw If no field of \a this is lying on the mesh named \a mName.
7444  *  \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
7445  *  \sa getFieldAtLevel()
7446  */
7447 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, int renumPol) const
7448 {
7449   if(getFileName().empty())
7450     throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
7451   MCAuto<DataArray> arrOut;
7452   MCAuto<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
7453   MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
7454   return ret2.retn();
7455 }
7456
7457 //= MEDFileFloatField1TS
7458
7459 MEDFileFloatField1TS::MEDFileFloatField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
7460 try:MEDFileTemplateField1TS<float>(fid,loadAll,ms)
7461 {
7462 }
7463 catch(INTERP_KERNEL::Exception& e)
7464 { throw e; }
7465
7466 MEDFileFloatField1TS::MEDFileFloatField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms)
7467 try:MEDFileTemplateField1TS<float>(fid,fieldName,loadAll,ms)
7468 {
7469 }
7470 catch(INTERP_KERNEL::Exception& e)
7471 { throw e; }
7472
7473 MEDFileFloatField1TS::MEDFileFloatField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms)
7474 try:MEDFileTemplateField1TS<float>(fid,fieldName,iteration,order,loadAll,ms)
7475 {
7476 }
7477 catch(INTERP_KERNEL::Exception& e)
7478 { throw e; }
7479
7480 //= MEDFileFloatField1TS
7481
7482 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
7483
7484 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
7485 {
7486 }
7487
7488 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileFieldNameScope(fieldName,meshName)
7489 {
7490 }
7491
7492 /*!
7493  * \param [in] fieldId field id in C mode
7494  */
7495 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
7496 {
7497   med_field_type typcha;
7498   std::string dtunitOut,meshName;
7499   int nbOfStep(MEDFileAnyTypeField1TS::LocateField2(fid,fieldId,false,_name,typcha,_infos,dtunitOut,meshName));
7500   setMeshName(meshName);
7501   setDtUnit(dtunitOut.c_str());
7502   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll,ms,entities);
7503 }
7504
7505 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
7506 try:MEDFileFieldNameScope(fieldName,meshName),_infos(infos)
7507 {
7508   setDtUnit(dtunit.c_str());
7509   loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll,ms,entities);
7510 }
7511 catch(INTERP_KERNEL::Exception& e)
7512 {
7513     throw e;
7514 }
7515
7516 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySizeWithoutChildren() const
7517 {
7518   std::size_t ret(_mesh_name.capacity()+_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MCAuto<MEDFileField1TSWithoutSDA>));
7519   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
7520     ret+=(*it).capacity();
7521   return ret;
7522 }
7523
7524 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTSWithoutSDA::getDirectChildrenWithNull() const
7525 {
7526   std::vector<const BigMemoryObject *> ret;
7527   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7528     ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)*it);
7529   return ret;
7530 }
7531
7532 /*!
7533  * 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
7534  * NULL.
7535  */
7536 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const
7537 {
7538   MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
7539   ret->setInfo(_infos);
7540   int sz=(int)_time_steps.size();
7541   for(const int *id=startIds;id!=endIds;id++)
7542     {
7543       if(*id>=0 && *id<sz)
7544         {
7545           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
7546           MCAuto<MEDFileAnyTypeField1TSWithoutSDA> tse2;
7547           if(tse)
7548             {
7549               tse->incrRef();
7550               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
7551             }
7552           ret->pushBackTimeStep(tse2);
7553         }
7554       else
7555         {
7556           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
7557           oss << " ! Should be in [0," << sz << ") !";
7558           throw INTERP_KERNEL::Exception(oss.str());
7559         }
7560     }
7561   if(ret->getNumberOfTS()>0)
7562     ret->synchronizeNameScope();
7563   ret->copyNameScope(*this);
7564   return ret.retn();
7565 }
7566
7567 /*!
7568  * 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
7569  * NULL.
7570  */
7571 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const
7572 {
7573   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
7574   int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7575   MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
7576   ret->setInfo(_infos);
7577   int sz=(int)_time_steps.size();
7578   int j=bg;
7579   for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
7580     {
7581       if(j>=0 && j<sz)
7582         {
7583           const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
7584           MCAuto<MEDFileAnyTypeField1TSWithoutSDA> tse2;
7585           if(tse)
7586             {
7587               tse->incrRef();
7588               tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
7589             }
7590           ret->pushBackTimeStep(tse2);
7591         }
7592       else
7593         {
7594           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
7595           oss << " ! Should be in [0," << sz << ") !";
7596           throw INTERP_KERNEL::Exception(oss.str());
7597         }
7598     }
7599   if(ret->getNumberOfTS()>0)
7600     ret->synchronizeNameScope();
7601   ret->copyNameScope(*this);
7602   return ret.retn();
7603 }
7604
7605 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
7606 {
7607   int id=0;
7608   MCAuto<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
7609   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
7610     {
7611       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
7612       if(!cur)
7613         continue;
7614       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
7615       if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
7616         ids->pushBackSilent(id);
7617     }
7618   return buildFromTimeStepIds(ids->begin(),ids->end());
7619 }
7620
7621 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
7622 {
7623   int id=0;
7624   MCAuto<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
7625   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
7626     {
7627       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
7628       if(!cur)
7629         continue;
7630       std::pair<int,int> p(cur->getIteration(),cur->getOrder());
7631       if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
7632         ids->pushBackSilent(id);
7633     }
7634   return buildFromTimeStepIds(ids->begin(),ids->end());
7635 }
7636
7637 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::presenceOfStructureElements() const
7638 {
7639   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7640     if((*it).isNotNull())
7641       if((*it)->presenceOfStructureElements())
7642         return true;
7643   return false;
7644 }
7645
7646 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::onlyStructureElements() const
7647 {
7648   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7649     if((*it).isNotNull())
7650       if(!(*it)->onlyStructureElements())
7651         return false;
7652   return true;
7653 }
7654
7655 void MEDFileAnyTypeFieldMultiTSWithoutSDA::killStructureElements()
7656 {
7657   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret;
7658   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7659     if((*it).isNotNull())
7660       {
7661         if((*it)->presenceOfStructureElements())
7662           {
7663             if(!(*it)->onlyStructureElements())
7664               {
7665                 (*it)->killStructureElements();
7666                 ret.push_back(*it);
7667               }
7668           }
7669         else
7670           {
7671             ret.push_back(*it);
7672           }
7673       }
7674   _time_steps=ret;
7675 }
7676
7677 void MEDFileAnyTypeFieldMultiTSWithoutSDA::keepOnlyStructureElements()
7678 {
7679   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret;
7680   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7681     if((*it).isNotNull())
7682       {
7683         if((*it)->presenceOfStructureElements())
7684           {
7685             if(!(*it)->onlyStructureElements())
7686               (*it)->keepOnlyStructureElements();
7687             ret.push_back(*it);
7688           }
7689       }
7690   _time_steps=ret;
7691 }
7692
7693 void MEDFileAnyTypeFieldMultiTSWithoutSDA::keepOnlyOnSE(const std::string& seName)
7694 {
7695   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret;
7696   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7697     if((*it).isNotNull())
7698       (*it)->keepOnlyOnSE(seName);
7699 }
7700
7701 void MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const
7702 {
7703   std::vector< std::pair<std::string,std::string> > ps2;
7704   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7705     if((*it).isNotNull())
7706       {
7707         (*it)->getMeshSENames(ps2);
7708         break;
7709       }
7710   if(ps2.empty())
7711     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshSENames : this appears to not contain SE only !");
7712   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7713     if((*it).isNotNull())
7714       {
7715         std::vector< std::pair<std::string,std::string> > ps3;
7716         (*it)->getMeshSENames(ps3);
7717         if(ps2!=ps3)
7718           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshSENames : For the moment only homogeneous SE def through time managed !");
7719       }
7720   for(std::vector< std::pair<std::string,std::string> >::const_iterator it=ps2.begin();it!=ps2.end();it++)
7721     {
7722       std::vector< std::pair<std::string,std::string> >::iterator it2(std::find(ps.begin(),ps.end(),*it));
7723       if(it2==ps.end())
7724         ps.push_back(*it);
7725     }
7726 }
7727
7728 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::presenceOfMultiDiscPerGeoType() const
7729 {
7730   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7731     {
7732       const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
7733       if(!cur)
7734         continue;
7735       if(cur->presenceOfMultiDiscPerGeoType())
7736         return true;
7737     }
7738   return false;
7739 }
7740
7741 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const
7742 {
7743   return _infos;
7744 }
7745
7746 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info)
7747 {
7748   _infos=info;
7749 }
7750
7751 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const
7752 {
7753   int ret=0;
7754   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7755     {
7756       const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
7757       if(pt->isDealingTS(iteration,order))
7758         return ret;
7759     }
7760   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
7761   std::vector< std::pair<int,int> > vp=getIterations();
7762   for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
7763     oss << "(" << (*it2).first << "," << (*it2).second << ") ";
7764   throw INTERP_KERNEL::Exception(oss.str());
7765 }
7766
7767 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const
7768 {
7769   return *_time_steps[getTimeStepPos(iteration,order)];
7770 }
7771
7772 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order)
7773 {
7774   return *_time_steps[getTimeStepPos(iteration,order)];
7775 }
7776
7777 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
7778 {
7779   bool ret(false);
7780   for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
7781     {
7782       if((*it).first==getMeshName())
7783         {
7784           setMeshName((*it).second);
7785           ret=true;
7786         }
7787     }
7788   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7789     {
7790       MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
7791       if(cur)
7792         ret=cur->changeMeshNames(modifTab) || ret;
7793     }
7794   return ret;
7795 }
7796
7797 /*!
7798  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
7799  */
7800 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const
7801 {
7802   return getTimeStepEntry(iteration,order).getUndergroundDataArray();
7803 }
7804
7805 /*!
7806  * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
7807  */
7808 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
7809 {
7810   return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
7811 }
7812
7813 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
7814                                                                        MEDFileFieldGlobsReal& glob)
7815 {
7816   bool ret=false;
7817   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7818     {
7819       MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
7820       if(f1ts)
7821         ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
7822     }
7823   return ret;
7824 }
7825
7826 void MEDFileAnyTypeFieldMultiTSWithoutSDA::accept(MEDFileFieldVisitor& visitor) const
7827 {
7828   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7829     if((*it).isNotNull())
7830       {
7831         visitor.newTimeStepEntry(*it);
7832         (*it)->accept(visitor);
7833         visitor.endTimeStepEntry(*it);
7834       }
7835 }
7836
7837 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
7838 {
7839   std::string startLine(bkOffset,' ');
7840   oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
7841   if(fmtsId>=0)
7842     oss << " (" << fmtsId << ")";
7843   oss << " has the following name: \"" << _name << "\"." << std::endl;
7844   oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
7845   for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
7846     {
7847       oss << startLine << "  -  \"" << *it << "\"" << std::endl;
7848     }
7849   int i=0;
7850   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7851     {
7852       std::string chapter(17,'0'+i);
7853       oss << startLine << chapter << std::endl;
7854       const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
7855       if(cur)
7856         cur->simpleRepr(bkOffset+2,oss,i);
7857       else
7858         oss << startLine << "  Field on one time step #" << i << " is not defined !" << std::endl;
7859       oss << startLine << chapter << std::endl;
7860     }
7861 }
7862
7863 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const
7864 {
7865   std::size_t sz=_time_steps.size();
7866   std::vector< std::pair<int,int> > ret(sz);
7867   ret1.resize(sz);
7868   for(std::size_t i=0;i<sz;i++)
7869     {
7870       const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
7871       if(f1ts)
7872         {
7873           ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
7874         }
7875       else
7876         {
7877           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
7878           throw INTERP_KERNEL::Exception(oss.str());
7879         }
7880     }
7881   return ret;
7882 }
7883
7884 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MCAuto<MEDFileAnyTypeField1TSWithoutSDA>& tse)
7885 {
7886   MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
7887   if(!tse2)
7888     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
7889   checkCoherencyOfType(tse2);
7890   if(_time_steps.empty())
7891     {
7892       setName(tse2->getName());
7893       setMeshName(tse2->getMeshName());
7894       setInfo(tse2->getInfo());
7895     }
7896   checkThatComponentsMatch(tse2->getInfo());
7897   if(getDtUnit().empty() && !tse->getDtUnit().empty())
7898     setDtUnit(tse->getDtUnit());
7899   _time_steps.push_back(tse);
7900 }
7901
7902 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope()
7903 {
7904   std::size_t nbOfCompo=_infos.size();
7905   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7906     {
7907       MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
7908       if(cur)
7909         {
7910           if((cur->getInfo()).size()!=nbOfCompo)
7911             {
7912               std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
7913               oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
7914               throw INTERP_KERNEL::Exception(oss.str());
7915             }
7916           cur->copyNameScope(*this);
7917         }
7918     }
7919 }
7920
7921 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
7922 {
7923   _time_steps.resize(nbPdt);
7924   for(int i=0;i<nbPdt;i++)
7925     {
7926       std::vector< std::pair<int,int> > ts;
7927       med_int numdt=0,numo=0;
7928       med_float dt=0.0;
7929       MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,_name.c_str(),i+1,&numdt,&numo,&dt));
7930       switch(fieldTyp)
7931       {
7932         case MED_FLOAT64:
7933           {
7934             _time_steps[i]=MEDFileField1TSWithoutSDA::New(getName(),getMeshName(),i+1,numdt,numo,_infos);
7935             break;
7936           }
7937         case MED_INT32:
7938           {
7939             _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(getName(),getMeshName(),i+1,numdt,numo,_infos);
7940             break;
7941           }
7942         default:
7943           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
7944       }
7945       if(loadAll)
7946         _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this,ms,entities);
7947       else
7948         _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this,ms,entities);
7949       synchronizeNameScope();
7950     }
7951 }
7952
7953 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const
7954 {
7955   if(_time_steps.empty())
7956     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
7957   checkThatNbOfCompoOfTSMatchThis();
7958   std::vector<std::string> infos(getInfo());
7959   int nbComp=infos.size();
7960   INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7961   INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7962   for(int i=0;i<nbComp;i++)
7963     {
7964       std::string info=infos[i];
7965       std::string c,u;
7966       MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
7967       MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7968       MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7969     }
7970   if(_name.empty())
7971     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
7972   MEDFILESAFECALLERWR0(MEDfieldCr,(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str()));
7973   int nbOfTS=_time_steps.size();
7974   for(int i=0;i<nbOfTS;i++)
7975     _time_steps[i]->writeLL(fid,opts,*this);
7976 }
7977
7978 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
7979 {
7980   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7981     {
7982       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7983       if(elt)
7984         elt->loadBigArraysRecursively(fid,nasc);
7985     }
7986 }
7987
7988 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
7989 {
7990   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7991     {
7992       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7993       if(elt)
7994         elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
7995     }
7996 }
7997
7998 void MEDFileAnyTypeFieldMultiTSWithoutSDA::unloadArrays()
7999 {
8000   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
8001     {
8002       MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
8003       if(elt)
8004         elt->unloadArrays();
8005     }
8006 }
8007
8008 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
8009 {
8010   return _time_steps.size();
8011 }
8012
8013 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS()
8014 {
8015   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA>  > newTS;
8016   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
8017     {
8018       const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
8019       if(tmp)
8020         newTS.push_back(*it);
8021     }
8022   _time_steps=newTS;
8023 }
8024
8025 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds)
8026 {
8027   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
8028   int maxId=(int)_time_steps.size();
8029   int ii=0;
8030   std::set<int> idsToDel;
8031   for(const int *id=startIds;id!=endIds;id++,ii++)
8032     {
8033       if(*id>=0 && *id<maxId)
8034         {
8035           idsToDel.insert(*id);
8036         }
8037       else
8038         {
8039           std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
8040           throw INTERP_KERNEL::Exception(oss.str());
8041         }
8042     }
8043   for(int iii=0;iii<maxId;iii++)
8044     if(idsToDel.find(iii)==idsToDel.end())
8045       newTS.push_back(_time_steps[iii]);
8046   _time_steps=newTS;
8047 }
8048
8049 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step)
8050 {
8051   static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
8052   int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
8053   if(nbOfEntriesToKill==0)
8054     return ;
8055   std::size_t sz=_time_steps.size();
8056   std::vector<bool> b(sz,true);
8057   int j=bg;
8058   for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
8059     b[j]=false;
8060   std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
8061   for(std::size_t i=0;i<sz;i++)
8062     if(b[i])
8063       newTS.push_back(_time_steps[i]);
8064   _time_steps=newTS;
8065 }
8066
8067 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const
8068 {
8069   int ret=0;
8070   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
8071   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
8072     {
8073       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
8074       if(tmp)
8075         {
8076           int it2,ord;
8077           tmp->getTime(it2,ord);
8078           if(it2==iteration && order==ord)
8079             return ret;
8080           else
8081             oss << "(" << it2 << ","  << ord << "), ";
8082         }
8083     }
8084   throw INTERP_KERNEL::Exception(oss.str());
8085 }
8086
8087 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const
8088 {
8089   int ret=0;
8090   std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
8091   oss.precision(15);
8092   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA>  >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
8093     {
8094       const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
8095       if(tmp)
8096         {
8097           int it2,ord;
8098           double ti=tmp->getTime(it2,ord);
8099           if(fabs(time-ti)<eps)
8100             return ret;
8101           else
8102             oss << ti << ", ";
8103         }
8104     }
8105   throw INTERP_KERNEL::Exception(oss.str());
8106 }
8107
8108 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
8109 {
8110   int lgth=_time_steps.size();
8111   std::vector< std::pair<int,int> > ret(lgth);
8112   for(int i=0;i<lgth;i++)
8113     _time_steps[i]->fillIteration(ret[i]);
8114   return ret;
8115 }
8116
8117 /*!
8118  * 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'
8119  * This method returns two things.
8120  * - The absolute dimension of 'this' in first parameter.
8121  * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
8122  *   to the first output parameter. The values in 'levs' will be returned in decreasing order.
8123  *
8124  * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
8125  * Only these 3 discretizations will be taken into account here.
8126  *
8127  * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
8128  * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
8129  * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
8130  *
8131  * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
8132  * 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'.
8133  *
8134  * Let's consider the typical following case :
8135  * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
8136  * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
8137  * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
8138  *   TETRA4 and SEG2
8139  * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
8140  *
8141  * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
8142  *
8143  * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
8144  * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
8145  * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
8146  * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
8147  */
8148 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
8149 {
8150   return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
8151 }
8152
8153 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const
8154 {
8155   if(pos<0 || pos>=(int)_time_steps.size())
8156     {
8157       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
8158       throw INTERP_KERNEL::Exception(oss.str());
8159     }
8160   const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
8161   if(item==0)
8162     {
8163       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
8164       oss << "\nTry to use following method eraseEmptyTS !";
8165       throw INTERP_KERNEL::Exception(oss.str());
8166     }
8167   return item;
8168 }
8169
8170 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos)
8171 {
8172   if(pos<0 || pos>=(int)_time_steps.size())
8173     {
8174       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
8175       throw INTERP_KERNEL::Exception(oss.str());
8176     }
8177   MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
8178   if(item==0)
8179     {
8180       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
8181       oss << "\nTry to use following method eraseEmptyTS !";
8182       throw INTERP_KERNEL::Exception(oss.str());
8183     }
8184   return item;
8185 }
8186
8187 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
8188 {
8189   std::vector<std::string> ret;
8190   std::set<std::string> ret2;
8191   for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
8192     {
8193       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
8194       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
8195         if(ret2.find(*it2)==ret2.end())
8196           {
8197             ret.push_back(*it2);
8198             ret2.insert(*it2);
8199           }
8200     }
8201   return ret;
8202 }
8203
8204 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
8205 {
8206   std::vector<std::string> ret;
8207   std::set<std::string> ret2;
8208   for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
8209     {
8210       std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
8211       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
8212         if(ret2.find(*it2)==ret2.end())
8213           {
8214             ret.push_back(*it2);
8215             ret2.insert(*it2);
8216           }
8217     }
8218   return ret;
8219 }
8220
8221 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
8222 {
8223   std::vector<std::string> ret;
8224   for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
8225     {
8226       std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
8227       ret.insert(ret.end(),tmp.begin(),tmp.end());
8228     }
8229   return ret;
8230 }
8231
8232 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
8233 {
8234   std::vector<std::string> ret;
8235   for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
8236     {
8237       std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
8238       ret.insert(ret.end(),tmp.begin(),tmp.end());
8239     }
8240   return ret;
8241 }
8242
8243 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
8244 {
8245   for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
8246     (*it)->changePflsRefsNamesGen2(mapOfModif);
8247 }
8248
8249 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
8250 {
8251   for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
8252     (*it)->changeLocsRefsNamesGen2(mapOfModif);
8253 }
8254
8255 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const
8256 {
8257   int lgth=_time_steps.size();
8258   std::vector< std::vector<TypeOfField> > ret(lgth);
8259   for(int i=0;i<lgth;i++)
8260     _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
8261   return ret;
8262 }
8263
8264 /*!
8265  * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
8266  */
8267 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
8268 {
8269   return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
8270 }
8271
8272 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCopy() const
8273 {
8274   MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
8275   std::size_t i=0;
8276   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
8277     {
8278       if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
8279         ret->_time_steps[i]=(*it)->deepCopy();
8280     }
8281   return ret.retn();
8282 }
8283
8284 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const
8285 {
8286   std::size_t sz(_infos.size()),sz2(_time_steps.size());
8287   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
8288   std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
8289   for(std::size_t i=0;i<sz;i++)
8290     {
8291       ret[i]=shallowCpy();
8292       ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
8293     }
8294   for(std::size_t i=0;i<sz2;i++)
8295     {
8296       std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
8297       if(ret1.size()!=sz)
8298         {
8299           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
8300           throw INTERP_KERNEL::Exception(oss.str());
8301         }
8302       ts[i]=ret1;
8303     }
8304   for(std::size_t i=0;i<sz;i++)
8305     for(std::size_t j=0;j<sz2;j++)
8306       ret[i]->_time_steps[j]=ts[j][i];
8307   return ret;
8308 }
8309
8310 /*!
8311  * This method splits into discretization each time steps in \a this.
8312  * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
8313  */
8314 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const
8315 {
8316   std::size_t sz(_time_steps.size());
8317   std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
8318   for(std::size_t i=0;i<sz;i++)
8319     {
8320       const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
8321       if(!timeStep)
8322         {
8323           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
8324           throw INTERP_KERNEL::Exception(oss.str());
8325         }
8326       items[i]=timeStep->splitDiscretizations();
8327     }
8328   //
8329   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
8330   std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
8331   std::vector< TypeOfField > types;
8332   for(std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
8333     for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
8334       {
8335         std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
8336         if(ts.size()!=1)
8337           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
8338         std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
8339         if(it2==types.end())
8340           types.push_back(ts[0]);
8341       }
8342   ret.resize(types.size()); ret2.resize(types.size());
8343   for(std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
8344     for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
8345       {
8346         TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
8347         std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
8348         ret2[pos].push_back(*it1);
8349       }
8350   for(std::size_t i=0;i<types.size();i++)
8351     {
8352       MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt(createNew());
8353       for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
8354         elt->pushBackTimeStep(*it1);//also updates infos in elt
8355       ret[i]=elt;
8356       elt->MEDFileFieldNameScope::operator=(*this);
8357     }
8358   return ret;
8359 }
8360
8361 /*!
8362  * Contrary to splitDiscretizations method this method makes the hypothesis that the times series are **NOT** impacted by the splitting of multi discretization.
8363  */
8364 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitMultiDiscrPerGeoTypes() const
8365 {
8366   std::size_t sz(_time_steps.size());
8367   std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
8368   std::size_t szOut(std::numeric_limits<std::size_t>::max());
8369   for(std::size_t i=0;i<sz;i++)
8370     {
8371       const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
8372       if(!timeStep)
8373         {
8374           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitMultiDiscrPerGeoTypes : time step #" << i << " is null !";
8375           throw INTERP_KERNEL::Exception(oss.str());
8376         }
8377       items[i]=timeStep->splitMultiDiscrPerGeoTypes();
8378       if(szOut==std::numeric_limits<std::size_t>::max())
8379         szOut=items[i].size();
8380       else
8381         if(items[i].size()!=szOut)
8382           throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitMultiDiscrPerGeoTypes : The splitting per discretization is expected to be same among time steps !");
8383     }
8384   if(szOut==std::numeric_limits<std::size_t>::max())
8385     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitMultiDiscrPerGeoTypes : empty field !");
8386   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(szOut);
8387   for(std::size_t i=0;i<szOut;i++)
8388     {
8389       MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt(createNew());
8390       for(std::size_t j=0;j<sz;j++)
8391         elt->pushBackTimeStep(items[j][i]);
8392       ret[i]=elt;
8393       elt->MEDFileFieldNameScope::operator=(*this);
8394     }
8395   return ret;
8396 }
8397
8398 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
8399 {
8400   setName(field->getName());
8401   if(field->getMesh())
8402     setMeshName(field->getMesh()->getName());
8403   if(_name.empty())
8404     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
8405   if(!arr)
8406     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
8407   _infos=arr->getInfoOnComponents();
8408 }
8409
8410 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const
8411 {
8412   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
8413   if(_name!=field->getName())
8414     {
8415       std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
8416       oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
8417       throw INTERP_KERNEL::Exception(oss.str());
8418     }
8419   if(!arr)
8420     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
8421   checkThatComponentsMatch(arr->getInfoOnComponents());
8422 }
8423
8424 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const
8425 {
8426   static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
8427   if(getInfo().size()!=compos.size())
8428     {
8429       std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
8430       oss << " number of components of element to append (" << compos.size() << ") !";
8431       throw INTERP_KERNEL::Exception(oss.str());
8432     }
8433   if(_infos!=compos)
8434     {
8435       std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
8436       std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
8437       oss << " But compo in input fields are : ";
8438       std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
8439       oss << " !";
8440       throw INTERP_KERNEL::Exception(oss.str());
8441     }
8442 }
8443
8444 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const
8445 {
8446   std::size_t sz=_infos.size();
8447   int j=0;
8448   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
8449     {
8450       const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
8451       if(elt)
8452         if(elt->getInfo().size()!=sz)
8453           {
8454             std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
8455             oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
8456             throw INTERP_KERNEL::Exception(oss.str());
8457           }
8458     }
8459 }
8460
8461 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
8462 {
8463   if(!field)
8464     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
8465   if(!_time_steps.empty())
8466     checkCoherencyOfTinyInfo(field,arr);
8467   MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
8468   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
8469   objC->setFieldNoProfileSBT(field,arr,glob,*this);
8470   copyTinyInfoFrom(field,arr);
8471   _time_steps.push_back(obj);
8472 }
8473
8474 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob)
8475 {
8476   if(!field)
8477     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
8478   if(!_time_steps.empty())
8479     checkCoherencyOfTinyInfo(field,arr);
8480   MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
8481   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
8482   objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
8483   copyTinyInfoFrom(field,arr);
8484   setMeshName(objC->getMeshName());
8485   _time_steps.push_back(obj);
8486 }
8487
8488 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ts)
8489 {
8490   int sz=(int)_time_steps.size();
8491   if(i<0 || i>=sz)
8492     {
8493       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
8494       throw INTERP_KERNEL::Exception(oss.str());
8495     }
8496   const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
8497   if(tsPtr)
8498     {
8499       if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
8500         {
8501           std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() <<  " !";
8502           throw INTERP_KERNEL::Exception(oss.str());
8503         }
8504     }
8505   _time_steps[i]=ts;
8506 }
8507
8508 //= MEDFileFieldMultiTSWithoutSDA
8509
8510 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::New(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
8511 {
8512   return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities);
8513 }
8514
8515 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
8516 {
8517 }
8518
8519 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName,meshName)
8520 {
8521 }
8522
8523 /*!
8524  * \param [in] fieldId field id in C mode
8525  */
8526 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
8527 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll,ms,entities)
8528 {
8529 }
8530 catch(INTERP_KERNEL::Exception& e)
8531 { throw e; }
8532
8533 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
8534 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities)
8535 {
8536 }
8537 catch(INTERP_KERNEL::Exception& e)
8538 { throw e; }
8539
8540 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
8541 {
8542   return new MEDFileField1TSWithoutSDA;
8543 }
8544
8545 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
8546 {
8547   if(!f1ts)
8548     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8549   const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
8550   if(!f1tsC)
8551     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8552 }
8553
8554 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const
8555 {
8556   return MEDFileField1TSWithoutSDA::TYPE_STR;
8557 }
8558
8559 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const
8560 {
8561   return new MEDFileFieldMultiTSWithoutSDA(*this);
8562 }
8563
8564 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const
8565 {
8566   return new MEDFileFieldMultiTSWithoutSDA;
8567 }
8568
8569 /*!
8570  * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
8571  * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
8572  */
8573 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
8574 {
8575   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
8576   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8577   if(!myF1TSC)
8578     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
8579   return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
8580 }
8581
8582 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const
8583 {
8584   MCAuto<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
8585   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
8586   int i=0;
8587   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
8588     {
8589       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
8590       if(eltToConv)
8591         {
8592           const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
8593           if(!eltToConvC)
8594             throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
8595           MCAuto<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
8596           ret->setIteration(i,elt);
8597         }
8598     }
8599   return ret.retn();
8600 }
8601
8602 //= MEDFileAnyTypeFieldMultiTS
8603
8604 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
8605 {
8606 }
8607
8608 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
8609 try:MEDFileFieldGlobsReal(fid)
8610 {
8611   _content=BuildContentFrom(fid,loadAll,ms);
8612   loadGlobals(fid);
8613 }
8614 catch(INTERP_KERNEL::Exception& e)
8615 {
8616     throw e;
8617 }
8618
8619 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
8620 {
8621   med_field_type typcha;
8622   std::vector<std::string> infos;
8623   std::string dtunit;
8624   std::string meshName;
8625   int i(-1);
8626   MEDFileAnyTypeField1TS::LocateField(fid,fieldName,i,typcha,infos,dtunit,meshName);
8627   MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
8628   switch(typcha)
8629   {
8630     case MED_FLOAT64:
8631       {
8632         ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll,ms,entities);
8633         break;
8634       }
8635     case MED_INT32:
8636       {
8637         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll,ms,entities);
8638         break;
8639       }
8640     default:
8641       {
8642         std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fid,fieldName) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
8643         throw INTERP_KERNEL::Exception(oss.str());
8644       }
8645   }
8646   ret->setMeshName(meshName);
8647   ret->setDtUnit(dtunit.c_str());
8648   return ret.retn();
8649 }
8650
8651 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
8652 {
8653   med_field_type typcha;
8654   //
8655   std::vector<std::string> infos;
8656   std::string dtunit,fieldName,meshName;
8657   MEDFileAnyTypeField1TS::LocateField2(fid,0,true,fieldName,typcha,infos,dtunit,meshName);
8658   MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
8659   switch(typcha)
8660   {
8661     case MED_FLOAT64:
8662       {
8663         ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
8664         break;
8665       }
8666     case MED_INT32:
8667       {
8668         ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
8669         break;
8670       }
8671     default:
8672       {
8673         std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fid) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
8674         throw INTERP_KERNEL::Exception(oss.str());
8675       }
8676   }
8677   ret->setMeshName(meshName);
8678   ret->setDtUnit(dtunit.c_str());
8679   return ret.retn();
8680 }
8681
8682 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c)
8683 {
8684   if(!c)
8685     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
8686   if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
8687     {
8688       MCAuto<MEDFileFieldMultiTS> ret(MEDFileFieldMultiTS::New());
8689       ret->_content=c;  c->incrRef();
8690       return ret.retn();
8691     }
8692   if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
8693     {
8694       MCAuto<MEDFileIntFieldMultiTS> ret(MEDFileIntFieldMultiTS::New());
8695       ret->_content=c;  c->incrRef();
8696       return ret.retn();
8697     }
8698   throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
8699 }
8700
8701 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, med_idt fid)
8702 {
8703   MEDFileAnyTypeFieldMultiTS *ret(BuildNewInstanceFromContent(c));
8704   std::string fileName(FileNameFromFID(fid));
8705   ret->setFileName(fileName);
8706   return ret;
8707 }
8708
8709 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
8710 try:MEDFileFieldGlobsReal(fid)
8711 {
8712   _content=BuildContentFrom(fid,fieldName,loadAll,ms,entities);
8713   loadGlobals(fid);
8714 }
8715 catch(INTERP_KERNEL::Exception& e)
8716 {
8717     throw e;
8718 }
8719
8720 //= MEDFileIntFieldMultiTSWithoutSDA
8721
8722 MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::New(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
8723 {
8724   return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities);
8725 }
8726
8727 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
8728 {
8729 }
8730
8731 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const std::string& fieldName, const std::string& meshName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName,meshName)
8732 {
8733 }
8734
8735 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, const std::string& meshName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
8736 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,meshName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities)
8737 {
8738 }
8739 catch(INTERP_KERNEL::Exception& e)
8740 { throw e; }
8741
8742 /*!
8743  * \param [in] fieldId field id in C mode
8744  */
8745 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
8746 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll,ms,entities)
8747 {
8748 }
8749 catch(INTERP_KERNEL::Exception& e)
8750 { throw e; }
8751
8752 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
8753 {
8754   return new MEDFileIntField1TSWithoutSDA;
8755 }
8756
8757 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
8758 {
8759   if(!f1ts)
8760     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8761   const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
8762   if(!f1tsC)
8763     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
8764 }
8765
8766 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const
8767 {
8768   return MEDFileIntField1TSWithoutSDA::TYPE_STR;
8769 }
8770
8771 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const
8772 {
8773   return new MEDFileIntFieldMultiTSWithoutSDA(*this);
8774 }
8775
8776 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const
8777 {
8778   return new MEDFileIntFieldMultiTSWithoutSDA;
8779 }
8780
8781 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const
8782 {
8783   MCAuto<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
8784   ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
8785   int i=0;
8786   for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
8787     {
8788       const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
8789       if(eltToConv)
8790         {
8791           const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
8792           if(!eltToConvC)
8793             throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
8794           MCAuto<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
8795           ret->setIteration(i,elt);
8796         }
8797     }
8798   return ret.retn();
8799 }
8800
8801 //= MEDFileAnyTypeFieldMultiTS
8802
8803 /*!
8804  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
8805  * that has been read from a specified MED file.
8806  *  \param [in] fileName - the name of the MED file to read.
8807  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
8808  *          is to delete this field using decrRef() as it is no more needed.
8809  *  \throw If reading the file fails.
8810  */
8811 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, bool loadAll)
8812 {
8813   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
8814   return New(fid,loadAll);
8815 }
8816
8817 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(med_idt fid, bool loadAll)
8818 {
8819   MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c(BuildContentFrom(fid,loadAll,0));
8820   MCAuto<MEDFileAnyTypeFieldMultiTS> ret(BuildNewInstanceFromContent(c,fid));
8821   ret->loadGlobals(fid);
8822   return ret.retn();
8823 }
8824
8825 /*!
8826  * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
8827  * that has been read from a specified MED file.
8828  *  \param [in] fileName - the name of the MED file to read.
8829  *  \param [in] fieldName - the name of the field to read.
8830  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
8831  *          is to delete this field using decrRef() as it is no more needed.
8832  *  \throw If reading the file fails.
8833  *  \throw If there is no field named \a fieldName in the file.
8834  */
8835 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
8836 {
8837   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
8838   return New(fid,fieldName,loadAll);
8839 }
8840
8841 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(med_idt fid, const std::string& fieldName, bool loadAll)
8842 {
8843   MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c(BuildContentFrom(fid,fieldName,loadAll,0,0));
8844   MCAuto<MEDFileAnyTypeFieldMultiTS> ret(BuildNewInstanceFromContent(c,fid));
8845   ret->loadGlobals(fid);
8846   return ret.retn();
8847 }
8848
8849 /*!
8850  * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8851  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8852  *
8853  * \warning this is a shallow copy constructor
8854  */
8855 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8856 {
8857   if(!shallowCopyOfContent)
8858     {
8859       const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
8860       otherPtr->incrRef();
8861       _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
8862     }
8863   else
8864     {
8865       _content=other.shallowCpy();
8866     }
8867 }
8868
8869 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase()
8870 {
8871   MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
8872   if(!ret)
8873     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
8874   return ret;
8875 }
8876
8877 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const
8878 {
8879   const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
8880   if(!ret)
8881     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
8882   return ret;
8883 }
8884
8885 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
8886 {
8887   return contentNotNullBase()->getPflsReallyUsed2();
8888 }
8889
8890 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
8891 {
8892   return contentNotNullBase()->getLocsReallyUsed2();
8893 }
8894
8895 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
8896 {
8897   return contentNotNullBase()->getPflsReallyUsedMulti2();
8898 }
8899
8900 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
8901 {
8902   return contentNotNullBase()->getLocsReallyUsedMulti2();
8903 }
8904
8905 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
8906 {
8907   contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
8908 }
8909
8910 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
8911 {
8912   contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
8913 }
8914
8915 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
8916 {
8917   return contentNotNullBase()->getNumberOfTS();
8918 }
8919
8920 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS()
8921 {
8922   contentNotNullBase()->eraseEmptyTS();
8923 }
8924
8925 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
8926 {
8927   contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
8928 }
8929
8930 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step)
8931 {
8932   contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
8933 }
8934
8935 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const
8936 {
8937   MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
8938   MCAuto<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8939   ret->_content=c;
8940   return ret.retn();
8941 }
8942
8943 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const
8944 {
8945   MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
8946   MCAuto<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8947   ret->_content=c;
8948   return ret.retn();
8949 }
8950
8951 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
8952 {
8953   return contentNotNullBase()->getIterations();
8954 }
8955
8956 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts)
8957 {
8958   for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
8959     pushBackTimeStep(*it);
8960 }
8961
8962 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(MEDFileAnyTypeFieldMultiTS *fmts)
8963 {
8964   if(!fmts)
8965     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps : Input fmts is NULL !");
8966   int nbOfTS(fmts->getNumberOfTS());
8967   for(int i=0;i<nbOfTS;i++)
8968     {
8969       MCAuto<MEDFileAnyTypeField1TS> elt(fmts->getTimeStepAtPos(i));
8970       pushBackTimeStep(elt);
8971     }
8972 }
8973
8974 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts)
8975 {
8976   if(!f1ts)
8977     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
8978   checkCoherencyOfType(f1ts);
8979   f1ts->incrRef();
8980   MCAuto<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
8981   MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
8982   c->incrRef();
8983   MCAuto<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
8984   if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
8985     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
8986   _content->pushBackTimeStep(cSafe);
8987   appendGlobs(*f1ts,1e-12);
8988 }
8989
8990 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope()
8991 {
8992   contentNotNullBase()->synchronizeNameScope();
8993 }
8994
8995 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const
8996 {
8997   return contentNotNullBase()->getPosOfTimeStep(iteration,order);
8998 }
8999
9000 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const
9001 {
9002   return contentNotNullBase()->getPosGivenTime(time,eps);
9003 }
9004
9005 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
9006 {
9007   return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
9008 }
9009
9010 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const
9011 {
9012   return contentNotNullBase()->getTypesOfFieldAvailable();
9013 }
9014
9015 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
9016 {
9017   return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
9018 }
9019
9020 std::string MEDFileAnyTypeFieldMultiTS::getName() const
9021 {
9022   return contentNotNullBase()->getName();
9023 }
9024
9025 void MEDFileAnyTypeFieldMultiTS::setName(const std::string& name)
9026 {
9027   contentNotNullBase()->setName(name);
9028 }
9029
9030 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const
9031 {
9032   return contentNotNullBase()->getDtUnit();
9033 }
9034
9035 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const std::string& dtUnit)
9036 {
9037   contentNotNullBase()->setDtUnit(dtUnit);
9038 }
9039
9040 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
9041 {
9042   contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
9043 }
9044
9045 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const
9046 {
9047   return contentNotNullBase()->getTimeSteps(ret1);
9048 }
9049
9050 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const
9051 {
9052   return contentNotNullBase()->getMeshName();
9053 }
9054
9055 void MEDFileAnyTypeFieldMultiTS::setMeshName(const std::string& newMeshName)
9056 {
9057   contentNotNullBase()->setMeshName(newMeshName);
9058 }
9059
9060 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
9061 {
9062   return contentNotNullBase()->changeMeshNames(modifTab);
9063 }
9064
9065 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const
9066 {
9067   return contentNotNullBase()->getInfo();
9068 }
9069
9070 bool MEDFileAnyTypeFieldMultiTS::presenceOfMultiDiscPerGeoType() const
9071 {
9072   return contentNotNullBase()->presenceOfMultiDiscPerGeoType();
9073 }
9074
9075 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info)
9076 {
9077   return contentNotNullBase()->setInfo(info);
9078 }
9079
9080 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const
9081 {
9082   const std::vector<std::string> ret=getInfo();
9083   return (int)ret.size();
9084 }
9085
9086 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const
9087 {
9088   writeGlobals(fid,*this);
9089   contentNotNullBase()->writeLL(fid,*this);
9090 }
9091
9092 /*!
9093  * This method alloc the arrays and load potentially huge arrays contained in this field.
9094  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
9095  * This method can be also called to refresh or reinit values from a file.
9096  *
9097  * \throw If the fileName is not set or points to a non readable MED file.
9098  */
9099 void MEDFileAnyTypeFieldMultiTS::loadArrays()
9100 {
9101   if(getFileName().empty())
9102     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::loadArrays : the structure does not come from a file !");
9103   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
9104   contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
9105 }
9106
9107 /*!
9108  * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
9109  * But once data loaded once, this method does nothing.
9110  *
9111  * \throw If the fileName is not set or points to a non readable MED file.
9112  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::unloadArrays
9113  */
9114 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary()
9115 {
9116   if(!getFileName().empty())
9117     {
9118       MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
9119       contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
9120     }
9121 }
9122
9123 /*!
9124  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
9125  * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
9126  * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileAnyTypeFieldMultiTS::unloadArraysWithoutDataLoss instead.
9127  *
9128  * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary, MEDFileAnyTypeFieldMultiTS::unloadArraysWithoutDataLoss
9129  */
9130 void MEDFileAnyTypeFieldMultiTS::unloadArrays()
9131 {
9132   contentNotNullBase()->unloadArrays();
9133 }
9134
9135 /*!
9136  * This method potentially releases big data arrays if \a this is coming from a file. If \a this has been built from scratch this method will have no effect.
9137  * This method is the symetrical method of MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary.
9138  * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
9139  *
9140  * \sa MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
9141  */
9142 void MEDFileAnyTypeFieldMultiTS::unloadArraysWithoutDataLoss()
9143 {
9144   if(!getFileName().empty())
9145     contentNotNullBase()->unloadArrays();
9146 }
9147
9148 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
9149 {
9150   std::ostringstream oss;
9151   contentNotNullBase()->simpleRepr(0,oss,-1);
9152   simpleReprGlobs(oss);
9153   return oss.str();
9154 }
9155
9156 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySizeWithoutChildren() const
9157 {
9158   return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
9159 }
9160
9161 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTS::getDirectChildrenWithNull() const
9162 {
9163   std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildrenWithNull());
9164   ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content);
9165   return ret;
9166 }
9167
9168 /*!
9169  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
9170  * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
9171  * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
9172  */
9173 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const
9174 {
9175   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9176   if(!content)
9177     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
9178   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
9179   std::size_t sz(contentsSplit.size());
9180   std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > ret(sz);
9181   for(std::size_t i=0;i<sz;i++)
9182     {
9183       ret[i]=shallowCpy();
9184       ret[i]->_content=contentsSplit[i];
9185     }
9186   return ret;
9187 }
9188
9189 /*!
9190  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
9191  * The returned instances are shallow copied of \a this included globals that are share with those contained in \a this.
9192  */
9193 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const
9194 {
9195   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9196   if(!content)
9197     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
9198   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit(content->splitDiscretizations());
9199   std::size_t sz(contentsSplit.size());
9200   std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > ret(sz);
9201   for(std::size_t i=0;i<sz;i++)
9202     {
9203       ret[i]=shallowCpy();
9204       ret[i]->_content=contentsSplit[i];
9205     }
9206   return ret;
9207 }
9208
9209 /*!
9210  * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of sub-discretizations over time steps in \a this.
9211  * The returned instances are shallow copied of \a this included globals that are share with those contained in \a this.
9212  */
9213 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitMultiDiscrPerGeoTypes() const
9214 {
9215   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9216   if(!content)
9217     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitMultiDiscrPerGeoTypes : no content in this ! Unable to split discretizations !");
9218   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit(content->splitMultiDiscrPerGeoTypes());
9219   std::size_t sz(contentsSplit.size());
9220   std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > ret(sz);
9221   for(std::size_t i=0;i<sz;i++)
9222     {
9223       ret[i]=shallowCpy();
9224       ret[i]->_content=contentsSplit[i];
9225     }
9226   return ret;
9227 }
9228
9229 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCopy() const
9230 {
9231   MCAuto<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
9232   if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
9233     ret->_content=_content->deepCopy();
9234   ret->deepCpyGlobs(*this);
9235   return ret.retn();
9236 }
9237
9238 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
9239 {
9240   return _content;
9241 }
9242
9243 /*!
9244  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
9245  *  \param [in] iteration - the iteration number of a required time step.
9246  *  \param [in] order - the iteration order number of required time step.
9247  *  \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
9248  *          delete this field using decrRef() as it is no more needed.
9249  *  \throw If there is no required time step in \a this field.
9250  */
9251 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const
9252 {
9253   int pos=getPosOfTimeStep(iteration,order);
9254   return getTimeStepAtPos(pos);
9255 }
9256
9257 /*!
9258  * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
9259  *  \param [in] time - the time of the time step of interest.
9260  *  \param [in] eps - a precision used to compare time values.
9261  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
9262  *          delete this field using decrRef() as it is no more needed.
9263  *  \throw If there is no required time step in \a this field.
9264  */
9265 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const
9266 {
9267   int pos=getPosGivenTime(time,eps);
9268   return getTimeStepAtPos(pos);
9269 }
9270
9271 /*!
9272  * 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.
9273  * The float64 value of time attached to the pair of integers are not considered here.
9274  * WARNING the returned pointers are not incremented. The caller is \b not responsible to deallocate them ! This method only reorganizes entries in \a vectFMTS.
9275  *
9276  * \param [in] vectFMTS - vector of not null fields defined on a same global data pointer.
9277  * \throw If there is a null pointer in \a vectFMTS.
9278  */
9279 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS)
9280 {
9281   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries : presence of null instance in input vector !";
9282   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
9283   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
9284   while(!lstFMTS.empty())
9285     {
9286       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
9287       MEDFileAnyTypeFieldMultiTS *curIt(*it);
9288       if(!curIt)
9289         throw INTERP_KERNEL::Exception(msg);
9290       std::vector< std::pair<int,int> > refIts=curIt->getIterations();
9291       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
9292       elt.push_back(curIt); it=lstFMTS.erase(it);
9293       while(it!=lstFMTS.end())
9294         {
9295           curIt=*it;
9296           if(!curIt)
9297             throw INTERP_KERNEL::Exception(msg);
9298           std::vector< std::pair<int,int> > curIts=curIt->getIterations();
9299           if(refIts==curIts)
9300             { elt.push_back(curIt); it=lstFMTS.erase(it); }
9301           else
9302             it++;
9303         }
9304       ret.push_back(elt);
9305     }
9306   return ret;
9307 }
9308
9309 /*!
9310  * This method splits the input list \a vectFMTS considering the aspect of the geometrical support over time.
9311  * All returned instances in a subvector can be safely loaded, rendered along time
9312  * All items must be defined on the same time step ids ( see MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries method ).
9313  * Each item in \a vectFMTS is expected to have one and exactly one spatial discretization along time.
9314  * 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).
9315  * All items in \a vectFMTS whose spatial discretization is not ON_NODES will appear once.
9316  * 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.
9317  *
9318  * \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().
9319  * \param [in] mesh - the mesh shared by all items in \a vectFMTS across time.
9320  * \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.
9321  * \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.
9322  *
9323  * \throw If an element in \a vectFMTS has not only one spatial discretization set.
9324  * \throw If an element in \a vectFMTS change of spatial discretization along time.
9325  * \throw If an element in \a vectFMTS lies on a mesh with meshname different from those in \a mesh.
9326  * \thorw If some elements in \a vectFMTS do not have the same times steps.
9327  * \throw If mesh is null.
9328  * \throw If an element in \a vectFMTS is null.
9329  * \sa MEDFileAnyTypeFieldMultiTS::AreOnSameSupportAcrossTime
9330  */
9331 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MCAuto<MEDFileFastCellSupportComparator> >& fsc)
9332 {
9333   static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : presence of a null instance in the input vector !";
9334   if(!mesh)
9335     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : input mesh is null !");
9336   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
9337   if(vectFMTS.empty())
9338     return ret;
9339   std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it(vectFMTS.begin());
9340   MEDFileAnyTypeFieldMultiTS *frstElt(*it);
9341   if(!frstElt)
9342     throw INTERP_KERNEL::Exception(msg);
9343   std::size_t i=0;
9344   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNotNodes;
9345   std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNodes;
9346   for(;it!=vectFMTS.end();it++,i++)
9347     {
9348       if(!(*it))
9349         throw INTERP_KERNEL::Exception(msg);
9350       TypeOfField tof0,tof1;
9351       if(CheckSupportAcrossTime(frstElt,*it,mesh,tof0,tof1)>0)
9352         {
9353           if(tof1!=ON_NODES)
9354             vectFMTSNotNodes.push_back(*it);
9355           else
9356             vectFMTSNodes.push_back(*it);
9357         }
9358       else
9359         vectFMTSNotNodes.push_back(*it);
9360     }
9361   std::vector< MCAuto<MEDFileFastCellSupportComparator> > cmps;
9362   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > retCell=SplitPerCommonSupportNotNodesAlg(vectFMTSNotNodes,mesh,cmps);
9363   ret=retCell;
9364   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it2=vectFMTSNodes.begin();it2!=vectFMTSNodes.end();it2++)
9365     {
9366       i=0;
9367       bool isFetched(false);
9368       for(std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> >::const_iterator it0=retCell.begin();it0!=retCell.end();it0++,i++)
9369         {
9370           if((*it0).empty())
9371             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : internal error !");
9372           if(cmps[i]->isCompatibleWithNodesDiscr(*it2))
9373             { ret[i].push_back(*it2); isFetched=true; }
9374         }
9375       if(!isFetched)
9376         {
9377           std::vector<MEDFileAnyTypeFieldMultiTS *> tmp(1,*it2);
9378           MCAuto<MEDFileMeshStruct> tmp2(MEDFileMeshStruct::New(mesh));
9379           ret.push_back(tmp); retCell.push_back(tmp); cmps.push_back(MEDFileFastCellSupportComparator::New(tmp2,*it2));
9380         }
9381     }
9382   fsc=cmps;
9383   return ret;
9384 }
9385
9386 /*!
9387  * 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.
9388  * \param [out] cmps - same size than the returned vector.
9389  */
9390 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupportNotNodesAlg(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MCAuto<MEDFileFastCellSupportComparator> >& cmps)
9391 {
9392   std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
9393   std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
9394   while(!lstFMTS.empty())
9395     {
9396       std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
9397       MEDFileAnyTypeFieldMultiTS *ref(*it);
9398       std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
9399       elt.push_back(ref); it=lstFMTS.erase(it);
9400       MCAuto<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(mesh));
9401       MCAuto<MEDFileFastCellSupportComparator> cmp(MEDFileFastCellSupportComparator::New(mst,ref));
9402       while(it!=lstFMTS.end())
9403         {
9404           MEDFileAnyTypeFieldMultiTS *curIt(*it);
9405           if(cmp->isEqual(curIt))
9406             { elt.push_back(curIt); it=lstFMTS.erase(it); }
9407           else
9408             it++;
9409         }
9410       ret.push_back(elt); cmps.push_back(cmp);
9411     }
9412   return ret;
9413 }
9414
9415 /*!
9416  * 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.
9417  * \a f0 and \a f1 must be defined each only on a same spatial discretization even if this can be different each other.
9418  *
9419  * \throw If \a f0 or \a f1 has not only one spatial discretization set.
9420  * \throw If \a f0 or \a f1 change of spatial discretization along time.
9421  * \throw If \a f0 or \a f1 on a mesh with meshname different from those in \a mesh.
9422  * \thorw If \a f0 and \a f1 do not have the same times steps.
9423  * \throw If mesh is null.
9424  * \throw If \a f0 or \a f1 is null.
9425  * \sa MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport
9426  */
9427 int MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime(MEDFileAnyTypeFieldMultiTS *f0, MEDFileAnyTypeFieldMultiTS *f1, const MEDFileMesh *mesh, TypeOfField& tof0, TypeOfField& tof1)
9428 {
9429   if(!mesh)
9430     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : input mesh is null !");
9431   if(!f0 || !f1)
9432     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : presence of null instance in fields over time !");
9433   if(f0->getMeshName()!=mesh->getName())
9434     {
9435       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh \""<< f0->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
9436       throw INTERP_KERNEL::Exception(oss.str());
9437     }
9438   if(f1->getMeshName()!=mesh->getName())
9439     {
9440       std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh \""<< f1->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
9441       throw INTERP_KERNEL::Exception(oss.str());
9442     }
9443   int nts=f0->getNumberOfTS();
9444   if(nts!=f1->getNumberOfTS())
9445     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : number of time steps are not the same !");
9446   if(nts==0)
9447     return nts;
9448   for(int i=0;i<nts;i++)
9449     {
9450       MCAuto<MEDFileAnyTypeField1TS> f0cur=f0->getTimeStepAtPos(i);
9451       MCAuto<MEDFileAnyTypeField1TS> f1cur=f1->getTimeStepAtPos(i);
9452       std::vector<TypeOfField> tofs0(f0cur->getTypesOfFieldAvailable()),tofs1(f1cur->getTypesOfFieldAvailable());
9453       if(tofs0.size()!=1 || tofs1.size()!=1)
9454         throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : All time steps must be defined on only one spatial discretization !");
9455       if(i!=0)
9456         {
9457           if(tof0!=tofs0[0] || tof1!=tofs1[0])
9458             throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : Across times steps MEDFileAnyTypeFieldMultiTS instances have to keep the same unique spatial discretization !");
9459         }
9460       else
9461         { tof0=tofs0[0]; tof1=tofs1[0]; }
9462       if(f0cur->getMeshIteration()!=mesh->getIteration() || f0cur->getMeshOrder()!=mesh->getOrder())
9463         {
9464           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() << ") !";
9465           throw INTERP_KERNEL::Exception(oss.str());
9466         }
9467       if(f1cur->getMeshIteration()!=mesh->getIteration() || f1cur->getMeshOrder()!=mesh->getOrder())
9468         {
9469           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() << ") !";
9470           throw INTERP_KERNEL::Exception(oss.str());
9471         }
9472       if(f0cur->getIteration()!=f1cur->getIteration() || f0cur->getOrder()!=f1cur->getOrder())
9473         {
9474           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() << ") !";
9475           throw INTERP_KERNEL::Exception(oss.str());
9476         }
9477     }
9478   return nts;
9479 }
9480
9481 /*!
9482  * Return an extraction of \a this using \a extractDef map to specify the extraction.
9483  * The keys of \a extractDef is level relative to max ext of \a mm mesh.
9484  *
9485  * \return A new object that the caller is responsible to deallocate.
9486  */
9487 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::extractPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef, MEDFileMesh *mm) const
9488 {
9489   if(!mm)
9490     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::extractPart : mesh is null !");
9491   MCAuto<MEDFileAnyTypeFieldMultiTS> fmtsOut(buildNewEmpty());
9492   int nbTS(getNumberOfTS());
9493   for(int i=0;i<nbTS;i++)
9494     {
9495       MCAuto<MEDFileAnyTypeField1TS> f1ts(getTimeStepAtPos(i));
9496       MCAuto<MEDFileAnyTypeField1TS> f1tsOut(f1ts->extractPart(extractDef,mm));
9497       fmtsOut->pushBackTimeStep(f1tsOut);
9498     }
9499   return fmtsOut.retn();
9500 }
9501
9502 template<class T>
9503 MCAuto<MEDFileAnyTypeField1TS> AggregateHelperF1TS(const std::vector< typename MLFieldTraits<T>::F1TSType const *>& f1tss, const std::vector< std::vector< std::pair<int,int> > >& dts)
9504 {
9505   MCAuto< typename MLFieldTraits<T>::F1TSType > ret(MLFieldTraits<T>::F1TSType::New());
9506   if(f1tss.empty())
9507     throw INTERP_KERNEL::Exception("AggregateHelperF1TS : empty vector !");
9508   std::size_t sz(f1tss.size()),i(0);
9509   std::vector< typename MLFieldTraits<T>::F1TSWSDAType const *> f1tsw(sz);
9510   for(typename std::vector< typename MLFieldTraits<T>::F1TSType const *>::const_iterator it=f1tss.begin();it!=f1tss.end();it++,i++)
9511     {
9512       typename MLFieldTraits<T>::F1TSType const *elt(*it);
9513       if(!elt)
9514         throw INTERP_KERNEL::Exception("AggregateHelperF1TS : presence of a null pointer !");
9515       f1tsw[i]=dynamic_cast<typename MLFieldTraits<T>::F1TSWSDAType const *>(elt->contentNotNullBase());
9516     }
9517   typename MLFieldTraits<T>::F1TSWSDAType *retc(dynamic_cast<typename MLFieldTraits<T>::F1TSWSDAType *>(ret->contentNotNullBase()));
9518   if(!retc)
9519     throw INTERP_KERNEL::Exception("AggregateHelperF1TS : internal error 1 !");
9520   retc->aggregate(f1tsw,dts);
9521   ret->setDtUnit(f1tss[0]->getDtUnit());
9522   return DynamicCast<typename MLFieldTraits<T>::F1TSType , MEDFileAnyTypeField1TS>(ret);
9523 }
9524
9525 template<class T>
9526 MCAuto< MEDFileAnyTypeFieldMultiTS > AggregateHelperFMTS(const std::vector< typename MLFieldTraits<T>::FMTSType const *>& fmtss, const std::vector< std::vector< std::pair<int,int> > >& dts)
9527 {
9528   MCAuto< typename MLFieldTraits<T>::FMTSType > ret(MLFieldTraits<T>::FMTSType::New());
9529   if(fmtss.empty())
9530     throw INTERP_KERNEL::Exception("AggregateHelperFMTS : empty vector !");
9531   std::size_t sz(fmtss.size());
9532   for(typename std::vector< typename MLFieldTraits<T>::FMTSType const *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
9533     {
9534       typename MLFieldTraits<T>::FMTSType const *elt(*it);
9535       if(!elt)
9536         throw INTERP_KERNEL::Exception("AggregateHelperFMTS : presence of null pointer !");
9537     }
9538   int nbTS(fmtss[0]->getNumberOfTS());
9539   for(typename std::vector< typename MLFieldTraits<T>::FMTSType const *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
9540     if((*it)->getNumberOfTS()!=nbTS)
9541       throw INTERP_KERNEL::Exception("AggregateHelperFMTS : all fields must have the same number of TS !");
9542   for(int iterTS=0;iterTS<nbTS;iterTS++)
9543     {
9544       std::size_t i(0);
9545       std::vector< typename MLFieldTraits<T>::F1TSType const *> f1tss(sz);
9546       std::vector< MCAuto<typename MLFieldTraits<T>::F1TSType> > f1tss2(sz);
9547       for(typename std::vector< typename MLFieldTraits<T>::FMTSType const *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++,i++)
9548         { f1tss2[i]=(*it)->getTimeStepAtPos(iterTS); f1tss[i]=f1tss2[i]; }
9549       MCAuto<MEDFileAnyTypeField1TS> f1ts(AggregateHelperF1TS<T>(f1tss,dts));
9550       ret->pushBackTimeStep(f1ts);
9551       ret->setDtUnit(f1ts->getDtUnit());
9552     }
9553   return DynamicCast<typename MLFieldTraits<T>::FMTSType , MEDFileAnyTypeFieldMultiTS>(ret);
9554 }
9555
9556 /*!
9557  * \a dts and \a ftmss are expected to have same size.
9558  */
9559 MCAuto<MEDFileAnyTypeFieldMultiTS> MEDFileAnyTypeFieldMultiTS::Aggregate(const std::vector<const MEDFileAnyTypeFieldMultiTS *>& fmtss, const std::vector< std::vector< std::pair<int,int> > >& dts)
9560 {
9561   if(fmtss.empty())
9562     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : input vector is empty !");
9563   std::size_t sz(fmtss.size());
9564   std::vector<const MEDFileFieldMultiTS *> fmtss1;
9565   std::vector<const MEDFileIntFieldMultiTS *> fmtss2;
9566   for(std::vector<const MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
9567     {
9568       if(!(*it))
9569         throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : presence of null instance in input vector !");
9570       const MEDFileFieldMultiTS *elt1(dynamic_cast<const MEDFileFieldMultiTS *>(*it));
9571       if(elt1)
9572         {
9573           fmtss1.push_back(elt1);
9574           continue;
9575         }
9576       const MEDFileIntFieldMultiTS *elt2(dynamic_cast<const MEDFileIntFieldMultiTS *>(*it));
9577       if(elt2)
9578         {
9579           fmtss2.push_back(elt2);
9580           continue;
9581         }
9582       throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : not recognized type !");
9583     }
9584   if(fmtss1.size()!=sz && fmtss2.size()!=sz)
9585     throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : type of data is not homogeneous !");
9586   if(fmtss1.size()==sz)
9587     return AggregateHelperFMTS<double>(fmtss1,dts);
9588   if(fmtss2.size()!=sz)
9589     return AggregateHelperFMTS<int>(fmtss2,dts);
9590   throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : not implemented yet !");
9591 }
9592
9593 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator()
9594 {
9595   return new MEDFileAnyTypeFieldMultiTSIterator(this);
9596 }
9597
9598 //= MEDFileFieldMultiTS
9599
9600 /*!
9601  * Returns a new empty instance of MEDFileFieldMultiTS.
9602  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
9603  *          is to delete this field using decrRef() as it is no more needed.
9604  */
9605 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
9606 {
9607   return new MEDFileFieldMultiTS;
9608 }
9609
9610 /*!
9611  * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
9612  * that has been read from a specified MED file.
9613  *  \param [in] fileName - the name of the MED file to read.
9614  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
9615  *          is to delete this field using decrRef() as it is no more needed.
9616  *  \throw If reading the file fails.
9617  */
9618 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, bool loadAll)
9619 {
9620   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
9621   return New(fid,loadAll);
9622 }
9623
9624 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(med_idt fid, bool loadAll)
9625 {
9626   MCAuto<MEDFileFieldMultiTS> ret(new MEDFileFieldMultiTS(fid,loadAll,0));
9627   ret->contentNotNull();//to check that content type matches with \a this type.
9628   return ret.retn();
9629 }
9630
9631 /*!
9632  * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
9633  * that has been read from a specified MED file.
9634  *  \param [in] fileName - the name of the MED file to read.
9635  *  \param [in] fieldName - the name of the field to read.
9636  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
9637  *          is to delete this field using decrRef() as it is no more needed.
9638  *  \throw If reading the file fails.
9639  *  \throw If there is no field named \a fieldName in the file.
9640  */
9641 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
9642 {
9643   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
9644   return New(fid,fieldName,loadAll);
9645 }
9646
9647 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(med_idt fid, const std::string& fieldName, bool loadAll)
9648 {
9649   MCAuto<MEDFileFieldMultiTS> ret(new MEDFileFieldMultiTS(fid,fieldName,loadAll,0));
9650   ret->contentNotNull();//to check that content type matches with \a this type.
9651   return ret.retn();
9652 }
9653
9654 /*!
9655  * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
9656  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
9657  *
9658  * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
9659  * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
9660  * \warning this is a shallow copy constructor
9661  *  \param [in] other - a MEDFileField1TSWithoutSDA to copy.
9662  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
9663  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
9664  *          is to delete this field using decrRef() as it is no more needed.
9665  */
9666 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
9667 {
9668   return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
9669 }
9670
9671 MEDFileFieldMultiTS *MEDFileFieldMultiTS::LoadSpecificEntities(const std::string& fileName, const std::string& fieldName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll)
9672 {
9673   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
9674   INTERP_KERNEL::AutoCppPtr<MEDFileEntities> ent(new MEDFileStaticEntities(entities));
9675   MCAuto<MEDFileFieldMultiTS> ret(new MEDFileFieldMultiTS(fid,fieldName,loadAll,0,ent));
9676   ret->contentNotNull();//to check that content type matches with \a this type.
9677   return ret.retn();
9678 }
9679
9680 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const
9681 {
9682   return new MEDFileFieldMultiTS(*this);
9683 }
9684
9685 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
9686 {
9687   if(!f1ts)
9688     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
9689   const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
9690   if(!f1tsC)
9691     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
9692 }
9693
9694 /*!
9695  * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
9696  * following the given input policy.
9697  *
9698  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
9699  *                            By default (true) the globals are deeply copied.
9700  * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
9701  */
9702 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool isDeepCpyGlobs) const
9703 {
9704   MCAuto<MEDFileIntFieldMultiTS> ret;
9705   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9706   if(content)
9707     {
9708       const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
9709       if(!contc)
9710         throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
9711       MCAuto<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
9712       ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc));
9713     }
9714   else
9715     ret=MEDFileIntFieldMultiTS::New();
9716   if(isDeepCpyGlobs)
9717     ret->deepCpyGlobs(*this);
9718   else
9719     ret->shallowCpyGlobs(*this);
9720   return ret.retn();
9721 }
9722
9723 /*!
9724  * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
9725  *  \param [in] pos - a time step id.
9726  *  \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
9727  *          delete this field using decrRef() as it is no more needed.
9728  *  \throw If \a pos is not a valid time step id.
9729  */
9730 MEDFileField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const
9731 {
9732   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
9733   if(!item)
9734     {
9735       std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
9736       throw INTERP_KERNEL::Exception(oss.str());
9737     }
9738   const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
9739   if(itemC)
9740     {
9741       MCAuto<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
9742       ret->shallowCpyGlobs(*this);
9743       return ret.retn();
9744     }
9745   std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
9746   throw INTERP_KERNEL::Exception(oss.str());
9747 }
9748
9749 /*!
9750  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9751  * mesh entities of a given dimension of the first mesh in MED file.
9752  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9753  *  \param [in] type - a spatial discretization of interest.
9754  *  \param [in] iteration - the iteration number of a required time step.
9755  *  \param [in] order - the iteration order number of required time step.
9756  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9757  *  \param [in] renumPol - specifies how to permute values of the result field according to
9758  *          the optional numbers of cells and nodes, if any. The valid values are
9759  *          - 0 - do not permute.
9760  *          - 1 - permute cells.
9761  *          - 2 - permute nodes.
9762  *          - 3 - permute cells and nodes.
9763  *
9764  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9765  *          caller is to delete this field using decrRef() as it is no more needed.
9766  *  \throw If the MED file is not readable.
9767  *  \throw If there is no mesh in the MED file.
9768  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9769  *  \throw If no field values of the required parameters are available.
9770  */
9771 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const
9772 {
9773   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9774   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9775   if(!myF1TSC)
9776     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
9777   MCAuto<DataArray> arrOut;
9778   MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNullBase());
9779   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9780   return ret.retn();
9781 }
9782
9783 /*!
9784  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9785  * the top level cells of the first mesh in MED file.
9786  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9787  *  \param [in] type - a spatial discretization of interest.
9788  *  \param [in] iteration - the iteration number of a required time step.
9789  *  \param [in] order - the iteration order number of required time step.
9790  *  \param [in] renumPol - specifies how to permute values of the result field according to
9791  *          the optional numbers of cells and nodes, if any. The valid values are
9792  *          - 0 - do not permute.
9793  *          - 1 - permute cells.
9794  *          - 2 - permute nodes.
9795  *          - 3 - permute cells and nodes.
9796  *
9797  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9798  *          caller is to delete this field using decrRef() as it is no more needed.
9799  *  \throw If the MED file is not readable.
9800  *  \throw If there is no mesh in the MED file.
9801  *  \throw If no field values of the required parameters are available.
9802  */
9803 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const
9804 {
9805   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9806   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9807   if(!myF1TSC)
9808     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
9809   MCAuto<DataArray> arrOut;
9810   MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNullBase());
9811   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9812   return ret.retn();
9813 }
9814
9815 /*!
9816  * This is the simplest version to fetch a field for MED structure. One drawback : if \a this is a complex field (multi spatial discretization inside a same field) this method will throw exception and more advance
9817  * method should be called (getFieldOnMeshAtLevel for example).
9818  * But for normal usage of field in MED file world this method is the most efficient to fetch data.
9819  *
9820  * \param [in] iteration - the iteration number of a required time step.
9821  * \param [in] order - the iteration order number of required time step.
9822  * \param [in] mesh - the mesh the field is lying on
9823  * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9824  *          caller is to delete this field using decrRef() as it is no more needed.
9825  */
9826 MEDCouplingFieldDouble *MEDFileFieldMultiTS::field(int iteration, int order, const MEDFileMesh *mesh) const
9827 {
9828   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9829   MCAuto<DataArray> arrOut;
9830   MCAuto<MEDCouplingFieldDouble> ret(myF1TS.fieldOnMesh(this,mesh,arrOut,*contentNotNullBase()));
9831   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9832   return ret.retn();
9833 }
9834
9835 /*!
9836  * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9837  * a given support.
9838  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9839  *  \param [in] type - a spatial discretization of interest.
9840  *  \param [in] iteration - the iteration number of a required time step.
9841  *  \param [in] order - the iteration order number of required time step.
9842  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9843  *  \param [in] mesh - the supporting mesh.
9844  *  \param [in] renumPol - specifies how to permute values of the result field according to
9845  *          the optional numbers of cells and nodes, if any. The valid values are
9846  *          - 0 - do not permute.
9847  *          - 1 - permute cells.
9848  *          - 2 - permute nodes.
9849  *          - 3 - permute cells and nodes.
9850  *
9851  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9852  *          caller is to delete this field using decrRef() as it is no more needed.
9853  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9854  *  \throw If no field of \a this is lying on \a mesh.
9855  *  \throw If no field values of the required parameters are available.
9856  */
9857 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
9858 {
9859   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9860   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9861   if(!myF1TSC)
9862     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
9863   MCAuto<DataArray> arrOut;
9864   MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
9865   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9866   return ret.retn();
9867 }
9868
9869 /*!
9870  * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
9871  * given support.
9872  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9873  *  \param [in] type - a spatial discretization of the new field.
9874  *  \param [in] iteration - the iteration number of a required time step.
9875  *  \param [in] order - the iteration order number of required time step.
9876  *  \param [in] mesh - the supporting mesh.
9877  *  \param [in] renumPol - specifies how to permute values of the result field according to
9878  *          the optional numbers of cells and nodes, if any. The valid values are
9879  *          - 0 - do not permute.
9880  *          - 1 - permute cells.
9881  *          - 2 - permute nodes.
9882  *          - 3 - permute cells and nodes.
9883  *
9884  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9885  *          caller is to delete this field using decrRef() as it is no more needed.
9886  *  \throw If no field of \a this is lying on \a mesh.
9887  *  \throw If no field values of the required parameters are available.
9888  */
9889 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const
9890 {
9891   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9892   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9893   if(!myF1TSC)
9894     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
9895   MCAuto<DataArray> arrOut;
9896   MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
9897   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9898   return ret.retn();
9899 }
9900
9901 /*!
9902  * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
9903  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
9904  * This method is useful for MED2 file format when field on different mesh was autorized.
9905  */
9906 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int iteration, int order, int meshDimRelToMax, int renumPol) const
9907 {
9908   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9909   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9910   if(!myF1TSC)
9911     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
9912   MCAuto<DataArray> arrOut;
9913   MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
9914   MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9915   return ret.retn();
9916 }
9917
9918 /*!
9919  * Returns values and a profile of the field of a given type, of a given time step,
9920  * lying on a given support.
9921  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9922  *  \param [in] type - a spatial discretization of the field.
9923  *  \param [in] iteration - the iteration number of a required time step.
9924  *  \param [in] order - the iteration order number of required time step.
9925  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9926  *  \param [in] mesh - the supporting mesh.
9927  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
9928  *          field of interest lies on. If the field lies on all entities of the given
9929  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
9930  *          using decrRef() as it is no more needed.
9931  *  \param [in] glob - the global data storing profiles and localization.
9932  *  \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
9933  *          field. The caller is to delete this array using decrRef() as it is no more needed.
9934  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9935  *  \throw If no field of \a this is lying on \a mesh.
9936  *  \throw If no field values of the required parameters are available.
9937  */
9938 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
9939 {
9940   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9941   const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9942   if(!myF1TSC)
9943     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
9944   MCAuto<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
9945   return MEDFileField1TS::ReturnSafelyTypedDataArray(ret);
9946 }
9947
9948 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const
9949 {
9950   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9951   if(!pt)
9952     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
9953   const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
9954   if(!ret)
9955     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 !");
9956   return ret;
9957 }
9958
9959 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull()
9960 {
9961   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9962   if(!pt)
9963     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
9964   MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
9965   if(!ret)
9966     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 !");
9967   return ret;
9968 }
9969
9970 /*!
9971  * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
9972  * the given field is checked if its elements are sorted suitable for writing to MED file
9973  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
9974  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9975  *  \param [in] field - the field to add to \a this.
9976  *  \throw If the name of \a field is empty.
9977  *  \throw If the data array of \a field is not set.
9978  *  \throw If existing time steps have different name or number of components than \a field.
9979  *  \throw If the underlying mesh of \a field has no name.
9980  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
9981  */
9982 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
9983 {
9984   const DataArrayDouble *arr=0;
9985   if(field)
9986     arr=field->getArray();
9987   contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
9988 }
9989
9990 /*!
9991  * Adds a MEDCouplingFieldDouble to \a this as another time step.
9992  * The mesh support of input parameter \a field is ignored here, it can be NULL.
9993  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
9994  * and \a profile.
9995  *
9996  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
9997  * A new profile is added only if no equal profile is missing.
9998  * For more info, see \ref AdvMEDLoaderAPIFieldRW
9999  *  \param [in] field - the field to add to \a this. The mesh support of field is ignored.
10000  *  \param [in] mesh - the supporting mesh of \a field.
10001  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
10002  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
10003  *  \throw If either \a field or \a mesh or \a profile has an empty name.
10004  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
10005  *  \throw If the data array of \a field is not set.
10006  *  \throw If the data array of \a this is already allocated but has different number of
10007  *         components than \a field.
10008  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
10009  *  \sa setFieldNoProfileSBT()
10010  */
10011 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
10012 {
10013   const DataArrayDouble *arr=0;
10014   if(field)
10015     arr=field->getArray();
10016   contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
10017 }
10018
10019 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
10020 {
10021   _content=new MEDFileFieldMultiTSWithoutSDA;
10022 }
10023
10024 MEDFileFieldMultiTS::MEDFileFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
10025 try:MEDFileAnyTypeFieldMultiTS(fid,loadAll,ms)
10026 {
10027 }
10028 catch(INTERP_KERNEL::Exception& e)
10029 { throw e; }
10030
10031 MEDFileFieldMultiTS::MEDFileFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
10032 try:MEDFileAnyTypeFieldMultiTS(fid,fieldName,loadAll,ms,entities)
10033 {
10034 }
10035 catch(INTERP_KERNEL::Exception& e)
10036 { throw e; }
10037
10038 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
10039 {
10040 }
10041
10042 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
10043 {
10044   return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
10045 }
10046
10047 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
10048 {
10049   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
10050 }
10051
10052 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
10053 {
10054   return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
10055 }
10056
10057 MEDFileFieldMultiTS *MEDFileFieldMultiTS::buildNewEmpty() const
10058 {
10059   return MEDFileFieldMultiTS::New();
10060 }
10061
10062 //= MEDFileAnyTypeFieldMultiTSIterator
10063
10064 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
10065 {
10066   if(fmts)
10067     {
10068       fmts->incrRef();
10069       _nb_iter=fmts->getNumberOfTS();
10070     }
10071 }
10072
10073 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
10074 {
10075 }
10076
10077 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt()
10078 {
10079   if(_iter_id<_nb_iter)
10080     {
10081       MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
10082       if(fmts)
10083         return fmts->getTimeStepAtPos(_iter_id++);
10084       else
10085         return 0;
10086     }
10087   else
10088     return 0;
10089 }
10090
10091 //= MEDFileIntFieldMultiTS
10092
10093 /*!
10094  * Returns a new empty instance of MEDFileFieldMultiTS.
10095  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
10096  *          is to delete this field using decrRef() as it is no more needed.
10097  */
10098 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
10099 {
10100   return new MEDFileIntFieldMultiTS;
10101 }
10102
10103 /*!
10104  * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
10105  * that has been read from a specified MED file.
10106  *  \param [in] fileName - the name of the MED file to read.
10107  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
10108  *          is to delete this field using decrRef() as it is no more needed.
10109  *  \throw If reading the file fails.
10110  */
10111 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, bool loadAll)
10112 {
10113   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10114   return New(fid,loadAll);
10115 }
10116
10117 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(med_idt fid, bool loadAll)
10118 {
10119   MCAuto<MEDFileIntFieldMultiTS> ret(new MEDFileIntFieldMultiTS(fid,loadAll,0));
10120   ret->contentNotNull();//to check that content type matches with \a this type.
10121   return ret.retn();
10122 }
10123
10124 /*!
10125  * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
10126  * that has been read from a specified MED file.
10127  *  \param [in] fileName - the name of the MED file to read.
10128  *  \param [in] fieldName - the name of the field to read.
10129  *  \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
10130  *          is to delete this field using decrRef() as it is no more needed.
10131  *  \throw If reading the file fails.
10132  *  \throw If there is no field named \a fieldName in the file.
10133  */
10134 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
10135 {
10136   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10137   return New(fid,fieldName,loadAll);
10138 }
10139
10140 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(med_idt fid, const std::string& fieldName, bool loadAll)
10141 {
10142   MCAuto<MEDFileIntFieldMultiTS> ret(new MEDFileIntFieldMultiTS(fid,fieldName,loadAll,0));
10143   ret->contentNotNull();//to check that content type matches with \a this type.
10144   return ret.retn();
10145 }
10146
10147 /*!
10148  * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
10149  * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
10150  *
10151  * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
10152  * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
10153  * \warning this is a shallow copy constructor
10154  *  \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
10155  *  \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
10156  *  \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
10157  *          is to delete this field using decrRef() as it is no more needed.
10158  */
10159 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
10160 {
10161   return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
10162 }
10163
10164 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::LoadSpecificEntities(const std::string& fileName, const std::string& fieldName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll)
10165 {
10166   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10167   INTERP_KERNEL::AutoCppPtr<MEDFileEntities> ent(new MEDFileStaticEntities(entities));
10168   MCAuto<MEDFileIntFieldMultiTS> ret(new MEDFileIntFieldMultiTS(fid,fieldName,loadAll,0,ent));
10169   ret->contentNotNull();//to check that content type matches with \a this type.
10170   return ret.retn();
10171 }
10172
10173 /*!
10174  * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
10175  * following the given input policy.
10176  *
10177  * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
10178  *                            By default (true) the globals are deeply copied.
10179  * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
10180  */
10181 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool isDeepCpyGlobs) const
10182 {
10183   MCAuto<MEDFileFieldMultiTS> ret;
10184   const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
10185   if(content)
10186     {
10187       const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
10188       if(!contc)
10189         throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
10190       MCAuto<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
10191       ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc));
10192     }
10193   else
10194     ret=MEDFileFieldMultiTS::New();
10195   if(isDeepCpyGlobs)
10196     ret->deepCpyGlobs(*this);
10197   else
10198     ret->shallowCpyGlobs(*this);
10199   return ret.retn();
10200 }
10201
10202 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const
10203 {
10204   return new MEDFileIntFieldMultiTS(*this);
10205 }
10206
10207 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
10208 {
10209   if(!f1ts)
10210     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
10211   const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
10212   if(!f1tsC)
10213     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
10214 }
10215
10216 /*!
10217  * This is the simplest version to fetch a field for MED structure. One drawback : if \a this is a complex field (multi spatial discretization inside a same field) this method will throw exception and more advance
10218  * method should be called (getFieldOnMeshAtLevel for example).
10219  * But for normal usage of field in MED file world this method is the most efficient to fetch data.
10220  *
10221  * \param [in] iteration - the iteration number of a required time step.
10222  * \param [in] order - the iteration order number of required time step.
10223  * \param [in] mesh - the mesh the field is lying on
10224  * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldInt. The
10225  *          caller is to delete this field using decrRef() as it is no more needed.
10226  */
10227 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::field(int iteration, int order, const MEDFileMesh *mesh) const
10228 {
10229   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
10230   const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
10231   if(!myF1TSC)
10232     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::field : mismatch of type of field expecting INT32 !");
10233   MCAuto<DataArray> arrOut;
10234   MCAuto<MEDCouplingFieldDouble> ret(myF1TS.fieldOnMesh(this,mesh,arrOut,*contentNotNullBase()));
10235   MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arrOut));
10236   return ret2.retn();
10237 }
10238
10239 /*!
10240  * Returns a new MEDCouplingFieldInt of a given type, of a given time step, lying on
10241  * mesh entities of a given dimension of the first mesh in MED file.
10242  * For more info, see \ref AdvMEDLoaderAPIFieldRW
10243  *  \param [in] type - a spatial discretization of interest.
10244  *  \param [in] iteration - the iteration number of a required time step.
10245  *  \param [in] order - the iteration order number of required time step.
10246  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
10247  *  \param [in] renumPol - specifies how to permute values of the result field according to
10248  *          the optional numbers of cells and nodes, if any. The valid values are
10249  *          - 0 - do not permute.
10250  *          - 1 - permute cells.
10251  *          - 2 - permute nodes.
10252  *          - 3 - permute cells and nodes.
10253  *
10254  *  \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
10255  *          caller is to delete this field using decrRef() as it is no more needed.
10256  *  \throw If the MED file is not readable.
10257  *  \throw If there is no mesh in the MED file.
10258  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
10259  *  \throw If no field values of the required parameters are available.
10260  */
10261 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const
10262 {
10263   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
10264   const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
10265   if(!myF1TSC)
10266     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
10267   MCAuto<DataArray> arr;
10268   MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arr,*contentNotNullBase()));
10269   MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
10270   return ret2.retn();
10271 }
10272
10273 /*!
10274  * Returns a new MEDCouplingFieldInt of a given type, of a given time step, lying on
10275  * the top level cells of the first mesh in MED file.
10276  * For more info, see \ref AdvMEDLoaderAPIFieldRW
10277  *  \param [in] type - a spatial discretization of interest.
10278  *  \param [in] iteration - the iteration number of a required time step.
10279  *  \param [in] order - the iteration order number of required time step.
10280  *  \param [in] renumPol - specifies how to permute values of the result field according to
10281  *          the optional numbers of cells and nodes, if any. The valid values are
10282  *          - 0 - do not permute.
10283  *          - 1 - permute cells.
10284  *          - 2 - permute nodes.
10285  *          - 3 - permute cells and nodes.
10286  *
10287  *  \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
10288  *          caller is to delete this field using decrRef() as it is no more needed.
10289  *  \throw If the MED file is not readable.
10290  *  \throw If there is no mesh in the MED file.
10291  *  \throw If no field values of the required parameters are available.
10292  */
10293 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const
10294 {
10295   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
10296   const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
10297   if(!myF1TSC)
10298     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
10299   MCAuto<DataArray> arr;
10300   MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arr,*contentNotNullBase()));
10301   MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
10302   return ret2.retn();
10303 }
10304
10305 /*!
10306  * Returns a new MEDCouplingFieldInt of a given type, of a given time step, lying on
10307  * a given support.
10308  * For more info, see \ref AdvMEDLoaderAPIFieldRW
10309  *  \param [in] type - a spatial discretization of interest.
10310  *  \param [in] iteration - the iteration number of a required time step.
10311  *  \param [in] order - the iteration order number of required time step.
10312  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
10313  *  \param [in] mesh - the supporting mesh.
10314  *  \param [in] renumPol - specifies how to permute values of the result field according to
10315  *          the optional numbers of cells and nodes, if any. The valid values are
10316  *          - 0 - do not permute.
10317  *          - 1 - permute cells.
10318  *          - 2 - permute nodes.
10319  *          - 3 - permute cells and nodes.
10320  *
10321  *  \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
10322  *          caller is to delete this field using decrRef() as it is no more needed.
10323  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
10324  *  \throw If no field of \a this is lying on \a mesh.
10325  *  \throw If no field values of the required parameters are available.
10326  */
10327 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
10328 {
10329   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
10330   const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
10331   if(!myF1TSC)
10332     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
10333   MCAuto<DataArray> arr;
10334   MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase()));
10335   MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
10336   return ret2.retn();
10337 }
10338
10339 /*!
10340  * Returns a new MEDCouplingFieldInt of given type, of a given time step, lying on a
10341  * given support.
10342  * For more info, see \ref AdvMEDLoaderAPIFieldRW
10343  *  \param [in] type - a spatial discretization of the new field.
10344  *  \param [in] iteration - the iteration number of a required time step.
10345  *  \param [in] order - the iteration order number of required time step.
10346  *  \param [in] mesh - the supporting mesh.
10347  *  \param [out] arrOut - the DataArrayInt containing values of field.
10348  *  \param [in] renumPol - specifies how to permute values of the result field according to
10349  *          the optional numbers of cells and nodes, if any. The valid values are
10350  *          - 0 - do not permute.
10351  *          - 1 - permute cells.
10352  *          - 2 - permute nodes.
10353  *          - 3 - permute cells and nodes.
10354  *
10355  *  \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
10356  *          caller is to delete this field using decrRef() as it is no more needed.
10357  *  \throw If no field of \a this is lying on \a mesh.
10358  *  \throw If no field values of the required parameters are available.
10359  */
10360 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const
10361 {
10362   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
10363   const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
10364   if(!myF1TSC)
10365     throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
10366   MCAuto<DataArray> arr;
10367   MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase()));
10368   MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
10369   return ret2.retn();
10370 }
10371
10372 /*!
10373  * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
10374  * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
10375  * This method is useful for MED2 file format when field on different mesh was autorized.
10376  */
10377 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const std::string& mname, int meshDimRelToMax, int renumPol) const
10378 {
10379   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
10380   const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
10381   if(!myF1TSC)
10382     throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
10383   MCAuto<DataArray> arr;
10384   MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase()));
10385   MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
10386   return ret2.retn();
10387 }
10388
10389 /*!
10390  * Returns values and a profile of the field of a given type, of a given time step,
10391  * lying on a given support.
10392  * For more info, see \ref AdvMEDLoaderAPIFieldRW
10393  *  \param [in] type - a spatial discretization of the field.
10394  *  \param [in] iteration - the iteration number of a required time step.
10395  *  \param [in] order - the iteration order number of required time step.
10396  *  \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
10397  *  \param [in] mesh - the supporting mesh.
10398  *  \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
10399  *          field of interest lies on. If the field lies on all entities of the given
10400  *          dimension, all ids in \a pfl are zero. The caller is to delete this array
10401  *          using decrRef() as it is no more needed.
10402  *  \param [in] glob - the global data storing profiles and localization.
10403  *  \return DataArrayInt * - a new instance of DataArrayInt holding values of the
10404  *          field. The caller is to delete this array using decrRef() as it is no more needed.
10405  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
10406  *  \throw If no field of \a this is lying on \a mesh.
10407  *  \throw If no field values of the required parameters are available.
10408  */
10409 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
10410 {
10411   const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
10412   const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
10413   if(!myF1TSC)
10414     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
10415   MCAuto<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
10416   return MEDFileIntField1TS::ReturnSafelyTypedDataArray(ret);
10417 }
10418
10419 /*!
10420  * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
10421  *  \param [in] pos - a time step id.
10422  *  \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
10423  *          delete this field using decrRef() as it is no more needed.
10424  *  \throw If \a pos is not a valid time step id.
10425  */
10426 MEDFileIntField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const
10427 {
10428   const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
10429   if(!item)
10430     {
10431       std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
10432       throw INTERP_KERNEL::Exception(oss.str());
10433     }
10434   const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
10435   if(itemC)
10436     {
10437       MCAuto<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
10438       ret->shallowCpyGlobs(*this);
10439       return ret.retn();
10440     }
10441   std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
10442   throw INTERP_KERNEL::Exception(oss.str());
10443 }
10444
10445 /*!
10446  * Adds a MEDCouplingFieldInt to \a this as another time step. The underlying mesh of
10447  * the given field is checked if its elements are sorted suitable for writing to MED file
10448  * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
10449  * For more info, see \ref AdvMEDLoaderAPIFieldRW
10450  *  \param [in] field - the field to add to \a this.
10451  *  \throw If the name of \a field is empty.
10452  *  \throw If the data array of \a field is not set.
10453  *  \throw If existing time steps have different name or number of components than \a field.
10454  *  \throw If the underlying mesh of \a field has no name.
10455  *  \throw If elements in the mesh are not in the order suitable for writing to the MED file.
10456  */
10457 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldInt *field)
10458 {
10459   MCAuto<MEDCouplingFieldDouble> field2(MEDFileIntField1TS::ConvertFieldIntToFieldDouble(field));
10460   contentNotNull()->appendFieldNoProfileSBT(field2,field->getArray(),*this);
10461 }
10462
10463 /*!
10464  * Adds a MEDCouplingFieldDouble to \a this as another time step.
10465  * The mesh support of input parameter \a field is ignored here, it can be NULL.
10466  * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
10467  * and \a profile.
10468  *
10469  * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
10470  * A new profile is added only if no equal profile is missing.
10471  * For more info, see \ref AdvMEDLoaderAPIFieldRW
10472  *  \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
10473  *  \param [in] arrOfVals - the values of the field \a field used.
10474  *  \param [in] mesh - the supporting mesh of \a field.
10475  *  \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
10476  *  \param [in] profile - ids of mesh entities on which corresponding field values lie.
10477  *  \throw If either \a field or \a mesh or \a profile has an empty name.
10478  *  \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
10479  *  \throw If the data array of \a field is not set.
10480  *  \throw If the data array of \a this is already allocated but has different number of
10481  *         components than \a field.
10482  *  \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
10483  *  \sa setFieldNoProfileSBT()
10484  */
10485 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldInt *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
10486 {
10487   MCAuto<MEDCouplingFieldDouble> field2(MEDFileIntField1TS::ConvertFieldIntToFieldDouble(field));
10488   contentNotNull()->appendFieldProfile(field2,field->getArray(),mesh,meshDimRelToMax,profile,*this);
10489 }
10490
10491 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const
10492 {
10493   const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
10494   if(!pt)
10495     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
10496   const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
10497   if(!ret)
10498     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 !");
10499   return ret;
10500 }
10501
10502 MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull()
10503 {
10504   MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
10505   if(!pt)
10506     throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
10507   MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
10508   if(!ret)
10509     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 !");
10510   return ret;
10511 }
10512
10513 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
10514 {
10515   _content=new MEDFileIntFieldMultiTSWithoutSDA;
10516 }
10517
10518 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
10519 {
10520 }
10521
10522 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
10523 try:MEDFileAnyTypeFieldMultiTS(fid,loadAll,ms)
10524 {
10525 }
10526 catch(INTERP_KERNEL::Exception& e)
10527 { throw e; }
10528
10529 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
10530 try:MEDFileAnyTypeFieldMultiTS(fid,fieldName,loadAll,ms,entities)
10531 {
10532 }
10533 catch(INTERP_KERNEL::Exception& e)
10534 { throw e; }
10535
10536 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
10537 {
10538   return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
10539 }
10540
10541 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::buildNewEmpty() const
10542 {
10543   return MEDFileIntFieldMultiTS::New();
10544 }
10545
10546 //= MEDFileFields
10547
10548 MEDFileFields *MEDFileFields::New()
10549 {
10550   return new MEDFileFields;
10551 }
10552
10553 MEDFileFields *MEDFileFields::New(const std::string& fileName, bool loadAll)
10554 {
10555   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10556   return New(fid,loadAll);
10557 }
10558
10559 MEDFileFields *MEDFileFields::NewAdv(const std::string& fileName, bool loadAll, const MEDFileEntities *entities)
10560 {
10561   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10562   return NewAdv(fid,loadAll,entities);
10563 }
10564
10565 MEDFileFields *MEDFileFields::NewAdv(med_idt fid, bool loadAll, const MEDFileEntities *entities)
10566 {
10567   return new MEDFileFields(fid,loadAll,0,entities);
10568 }
10569
10570 MEDFileFields *MEDFileFields::NewWithDynGT(const std::string& fileName, const MEDFileStructureElements *se, bool loadAll)
10571 {
10572   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10573   return NewWithDynGT(fid,se,loadAll);
10574 }
10575
10576 MEDFileFields *MEDFileFields::NewWithDynGT(med_idt fid, const MEDFileStructureElements *se, bool loadAll)
10577 {
10578   if(!se)
10579     throw INTERP_KERNEL::Exception("MEDFileFields::NewWithDynGT : null struct element pointer !");
10580   INTERP_KERNEL::AutoCppPtr<MEDFileEntities> entities(MEDFileEntities::BuildFrom(*se));
10581   return new MEDFileFields(fid,loadAll,0,entities);
10582 }
10583
10584 MEDFileFields *MEDFileFields::New(med_idt fid, bool loadAll)
10585 {
10586   return new MEDFileFields(fid,loadAll,0,0);
10587 }
10588
10589 MEDFileFields *MEDFileFields::LoadPartOf(const std::string& fileName, bool loadAll, const MEDFileMeshes *ms)
10590 {
10591   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10592   return new MEDFileFields(fid,loadAll,ms,0);
10593 }
10594
10595 MEDFileFields *MEDFileFields::LoadSpecificEntities(const std::string& fileName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll)
10596 {
10597   MEDFileUtilities::CheckFileForRead(fileName);
10598   INTERP_KERNEL::AutoCppPtr<MEDFileEntities> ent(new MEDFileStaticEntities(entities));
10599   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10600   return new MEDFileFields(fid,loadAll,0,ent);
10601 }
10602
10603 std::size_t MEDFileFields::getHeapMemorySizeWithoutChildren() const
10604 {
10605   std::size_t ret(MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren());
10606   ret+=_fields.capacity()*sizeof(MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
10607   return ret;
10608 }
10609
10610 std::vector<const BigMemoryObject *> MEDFileFields::getDirectChildrenWithNull() const
10611 {
10612   std::vector<const BigMemoryObject *> ret;
10613   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10614     ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)*it);
10615   return ret;
10616 }
10617
10618 MEDFileFields *MEDFileFields::deepCopy() const
10619 {
10620   MCAuto<MEDFileFields> ret(shallowCpy());
10621   std::size_t i(0);
10622   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10623     {
10624       if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
10625         ret->_fields[i]=(*it)->deepCopy();
10626     }
10627   ret->deepCpyGlobs(*this);
10628   return ret.retn();
10629 }
10630
10631 MEDFileFields *MEDFileFields::shallowCpy() const
10632 {
10633   return new MEDFileFields(*this);
10634 }
10635
10636 /*!
10637  * 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
10638  * 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.
10639  * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
10640  *
10641  * \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.
10642  * \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.
10643  *
10644  * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
10645  */
10646 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const
10647 {
10648   std::set< std::pair<int,int> > s;
10649   bool firstShot=true;
10650   areThereSomeForgottenTS=false;
10651   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10652     {
10653       if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
10654         continue;
10655       std::vector< std::pair<int,int> > v=(*it)->getIterations();
10656       std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
10657       if(firstShot)
10658         { s=s1; firstShot=false; }
10659       else
10660         {
10661           std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
10662           if(s!=s2)
10663             areThereSomeForgottenTS=true;
10664           s=s2;
10665         }
10666     }
10667   std::vector< std::pair<int,int> > ret;
10668   std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
10669   return ret;
10670 }
10671
10672 int MEDFileFields::getNumberOfFields() const
10673 {
10674   return _fields.size();
10675 }
10676
10677 std::vector<std::string> MEDFileFields::getFieldsNames() const
10678 {
10679   std::vector<std::string> ret(_fields.size());
10680   int i(0);
10681   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10682     {
10683       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
10684       if(f)
10685         {
10686           ret[i]=f->getName();
10687         }
10688       else
10689         {
10690           std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
10691           throw INTERP_KERNEL::Exception(oss.str());
10692         }
10693     }
10694   return ret;
10695 }
10696
10697 std::vector<std::string> MEDFileFields::getMeshesNames() const
10698 {
10699   std::vector<std::string> ret;
10700   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10701     {
10702       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
10703       if(cur)
10704         ret.push_back(cur->getMeshName());
10705     }
10706   return ret;
10707 }
10708
10709 std::string MEDFileFields::simpleRepr() const
10710 {
10711   std::ostringstream oss;
10712   oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
10713   simpleRepr(0,oss);
10714   return oss.str();
10715 }
10716
10717 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
10718 {
10719   int nbOfFields(getNumberOfFields());
10720   std::string startLine(bkOffset,' ');
10721   oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
10722   int i=0;
10723   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10724     {
10725       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
10726       if(cur)
10727         {
10728           oss << startLine << "  - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
10729         }
10730       else
10731         {
10732           oss << startLine << "  - not defined !" << std::endl;
10733         }
10734     }
10735   i=0;
10736   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10737     {
10738       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
10739       std::string chapter(17,'0'+i);
10740       oss << startLine << chapter << std::endl;
10741       if(cur)
10742         {
10743           cur->simpleRepr(bkOffset+2,oss,i);
10744         }
10745       else
10746         {
10747           oss << startLine << "  - not defined !" << std::endl;
10748         }
10749       oss << startLine << chapter << std::endl;
10750     }
10751   simpleReprGlobs(oss);
10752 }
10753
10754 MEDFileFields::MEDFileFields()
10755 {
10756 }
10757
10758 MEDFileFields::MEDFileFields(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
10759 try:MEDFileFieldGlobsReal(fid)
10760 {
10761   int nbFields(MEDnField(fid));
10762   _fields.resize(nbFields);
10763   med_field_type typcha;
10764   for(int i=0;i<nbFields;i++)
10765     {
10766       std::vector<std::string> infos;
10767       std::string fieldName,dtunit,meshName;
10768       int nbOfStep(MEDFileAnyTypeField1TS::LocateField2(fid,i,false,fieldName,typcha,infos,dtunit,meshName));
10769       switch(typcha)
10770       {
10771         case MED_FLOAT64:
10772           {
10773             _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
10774             break;
10775           }
10776         case MED_INT32:
10777           {
10778             _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
10779             break;
10780           }
10781         default:
10782           {
10783             std::ostringstream oss; oss << "constructor MEDFileFields(fileName) : file \'" << FileNameFromFID(fid) << "\' at pos #" << i << " field has name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
10784             throw INTERP_KERNEL::Exception(oss.str());
10785           }
10786       }
10787     }
10788   loadAllGlobals(fid,entities);
10789 }
10790 catch(INTERP_KERNEL::Exception& e)
10791 {
10792     throw e;
10793 }
10794
10795 void MEDFileFields::writeLL(med_idt fid) const
10796 {
10797   int i=0;
10798   writeGlobals(fid,*this);
10799   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10800     {
10801       const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
10802       if(!elt)
10803         {
10804           std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
10805           throw INTERP_KERNEL::Exception(oss.str());
10806         }
10807       elt->writeLL(fid,*this);
10808     }
10809 }
10810
10811 /*!
10812  * This method alloc the arrays and load potentially huge arrays contained in this field.
10813  * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
10814  * This method can be also called to refresh or reinit values from a file.
10815  *
10816  * \throw If the fileName is not set or points to a non readable MED file.
10817  */
10818 void MEDFileFields::loadArrays()
10819 {
10820   if(getFileName().empty())
10821     throw INTERP_KERNEL::Exception("MEDFileFields::loadArrays : the structure does not come from a file !");
10822   MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
10823   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
10824     {
10825       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
10826       if(elt)
10827         elt->loadBigArraysRecursively(fid,*elt);
10828     }
10829 }
10830
10831 /*!
10832  * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
10833  * But once data loaded once, this method does nothing.
10834  *
10835  * \throw If the fileName is not set or points to a non readable MED file.
10836  * \sa MEDFileFields::loadArrays, MEDFileFields::unloadArrays
10837  */
10838 void MEDFileFields::loadArraysIfNecessary()
10839 {
10840   if(!getFileName().empty())
10841     {
10842       MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
10843       for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
10844         {
10845           MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
10846           if(elt)
10847             elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
10848         }
10849     }
10850 }
10851
10852 /*!
10853  * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
10854  * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
10855  * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileFields::unloadArraysWithoutDataLoss instead.
10856  *
10857  * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary, MEDFileFields::unloadArraysWithoutDataLoss
10858  */
10859 void MEDFileFields::unloadArrays()
10860 {
10861   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
10862     {
10863       MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
10864       if(elt)
10865         elt->unloadArrays();
10866     }
10867 }
10868
10869 /*!
10870  * This method potentially releases big data arrays if \a this is coming from a file. If \a this has been built from scratch this method will have no effect.
10871  * This method is the symetrical method of MEDFileFields::loadArraysIfNecessary.
10872  * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
10873  *
10874  * \sa MEDFileFields::loadArraysIfNecessary
10875  */
10876 void MEDFileFields::unloadArraysWithoutDataLoss()
10877 {
10878   if(!getFileName().empty())
10879     unloadArrays();
10880 }
10881
10882 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
10883 {
10884   std::vector<std::string> ret;
10885   std::set<std::string> ret2;
10886   for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10887     {
10888       std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
10889       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
10890         if(ret2.find(*it2)==ret2.end())
10891           {
10892             ret.push_back(*it2);
10893             ret2.insert(*it2);
10894           }
10895     }
10896   return ret;
10897 }
10898
10899 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
10900 {
10901   std::vector<std::string> ret;
10902   std::set<std::string> ret2;
10903   for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10904     {
10905       std::vector<std::string> tmp((*it)->getLocsReallyUsed2());
10906       for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
10907         if(ret2.find(*it2)==ret2.end())
10908           {
10909             ret.push_back(*it2);
10910             ret2.insert(*it2);
10911           }
10912     }
10913   return ret;
10914 }
10915
10916 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
10917 {
10918   std::vector<std::string> ret;
10919   for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10920     {
10921       std::vector<std::string> tmp((*it)->getPflsReallyUsedMulti2());
10922       ret.insert(ret.end(),tmp.begin(),tmp.end());
10923     }
10924   return ret;
10925 }
10926
10927 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
10928 {
10929   std::vector<std::string> ret;
10930   for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10931     {
10932       std::vector<std::string> tmp((*it)->getLocsReallyUsed2());
10933       ret.insert(ret.end(),tmp.begin(),tmp.end());
10934     }
10935   return ret;
10936 }
10937
10938 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
10939 {
10940   for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
10941     (*it)->changePflsRefsNamesGen2(mapOfModif);
10942 }
10943
10944 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
10945 {
10946   for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
10947     (*it)->changeLocsRefsNamesGen2(mapOfModif);
10948 }
10949
10950 void MEDFileFields::resize(int newSize)
10951 {
10952   _fields.resize(newSize);
10953 }
10954
10955 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields)
10956 {
10957   for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
10958     pushField(*it);
10959 }
10960
10961 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field)
10962 {
10963   if(!field)
10964     throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
10965   _fields.push_back(field->getContent());
10966   appendGlobs(*field,1e-12);
10967 }
10968
10969 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field)
10970 {
10971   if(!field)
10972     throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
10973   if(i>=(int)_fields.size())
10974     _fields.resize(i+1);
10975   _fields[i]=field->getContent();
10976   appendGlobs(*field,1e-12);
10977 }
10978
10979 void MEDFileFields::destroyFieldAtPos(int i)
10980 {
10981   destroyFieldsAtPos(&i,&i+1);
10982 }
10983
10984 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds)
10985 {
10986   std::vector<bool> b(_fields.size(),true);
10987   for(const int *i=startIds;i!=endIds;i++)
10988     {
10989       if(*i<0 || *i>=(int)_fields.size())
10990         {
10991           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
10992           throw INTERP_KERNEL::Exception(oss.str());
10993         }
10994       b[*i]=false;
10995     }
10996   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
10997   std::size_t j=0;
10998   for(std::size_t i=0;i<_fields.size();i++)
10999     if(b[i])
11000       fields[j++]=_fields[i];
11001   _fields=fields;
11002 }
11003
11004 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step)
11005 {
11006   static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
11007   int nbOfEntriesToKill(DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg));
11008   std::vector<bool> b(_fields.size(),true);
11009   int k=bg;
11010   for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
11011     {
11012       if(k<0 || k>=(int)_fields.size())
11013         {
11014           std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
11015           throw INTERP_KERNEL::Exception(oss.str());
11016         }
11017       b[k]=false;
11018     }
11019   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
11020   std::size_t j(0);
11021   for(std::size_t i=0;i<_fields.size();i++)
11022     if(b[i])
11023       fields[j++]=_fields[i];
11024   _fields=fields;
11025 }
11026
11027 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
11028 {
11029   bool ret(false);
11030   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
11031     {
11032       MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
11033       if(cur)
11034         ret=cur->changeMeshNames(modifTab) || ret;
11035     }
11036   return ret;
11037 }
11038
11039 /*!
11040  * \param [in] meshName the name of the mesh that will be renumbered.
11041  * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
11042  *             This code corresponds to the distribution of types in the corresponding mesh.
11043  * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
11044  * \param [in] renumO2N the old to new renumber array.
11045  * \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
11046  *         field in \a this.
11047  */
11048 bool MEDFileFields::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N)
11049 {
11050   bool ret(false);
11051   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
11052     {
11053       MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
11054       if(fmts)
11055         {
11056           ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
11057         }
11058     }
11059   return ret;
11060 }
11061
11062 /*!
11063  * Return an extraction of \a this using \a extractDef map to specify the extraction.
11064  * The keys of \a extractDef is level relative to max ext of \a mm mesh.
11065  *
11066  * \return A new object that the caller is responsible to deallocate.
11067  */
11068 MEDFileFields *MEDFileFields::extractPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef, MEDFileMesh *mm) const
11069 {
11070   if(!mm)
11071     throw INTERP_KERNEL::Exception("MEDFileFields::extractPart : input mesh is NULL !");
11072   MCAuto<MEDFileFields> fsOut(MEDFileFields::New());
11073   int nbFields(getNumberOfFields());
11074   for(int i=0;i<nbFields;i++)
11075     {
11076       MCAuto<MEDFileAnyTypeFieldMultiTS> fmts(getFieldAtPos(i));
11077       if(!fmts)
11078         {
11079           std::ostringstream oss; oss << "MEDFileFields::extractPart : at pos #" << i << " field is null !";
11080           throw INTERP_KERNEL::Exception(oss.str());
11081         }
11082       MCAuto<MEDFileAnyTypeFieldMultiTS> fmtsOut(fmts->extractPart(extractDef,mm));
11083       fsOut->pushField(fmtsOut);
11084     }
11085   return fsOut.retn();
11086 }
11087
11088 void MEDFileFields::accept(MEDFileFieldVisitor& visitor) const
11089 {
11090   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
11091     if((*it).isNotNull())
11092       {
11093         visitor.newFieldEntry(*it);
11094         (*it)->accept(visitor);
11095         visitor.endFieldEntry(*it);
11096       }
11097 }
11098
11099 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const
11100 {
11101   if(i<0 || i>=(int)_fields.size())
11102     {
11103       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
11104       throw INTERP_KERNEL::Exception(oss.str());
11105     }
11106   const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
11107   if(!fmts)
11108     return 0;
11109   MCAuto<MEDFileAnyTypeFieldMultiTS> ret;
11110   const MEDFileFieldMultiTSWithoutSDA *fmtsC(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts));
11111   const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts));
11112   if(fmtsC)
11113     ret=MEDFileFieldMultiTS::New(*fmtsC,false);
11114   else if(fmtsC2)
11115     ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
11116   else
11117     {
11118       std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
11119       throw INTERP_KERNEL::Exception(oss.str());
11120     }
11121   ret->shallowCpyGlobs(*this);
11122   return ret.retn();
11123 }
11124
11125 /*!
11126  * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
11127  * This method is accessible in python using __getitem__ with a list in input.
11128  * \return a new object that the caller should deal with.
11129  */
11130 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const
11131 {
11132   MCAuto<MEDFileFields> ret=shallowCpy();
11133   std::size_t sz=std::distance(startIds,endIds);
11134   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
11135   int j=0;
11136   for(const int *i=startIds;i!=endIds;i++,j++)
11137     {
11138       if(*i<0 || *i>=(int)_fields.size())
11139         {
11140           std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
11141           throw INTERP_KERNEL::Exception(oss.str());
11142         }
11143       fields[j]=_fields[*i];
11144     }
11145   ret->_fields=fields;
11146   return ret.retn();
11147 }
11148
11149 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const std::string& fieldName) const
11150 {
11151   return getFieldAtPos(getPosFromFieldName(fieldName));
11152 }
11153
11154 /*!
11155  * This method removes, if any, fields in \a this having no time steps.
11156  * If there is one or more than one such field in \a this true is returned and those fields will not be referenced anymore in \a this.
11157  *
11158  * If false is returned \a this does not contain such fields. If false is returned this method can be considered as const.
11159  */
11160 bool MEDFileFields::removeFieldsWithoutAnyTimeStep()
11161 {
11162   std::vector<MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > newFields;
11163   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
11164     {
11165       const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
11166       if(elt)
11167         {
11168           if(elt->getNumberOfTS()>0)
11169             newFields.push_back(*it);
11170         }
11171     }
11172   if(_fields.size()==newFields.size())
11173     return false;
11174   _fields=newFields;
11175   return true;
11176 }
11177
11178 /*!
11179  * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
11180  * This method can be seen as a filter applied on \a this, that returns an object containing
11181  * 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
11182  * shallow copied from \a this.
11183  *
11184  * \param [in] meshName - the name of the mesh on w
11185  * \return a new object that the caller should deal with.
11186  */
11187 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const std::string& meshName) const
11188 {
11189   MCAuto<MEDFileFields> ret(MEDFileFields::New());
11190   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
11191     {
11192       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
11193       if(!cur)
11194         continue;
11195       if(cur->getMeshName()==meshName)
11196         {
11197           cur->incrRef();
11198           MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
11199           ret->_fields.push_back(cur2);
11200         }
11201     }
11202   ret->shallowCpyOnlyUsedGlobs(*this);
11203   return ret.retn();
11204 }
11205
11206 /*!
11207  * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
11208  * Input time steps are specified using a pair of integer (iteration, order).
11209  * 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,
11210  * but for each multitimestep only the time steps in \a timeSteps are kept.
11211  * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
11212  *
11213  * The returned object points to shallow copy of elements in \a this.
11214  *
11215  * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
11216  * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
11217  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
11218  */
11219 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
11220 {
11221   MCAuto<MEDFileFields> ret(MEDFileFields::New());
11222   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
11223     {
11224       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
11225       if(!cur)
11226         continue;
11227       MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
11228       ret->_fields.push_back(elt);
11229     }
11230   ret->shallowCpyOnlyUsedGlobs(*this);
11231   return ret.retn();
11232 }
11233
11234 /*!
11235  * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
11236  */
11237 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
11238 {
11239   MCAuto<MEDFileFields> ret=MEDFileFields::New();
11240   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
11241     {
11242       const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
11243       if(!cur)
11244         continue;
11245       MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
11246       if(elt->getNumberOfTS()!=0)
11247         ret->_fields.push_back(elt);
11248     }
11249   ret->shallowCpyOnlyUsedGlobs(*this);
11250   return ret.retn();
11251 }
11252
11253 bool MEDFileFields::presenceOfStructureElements() const
11254 {
11255   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
11256     if((*it).isNotNull())
11257       if((*it)->presenceOfStructureElements())
11258         return true;
11259   return false;
11260 }
11261
11262 void MEDFileFields::killStructureElements()
11263 {
11264   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
11265   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
11266     if((*it).isNotNull())
11267       {
11268         if((*it)->presenceOfStructureElements())
11269           {
11270             if(!(*it)->onlyStructureElements())
11271               {
11272                 (*it)->killStructureElements();
11273                 ret.push_back(*it);
11274               }
11275           }
11276         else
11277           {
11278             ret.push_back(*it);
11279           }
11280       }
11281   _fields=ret;
11282 }
11283
11284 void MEDFileFields::keepOnlyStructureElements()
11285 {
11286   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
11287   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
11288     if((*it).isNotNull())
11289       {
11290         if((*it)->presenceOfStructureElements())
11291           {
11292             if(!(*it)->onlyStructureElements())
11293               (*it)->keepOnlyStructureElements();
11294             ret.push_back(*it);
11295           }
11296       }
11297   _fields=ret;
11298 }
11299
11300 void MEDFileFields::keepOnlyOnMeshSE(const std::string& meshName, const std::string& seName)
11301 {
11302   std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
11303   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
11304     if((*it).isNotNull())
11305       {
11306         if((*it)->getMeshName()!=meshName)
11307           continue;
11308         std::vector< std::pair<std::string,std::string> > ps;
11309         (*it)->getMeshSENames(ps);
11310         std::pair<std::string,std::string> p(meshName,seName);
11311         if(std::find(ps.begin(),ps.end(),p)!=ps.end())
11312           (*it)->keepOnlyOnSE(seName);
11313         ret.push_back(*it);
11314       }
11315   _fields=ret;
11316 }
11317
11318 void MEDFileFields::getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const
11319 {
11320   for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
11321     if((*it).isNotNull())
11322       (*it)->getMeshSENames(ps);
11323 }
11324
11325 void MEDFileFields::blowUpSE(MEDFileMeshes *ms, const MEDFileStructureElements *ses)
11326 {
11327   MEDFileBlowStrEltUp::DealWithSE(this,ms,ses);
11328 }
11329
11330 MCAuto<MEDFileFields> MEDFileFields::partOfThisOnStructureElements() const
11331 {
11332   MCAuto<MEDFileFields> ret(deepCopy());
11333   ret->keepOnlyStructureElements();
11334   return ret;
11335 }
11336
11337 MCAuto<MEDFileFields> MEDFileFields::partOfThisLyingOnSpecifiedMeshSEName(const std::string& meshName, const std::string& seName) const
11338 {
11339   MCAuto<MEDFileFields> ret(deepCopy());
11340   ret->keepOnlyOnMeshSE(meshName,seName);
11341   return ret;
11342 }
11343
11344 void MEDFileFields::aggregate(const MEDFileFields& other)
11345 {
11346   int nbFieldsToAdd(other.getNumberOfFields());
11347   std::vector<std::string> fsn(getFieldsNames());
11348   for(int i=0;i<nbFieldsToAdd;i++)
11349     {
11350       MCAuto<MEDFileAnyTypeFieldMultiTS> elt(other.getFieldAtPos(i));
11351       std::string name(elt->getName());
11352       if(std::find(fsn.begin(),fsn.end(),name)!=fsn.end())
11353         {
11354           std::ostringstream oss; oss << "MEDFileFields::aggregate : name \"" << name << "\" already appears !";
11355           throw INTERP_KERNEL::Exception(oss.str());
11356         }
11357       pushField(elt);
11358     }
11359 }
11360
11361 MEDFileFieldsIterator *MEDFileFields::iterator()
11362 {
11363   return new MEDFileFieldsIterator(this);
11364 }
11365
11366 int MEDFileFields::getPosFromFieldName(const std::string& fieldName) const
11367 {
11368   std::string tmp(fieldName);
11369   std::vector<std::string> poss;
11370   for(std::size_t i=0;i<_fields.size();i++)
11371     {
11372       const MEDFileAnyTypeFieldMultiTSWithoutSDA *f(_fields[i]);
11373       if(f)
11374         {
11375           std::string fname(f->getName());
11376           if(tmp==fname)
11377             return i;
11378           else
11379             poss.push_back(fname);
11380         }
11381     }
11382   std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
11383   std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
11384   oss << " !";
11385   throw INTERP_KERNEL::Exception(oss.str());
11386 }
11387
11388 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
11389 {
11390   if(fs)
11391     {
11392       fs->incrRef();
11393       _nb_iter=fs->getNumberOfFields();
11394     }
11395 }
11396
11397 MEDFileFieldsIterator::~MEDFileFieldsIterator()
11398 {
11399 }
11400
11401 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
11402 {
11403   if(_iter_id<_nb_iter)
11404     {
11405       MEDFileFields *fs(_fs);
11406       if(fs)
11407         return fs->getFieldAtPos(_iter_id++);
11408       else
11409         return 0;
11410     }
11411   else
11412     return 0;
11413 }