X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDLoader%2FMEDFileFieldOverView.cxx;h=8f2d9bc2d7376e67f9bc01e3a290ab81aab405e5;hb=1b0f297f9ff050751963bb9bece9fd09f3156560;hp=c4a5f81a88ccb4b322417effb1666f44f8351666;hpb=fb512e2b77325290aaa2b4c9fd8f22d5949b6369;p=tools%2Fmedcoupling.git

diff --git a/src/MEDLoader/MEDFileFieldOverView.cxx b/src/MEDLoader/MEDFileFieldOverView.cxx
index c4a5f81a8..8f2d9bc2d 100644
--- a/src/MEDLoader/MEDFileFieldOverView.cxx
+++ b/src/MEDLoader/MEDFileFieldOverView.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2014  CEA/DEN, EDF R&D
+// Copyright (C) 2007-2015  CEA/DEN, EDF R&D
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
@@ -22,12 +22,13 @@
 #include "MEDFileField.hxx"
 #include "MEDFileMesh.hxx"
 
+#include "MEDCouplingFieldDiscretization.hxx"
 #include "CellModel.hxx"
 
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
 
 const unsigned char MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE[MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE_LGTH]=
-  {1,3,21,5,9,7,22,34,23,28,255,255,255,255,10,14,13,255,12,255,24,255,16,27,255,26,255,29,255,255,25,42,36,4};
+{1,3,21,5,9,7,22,34,23,28,255,255,255,255,10,14,13,255,12,255,24,255,16,27,255,26,255,29,255,255,25,42,36,4};
 
 const unsigned char MEDMeshMultiLev::HEXA27_PERM_ARRAY[27]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,24,22,21,23,20,25,26};
 
@@ -47,7 +48,7 @@ std::size_t MEDFileMeshStruct::getHeapMemorySizeWithoutChildren() const
   return ret;
 }
 
-std::vector<const BigMemoryObject *> MEDFileMeshStruct::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileMeshStruct::getDirectChildrenWithNull() const
 {
   return std::vector<const BigMemoryObject *>();
 }
@@ -158,7 +159,7 @@ std::size_t MEDMeshMultiLev::getHeapMemorySizeWithoutChildren() const
   return 0;
 }
 
-std::vector<const BigMemoryObject *> MEDMeshMultiLev::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDMeshMultiLev::getDirectChildrenWithNull() const
 {
   return std::vector<const BigMemoryObject *>();
 }
@@ -197,7 +198,7 @@ MEDMeshMultiLev *MEDMeshMultiLev::New(const MEDFileMesh *m, const std::vector<IN
 
 MEDMeshMultiLev *MEDMeshMultiLev::NewOnlyOnNode(const MEDFileMesh *m, const DataArrayInt *pflOnNode)
 {
-  MEDCouplingAutoRefCountObjectPtr<MEDMeshMultiLev> ret(MEDMeshMultiLev::New(m,m->getNonEmptyLevels()));
+  MCAuto<MEDMeshMultiLev> ret(MEDMeshMultiLev::New(m,m->getNonEmptyLevels()));
   ret->selectPartOfNodes(pflOnNode);
   return ret.retn();
 }
@@ -209,6 +210,15 @@ void MEDMeshMultiLev::setNodeReduction(const DataArrayInt *nr)
   _node_reduction=const_cast<DataArrayInt*>(nr);
 }
 
+void MEDMeshMultiLev::setCellReduction(const DataArrayInt *cr)
+{
+  if(_pfls.size()!=1)
+    throw INTERP_KERNEL::Exception("MEDMeshMultiLev::setCellReduction : can be used only for single geo type mesh !");
+  _pfls[0]=const_cast<DataArrayInt*>(cr);
+  if(cr)
+    cr->incrRef();
+}
+
 bool MEDMeshMultiLev::isFastlyTheSameStruct(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs) const
 {
   if(fst.getType()==ON_NODES)
@@ -244,7 +254,7 @@ bool MEDMeshMultiLev::isFastlyTheSameStruct(const MEDFileField1TSStructItem& fst
 
 DataArray *MEDMeshMultiLev::buildDataArray(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs, const DataArray *vals) const
 {
-  MEDCouplingAutoRefCountObjectPtr<DataArray> ret(const_cast<DataArray *>(vals)); ret->incrRef();
+  MCAuto<DataArray> ret(const_cast<DataArray *>(vals)); ret->incrRef();
   if(isFastlyTheSameStruct(fst,globs))
     return ret.retn();
   else
@@ -269,10 +279,10 @@ void MEDMeshMultiLev::retrieveFamilyIdsOnCells(DataArrayInt *& famIds, bool& isW
         presenceOfPfls=true;
     }
   if(!presenceOfPfls)
-    { famIds=const_cast<DataArrayInt *>(fids); famIds->incrRef(); isWithoutCopy=_cell_fam_ids_nocpy; return ; }
+    { famIds=const_cast<DataArrayInt *>(fids); famIds->incrRef(); isWithoutCopy=_mesh->isObjectInTheProgeny(famIds); return ; }
   //bad luck the slowest part
   isWithoutCopy=false;
-  std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > retSafe(sz);
+  std::vector< MCAuto<DataArrayInt> > retSafe(sz);
   std::vector< const DataArrayInt *> ret(sz);
   int start(0);
   for(std::size_t i=0;i<sz;i++)
@@ -281,12 +291,12 @@ void MEDMeshMultiLev::retrieveFamilyIdsOnCells(DataArrayInt *& famIds, bool& isW
       int lgth(_nb_entities[i]);
       if(pfl)
         {
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(fids->selectByTupleId2(start,start+lgth,1));
+          MCAuto<DataArrayInt> tmp(fids->selectByTupleIdSafeSlice(start,start+lgth,1));
           retSafe[i]=tmp->selectByTupleIdSafe(pfl->begin(),pfl->end());
         }
       else
         {
-          retSafe[i]=fids->selectByTupleId2(start,start+lgth,1);
+          retSafe[i]=fids->selectByTupleIdSafeSlice(start,start+lgth,1);
         }
       ret[i]=retSafe[i];
       start+=lgth;
@@ -312,10 +322,10 @@ void MEDMeshMultiLev::retrieveNumberIdsOnCells(DataArrayInt *& numIds, bool& isW
         presenceOfPfls=true;
     }
   if(!presenceOfPfls)
-    { numIds=const_cast<DataArrayInt *>(nids); numIds->incrRef(); isWithoutCopy=_cell_num_ids_nocpy; return ; }
+    { numIds=const_cast<DataArrayInt *>(nids); numIds->incrRef(); isWithoutCopy=_mesh->isObjectInTheProgeny(numIds); return ; }
   //bad luck the slowest part
   isWithoutCopy=false;
-  std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > retSafe(sz);
+  std::vector< MCAuto<DataArrayInt> > retSafe(sz);
   std::vector< const DataArrayInt *> ret(sz);
   int start(0);
   for(std::size_t i=0;i<sz;i++)
@@ -324,12 +334,12 @@ void MEDMeshMultiLev::retrieveNumberIdsOnCells(DataArrayInt *& numIds, bool& isW
       int lgth(_nb_entities[i]);
       if(pfl)
         {
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(nids->selectByTupleId2(start,start+lgth,1));
+          MCAuto<DataArrayInt> tmp(nids->selectByTupleIdSafeSlice(start,start+lgth,1));
           retSafe[i]=tmp->selectByTupleIdSafe(pfl->begin(),pfl->end());
         }
       else
         {
-          retSafe[i]=nids->selectByTupleId2(start,start+lgth,1);
+          retSafe[i]=nids->selectByTupleIdSafeSlice(start,start+lgth,1);
         }
       ret[i]=retSafe[i];
       start+=lgth;
@@ -354,8 +364,8 @@ void MEDMeshMultiLev::retrieveFamilyIdsOnNodes(DataArrayInt *& famIds, bool& isW
     }
   else
     {
-      isWithoutCopy=_node_fam_ids_nocpy;
       famIds=const_cast<DataArrayInt *>(fids); famIds->incrRef();
+      isWithoutCopy=_mesh->isObjectInTheProgeny(famIds);
     }
 }
 
@@ -376,46 +386,66 @@ void MEDMeshMultiLev::retrieveNumberIdsOnNodes(DataArrayInt *& numIds, bool& isW
     }
   else
     {
-      isWithoutCopy=_node_num_ids_nocpy;
       numIds=const_cast<DataArrayInt *>(fids); numIds->incrRef();
+      isWithoutCopy=_mesh->isObjectInTheProgeny(numIds);
     }
 }
 
+/*!
+ * This method returns, if any, a new object containing the global node ids **BUT CONTRARY TO OTHER RETRIEVE METHODS** the returned object is always a NON AGGREGATED object. So the returned object if not null
+ * can be used as this safely.
+ */
+DataArrayInt *MEDMeshMultiLev::retrieveGlobalNodeIdsIfAny() const
+{
+  const MEDFileUMesh *umesh(dynamic_cast<const MEDFileUMesh *>(_mesh));
+  if(!umesh)
+    return 0;
+  const PartDefinition *pd(umesh->getPartDefAtLevel(1));
+  if(!pd)
+    return 0;
+  MCAuto<DataArrayInt> tmp(pd->toDAI());
+  const DataArrayInt *tmpCpp(tmp);
+  if(!tmpCpp)
+    return 0;
+  //
+  const DataArrayInt *nr(_node_reduction);
+  if(nr)
+    return tmp->selectByTupleIdSafe(nr->begin(),nr->end());
+  else
+    return tmp->deepCopy();// Yes a deep copy is needed because this method has to return a non aggregated object !
+}
+
 std::vector< INTERP_KERNEL::NormalizedCellType > MEDMeshMultiLev::getGeoTypes() const
 {
   return _geo_types;
 }
 
-void MEDMeshMultiLev::setFamilyIdsOnCells(DataArrayInt *famIds, bool isNoCopy)
+void MEDMeshMultiLev::setFamilyIdsOnCells(DataArrayInt *famIds)
 {
   _cell_fam_ids=famIds;
   if(famIds)
     famIds->incrRef();
-  _cell_fam_ids_nocpy=isNoCopy;
 }
 
-void MEDMeshMultiLev::setNumberIdsOnCells(DataArrayInt *numIds, bool isNoCopy)
+void MEDMeshMultiLev::setNumberIdsOnCells(DataArrayInt *numIds)
 {
   _cell_num_ids=numIds;
   if(numIds)
     numIds->incrRef();
-  _cell_num_ids_nocpy=isNoCopy;
 }
 
-void MEDMeshMultiLev::setFamilyIdsOnNodes(DataArrayInt *famIds, bool isNoCopy)
+void MEDMeshMultiLev::setFamilyIdsOnNodes(DataArrayInt *famIds)
 {
   _node_fam_ids=famIds;
   if(famIds)
     famIds->incrRef();
-  _node_fam_ids_nocpy=isNoCopy;
 }
 
-void MEDMeshMultiLev::setNumberIdsOnNodes(DataArrayInt *numIds, bool isNoCopy)
+void MEDMeshMultiLev::setNumberIdsOnNodes(DataArrayInt *numIds)
 {
   _node_num_ids=numIds;
   if(numIds)
     numIds->incrRef();
-  _node_num_ids_nocpy=isNoCopy;
 }
 
 std::string MEDMeshMultiLev::getPflNameOfId(int id) const
@@ -438,7 +468,7 @@ int MEDMeshMultiLev::getNumberOfCells(INTERP_KERNEL::NormalizedCellType t) const
   std::size_t sz(_nb_entities.size());
   for(std::size_t i=0;i<sz;i++)
     if(_geo_types[i]==t)
-        return _nb_entities[i];
+      return _nb_entities[i];
   throw INTERP_KERNEL::Exception("MEDMeshMultiLev::getNumberOfCells : not existing geometric type in this !");
 }
 
@@ -457,28 +487,28 @@ DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem&
       std::string pflName(p.getPflName());
       const DataArrayInt *nr(_node_reduction);
       if(pflName.empty() && !nr)
-        return vals->deepCpy();
+        return vals->deepCopy();
       if(pflName.empty() && nr)
-         throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for nodes 2 !");
+        throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for nodes 2 !");
       if(!pflName.empty() && nr)
         {
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(globs->getProfile(pflName.c_str())->deepCpy());
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(nr->deepCpy());
+          MCAuto<DataArrayInt> p1(globs->getProfile(pflName.c_str())->deepCopy());
+          MCAuto<DataArrayInt> p2(nr->deepCopy());
           p1->sort(true); p2->sort(true);
           if(!p1->isEqualWithoutConsideringStr(*p2))
             throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : it appears that a profile on nodes does not cover the cells correctly !");
           p1=DataArrayInt::FindPermutationFromFirstToSecond(globs->getProfile(pflName.c_str()),nr);
-          MEDCouplingAutoRefCountObjectPtr<DataArray> ret(vals->deepCpy());
+          MCAuto<DataArray> ret(vals->deepCopy());
           ret->renumberInPlace(p1->begin());
           return ret.retn();
         }
       if(!pflName.empty() && !nr)
         {
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(globs->getProfile(pflName.c_str())->deepCpy());
+          MCAuto<DataArrayInt> p1(globs->getProfile(pflName.c_str())->deepCopy());
           p1->sort(true);
-          if(!p1->isIdentity() || p1->getNumberOfTuples()!=getNumberOfNodes())
+          if(!p1->isIota(getNumberOfNodes()))
             throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for nodes 4 !");
-          MEDCouplingAutoRefCountObjectPtr<DataArray> ret(vals->deepCpy());
+          MCAuto<DataArray> ret(vals->deepCopy());
           ret->renumberInPlace(globs->getProfile(pflName.c_str())->begin());
           return ret.retn();
         }
@@ -491,7 +521,7 @@ DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem&
       if(s.size()!=_geo_types.size())
         throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 2 !");
       std::vector< const DataArray *> arr(s.size());
-      std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > arrSafe(s.size());
+      std::vector< MCAuto<DataArray> > arrSafe(s.size());
       int iii(0);
       int nc(vals->getNumberOfComponents());
       std::vector<std::string> compInfo(vals->getInfoOnComponents());
@@ -512,7 +542,7 @@ DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem&
               int nbi(ps[0]->getNbOfIntegrationPts(globs));
               const DataArrayInt *otherP(ps[0]->getPfl(globs));
               const std::pair<int,int>& strtStop(ps[0]->getStartStop());
-              MEDCouplingAutoRefCountObjectPtr<DataArray> ret(vals->selectByTupleId2(strtStop.first,strtStop.second,1));
+              MCAuto<DataArray> ret(vals->selectByTupleIdSafeSlice(strtStop.first,strtStop.second,1));
               if(!thisP && !otherP)
                 {
                   arrSafe[iii]=ret; arr[iii]=ret;
@@ -520,10 +550,10 @@ DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem&
                 }
               if(thisP && otherP)
                 {
-                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->invertArrayN2O2O2N(getNumberOfCells(ps[0]->getGeo())));
-                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(thisP->deepCpy());
+                  MCAuto<DataArrayInt> p1(otherP->invertArrayN2O2O2N(getNumberOfCells(ps[0]->getGeo())));
+                  MCAuto<DataArrayInt> p2(thisP->deepCopy());
                   p2->transformWithIndArr(p1->begin(),p1->end());
-                  //p1=p2->getIdsNotEqual(-1);
+                  //p1=p2->findIdsNotEqual(-1);
                   //p1=p2->selectByTupleIdSafe(p1->begin(),p1->end());
                   ret->rearrange(nbi*nc); ret=ret->selectByTupleIdSafe(p2->begin(),p2->end()); ret->rearrange(nc); ret->setInfoOnComponents(compInfo);
                   arrSafe[iii]=ret; arr[iii]=ret;
@@ -531,7 +561,7 @@ DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem&
                 }
               if(!thisP && otherP)
                 {
-                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->deepCpy());
+                  MCAuto<DataArrayInt> p1(otherP->deepCopy());
                   p1->sort(true);
                   p1->checkAllIdsInRange(0,getNumberOfCells(ps[0]->getGeo()));
                   p1=DataArrayInt::FindPermutationFromFirstToSecond(otherP,p1);
@@ -545,45 +575,45 @@ DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem&
             {
               std::vector< const DataArrayInt * >otherPS(ps.size());
               std::vector< const DataArray * > arr2(ps.size());
-              std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > arr2Safe(ps.size());
+              std::vector< MCAuto<DataArray> > arr2Safe(ps.size());
               std::vector< const DataArrayInt * > nbis(ps.size());
-              std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > nbisSafe(ps.size());
+              std::vector< MCAuto<DataArrayInt> > nbisSafe(ps.size());
               int jj(0);
               for(std::vector<const MEDFileField1TSStructItem2 *>::const_iterator it2=ps.begin();it2!=ps.end();it2++,jj++)
                 {
                   int nbi((*it2)->getNbOfIntegrationPts(globs));
                   const DataArrayInt *otherPfl((*it2)->getPfl(globs));
                   const std::pair<int,int>& strtStop((*it2)->getStartStop());
-                  MEDCouplingAutoRefCountObjectPtr<DataArray> ret2(vals->selectByTupleId2(strtStop.first,strtStop.second,1));
+                  MCAuto<DataArray> ret2(vals->selectByTupleIdSafeSlice(strtStop.first,strtStop.second,1));
                   if(!otherPfl)
                     throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 4 !");
                   arr2[jj]=ret2; arr2Safe[jj]=ret2; otherPS[jj]=otherPfl;
                   nbisSafe[jj]=DataArrayInt::New(); nbisSafe[jj]->alloc(otherPfl->getNumberOfTuples(),1); nbisSafe[jj]->fillWithValue(nbi);
                   nbis[jj]=nbisSafe[jj];
                 }
-              MEDCouplingAutoRefCountObjectPtr<DataArray> arr3(DataArray::Aggregate(arr2));
-              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> otherP(DataArrayInt::Aggregate(otherPS));
-              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> zenbis(DataArrayInt::Aggregate(nbis));
-              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> otherPN(otherP->invertArrayN2O2O2N(getNumberOfCells(*it)));
-              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1;
+              MCAuto<DataArray> arr3(DataArray::Aggregate(arr2));
+              MCAuto<DataArrayInt> otherP(DataArrayInt::Aggregate(otherPS));
+              MCAuto<DataArrayInt> zenbis(DataArrayInt::Aggregate(nbis));
+              MCAuto<DataArrayInt> otherPN(otherP->invertArrayN2O2O2N(getNumberOfCells(*it)));
+              MCAuto<DataArrayInt> p1;
               if(thisP)
                 p1=DataArrayInt::FindPermutationFromFirstToSecond(otherP,thisP);
               else
-                p1=otherP->deepCpy();
-              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> zenbisN(zenbis->renumber(p1->begin()));
-              zenbisN->computeOffsets2();
+                p1=otherP->deepCopy();
+              MCAuto<DataArrayInt> zenbisN(zenbis->renumber(p1->begin()));
+              zenbisN->computeOffsetsFull();
               jj=0;
               for(std::vector<const MEDFileField1TSStructItem2 *>::const_iterator it2=ps.begin();it2!=ps.end();it2++,jj++)
                 {
                   //int nbi((*it2)->getNbOfIntegrationPts(globs));
                   const DataArrayInt *otherPfl((*it2)->getPfl(globs));
                   const std::pair<int,int>& strtStop((*it2)->getStartStop());
-                  MEDCouplingAutoRefCountObjectPtr<DataArray> ret2(vals->selectByTupleId2(strtStop.first,strtStop.second,1));
+                  MCAuto<DataArray> ret2(vals->selectByTupleIdSafeSlice(strtStop.first,strtStop.second,1));
                   //
-                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(otherPfl->deepCpy());
+                  MCAuto<DataArrayInt> p2(otherPfl->deepCopy());
                   p2->transformWithIndArr(otherPN->begin(),otherPN->end());
                   p2->transformWithIndArr(p1->begin(),p1->end());
-                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idsN(p2->buildExplicitArrByRanges(zenbisN));
+                  MCAuto<DataArrayInt> idsN(p2->buildExplicitArrByRanges(zenbisN));
                   arr3->setPartOfValuesBase3(ret2,idsN->begin(),idsN->end(),0,nc,1);
                 }
               arrSafe[iii]=arr3; arr[iii]=arr3;
@@ -609,7 +639,7 @@ void MEDMeshMultiLev::appendVertices(const DataArrayInt *verticesToAdd, DataArra
   const DataArrayInt *cf(_cell_fam_ids),*cn(_cell_num_ids),*nf(_node_fam_ids),*nn(_node_num_ids);
   if(cf)
     {
-      MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp;
+      MCAuto<DataArrayInt> tmp;
       std::vector<const DataArrayInt *> a(2);
       a[0]=cf;
       if(nf)
@@ -620,11 +650,10 @@ void MEDMeshMultiLev::appendVertices(const DataArrayInt *verticesToAdd, DataArra
         }
       a[1]=tmp;
       _cell_fam_ids=DataArrayInt::Aggregate(a);
-      _cell_fam_ids_nocpy=false;
     }
   if(cn)
     {
-      MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp;
+      MCAuto<DataArrayInt> tmp;
       std::vector<const DataArrayInt *> a(2);
       a[0]=cn;
       if(nn)
@@ -635,15 +664,14 @@ void MEDMeshMultiLev::appendVertices(const DataArrayInt *verticesToAdd, DataArra
         }
       a[1]=tmp;
       _cell_num_ids=DataArrayInt::Aggregate(a);
-      _cell_num_ids_nocpy=false;
     }
 }
 
-MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh):_mesh(mesh),_nb_nodes(0),_cell_fam_ids_nocpy(false)
+MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh):_mesh(mesh),_nb_nodes(0)
 {
 }
 
-MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh, int nbNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):_mesh(mesh),_geo_types(gts),_nb_entities(nbEntities),_nb_nodes(nbNodes),_cell_fam_ids_nocpy(false),_cell_num_ids_nocpy(false),_node_fam_ids_nocpy(false),_node_num_ids_nocpy(false)
+MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh, int nbNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):_mesh(mesh),_geo_types(gts),_nb_entities(nbEntities),_nb_nodes(nbNodes)
 {
   std::size_t sz(_geo_types.size());
   if(sz!=pfls.size() || sz!=nbEntities.size())
@@ -657,7 +685,7 @@ MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh, int nbNodes, const std
     }
 }
 
-MEDMeshMultiLev::MEDMeshMultiLev(const MEDMeshMultiLev& other):RefCountObject(other),_mesh(other._mesh),_pfls(other._pfls),_geo_types(other._geo_types),_nb_entities(other._nb_entities),_node_reduction(other._node_reduction),_nb_nodes(other._nb_nodes),_cell_fam_ids(other._cell_fam_ids),_cell_fam_ids_nocpy(other._cell_fam_ids_nocpy),_cell_num_ids(other._cell_num_ids),_cell_num_ids_nocpy(other._cell_num_ids_nocpy),_node_fam_ids(other._node_fam_ids),_node_fam_ids_nocpy(other._node_fam_ids_nocpy),_node_num_ids(other._node_num_ids),_node_num_ids_nocpy(other._node_num_ids_nocpy)
+MEDMeshMultiLev::MEDMeshMultiLev(const MEDMeshMultiLev& other):RefCountObject(other),_mesh(other._mesh),_pfls(other._pfls),_geo_types(other._geo_types),_nb_entities(other._nb_entities),_node_reduction(other._node_reduction),_nb_nodes(other._nb_nodes),_cell_fam_ids(other._cell_fam_ids),_cell_num_ids(other._cell_num_ids),_node_fam_ids(other._node_fam_ids),_node_num_ids(other._node_num_ids)
 {
 }
 
@@ -699,8 +727,8 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<int>
       _nb_entities[i]=obj->getNumberOfCells();
     }
   // ids fields management
-  _cell_fam_ids_nocpy=(levs.size()==1);
-  if(_cell_fam_ids_nocpy)
+  bool cellFamIdsNoCpy(levs.size()==1);
+  if(cellFamIdsNoCpy)
     {
       const DataArrayInt *tmp(m->getFamilyFieldAtLevel(levs[0]));
       if(tmp)
@@ -722,8 +750,8 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<int>
       if(f && !tmps.empty())
         _cell_fam_ids=DataArrayInt::Aggregate(tmps);
     }
-  _cell_num_ids_nocpy=(levs.size()==1);
-  if(_cell_num_ids_nocpy)
+  bool cellNumIdsNoCpy(levs.size()==1);
+  if(cellNumIdsNoCpy)
     {
       const DataArrayInt *tmp(m->getNumberFieldAtLevel(levs[0]));
       if(tmp)
@@ -746,7 +774,6 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<int>
         _cell_num_ids=DataArrayInt::Aggregate(tmps);
     }
   // node part
-  _node_fam_ids_nocpy=true;
   {
     const DataArrayInt *tmp(m->getFamilyFieldAtLevel(1));
     if(tmp)
@@ -755,7 +782,6 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<int>
         _node_fam_ids=(const_cast<DataArrayInt *>(tmp));
       }
   }
-  _node_num_ids_nocpy=true;
   {
     const DataArrayInt *tmp(m->getNumberFieldAtLevel(1));
     if(tmp)
@@ -794,27 +820,22 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTE
   int lev((int)dim-m->getMeshDimension());
   if(isSameDim && isNoPfl && m->getGeoTypesAtLevel(lev)==gts)//optimized part
     {
-      _cell_fam_ids_nocpy=true;
       const DataArrayInt *famIds(m->getFamilyFieldAtLevel(lev));
       if(famIds)
         { _cell_fam_ids=const_cast<DataArrayInt*>(famIds); famIds->incrRef(); }
-      _cell_num_ids_nocpy=true;
       const DataArrayInt *numIds(m->getNumberFieldAtLevel(lev));
       if(numIds)
         { _cell_num_ids=const_cast<DataArrayInt*>(numIds); numIds->incrRef(); }
-      _node_fam_ids_nocpy=true;
       famIds=m->getFamilyFieldAtLevel(1);
       if(famIds)
         { _node_fam_ids=const_cast<DataArrayInt*>(famIds); famIds->incrRef(); }
-      _node_num_ids_nocpy=true;
       numIds=m->getNumberFieldAtLevel(1);
       if(numIds)
         { _node_num_ids=const_cast<DataArrayInt*>(numIds); numIds->incrRef(); }
       return ;
     }
   //
-  _cell_fam_ids_nocpy=false;
-  std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > famIdsSafe(sz);
+  std::vector< MCAuto<DataArrayInt> > famIdsSafe(sz);
   std::vector<const DataArrayInt *> famIds(sz);
   bool f(true);
   for(std::size_t i=0;i<sz;i++)
@@ -826,8 +847,7 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTE
     }
   if(f)
     _cell_fam_ids=DataArrayInt::Aggregate(famIds);
-  _cell_num_ids_nocpy=false;
-  std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > numIdsSafe(sz);
+  std::vector< MCAuto<DataArrayInt> > numIdsSafe(sz);
   std::vector<const DataArrayInt *> numIds(sz);
   bool n(true);
   for(std::size_t i=0;i<sz;i++)
@@ -840,11 +860,9 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTE
   if(n)
     _cell_num_ids=DataArrayInt::Aggregate(numIds);
   // node ids management
-  _node_fam_ids_nocpy=true;
   const DataArrayInt *nodeFamIds(m->getFamilyFieldAtLevel(1));
   if(nodeFamIds)
     { _node_fam_ids=const_cast<DataArrayInt*>(nodeFamIds); nodeFamIds->incrRef(); }
-  _node_num_ids_nocpy=true;
   const DataArrayInt *nodeNumIds(m->getNumberFieldAtLevel(1));
   if(nodeNumIds)
     { _node_num_ids=const_cast<DataArrayInt*>(nodeNumIds); nodeNumIds->incrRef(); }
@@ -852,44 +870,44 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTE
 
 void MEDUMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes)
 {
-   if(!pflNodes || !pflNodes->isAllocated())
-     return ;
-   std::size_t sz(_parts.size());
-   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > a(sz);
-   std::vector< const DataArrayInt *> aa(sz);
-   for(std::size_t i=0;i<sz;i++)
-     {
-       const DataArrayInt *pfl(_pfls[i]);
-       MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> m(_parts[i]);
-       if(pfl)
-         m=dynamic_cast<MEDCoupling1GTUMesh *>(_parts[i]->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
-       DataArrayInt *cellIds=0;
-       m->fillCellIdsToKeepFromNodeIds(pflNodes->begin(),pflNodes->end(),true,cellIds);
-       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIdsSafe(cellIds);
-       MEDCouplingAutoRefCountObjectPtr<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
-       int tmp=-1;
-       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n(m2->getNodeIdsInUse(tmp));
-       a[i]=o2n->invertArrayO2N2N2O(tmp); aa[i]=a[i];
-       if(pfl)
-         _pfls[i]=pfl->selectByTupleIdSafe(cellIds->begin(),cellIds->end());
-       else
-         _pfls[i]=cellIdsSafe;
-     }
-   if(!aa.empty())
-     _node_reduction=DataArrayInt::Aggregate(aa);//general case
-   else
-     _node_reduction=pflNodes->deepCpy();//case where no cells in read mesh.
-   _node_reduction->sort(true);
-   _node_reduction=_node_reduction->buildUnique();
-   if(_node_reduction->getNumberOfTuples()==pflNodes->getNumberOfTuples())
-     return ;//This is the classical case where the input node profile corresponds perfectly to a subset of cells in _parts
-   if(_node_reduction->getNumberOfTuples()>pflNodes->getNumberOfTuples())
-     throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::selectPartOfNodes : internal error in MEDCoupling during cell select from a list of nodes !");
-   // Here the cells available in _parts is not enough to cover all the nodes in pflNodes. So adding vertices cells in _parts...
-   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pflNodes2(pflNodes->deepCpy());
-   pflNodes2->sort(true);
-   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> diff(pflNodes2->buildSubstractionOptimized(_node_reduction));
-   appendVertices(diff,pflNodes2);
+  if(!pflNodes || !pflNodes->isAllocated())
+    return ;
+  std::size_t sz(_parts.size());
+  std::vector< MCAuto<DataArrayInt> > a(sz);
+  std::vector< const DataArrayInt *> aa(sz);
+  for(std::size_t i=0;i<sz;i++)
+    {
+      const DataArrayInt *pfl(_pfls[i]);
+      MCAuto<MEDCoupling1GTUMesh> m(_parts[i]);
+      if(pfl)
+        m=dynamic_cast<MEDCoupling1GTUMesh *>(_parts[i]->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
+      DataArrayInt *cellIds=0;
+      m->fillCellIdsToKeepFromNodeIds(pflNodes->begin(),pflNodes->end(),true,cellIds);
+      MCAuto<DataArrayInt> cellIdsSafe(cellIds);
+      MCAuto<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
+      int tmp=-1;
+      MCAuto<DataArrayInt> o2n(m2->getNodeIdsInUse(tmp));
+      a[i]=o2n->invertArrayO2N2N2O(tmp); aa[i]=a[i];
+      if(pfl)
+        _pfls[i]=pfl->selectByTupleIdSafe(cellIds->begin(),cellIds->end());
+      else
+        _pfls[i]=cellIdsSafe;
+    }
+  if(!aa.empty())
+    _node_reduction=DataArrayInt::Aggregate(aa);//general case
+  else
+    _node_reduction=pflNodes->deepCopy();//case where no cells in read mesh.
+  _node_reduction->sort(true);
+  _node_reduction=_node_reduction->buildUnique();
+  if(_node_reduction->getNumberOfTuples()==pflNodes->getNumberOfTuples())
+    return ;//This is the classical case where the input node profile corresponds perfectly to a subset of cells in _parts
+  if(_node_reduction->getNumberOfTuples()>pflNodes->getNumberOfTuples())
+    throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::selectPartOfNodes : internal error in MEDCoupling during cell select from a list of nodes !");
+  // Here the cells available in _parts is not enough to cover all the nodes in pflNodes. So adding vertices cells in _parts...
+  MCAuto<DataArrayInt> pflNodes2(pflNodes->deepCopy());
+  pflNodes2->sort(true);
+  MCAuto<DataArrayInt> diff(pflNodes2->buildSubstractionOptimized(_node_reduction));
+  appendVertices(diff,pflNodes2);
 }
 
 MEDMeshMultiLev *MEDUMeshMultiLev::prepare() const
@@ -901,7 +919,7 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDUMeshMultiLev& other):MEDMeshMultiLe
 {
 }
 
-MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDStructuredMeshMultiLev& other, const MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh>& part):MEDMeshMultiLev(other)
+MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDStructuredMeshMultiLev& other, const MCAuto<MEDCoupling1GTUMesh>& part):MEDMeshMultiLev(other)
 {
   _parts.resize(1);
   _parts[0]=part;
@@ -911,6 +929,7 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDStructuredMeshMultiLev& other, const
 }
 
 /*! 
+ * To be called only once ! Because due to some optimizations (sometimes aggressive) the internal state can be changed...
  * If returned value is false output pointer \a coords is not the internal pointer. If returned value is true output pointer \a coords is directly the internal pointer.
  * If true is returned, the \a coords output parameter should be used with care (non const method call) to avoid to change the internal state of MEDFileUMesh instance.
  */
@@ -923,18 +942,18 @@ bool MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *
     tmp=_parts[0]->getCoords();
   if(!tmp)
     throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::getVTUArrays : the coordinates are null !");
-  MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a(const_cast<DataArrayDouble *>(tmp)); tmp->incrRef();
+  MCAuto<DataArrayDouble> a(const_cast<DataArrayDouble *>(tmp)); tmp->incrRef();
   int szBCE(0),szD(0),szF(0);
   bool isPolyh(false);
   int iii(0);
-  for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++,iii++)
+  for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++,iii++)
     {
       const MEDCoupling1GTUMesh *cur(*it);
       if(!cur)
         throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::getVTUArrays : a part is null !");
       //
       const DataArrayInt *pfl(_pfls[iii]);
-      MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> cur2;
+      MCAuto<MEDCoupling1GTUMesh> cur2;
       if(!pfl)
         { cur2=const_cast<MEDCoupling1GTUMesh *>(cur); cur2->incrRef(); }
       else
@@ -947,25 +966,25 @@ bool MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *
       else
         {
           isPolyh=true;
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp2(cur->computeEffectiveNbOfNodesPerCell());
+          MCAuto<DataArrayInt> tmp2(cur->computeEffectiveNbOfNodesPerCell());
           szD+=tmp2->accumulate(0)+curNbCells;
           szF+=2*curNbCells+cur->getNodalConnectivity()->getNumberOfTuples();
         }
     }
-  MEDCouplingAutoRefCountObjectPtr<DataArrayByte> b(DataArrayByte::New()); b->alloc(szBCE,1); char *bPtr(b->getPointer());
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()); c->alloc(szBCE,1); int *cPtr(c->getPointer());
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> d(DataArrayInt::New()); d->alloc(szD,1); int *dPtr(d->getPointer());
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> e(DataArrayInt::New()),f(DataArrayInt::New()); int *ePtr(0),*fPtr(0);
+  MCAuto<DataArrayByte> b(DataArrayByte::New()); b->alloc(szBCE,1); char *bPtr(b->getPointer());
+  MCAuto<DataArrayInt> c(DataArrayInt::New()); c->alloc(szBCE,1); int *cPtr(c->getPointer());
+  MCAuto<DataArrayInt> d(DataArrayInt::New()); d->alloc(szD,1); int *dPtr(d->getPointer());
+  MCAuto<DataArrayInt> e(DataArrayInt::New()),f(DataArrayInt::New()); int *ePtr(0),*fPtr(0);
   if(isPolyh)
     { e->alloc(szBCE,1); ePtr=e->getPointer(); f->alloc(szF,1); fPtr=f->getPointer(); }
   int k(0);
   iii=0;
-  for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++,iii++)
+  for(std::vector< MCAuto<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++,iii++)
     {
       const MEDCoupling1GTUMesh *cur(*it);
       //
       const DataArrayInt *pfl(_pfls[iii]);
-      MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> cur2;
+      MCAuto<MEDCoupling1GTUMesh> cur2;
       if(!pfl)
         { cur2=const_cast<MEDCoupling1GTUMesh *>(cur); cur2->incrRef(); }
       else
@@ -1018,7 +1037,7 @@ bool MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *
                 {
                   *dPtr++=connIPtr[1]-connIPtr[0];
                   dPtr=std::copy(connPtr+connIPtr[0],connPtr+connIPtr[1],dPtr);
-                  *cPtr++=k; k+=connIPtr[1]-connIPtr[0];
+                  *cPtr++=k; k+=connIPtr[1]-connIPtr[0]+1;
                 }
             }
           else
@@ -1068,10 +1087,10 @@ bool MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *
     { faceLocations=0; faces=0; }
   else
     { faceLocations=e.retn(); faces=f.retn(); }
-  return tmp==((DataArrayDouble *)a);
+  return _mesh->isObjectInTheProgeny(coords);
 }
 
-void MEDUMeshMultiLev::reorderNodesIfNecessary(MEDCouplingAutoRefCountObjectPtr<DataArrayDouble>& coords, DataArrayInt *nodalConnVTK, DataArrayInt *polyhedNodalConnVTK) const
+void MEDUMeshMultiLev::reorderNodesIfNecessary(MCAuto<DataArrayDouble>& coords, DataArrayInt *nodalConnVTK, DataArrayInt *polyhedNodalConnVTK) const
 {
   const DataArrayInt *nr(_node_reduction);
   if(!nr)
@@ -1118,14 +1137,14 @@ void MEDUMeshMultiLev::reorderNodesIfNecessary(MEDCouplingAutoRefCountObjectPtr<
   if(szExp!=nr->getNumberOfTuples())
     throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::reorderNodesIfNecessary : internal error #3 !");
   // Go renumbering !
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n(DataArrayInt::New()); o2n->alloc(sz,1);
+  MCAuto<DataArrayInt> o2n(DataArrayInt::New()); o2n->alloc(sz,1);
   int *o2nPtr(o2n->getPointer());
   int newId(0);
   for(int i=0;i<sz;i++,o2nPtr++)
     if(b[i]) *o2nPtr=newId++; else *o2nPtr=-1;
   const int *o2nPtrc(o2n->begin());
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> n2o(o2n->invertArrayO2N2N2O(nr->getNumberOfTuples()));
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> perm(DataArrayInt::FindPermutationFromFirstToSecond(n2o,nr));
+  MCAuto<DataArrayInt> n2o(o2n->invertArrayO2N2N2O(nr->getNumberOfTuples()));
+  MCAuto<DataArrayInt> perm(DataArrayInt::FindPermutationFromFirstToSecond(n2o,nr));
   const int *permPtr(perm->begin());
   int *work2(nodalConnVTK->getPointer()),*endW2(nodalConnVTK->getPointer()+nodalConnVTK->getNumberOfTuples());
   while(work2!=endW2)
@@ -1156,7 +1175,7 @@ void MEDUMeshMultiLev::appendVertices(const DataArrayInt *verticesToAdd, DataArr
 {
   int nbOfCells(verticesToAdd->getNumberOfTuples());//it is not a bug cells are NORM_POINT1
   MEDMeshMultiLev::appendVertices(verticesToAdd,nr);
-  MEDCouplingAutoRefCountObjectPtr<MEDCoupling1SGTUMesh> elt(MEDCoupling1SGTUMesh::New("",INTERP_KERNEL::NORM_POINT1));
+  MCAuto<MEDCoupling1SGTUMesh> elt(MEDCoupling1SGTUMesh::New("",INTERP_KERNEL::NORM_POINT1));
   elt->allocateCells(nbOfCells);
   for(int i=0;i<nbOfCells;i++)
     {
@@ -1166,20 +1185,29 @@ void MEDUMeshMultiLev::appendVertices(const DataArrayInt *verticesToAdd, DataArr
   if(_parts.empty())
     throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::appendVertices : parts are empty !");
   elt->setCoords(_parts[0]->getCoords());
-  MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> elt2((MEDCoupling1SGTUMesh *)elt); elt2->incrRef();
+  MCAuto<MEDCoupling1GTUMesh> elt2((MEDCoupling1SGTUMesh *)elt); elt2->incrRef();
   _parts.push_back(elt2);
 }
 
 //=
 
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m):MEDMeshMultiLev(m),_is_internal(true)
+MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, const std::vector<int>& lev):MEDMeshMultiLev(m),_is_internal(true)
 {
+  initStdFieldOfIntegers(m);
 }
 
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, const std::vector<int>& lev):MEDMeshMultiLev(m),_is_internal(true)
+MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, int nbOfNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(m,nbOfNodes,gts,pfls,nbEntities),_is_internal(true)
+{
+  initStdFieldOfIntegers(m);
+}
+
+MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDStructuredMeshMultiLev& other):MEDMeshMultiLev(other),_is_internal(true),_face_fam_ids(other._face_fam_ids),_face_num_ids(other._face_num_ids)
+{
+}
+
+void MEDStructuredMeshMultiLev::initStdFieldOfIntegers(const MEDFileStructuredMesh *m)
 {
   // ids fields management
-  _cell_fam_ids_nocpy=true; _cell_num_ids_nocpy=true;
   const DataArrayInt *tmp(0);
   tmp=m->getFamilyFieldAtLevel(0);
   if(tmp)
@@ -1194,7 +1222,6 @@ MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh
       _cell_num_ids=const_cast<DataArrayInt *>(tmp);
     }
   //
-  _node_fam_ids_nocpy=true; _node_num_ids_nocpy=true;
   tmp=0;
   tmp=m->getFamilyFieldAtLevel(1);
   if(tmp)
@@ -1208,44 +1235,25 @@ MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh
       tmp->incrRef();
       _node_num_ids=const_cast<DataArrayInt *>(tmp);
     }
-}
-
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, int nbOfNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(m,nbOfNodes,gts,pfls,nbEntities),_is_internal(true)
-{
-  // ids fields management
-  _cell_fam_ids_nocpy=true; _cell_num_ids_nocpy=true;
-  const DataArrayInt *tmp(0);
-  tmp=m->getFamilyFieldAtLevel(0);
-  if(tmp)
-    {
-      tmp->incrRef();
-      _cell_fam_ids=const_cast<DataArrayInt *>(tmp);
-    }
-  tmp=m->getNumberFieldAtLevel(0);
-  if(tmp)
-    {
-      tmp->incrRef();
-      _cell_num_ids=const_cast<DataArrayInt *>(tmp);
-    }
-  //
-  _node_fam_ids_nocpy=true; _node_num_ids_nocpy=true;
-  tmp=0;
-  tmp=m->getFamilyFieldAtLevel(1);
+  // faces (if any)
+  tmp=m->getFamilyFieldAtLevel(-1);
   if(tmp)
     {
       tmp->incrRef();
-      _node_fam_ids=const_cast<DataArrayInt *>(tmp);
+      _face_fam_ids=const_cast<DataArrayInt *>(tmp);
     }
-  tmp=m->getNumberFieldAtLevel(1);
+  tmp=m->getNumberFieldAtLevel(-1);
   if(tmp)
     {
       tmp->incrRef();
-      _node_num_ids=const_cast<DataArrayInt *>(tmp);
+      _face_num_ids=const_cast<DataArrayInt *>(tmp);
     }
 }
 
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDStructuredMeshMultiLev& other):MEDMeshMultiLev(other),_is_internal(true)
+void MEDStructuredMeshMultiLev::moveFaceToCell() const
 {
+  const_cast<MEDStructuredMeshMultiLev *>(this)->_cell_fam_ids=_face_fam_ids; const_cast<MEDStructuredMeshMultiLev *>(this)->_face_fam_ids=0;
+  const_cast<MEDStructuredMeshMultiLev *>(this)->_cell_num_ids=_face_num_ids; const_cast<MEDStructuredMeshMultiLev *>(this)->_face_num_ids=0;
 }
 
 bool MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase(MEDMeshMultiLev *&ret) const
@@ -1257,17 +1265,18 @@ bool MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase(MEDMeshMu
     throw INTERP_KERNEL::Exception("MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase only one geo types supported at most supported for the moment !");
   INTERP_KERNEL::NormalizedCellType gt(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(_mesh->getMeshDimension()));
   if(_geo_types[0]==gt)
-     return false;
+    return false;
   MEDCoupling1GTUMesh *facesIfPresent((static_cast<const MEDFileStructuredMesh *>(_mesh))->getImplicitFaceMesh());
   if(!facesIfPresent)
     return false;
   const DataArrayInt *pfl(0),*nr(_node_reduction);
   if(!_pfls.empty())
     pfl=_pfls[0];
-  MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> facesIfPresent2(facesIfPresent); facesIfPresent->incrRef();
-  MEDCouplingAutoRefCountObjectPtr<MEDUMeshMultiLev> ret2(new MEDUMeshMultiLev(*this,facesIfPresent2));
+  MCAuto<MEDCoupling1GTUMesh> facesIfPresent2(facesIfPresent); facesIfPresent->incrRef();
+  moveFaceToCell();
+  MCAuto<MEDUMeshMultiLev> ret2(new MEDUMeshMultiLev(*this,facesIfPresent2));
   if(pfl)
-    throw INTERP_KERNEL::Exception("MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase : case is not treated yet for profile on implicit unstructured mesh.");
+    ret2->setCellReduction(pfl);
   if(nr)
     throw INTERP_KERNEL::Exception("MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase : case is not treated yet for node reduction on implicit unstructured mesh.");
   ret=ret2.retn();
@@ -1276,7 +1285,6 @@ bool MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase(MEDMeshMu
 
 void MEDStructuredMeshMultiLev::dealWithImplicitUnstructuredMesh(const MEDFileMesh *m)
 {
-  _cell_fam_ids_nocpy=true; _cell_num_ids_nocpy=true;
   const DataArrayInt *tmp(0);
   tmp=m->getFamilyFieldAtLevel(-1);
   if(tmp)
@@ -1297,8 +1305,8 @@ void MEDStructuredMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes)
   if(!pflNodes || !pflNodes->isAllocated())
     return ;
   std::vector<int> ngs(getNodeGridStructure());
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> conn(MEDCouplingStructuredMesh::Build1GTNodalConnectivity(&ngs[0],&ngs[0]+ngs.size()));
-  MEDCouplingAutoRefCountObjectPtr<MEDCoupling1SGTUMesh> m(MEDCoupling1SGTUMesh::New("",MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(ngs.size())));
+  MCAuto<DataArrayInt> conn(MEDCouplingStructuredMesh::Build1GTNodalConnectivity(&ngs[0],&ngs[0]+ngs.size()));
+  MCAuto<MEDCoupling1SGTUMesh> m(MEDCoupling1SGTUMesh::New("",MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(ngs.size())));
   m->setNodalConnectivity(conn);
   const DataArrayInt *pfl(_pfls[0]);
   if(pfl)
@@ -1307,8 +1315,8 @@ void MEDStructuredMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes)
     }
   DataArrayInt *cellIds=0;
   m->fillCellIdsToKeepFromNodeIds(pflNodes->begin(),pflNodes->end(),true,cellIds);
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIdsSafe(cellIds);
-  MEDCouplingAutoRefCountObjectPtr<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
+  MCAuto<DataArrayInt> cellIdsSafe(cellIds);
+  MCAuto<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
   int tmp=-1;
   _node_reduction=m2->getNodeIdsInUse(tmp);
   if(pfl)
@@ -1390,59 +1398,59 @@ MEDMeshMultiLev *MEDCMeshMultiLev::prepare() const
   const DataArrayInt *pfl(0),*nr(_node_reduction);
   if(!_pfls.empty())
     pfl=_pfls[0];
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nnr;
+  MCAuto<DataArrayInt> nnr;
   std::vector<int> cgs,ngs(getNodeGridStructure());
   cgs.resize(ngs.size());
   std::transform(ngs.begin(),ngs.end(),cgs.begin(),std::bind2nd(std::plus<int>(),-1));
   if(pfl)
     {
       std::vector< std::pair<int,int> > cellParts;
-      MEDCouplingAutoRefCountObjectPtr<MEDMeshMultiLev> ret2;
+      MCAuto<MEDMeshMultiLev> ret2;
       if(MEDCouplingStructuredMesh::IsPartStructured(pfl->begin(),pfl->end(),cgs,cellParts))
         {
-          MEDCouplingAutoRefCountObjectPtr<MEDCMeshMultiLev> ret(new MEDCMeshMultiLev(*this));
+          MCAuto<MEDCMeshMultiLev> ret(new MEDCMeshMultiLev(*this));
           ret->_is_internal=false;
           if(nr)
-            { nnr=nr->deepCpy(); nnr->sort(true); ret->setNodeReduction(nnr); }
+            { nnr=nr->deepCopy(); nnr->sort(true); ret->setNodeReduction(nnr); }
           ret->_nb_entities[0]=pfl->getNumberOfTuples();
           ret->_pfls[0]=0;
-          std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > coords(_coords.size());
+          std::vector< MCAuto<DataArrayDouble> > coords(_coords.size());
           for(std::size_t i=0;i<_coords.size();i++)
-            coords[i]=_coords[i]->selectByTupleId2(cellParts[i].first,cellParts[i].second+1,1);
+            coords[i]=_coords[i]->selectByTupleIdSafeSlice(cellParts[i].first,cellParts[i].second+1,1);
           ret->_coords=coords;
           ret2=(MEDCMeshMultiLev *)ret; ret2->incrRef();
         }
       else
         {
-          MEDCouplingAutoRefCountObjectPtr<MEDCouplingCMesh> m(MEDCouplingCMesh::New());
+          MCAuto<MEDCouplingCMesh> m(MEDCouplingCMesh::New());
           for(std::size_t i=0;i<ngs.size();i++)
             m->setCoordsAt(i,_coords[i]);
-          MEDCouplingAutoRefCountObjectPtr<MEDCoupling1SGTUMesh> m2(m->build1SGTUnstructured());
-          MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> m3=dynamic_cast<MEDCoupling1GTUMesh *>(m2->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
-          MEDCouplingAutoRefCountObjectPtr<MEDUMeshMultiLev> ret(new MEDUMeshMultiLev(*this,m3));
+          MCAuto<MEDCoupling1SGTUMesh> m2(m->build1SGTUnstructured());
+          MCAuto<MEDCoupling1GTUMesh> m3=dynamic_cast<MEDCoupling1GTUMesh *>(m2->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
+          MCAuto<MEDUMeshMultiLev> ret(new MEDUMeshMultiLev(*this,m3));
           if(nr)
-            { m3->zipCoords(); nnr=nr->deepCpy(); nnr->sort(true); ret->setNodeReduction(nnr); }
+            { m3->zipCoords(); nnr=nr->deepCopy(); nnr->sort(true); ret->setNodeReduction(nnr); }
           ret2=(MEDUMeshMultiLev *)ret; ret2->incrRef();
         }
       const DataArrayInt *famIds(_cell_fam_ids),*numIds(_cell_num_ids);
       if(famIds)
         {
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(famIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
-          ret2->setFamilyIdsOnCells(tmp,false);
+          MCAuto<DataArrayInt> tmp(famIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
+          ret2->setFamilyIdsOnCells(tmp);
         }
       if(numIds)
         {
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(numIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
-          ret2->setNumberIdsOnCells(tmp,false);
+          MCAuto<DataArrayInt> tmp(numIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
+          ret2->setNumberIdsOnCells(tmp);
         }
       return ret2.retn();
-      
+
     }
   else
     {
-      MEDCouplingAutoRefCountObjectPtr<MEDCMeshMultiLev> ret(new MEDCMeshMultiLev(*this));
+      MCAuto<MEDCMeshMultiLev> ret(new MEDCMeshMultiLev(*this));
       if(nr)
-        { nnr=nr->deepCpy(); nnr->sort(true); ret->setNodeReduction(nnr); }
+        { nnr=nr->deepCopy(); nnr->sort(true); ret->setNodeReduction(nnr); }
       return ret.retn();
     }
 }
@@ -1526,14 +1534,14 @@ MEDMeshMultiLev *MEDCurveLinearMeshMultiLev::prepare() const
   const DataArrayInt *pfl(0),*nr(_node_reduction);
   if(!_pfls.empty())
     pfl=_pfls[0];
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nnr;
+  MCAuto<DataArrayInt> nnr;
   std::vector<int> cgs,ngs(getNodeGridStructure());
   cgs.resize(ngs.size());
   std::transform(ngs.begin(),ngs.end(),cgs.begin(),std::bind2nd(std::plus<int>(),-1));
   if(pfl)
     {
       std::vector< std::pair<int,int> > cellParts,nodeParts;
-      MEDCouplingAutoRefCountObjectPtr<MEDMeshMultiLev> ret2;
+      MCAuto<MEDMeshMultiLev> ret2;
       if(MEDCouplingStructuredMesh::IsPartStructured(pfl->begin(),pfl->end(),cgs,cellParts))
         {
           nodeParts=cellParts;
@@ -1543,11 +1551,11 @@ MEDMeshMultiLev *MEDCurveLinearMeshMultiLev::prepare() const
               nodeParts[i].second++;
               st[i]=nodeParts[i].second-nodeParts[i].first;
             }
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p(MEDCouplingStructuredMesh::BuildExplicitIdsFrom(ngs,nodeParts));
-          MEDCouplingAutoRefCountObjectPtr<MEDCurveLinearMeshMultiLev> ret(new MEDCurveLinearMeshMultiLev(*this));
+          MCAuto<DataArrayInt> p(MEDCouplingStructuredMesh::BuildExplicitIdsFrom(ngs,nodeParts));
+          MCAuto<MEDCurveLinearMeshMultiLev> ret(new MEDCurveLinearMeshMultiLev(*this));
           ret->_is_internal=false;
           if(nr)
-            { nnr=nr->deepCpy(); nnr->sort(true); ret->setNodeReduction(nnr); }
+            { nnr=nr->deepCopy(); nnr->sort(true); ret->setNodeReduction(nnr); }
           ret->_nb_entities[0]=pfl->getNumberOfTuples();
           ret->_pfls[0]=0;
           ret->_coords=_coords->selectByTupleIdSafe(p->begin(),p->end());
@@ -1556,33 +1564,33 @@ MEDMeshMultiLev *MEDCurveLinearMeshMultiLev::prepare() const
         }
       else
         {
-          MEDCouplingAutoRefCountObjectPtr<MEDCouplingCurveLinearMesh> m(MEDCouplingCurveLinearMesh::New());
+          MCAuto<MEDCouplingCurveLinearMesh> m(MEDCouplingCurveLinearMesh::New());
           m->setCoords(_coords); m->setNodeGridStructure(&_structure[0],&_structure[0]+_structure.size());
-          MEDCouplingAutoRefCountObjectPtr<MEDCoupling1SGTUMesh> m2(m->build1SGTUnstructured());
-          MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> m3=dynamic_cast<MEDCoupling1GTUMesh *>(m2->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
-          MEDCouplingAutoRefCountObjectPtr<MEDUMeshMultiLev> ret(new MEDUMeshMultiLev(*this,m3));
+          MCAuto<MEDCoupling1SGTUMesh> m2(m->build1SGTUnstructured());
+          MCAuto<MEDCoupling1GTUMesh> m3=dynamic_cast<MEDCoupling1GTUMesh *>(m2->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
+          MCAuto<MEDUMeshMultiLev> ret(new MEDUMeshMultiLev(*this,m3));
           if(nr)
-            { m3->zipCoords(); nnr=nr->deepCpy(); nnr->sort(true); ret->setNodeReduction(nnr); }
+            { m3->zipCoords(); nnr=nr->deepCopy(); nnr->sort(true); ret->setNodeReduction(nnr); }
           ret2=(MEDUMeshMultiLev *)ret; ret2->incrRef();
         }
       const DataArrayInt *famIds(_cell_fam_ids),*numIds(_cell_num_ids);
       if(famIds)
         {
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(famIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
-          ret2->setFamilyIdsOnCells(tmp,false);
+          MCAuto<DataArrayInt> tmp(famIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
+          ret2->setFamilyIdsOnCells(tmp);
         }
       if(numIds)
         {
-          MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(numIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
-          ret2->setNumberIdsOnCells(tmp,false);
+          MCAuto<DataArrayInt> tmp(numIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
+          ret2->setNumberIdsOnCells(tmp);
         }
       return ret2.retn();
     }
   else
     {
-      MEDCouplingAutoRefCountObjectPtr<MEDCurveLinearMeshMultiLev> ret(new MEDCurveLinearMeshMultiLev(*this));
+      MCAuto<MEDCurveLinearMeshMultiLev> ret(new MEDCurveLinearMeshMultiLev(*this));
       if(nr)
-        { nnr=nr->deepCpy(); nnr->sort(true); ret->setNodeReduction(nnr); }
+        { nnr=nr->deepCopy(); nnr->sort(true); ret->setNodeReduction(nnr); }
       return ret.retn();
     }
 }
@@ -1681,7 +1689,7 @@ void MEDFileField1TSStructItem2::checkInRange(int nbOfEntity, int nip, const MED
   if(_pfl->getName().empty())
     {
       if(nbOfEntity!=(_start_end.second-_start_end.first)/nip)
-        throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::checkInRange : Mismatch between number of entities and size of node field !");
+        throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::checkInRange : Mismatch between number of entities and size of field !");
       return ;
     }
   else
@@ -1707,7 +1715,7 @@ bool MEDFileField1TSStructItem2::isFastlyEqual(int& startExp, INTERP_KERNEL::Nor
   return true;
 }
 
-bool MEDFileField1TSStructItem2::operator==(const MEDFileField1TSStructItem2& other) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem2::operator==(const MEDFileField1TSStructItem2& other) const
 {
   //_nb_of_entity is not taken into account here. It is not a bug, because no mesh consideration needed here to perform fast compare.
   //idem for _loc. It is not an effective attribute for support comparison.
@@ -1757,13 +1765,13 @@ MEDFileField1TSStructItem2 MEDFileField1TSStructItem2::BuildAggregationOf(const
         throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::BuildAggregationOf : invalid situation ! Several same geo type chunk must all lie on profiles !");
       arrs[i]=globs->getProfile(obj->_pfl->getName().c_str());
     }
-  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr(DataArrayInt::Aggregate(arrs));
+  MCAuto<DataArrayInt> arr(DataArrayInt::Aggregate(arrs));
   arr->sort();
   int oldNbTuples(arr->getNumberOfTuples());
   arr=arr->buildUnique();
   if(oldNbTuples!=arr->getNumberOfTuples())
     throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::BuildAggregationOf : some entities are present several times !");
-  if(arr->isIdentity() && oldNbTuples==nbEntityRef)
+  if(arr->isIota(nbEntityRef))
     {
       std::pair<int,int> p(0,nbEntityRef);
       std::string a,b;
@@ -1789,12 +1797,10 @@ std::size_t MEDFileField1TSStructItem2::getHeapMemorySizeWithoutChildren() const
   return ret;
 }
 
-std::vector<const BigMemoryObject *> MEDFileField1TSStructItem2::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileField1TSStructItem2::getDirectChildrenWithNull() const
 {
   std::vector<const BigMemoryObject *> ret;
-  const DataArrayInt *pfl(_pfl);
-  if(pfl)
-    ret.push_back(pfl);
+  ret.push_back((const DataArrayInt *)_pfl);
   return ret;
 }
 
@@ -1807,7 +1813,7 @@ MEDFileField1TSStructItem::MEDFileField1TSStructItem(TypeOfField a, const std::v
 void MEDFileField1TSStructItem::checkWithMeshStruct(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs)
 {
   switch(_type)
-    {
+  {
     case ON_NODES:
       {
         int nbOfEnt=mst->getNumberOfNodes();
@@ -1836,10 +1842,10 @@ void MEDFileField1TSStructItem::checkWithMeshStruct(const MEDFileMeshStruct *mst
       }
     default:
       throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::checkWithMeshStruct : not managed field type !");
-    }
+  }
 }
 
-bool MEDFileField1TSStructItem::operator==(const MEDFileField1TSStructItem& other) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem::operator==(const MEDFileField1TSStructItem& other) const
 {
   if(_type!=other._type)
     return false;
@@ -1939,19 +1945,24 @@ bool MEDFileField1TSStructItem::isCompatibleWithNodesDiscr(const MEDFileField1TS
   int theFirstLevFull;
   bool ret0=isFullyOnOneLev(meshSt,theFirstLevFull);
   const MEDFileField1TSStructItem2& otherNodeIt(other._items[0]);
+  int nbOfNodes(meshSt->getNumberOfNodes());
   if(otherNodeIt.getPflName().empty())
     {//on all nodes
       if(!ret0)
         return false;
-      return theFirstLevFull==0;
+      std::vector<bool> nodesFetched(nbOfNodes,false);
+      meshSt->getTheMesh()->whichAreNodesFetched(*this,globs,nodesFetched);
+      if(std::find(nodesFetched.begin(),nodesFetched.end(),false)==nodesFetched.end())
+        return theFirstLevFull==0;
+      else
+        return false;
     }
   else
     {
       const DataArrayInt *pfl=globs->getProfile(otherNodeIt.getPflName().c_str());
-      MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cpyPfl(pfl->deepCpy());
+      MCAuto<DataArrayInt> cpyPfl(pfl->deepCopy());
       cpyPfl->sort();
-      int nbOfNodes(meshSt->getNumberOfNodes());
-      if(cpyPfl->isIdentity() && cpyPfl->getNumberOfTuples()==nbOfNodes)
+      if(cpyPfl->isIota(nbOfNodes))
         {//on all nodes also !
           if(!ret0)
             return false;
@@ -1992,7 +2003,7 @@ bool MEDFileField1TSStructItem::isFullyOnOneLev(const MEDFileMeshStruct *meshSt,
   return false;
 }
 
-const MEDFileField1TSStructItem2& MEDFileField1TSStructItem::operator[](std::size_t i) const throw(INTERP_KERNEL::Exception)
+const MEDFileField1TSStructItem2& MEDFileField1TSStructItem::operator[](std::size_t i) const
 {
   if(i>=_items.size())
     throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::operator[] : input is not in valid range !");
@@ -2005,7 +2016,7 @@ std::size_t MEDFileField1TSStructItem::getHeapMemorySizeWithoutChildren() const
   return ret;
 }
 
-std::vector<const BigMemoryObject *> MEDFileField1TSStructItem::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileField1TSStructItem::getDirectChildrenWithNull() const
 {
   std::vector<const BigMemoryObject *> ret;
   for(std::vector< MEDFileField1TSStructItem2 >::const_iterator it=_items.begin();it!=_items.end();it++)
@@ -2056,7 +2067,6 @@ std::vector<INTERP_KERNEL::NormalizedCellType> MEDFileField1TSStructItem::getGeo
 
 MEDFileField1TSStructItem MEDFileField1TSStructItem::BuildItemFrom(const MEDFileAnyTypeField1TS *ref, const MEDFileMeshStruct *meshSt)
 {
-  TypeOfField atype;
   std::vector< MEDFileField1TSStructItem2 > anItems;
   //
   std::vector< std::vector<std::string> > pfls,locs;
@@ -2066,17 +2076,15 @@ MEDFileField1TSStructItem MEDFileField1TSStructItem::BuildItemFrom(const MEDFile
   std::size_t nbOfGeoTypes(geoTypes.size());
   if(nbOfGeoTypes==0)
     throw INTERP_KERNEL::Exception("MEDFileField1TSStruct : not null by empty ref  !");
-  bool isFirst=true;
+  if(typesF[0].empty())
+    throw INTERP_KERNEL::Exception("MEDFileField1TSStruct : internal error #1 bis !");
+  TypeOfField atype(typesF[0][0]);
   for(std::size_t i=0;i<nbOfGeoTypes;i++)
     {
       std::size_t sz=typesF[i].size();
       if(strtEnds[i].size()<1 || sz<1 || pfls[i].size()<1)
         throw INTERP_KERNEL::Exception("MEDFileField1TSStruct : internal error #1 !");
       //
-      if(isFirst)
-        atype=typesF[i][0];
-      isFirst=false;
-      //
       for(std::size_t j=0;j<sz;j++)
         {
           if(atype==typesF[i][j])
@@ -2086,7 +2094,15 @@ MEDFileField1TSStructItem MEDFileField1TSStructItem::BuildItemFrom(const MEDFile
         }
     }
   MEDFileField1TSStructItem ret(atype,anItems);
-  ret.checkWithMeshStruct(meshSt,ref);
+  try
+    {
+      ret.checkWithMeshStruct(meshSt,ref);
+    }
+  catch(INTERP_KERNEL::Exception& e)
+    {
+      std::ostringstream oss; oss << e.what() << " (" << MEDCouplingFieldDiscretization::GetTypeOfFieldRepr(ret.getType()) << ")";
+      throw INTERP_KERNEL::Exception(oss.str().c_str());
+    }
   return ret;
 }
 
@@ -2188,7 +2204,7 @@ std::size_t MEDFileField1TSStruct::getHeapMemorySizeWithoutChildren() const
   return ret;
 }
 
-std::vector<const BigMemoryObject *> MEDFileField1TSStruct::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileField1TSStruct::getDirectChildrenWithNull() const
 {
   std::vector<const BigMemoryObject *> ret;
   for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++)
@@ -2203,7 +2219,7 @@ MEDMeshMultiLev *MEDFileField1TSStruct::buildFromScratchDataSetSupport(const MED
   int pos0(-1),pos1(-1);
   if(presenceOfCellDiscr(pos0))
     {
-      MEDCouplingAutoRefCountObjectPtr<MEDMeshMultiLev> ret(_already_checked[pos0].buildFromScratchDataSetSupportOnCells(mst,globs));
+      MCAuto<MEDMeshMultiLev> ret(_already_checked[pos0].buildFromScratchDataSetSupportOnCells(mst,globs));
       if(presenceOfPartialNodeDiscr(pos1))
         ret->setNodeReduction(_already_checked[pos1][0].getPfl(globs));
       return ret.retn();
@@ -2318,30 +2334,35 @@ MEDFileFastCellSupportComparator::MEDFileFastCellSupportComparator(const MEDFile
   _f1ts_cmps.resize(nbPts);
   for(int i=0;i<nbPts;i++)
     {
-      MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> elt=ref->getTimeStepAtPos(i);
-      _f1ts_cmps[i]=MEDFileField1TSStruct::New(elt,_mesh_comp);
-      _f1ts_cmps[i]->checkWithMeshStruct(_mesh_comp,elt);
+      MCAuto<MEDFileAnyTypeField1TS> elt=ref->getTimeStepAtPos(i);
+      try
+        {
+          _f1ts_cmps[i]=MEDFileField1TSStruct::New(elt,_mesh_comp);
+          _f1ts_cmps[i]->checkWithMeshStruct(_mesh_comp,elt);
+        }
+      catch(INTERP_KERNEL::Exception& e)
+        {
+          std::ostringstream oss; oss << "Problem in field with name \"" << ref->getName() << "\"" << std::endl;
+          oss << "More Details : " << e.what();
+          throw INTERP_KERNEL::Exception(oss.str().c_str());
+        }
     }
 }
 
 std::size_t MEDFileFastCellSupportComparator::getHeapMemorySizeWithoutChildren() const
 {
-  std::size_t ret(_f1ts_cmps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSStruct>));
+  std::size_t ret(_f1ts_cmps.capacity()*sizeof(MCAuto<MEDFileField1TSStruct>));
   return ret;
 }
 
-std::vector<const BigMemoryObject *> MEDFileFastCellSupportComparator::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileFastCellSupportComparator::getDirectChildrenWithNull() const
 {
   std::vector<const BigMemoryObject *> ret;
   const MEDFileMeshStruct *mst(_mesh_comp);
   if(mst)
     ret.push_back(mst);
-  for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSStruct> >::const_iterator it=_f1ts_cmps.begin();it!=_f1ts_cmps.end();it++)
-    {
-      const MEDFileField1TSStruct *cur(*it);
-      if(cur)
-        ret.push_back(cur);
-    }
+  for(std::vector< MCAuto<MEDFileField1TSStruct> >::const_iterator it=_f1ts_cmps.begin();it!=_f1ts_cmps.end();it++)
+    ret.push_back((const MEDFileField1TSStruct *)*it);
   return ret;
 }
 
@@ -2355,7 +2376,7 @@ bool MEDFileFastCellSupportComparator::isEqual(const MEDFileAnyTypeFieldMultiTS
     }
   for(int i=0;i<nbPts;i++)
     {
-      MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> elt=other->getTimeStepAtPos(i);
+      MCAuto<MEDFileAnyTypeField1TS> elt=other->getTimeStepAtPos(i);
       if(!_f1ts_cmps[i]->isEqualConsideringThePast(elt,_mesh_comp))
         if(!_f1ts_cmps[i]->isSupportSameAs(elt,_mesh_comp))
           return false;
@@ -2373,7 +2394,7 @@ bool MEDFileFastCellSupportComparator::isCompatibleWithNodesDiscr(const MEDFileA
     }
   for(int i=0;i<nbPts;i++)
     {
-      MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> elt=other->getTimeStepAtPos(i);
+      MCAuto<MEDFileAnyTypeField1TS> elt=other->getTimeStepAtPos(i);
       if(!_f1ts_cmps[i]->isCompatibleWithNodesDiscr(elt,_mesh_comp))
         return false;
     }