X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDLoader%2FMEDFileFieldOverView.cxx;h=e437d57fa9877d07845e910aebcc3a6f864da1e4;hb=4a8694e2c6bbc95f4d1f7583d8d8b945892eb74c;hp=674a29cbd10f7b9f2e207bb168f04a145d7effe7;hpb=519194e7f5cab5546af9772cc50330dd43e067f1;p=tools%2Fmedcoupling.git

diff --git a/src/MEDLoader/MEDFileFieldOverView.cxx b/src/MEDLoader/MEDFileFieldOverView.cxx
index 674a29cbd..e437d57fa 100644
--- a/src/MEDLoader/MEDFileFieldOverView.cxx
+++ b/src/MEDLoader/MEDFileFieldOverView.cxx
@@ -36,7 +36,7 @@ MEDFileMeshStruct *MEDFileMeshStruct::New(const MEDFileMesh *mesh)
   return new MEDFileMeshStruct(mesh);
 }
 
-std::size_t MEDFileMeshStruct::getHeapMemorySize() const
+std::size_t MEDFileMeshStruct::getHeapMemorySizeWithoutChildren() const
 {
   std::size_t ret(0);
   for(std::vector< std::vector<int> >::const_iterator it0=_geo_types_distrib.begin();it0!=_geo_types_distrib.end();it0++)
@@ -45,6 +45,11 @@ std::size_t MEDFileMeshStruct::getHeapMemorySize() const
   return ret;
 }
 
+std::vector<const BigMemoryObject *> MEDFileMeshStruct::getDirectChildren() const
+{
+  return std::vector<const BigMemoryObject *>();
+}
+
 MEDFileMeshStruct::MEDFileMeshStruct(const MEDFileMesh *mesh):_mesh(mesh)
 {
   std::vector<int> levs=mesh->getNonEmptyLevels();
@@ -55,7 +60,7 @@ MEDFileMeshStruct::MEDFileMeshStruct(const MEDFileMesh *mesh):_mesh(mesh)
     _geo_types_distrib[-(*lev)]=mesh->getDistributionOfTypes(*lev);
 }
 
-int MEDFileMeshStruct::getLevelOfGeoType(INTERP_KERNEL::NormalizedCellType t) const throw(INTERP_KERNEL::Exception)
+int MEDFileMeshStruct::getLevelOfGeoType(INTERP_KERNEL::NormalizedCellType t) const
 {
   int j=0;
   for(std::vector< std::vector<int> >::const_iterator it1=_geo_types_distrib.begin();it1!=_geo_types_distrib.end();it1++,j--)
@@ -71,7 +76,7 @@ int MEDFileMeshStruct::getLevelOfGeoType(INTERP_KERNEL::NormalizedCellType t) co
   throw INTERP_KERNEL::Exception("MEDFileMeshStruct::getLevelOfGeoType : The specified geometric type is not present in the mesh structure !");
 }
 
-int MEDFileMeshStruct::getNumberOfElemsOfGeoType(INTERP_KERNEL::NormalizedCellType t) const throw(INTERP_KERNEL::Exception)
+int MEDFileMeshStruct::getNumberOfElemsOfGeoType(INTERP_KERNEL::NormalizedCellType t) const
 {
   for(std::vector< std::vector<int> >::const_iterator it1=_geo_types_distrib.begin();it1!=_geo_types_distrib.end();it1++)
     {
@@ -91,10 +96,10 @@ int MEDFileMeshStruct::getNumberOfLevs() const
   return (int)_geo_types_distrib.size();
 }
 
-int MEDFileMeshStruct::getNumberOfGeoTypesInLev(int relativeLev) const throw(INTERP_KERNEL::Exception)
+int MEDFileMeshStruct::getNumberOfGeoTypesInLev(int relativeLev) const
 {
   int pos(-relativeLev);
-  if(pos<0 || pos>=_geo_types_distrib.size())
+  if(pos<0 || pos>=(int)_geo_types_distrib.size())
     throw INTERP_KERNEL::Exception("MEDFileMeshStruct::getNumberOfGeoTypesInLev : invalid level specified !");
   std::size_t sz=_geo_types_distrib[pos].size();
   if(sz%3!=0)
@@ -104,12 +109,17 @@ int MEDFileMeshStruct::getNumberOfGeoTypesInLev(int relativeLev) const throw(INT
 
 //=
 
-std::size_t MEDMeshMultiLev::getHeapMemorySize() const
+std::size_t MEDMeshMultiLev::getHeapMemorySizeWithoutChildren() const
 {
   return 0;
 }
 
-MEDMeshMultiLev *MEDMeshMultiLev::New(const MEDFileMesh *m, const std::vector<int>& levs) throw(INTERP_KERNEL::Exception)
+std::vector<const BigMemoryObject *> MEDMeshMultiLev::getDirectChildren() const
+{
+  return std::vector<const BigMemoryObject *>();
+}
+
+MEDMeshMultiLev *MEDMeshMultiLev::New(const MEDFileMesh *m, const std::vector<int>& levs)
 {
   if(!m)
     throw INTERP_KERNEL::Exception("MEDMeshMultiLev::New : null input pointer !");
@@ -125,7 +135,7 @@ MEDMeshMultiLev *MEDMeshMultiLev::New(const MEDFileMesh *m, const std::vector<in
   throw INTERP_KERNEL::Exception("MEDMeshMultiLev::New : unrecognized type of mesh ! Must be in [MEDFileUMesh,MEDFileCMesh,MEDFileCurveLinearMesh] !");
 }
 
-MEDMeshMultiLev *MEDMeshMultiLev::New(const MEDFileMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities) throw(INTERP_KERNEL::Exception)
+MEDMeshMultiLev *MEDMeshMultiLev::New(const MEDFileMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities)
 {
   if(!m)
     throw INTERP_KERNEL::Exception("MEDMeshMultiLev::New 2 : null input pointer !");
@@ -141,7 +151,7 @@ MEDMeshMultiLev *MEDMeshMultiLev::New(const MEDFileMesh *m, const std::vector<IN
   throw INTERP_KERNEL::Exception("MEDMeshMultiLev::New 2 : unrecognized type of mesh ! Must be in [MEDFileUMesh,MEDFileCMesh,MEDFileCurveLinearMesh] !");
 }
 
-MEDMeshMultiLev *MEDMeshMultiLev::NewOnlyOnNode(const MEDFileMesh *m, const DataArrayInt *pflOnNode) throw(INTERP_KERNEL::Exception)
+MEDMeshMultiLev *MEDMeshMultiLev::NewOnlyOnNode(const MEDFileMesh *m, const DataArrayInt *pflOnNode)
 {
   std::vector<int> levs(1,0);
   MEDCouplingAutoRefCountObjectPtr<MEDMeshMultiLev> ret(MEDMeshMultiLev::New(m,levs));
@@ -156,7 +166,7 @@ void MEDMeshMultiLev::setNodeReduction(const DataArrayInt *nr)
   _node_reduction=const_cast<DataArrayInt*>(nr);
 }
 
-bool MEDMeshMultiLev::isFastlyTheSameStruct(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+bool MEDMeshMultiLev::isFastlyTheSameStruct(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs) const
 {
   if(fst.getType()==ON_NODES)
     {
@@ -187,7 +197,7 @@ bool MEDMeshMultiLev::isFastlyTheSameStruct(const MEDFileField1TSStructItem& fst
     }
 }
 
-DataArray *MEDMeshMultiLev::buildDataArray(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs, const DataArray *vals) const throw(INTERP_KERNEL::Exception)
+DataArray *MEDMeshMultiLev::buildDataArray(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs, const DataArray *vals) const
 {
   MEDCouplingAutoRefCountObjectPtr<DataArray> ret(const_cast<DataArray *>(vals)); ret->incrRef();
   if(isFastlyTheSameStruct(fst,globs))
@@ -199,7 +209,7 @@ DataArray *MEDMeshMultiLev::buildDataArray(const MEDFileField1TSStructItem& fst,
 std::string MEDMeshMultiLev::getPflNameOfId(int id) const
 {
   std::size_t sz(_pfls.size());
-  if(id<0 || id>=sz)
+  if(id<0 || id>=(int)sz)
     throw INTERP_KERNEL::Exception("MEDMeshMultiLev::getPflNameOfId : invalid input id !");
   const DataArrayInt *pfl(_pfls[id]);
   if(!pfl)
@@ -207,7 +217,25 @@ std::string MEDMeshMultiLev::getPflNameOfId(int id) const
   return pfl->getName();
 }
 
-DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs, const DataArray *vals) const throw(INTERP_KERNEL::Exception)
+/*!
+ * Returns the number of cells having geometric type \a t.
+ * The profiles are **NOT** taken into account here.
+ */
+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];
+  throw INTERP_KERNEL::Exception("MEDMeshMultiLev::getNumberOfCells : not existing geometric type in this !");
+}
+
+int MEDMeshMultiLev::getNumberOfNodes() const
+{
+  return _nb_nodes;
+}
+
+DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs, const DataArray *vals) const
 {
   if(fst.getType()==ON_NODES)
     {
@@ -236,7 +264,7 @@ DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem&
         {
           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(globs->getProfile(pflName.c_str())->deepCpy());
           p1->sort(true);
-          if(!p1->isIdentity() || p1->getNumberOfTuples()!=p.getNbEntity())
+          if(!p1->isIdentity() || p1->getNumberOfTuples()!=getNumberOfNodes())
             throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for nodes 4 !");
           MEDCouplingAutoRefCountObjectPtr<DataArray> ret(vals->deepCpy());
           ret->renumberInPlace(globs->getProfile(pflName.c_str())->begin());
@@ -247,58 +275,108 @@ DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem&
   else
     {
       std::size_t sz(fst.getNumberOfItems());
-      std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > arrSafe(sz);
-      std::vector< const DataArray *> arr(sz);
-      for(std::size_t i=0;i<sz;i++)
+      std::set<INTERP_KERNEL::NormalizedCellType> s(_geo_types.begin(),_geo_types.end());
+      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());
+      int iii(0);
+      int nc(vals->getNumberOfComponents());
+      std::vector<std::string> compInfo(vals->getInfoOnComponents());
+      for(std::vector< INTERP_KERNEL::NormalizedCellType >::const_iterator it=_geo_types.begin();it!=_geo_types.end();it++,iii++)
         {
-          const MEDFileField1TSStructItem2& p(fst[i]);
-          const std::pair<int,int>& strtStop(p.getStartStop());
-          std::vector< INTERP_KERNEL::NormalizedCellType >::const_iterator it(std::find(_geo_types.begin(),_geo_types.end(),p.getGeo()));
-          if(it==_geo_types.end())
-            throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 1 !");
-          if(std::find(it+1,_geo_types.end(),p.getGeo())!=_geo_types.end())
-            throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 2 !");
-          std::size_t pos(std::distance(_geo_types.begin(),it));
-          const DataArrayInt *thisP(_pfls[pos]),*otherP(p.getPfl(globs));
-          MEDCouplingAutoRefCountObjectPtr<DataArray> ret(vals->selectByTupleId2(strtStop.first,strtStop.second,1));
-          if(!thisP && !otherP)
+          const DataArrayInt *thisP(_pfls[iii]);
+          std::vector<const MEDFileField1TSStructItem2 *> ps;
+          for(std::size_t i=0;i<sz;i++)
             {
-              arrSafe[i]=ret; arr[i]=ret;
-              continue;
-            }
-          int nbi(p.getNbOfIntegrationPts(globs)),nc(ret->getNumberOfComponents());
-          if(!thisP && otherP)
-            {
-              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->deepCpy());
-              p1->sort(true);
-              if(!p1->isIdentity() || p1->getNumberOfTuples()!=p.getNbEntity())
-                throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 3 !");
-              ret->rearrange(nbi*nc); ret->renumberInPlace(otherP->begin()); ret->rearrange(nc);
-              arrSafe[i]=ret; arr[i]=ret;
-              continue;
+              const MEDFileField1TSStructItem2& p(fst[i]);
+              if(p.getGeo()==*it)
+                ps.push_back(&p);
             }
-          if(thisP && otherP)
+          if(ps.empty())
+            throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 1 !");
+          if(ps.size()==1)
             {
-              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->deepCpy());
-              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(thisP->deepCpy());
-              p1->sort(true); p2->sort(true);
-              if(!p1->isEqualWithoutConsideringStr(*p2))
-                throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 4 !");
-              p1=DataArrayInt::FindPermutationFromFirstToSecond(otherP,thisP);
-              ret->rearrange(nbi*nc); ret->renumberInPlace(p1->begin()); ret->rearrange(nc);
-              continue;
+              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));
+              if(!thisP && !otherP)
+                {
+                  arrSafe[iii]=ret; arr[iii]=ret;
+                  continue;
+                }
+              if(thisP && otherP)
+                {
+                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->invertArrayN2O2O2N(getNumberOfCells(ps[0]->getGeo())));
+                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(thisP->deepCpy());
+                  p2->transformWithIndArr(p1->begin(),p1->end());
+                  //p1=p2->getIdsNotEqual(-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;
+                  continue;
+                }
+              if(!thisP && otherP)
+                {
+                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->deepCpy());
+                  p1->sort(true);
+                  p1->checkAllIdsInRange(0,getNumberOfCells(ps[0]->getGeo()));
+                  p1=DataArrayInt::FindPermutationFromFirstToSecond(otherP,p1);
+                  ret->rearrange(nbi*nc); ret->renumberInPlace(p1->begin()); ret->rearrange(nc); ret->setInfoOnComponents(compInfo);
+                  arrSafe[iii]=ret; arr[iii]=ret;
+                  continue;
+                }
+              throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 3 !");
             }
-          if(thisP && !otherP)
+          else
             {
-              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(thisP->deepCpy());
-              p1->sort(true);
-              if(!p1->isIdentity() || p1->getNumberOfTuples()!=p.getNbEntity())
-                throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 3 !");
-              ret->rearrange(nbi*nc); ret->renumberInPlaceR(otherP->begin()); ret->rearrange(nc);
-              arrSafe[i]=ret; arr[i]=ret;
+              std::vector< const DataArrayInt * >otherPS(ps.size());
+              std::vector< const DataArray * > arr2(ps.size());
+              std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > arr2Safe(ps.size());
+              std::vector< const DataArrayInt * > nbis(ps.size());
+              std::vector< MEDCouplingAutoRefCountObjectPtr<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));
+                  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;
+              if(thisP)
+                p1=DataArrayInt::FindPermutationFromFirstToSecond(otherP,thisP);
+              else
+                p1=otherP->deepCpy();
+              MEDCouplingAutoRefCountObjectPtr<DataArrayInt> zenbisN(zenbis->renumber(p1->begin()));
+              zenbisN->computeOffsets2();
+              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));
+                  //
+                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(otherPfl->deepCpy());
+                  p2->transformWithIndArr(otherPN->begin(),otherPN->end());
+                  p2->transformWithIndArr(p1->begin(),p1->end());
+                  MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idsN(p2->buildExplicitArrByRanges(zenbisN));
+                  arr3->setPartOfValuesBase3(ret2,idsN->begin(),idsN->end(),0,nc,1);
+                }
+              arrSafe[iii]=arr3; arr[iii]=arr3;
               continue;
             }
-          throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 6 !");
         }
       return DataArray::Aggregate(arr);
     }
@@ -308,7 +386,7 @@ MEDMeshMultiLev::MEDMeshMultiLev()
 {
 }
 
-MEDMeshMultiLev::MEDMeshMultiLev(const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):_geo_types(gts),_nb_entities(nbEntities)
+MEDMeshMultiLev::MEDMeshMultiLev(int nbNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):_geo_types(gts),_nb_entities(nbEntities),_nb_nodes(nbNodes)
 {
   std::size_t sz(_geo_types.size());
   if(sz!=pfls.size() || sz!=nbEntities.size())
@@ -322,13 +400,13 @@ MEDMeshMultiLev::MEDMeshMultiLev(const std::vector<INTERP_KERNEL::NormalizedCell
     }
 }
 
-MEDMeshMultiLev::MEDMeshMultiLev(const MEDMeshMultiLev& other):_pfls(other._pfls),_geo_types(other._geo_types),_nb_entities(other._nb_entities),_node_reduction(other._node_reduction)
+MEDMeshMultiLev::MEDMeshMultiLev(const MEDMeshMultiLev& other):_pfls(other._pfls),_geo_types(other._geo_types),_nb_entities(other._nb_entities),_node_reduction(other._node_reduction),_nb_nodes(other._nb_nodes)
 {
 }
 
 //=
 
-MEDUMeshMultiLev *MEDUMeshMultiLev::New(const MEDFileUMesh *m, const std::vector<int>& levs) throw(INTERP_KERNEL::Exception)
+MEDUMeshMultiLev *MEDUMeshMultiLev::New(const MEDFileUMesh *m, const std::vector<int>& levs)
 {
   return new MEDUMeshMultiLev(m,levs);
 }
@@ -359,12 +437,12 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<int>
     }
 }
 
-MEDUMeshMultiLev *MEDUMeshMultiLev::New(const MEDFileUMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities) throw(INTERP_KERNEL::Exception)
+MEDUMeshMultiLev *MEDUMeshMultiLev::New(const MEDFileUMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities)
 {
   return new MEDUMeshMultiLev(m,gts,pfls,nbEntities);
 }
 
-MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(gts,pfls,nbEntities)
+MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(m->getNumberOfNodes(),gts,pfls,nbEntities)
 {
   std::size_t sz(gts.size());
   _parts.resize(sz);
@@ -377,7 +455,7 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTE
     }
 }
 
-void MEDUMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes) throw(INTERP_KERNEL::Exception)
+void MEDUMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes)
 {
    if(!pflNodes || !pflNodes->isAllocated())
      return ;
@@ -396,7 +474,8 @@ void MEDUMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes) throw(INT
        MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIdsSafe(cellIds);
        MEDCouplingAutoRefCountObjectPtr<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
        int tmp=-1;
-       a[i]=m2->getNodeIdsInUse(tmp); aa[i]=a[i];
+       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
@@ -407,7 +486,7 @@ void MEDUMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes) throw(INT
    _node_reduction=_node_reduction->buildUnique();
 }
 
-MEDMeshMultiLev *MEDUMeshMultiLev::prepare() const throw(INTERP_KERNEL::Exception)
+MEDMeshMultiLev *MEDUMeshMultiLev::prepare() const
 {
   return new MEDUMeshMultiLev(*this);
 }
@@ -420,9 +499,12 @@ MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDStructuredMeshMultiLev& other, const
 {
   _parts.resize(1);
   _parts[0]=part;
+  _geo_types.resize(1); _geo_types[0]=part->getCellModelEnum();
+  _nb_entities.resize(1); _nb_entities[0]=part->getNumberOfCells();
+  _pfls.resize(1); _pfls[0]=0;
 }
 
-void MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *&types, DataArrayInt *&cellLocations, DataArrayInt *& cells, DataArrayInt *&faceLocations, DataArrayInt *&faces) const throw(INTERP_KERNEL::Exception)
+void MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *&types, DataArrayInt *&cellLocations, DataArrayInt *& cells, DataArrayInt *&faceLocations, DataArrayInt *&faces) const
 {
   if(_parts.empty())
     throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::getVTUArrays : empty array !");
@@ -520,7 +602,7 @@ void MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *
             {
               for(int i=0;i<curNbCells;i++,connIPtr++)
                 {
-                  std::set<int> s(connPtr+connIPtr[0],connPtr+connIPtr[1]);
+                  std::set<int> s(connPtr+connIPtr[0],connPtr+connIPtr[1]); s.erase(-1);
                   *dPtr++=(int)s.size();
                   dPtr=std::copy(s.begin(),s.end(),dPtr);
                   *cPtr=k+(int)s.size(); k=*cPtr++;
@@ -546,7 +628,7 @@ void MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *
                           fPtr=std::copy(work,work2,fPtr);
                           work=work2+1;
                         }
-                      *ePtr=kk; kk+=connIPtr[1]-connIPtr[0]+2;
+                      *ePtr++=kk; kk+=connIPtr[1]-connIPtr[0]+2;
                     }
                 }
             }
@@ -563,7 +645,7 @@ void MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *
     { faceLocations=e.retn(); faces=f.retn(); }
 }
 
-void MEDUMeshMultiLev::reorderNodesIfNecessary(MEDCouplingAutoRefCountObjectPtr<DataArrayDouble>& coords, DataArrayInt *nodalConnVTK, DataArrayInt *polyhedNodalConnVTK) const throw(INTERP_KERNEL::Exception)
+void MEDUMeshMultiLev::reorderNodesIfNecessary(MEDCouplingAutoRefCountObjectPtr<DataArrayDouble>& coords, DataArrayInt *nodalConnVTK, DataArrayInt *polyhedNodalConnVTK) const
 {
   const DataArrayInt *nr(_node_reduction);
   if(!nr)
@@ -644,11 +726,11 @@ MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev()
 {
 }
 
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(gts,pfls,nbEntities)
+MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(int nbOfNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(nbOfNodes,gts,pfls,nbEntities)
 {
 }
 
-void MEDStructuredMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes) throw(INTERP_KERNEL::Exception)
+void MEDStructuredMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes)
 {
   if(!pflNodes || !pflNodes->isAllocated())
     return ;
@@ -679,12 +761,12 @@ MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDStructuredMeshMult
 
 //=
 
-MEDCMeshMultiLev *MEDCMeshMultiLev::New(const MEDFileCMesh *m, const std::vector<int>& levs) throw(INTERP_KERNEL::Exception)
+MEDCMeshMultiLev *MEDCMeshMultiLev::New(const MEDFileCMesh *m, const std::vector<int>& levs)
 {
   return new MEDCMeshMultiLev(m,levs);
 }
 
-MEDCMeshMultiLev *MEDCMeshMultiLev::New(const MEDFileCMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities) throw(INTERP_KERNEL::Exception)
+MEDCMeshMultiLev *MEDCMeshMultiLev::New(const MEDFileCMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities)
 {
   return new MEDCMeshMultiLev(m,gts,pfls,nbEntities);
 }
@@ -706,7 +788,7 @@ MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDFileCMesh *m, const std::vector<int>
     }
 }
 
-MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDFileCMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDStructuredMeshMultiLev(gts,pfls,nbEntities)
+MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDFileCMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDStructuredMeshMultiLev(m->getNumberOfNodes(),gts,pfls,nbEntities)
 {
   if(!m)
     throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : null input pointer !");
@@ -722,15 +804,15 @@ MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDFileCMesh *m, const std::vector<INTE
       DataArrayDouble *elt(const_cast<DataArrayDouble *>(m->getMesh()->getCoordsAt(i)));
       if(!elt)
         throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : presence of null pointer for an vector of double along an axis !");
-      _coords[i]=elt;
+      _coords[i]=elt; _coords[i]->incrRef();
     }
 }
 
-MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDCMeshMultiLev& other):MEDStructuredMeshMultiLev(other)
+MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDCMeshMultiLev& other):MEDStructuredMeshMultiLev(other),_coords(other._coords)
 {
 }
 
-std::vector<int> MEDCMeshMultiLev::getNodeGridStructure() const throw(INTERP_KERNEL::Exception)
+std::vector<int> MEDCMeshMultiLev::getNodeGridStructure() const
 {
   std::vector<int> ret(_coords.size());
   for(std::size_t i=0;i<_coords.size();i++)
@@ -738,7 +820,7 @@ std::vector<int> MEDCMeshMultiLev::getNodeGridStructure() const throw(INTERP_KER
   return ret;
 }
 
-MEDMeshMultiLev *MEDCMeshMultiLev::prepare() const throw(INTERP_KERNEL::Exception)
+MEDMeshMultiLev *MEDCMeshMultiLev::prepare() const
 {
   const DataArrayInt *pfl(_pfls[0]),*nr(_node_reduction);
   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nnr;
@@ -783,7 +865,7 @@ MEDMeshMultiLev *MEDCMeshMultiLev::prepare() const throw(INTERP_KERNEL::Exceptio
     }
 }
 
-std::vector< DataArrayDouble * > MEDCMeshMultiLev::buildVTUArrays() const throw(INTERP_KERNEL::Exception)
+std::vector< DataArrayDouble * > MEDCMeshMultiLev::buildVTUArrays() const
 {
   std::size_t sz(_coords.size());
   std::vector< DataArrayDouble * > ret(sz);
@@ -797,12 +879,12 @@ std::vector< DataArrayDouble * > MEDCMeshMultiLev::buildVTUArrays() const throw(
 
 //=
 
-MEDCurveLinearMeshMultiLev *MEDCurveLinearMeshMultiLev::New(const MEDFileCurveLinearMesh *m, const std::vector<int>& levs) throw(INTERP_KERNEL::Exception)
+MEDCurveLinearMeshMultiLev *MEDCurveLinearMeshMultiLev::New(const MEDFileCurveLinearMesh *m, const std::vector<int>& levs)
 {
   return new MEDCurveLinearMeshMultiLev(m,levs);
 }
 
-MEDCurveLinearMeshMultiLev *MEDCurveLinearMeshMultiLev::New(const MEDFileCurveLinearMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities) throw(INTERP_KERNEL::Exception)
+MEDCurveLinearMeshMultiLev *MEDCurveLinearMeshMultiLev::New(const MEDFileCurveLinearMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities)
 {
   return new MEDCurveLinearMeshMultiLev(m,gts,pfls,nbEntities);
 }
@@ -821,7 +903,7 @@ MEDCurveLinearMeshMultiLev::MEDCurveLinearMeshMultiLev(const MEDFileCurveLinearM
   _structure=m->getMesh()->getNodeGridStructure();
 }
 
-MEDCurveLinearMeshMultiLev::MEDCurveLinearMeshMultiLev(const MEDFileCurveLinearMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDStructuredMeshMultiLev(gts,pfls,nbEntities)
+MEDCurveLinearMeshMultiLev::MEDCurveLinearMeshMultiLev(const MEDFileCurveLinearMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDStructuredMeshMultiLev(m->getNumberOfNodes(),gts,pfls,nbEntities)
 {
   if(!m)
     throw INTERP_KERNEL::Exception("MEDCurveLinearMeshMultiLev constructor 2 : null input pointer !");
@@ -842,12 +924,12 @@ MEDCurveLinearMeshMultiLev::MEDCurveLinearMeshMultiLev(const MEDCurveLinearMeshM
 {
 }
 
-std::vector<int> MEDCurveLinearMeshMultiLev::getNodeGridStructure() const throw(INTERP_KERNEL::Exception)
+std::vector<int> MEDCurveLinearMeshMultiLev::getNodeGridStructure() const
 {
   return _structure;
 }
 
-MEDMeshMultiLev *MEDCurveLinearMeshMultiLev::prepare() const throw(INTERP_KERNEL::Exception)
+MEDMeshMultiLev *MEDCurveLinearMeshMultiLev::prepare() const
 {
   const DataArrayInt *pfl(_pfls[0]),*nr(_node_reduction);
   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nnr;
@@ -897,7 +979,7 @@ MEDMeshMultiLev *MEDCurveLinearMeshMultiLev::prepare() const throw(INTERP_KERNEL
     }
 }
 
-void MEDCurveLinearMeshMultiLev::buildVTUArrays(DataArrayDouble *&coords, std::vector<int>& nodeStrct) const throw(INTERP_KERNEL::Exception)
+void MEDCurveLinearMeshMultiLev::buildVTUArrays(DataArrayDouble *&coords, std::vector<int>& nodeStrct) const
 {
   nodeStrct=_structure;
   const DataArrayDouble *coo(_coords);
@@ -917,20 +999,20 @@ MEDFileField1TSStructItem2::MEDFileField1TSStructItem2(INTERP_KERNEL::Normalized
   _pfl->setName(c.c_str());
 }
 
-void MEDFileField1TSStructItem2::checkWithMeshStructForCells(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) throw(INTERP_KERNEL::Exception)
+void MEDFileField1TSStructItem2::checkWithMeshStructForCells(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs)
 {
   int nbOfEnt=mst->getNumberOfElemsOfGeoType(_geo_type);
   checkInRange(nbOfEnt,1,globs);
 }
 
-void MEDFileField1TSStructItem2::checkWithMeshStructForGaussNE(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) throw(INTERP_KERNEL::Exception)
+void MEDFileField1TSStructItem2::checkWithMeshStructForGaussNE(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs)
 {
   int nbOfEnt=mst->getNumberOfElemsOfGeoType(_geo_type);
   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
   checkInRange(nbOfEnt,(int)cm.getNumberOfNodes(),globs);
 }
 
-void MEDFileField1TSStructItem2::checkWithMeshStructForGaussPT(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) throw(INTERP_KERNEL::Exception)
+void MEDFileField1TSStructItem2::checkWithMeshStructForGaussPT(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs)
 {
   if(!globs)
     throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::checkWithMeshStructForGaussPT : no globals specified !");
@@ -979,7 +1061,7 @@ const DataArrayInt *MEDFileField1TSStructItem2::getPfl(const MEDFileFieldGlobsRe
  * \param [in] nbOfEntity - number of entity that can be either cells or nodes. Not other possiblity.
  * \param [in] nip - number of integration points. 1 for ON_CELLS and NO_NODES
  */
-void MEDFileField1TSStructItem2::checkInRange(int nbOfEntity, int nip, const MEDFileFieldGlobsReal *globs) throw(INTERP_KERNEL::Exception)
+void MEDFileField1TSStructItem2::checkInRange(int nbOfEntity, int nip, const MEDFileFieldGlobsReal *globs)
 {
   _nb_of_entity=nbOfEntity;
   if(_pfl->getName().empty())
@@ -1018,7 +1100,7 @@ bool MEDFileField1TSStructItem2::operator==(const MEDFileField1TSStructItem2& ot
   return _geo_type==other._geo_type && _start_end==other._start_end && _pfl->getName()==other._pfl->getName();
 }
 
-bool MEDFileField1TSStructItem2::isCellSupportEqual(const MEDFileField1TSStructItem2& other, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem2::isCellSupportEqual(const MEDFileField1TSStructItem2& other, const MEDFileFieldGlobsReal *globs) const
 {
   if(_geo_type!=other._geo_type)
     return false;
@@ -1032,7 +1114,7 @@ bool MEDFileField1TSStructItem2::isCellSupportEqual(const MEDFileField1TSStructI
   return pfl1->isEqualWithoutConsideringStr(*pfl2);
 }
 
-bool MEDFileField1TSStructItem2::isNodeSupportEqual(const MEDFileField1TSStructItem2& other, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem2::isNodeSupportEqual(const MEDFileField1TSStructItem2& other, const MEDFileFieldGlobsReal *globs) const
 {
   return isCellSupportEqual(other,globs);
 }
@@ -1040,7 +1122,7 @@ bool MEDFileField1TSStructItem2::isNodeSupportEqual(const MEDFileField1TSStructI
 /*!
  * \a objs must be non empty. \a objs should contain items having same geometric type.
  */
-MEDFileField1TSStructItem2 MEDFileField1TSStructItem2::BuildAggregationOf(const std::vector<const MEDFileField1TSStructItem2 *>& objs, const MEDFileFieldGlobsReal *globs) throw(INTERP_KERNEL::Exception)
+MEDFileField1TSStructItem2 MEDFileField1TSStructItem2::BuildAggregationOf(const std::vector<const MEDFileField1TSStructItem2 *>& objs, const MEDFileFieldGlobsReal *globs)
 {
   if(objs.empty())
     throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::BuildAggregationOf : empty input !");
@@ -1087,13 +1169,18 @@ MEDFileField1TSStructItem2 MEDFileField1TSStructItem2::BuildAggregationOf(const
     }
 }
 
-std::size_t MEDFileField1TSStructItem2::getHeapMemorySize() const
+std::size_t MEDFileField1TSStructItem2::getHeapMemorySizeWithoutChildren() const
 {
-  std::size_t ret(0);
+  std::size_t ret(_loc.capacity());
+  return ret;
+}
+
+std::vector<const BigMemoryObject *> MEDFileField1TSStructItem2::getDirectChildren() const
+{
+  std::vector<const BigMemoryObject *> ret;
   const DataArrayInt *pfl(_pfl);
   if(pfl)
-    ret+=pfl->getHeapMemorySize();
-  ret+=_loc.capacity();
+    ret.push_back(pfl);
   return ret;
 }
 
@@ -1103,7 +1190,7 @@ MEDFileField1TSStructItem::MEDFileField1TSStructItem(TypeOfField a, const std::v
 {
 }
 
-void MEDFileField1TSStructItem::checkWithMeshStruct(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) throw(INTERP_KERNEL::Exception)
+void MEDFileField1TSStructItem::checkWithMeshStruct(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs)
 {
   switch(_type)
     {
@@ -1150,7 +1237,7 @@ bool MEDFileField1TSStructItem::operator==(const MEDFileField1TSStructItem& othe
   return true;
 }
 
-bool MEDFileField1TSStructItem::isCellSupportEqual(const MEDFileField1TSStructItem& other, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem::isCellSupportEqual(const MEDFileField1TSStructItem& other, const MEDFileFieldGlobsReal *globs) const
 {
   if(_type!=other._type)
     return false;
@@ -1162,7 +1249,7 @@ bool MEDFileField1TSStructItem::isCellSupportEqual(const MEDFileField1TSStructIt
   return true;
 }
 
-bool MEDFileField1TSStructItem::isNodeSupportEqual(const MEDFileField1TSStructItem& other, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem::isNodeSupportEqual(const MEDFileField1TSStructItem& other, const MEDFileFieldGlobsReal *globs) const
 {
   if(_type!=other._type)
     return false;
@@ -1191,7 +1278,7 @@ private:
   INTERP_KERNEL::NormalizedCellType _geo_type;
 };
 
-MEDFileField1TSStructItem MEDFileField1TSStructItem::simplifyMeOnCellEntity(const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+MEDFileField1TSStructItem MEDFileField1TSStructItem::simplifyMeOnCellEntity(const MEDFileFieldGlobsReal *globs) const
 {
   if(!isEntityCell())
     throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::simplifyMeOnCellEntity : must be on ON_CELLS, ON_GAUSS_NE or ON_GAUSS_PT !");
@@ -1229,7 +1316,7 @@ MEDFileField1TSStructItem MEDFileField1TSStructItem::simplifyMeOnCellEntity(cons
 /*!
  * \a this is expected to be ON_CELLS and simplified.
  */
-bool MEDFileField1TSStructItem::isCompatibleWithNodesDiscr(const MEDFileField1TSStructItem& other, const MEDFileMeshStruct *meshSt, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem::isCompatibleWithNodesDiscr(const MEDFileField1TSStructItem& other, const MEDFileMeshStruct *meshSt, const MEDFileFieldGlobsReal *globs) const
 {
   if(other._type!=ON_NODES)
     throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::isCompatibleWithNodesDiscr : other must be on nodes !");
@@ -1262,7 +1349,7 @@ bool MEDFileField1TSStructItem::isCompatibleWithNodesDiscr(const MEDFileField1TS
     }
 }
 
-bool MEDFileField1TSStructItem::isFullyOnOneLev(const MEDFileMeshStruct *meshSt, int& theFirstLevFull) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem::isFullyOnOneLev(const MEDFileMeshStruct *meshSt, int& theFirstLevFull) const
 {
   if(_type!=ON_CELLS)
     throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::isFullyOnOneLev : works only for ON_CELLS discretization !");
@@ -1299,16 +1386,21 @@ const MEDFileField1TSStructItem2& MEDFileField1TSStructItem::operator[](std::siz
   return _items[i];
 }
 
-std::size_t MEDFileField1TSStructItem::getHeapMemorySize() const
+std::size_t MEDFileField1TSStructItem::getHeapMemorySizeWithoutChildren() const
 {
-  std::size_t ret(0);
+  std::size_t ret(_items.size()*sizeof(MEDFileField1TSStructItem2));
+  return ret;
+}
+
+std::vector<const BigMemoryObject *> MEDFileField1TSStructItem::getDirectChildren() const
+{
+  std::vector<const BigMemoryObject *> ret;
   for(std::vector< MEDFileField1TSStructItem2 >::const_iterator it=_items.begin();it!=_items.end();it++)
-    ret+=(*it).getHeapMemorySize();
-  ret+=_items.size()*sizeof(MEDFileField1TSStructItem2);
+    ret.push_back(&(*it));
   return ret;
 }
 
-MEDMeshMultiLev *MEDFileField1TSStructItem::buildFromScratchDataSetSupportOnCells(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+MEDMeshMultiLev *MEDFileField1TSStructItem::buildFromScratchDataSetSupportOnCells(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) const
 {
   std::size_t sz(_items.size());
   std::vector<INTERP_KERNEL::NormalizedCellType> a0(sz);
@@ -1362,7 +1454,7 @@ MEDFileField1TSStructItem MEDFileField1TSStructItem::BuildItemFrom(const MEDFile
 
 //=
 
-MEDFileField1TSStruct *MEDFileField1TSStruct::New(const MEDFileAnyTypeField1TS *ref, MEDFileMeshStruct *mst) throw(INTERP_KERNEL::Exception)
+MEDFileField1TSStruct *MEDFileField1TSStruct::New(const MEDFileAnyTypeField1TS *ref, MEDFileMeshStruct *mst)
 {
   return new MEDFileField1TSStruct(ref,mst);
 }
@@ -1372,14 +1464,14 @@ MEDFileField1TSStruct::MEDFileField1TSStruct(const MEDFileAnyTypeField1TS *ref,
   _already_checked.push_back(MEDFileField1TSStructItem::BuildItemFrom(ref,mst));
 }
 
-void MEDFileField1TSStruct::checkWithMeshStruct(MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) throw(INTERP_KERNEL::Exception)
+void MEDFileField1TSStruct::checkWithMeshStruct(MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs)
 {
   if(_already_checked.empty())
     throw INTERP_KERNEL::Exception("MEDFileField1TSStruct::checkWithMeshStruct : not correctly initialized !");
   _already_checked.back().checkWithMeshStruct(mst,globs);
 }
 
-bool MEDFileField1TSStruct::isEqualConsideringThePast(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *mst) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStruct::isEqualConsideringThePast(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *mst) const
 {
   MEDFileField1TSStructItem b(MEDFileField1TSStructItem::BuildItemFrom(other,mst));
   for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++)
@@ -1393,7 +1485,7 @@ bool MEDFileField1TSStruct::isEqualConsideringThePast(const MEDFileAnyTypeField1
 /*!
  * Not const because \a other structure will be added to the \c _already_checked attribute in case of success.
  */
-bool MEDFileField1TSStruct::isSupportSameAs(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *meshSt) throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStruct::isSupportSameAs(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *meshSt)
 {
   if(_already_checked.empty())
     throw INTERP_KERNEL::Exception("MEDFileField1TSStruct::isSupportSameAs : no ref !");
@@ -1423,7 +1515,7 @@ bool MEDFileField1TSStruct::isSupportSameAs(const MEDFileAnyTypeField1TS *other,
 /*!
  * \param [in] other - a field with only one spatial discretization : ON_NODES.
  */
-bool MEDFileField1TSStruct::isCompatibleWithNodesDiscr(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *meshSt) throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStruct::isCompatibleWithNodesDiscr(const MEDFileAnyTypeField1TS *other, const MEDFileMeshStruct *meshSt)
 {
   if(_already_checked.empty())
     throw INTERP_KERNEL::Exception("MEDFileField1TSStruct::isCompatibleWithNodesDiscr : no ref !");
@@ -1452,16 +1544,21 @@ bool MEDFileField1TSStruct::isCompatibleWithNodesDiscr(const MEDFileAnyTypeField
     return _already_checked[0].isNodeSupportEqual(other1,other);
 }
 
-std::size_t MEDFileField1TSStruct::getHeapMemorySize() const
+std::size_t MEDFileField1TSStruct::getHeapMemorySizeWithoutChildren() const
 {
-  std::size_t ret(0);
+  std::size_t ret(_already_checked.capacity()*sizeof(MEDFileField1TSStructItem));
+  return ret;
+}
+
+std::vector<const BigMemoryObject *> MEDFileField1TSStruct::getDirectChildren() const
+{
+  std::vector<const BigMemoryObject *> ret;
   for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++)
-    ret+=(*it).getHeapMemorySize();
-  ret+=_already_checked.capacity()*sizeof(MEDFileField1TSStructItem);
+    ret.push_back(&(*it));
   return ret;
 }
 
-MEDMeshMultiLev *MEDFileField1TSStruct::buildFromScratchDataSetSupport(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+MEDMeshMultiLev *MEDFileField1TSStruct::buildFromScratchDataSetSupport(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs) const
 {
   if(_already_checked.empty())
     throw INTERP_KERNEL::Exception("MEDFileField1TSStruct::buildFromScratchDataSetSupport : No outline structure in this !");
@@ -1485,7 +1582,7 @@ MEDMeshMultiLev *MEDFileField1TSStruct::buildFromScratchDataSetSupport(const MED
     }
 }
 
-bool MEDFileField1TSStruct::isDataSetSupportFastlyEqualTo(const MEDFileField1TSStruct& other, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStruct::isDataSetSupportFastlyEqualTo(const MEDFileField1TSStruct& other, const MEDFileFieldGlobsReal *globs) const
 {
   int b0,b1;
   bool a0(presenceOfCellDiscr(b0)),a1(presenceOfPartialNodeDiscr(b1));
@@ -1506,7 +1603,7 @@ bool MEDFileField1TSStruct::isDataSetSupportFastlyEqualTo(const MEDFileField1TSS
  * Returns true if presence in \a this of discretization ON_CELLS, ON_GAUSS_PT, ON_GAUSS_NE.
  * If true is returned the pos of the easiest is returned. The easiest is the first element in \a this having the less splitted subparts.
  */
-bool MEDFileField1TSStruct::presenceOfCellDiscr(int& pos) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStruct::presenceOfCellDiscr(int& pos) const
 {
   std::size_t refSz(std::numeric_limits<std::size_t>::max());
   bool ret(false);
@@ -1530,7 +1627,7 @@ bool MEDFileField1TSStruct::presenceOfCellDiscr(int& pos) const throw(INTERP_KER
  * Returns true if presence in \a this of discretization ON_NODES.
  * If true is returned the pos of the first element containing the single subpart.
  */
-bool MEDFileField1TSStruct::presenceOfPartialNodeDiscr(int& pos) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStruct::presenceOfPartialNodeDiscr(int& pos) const
 {
   int i(0);
   for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++,i++)
@@ -1552,7 +1649,7 @@ bool MEDFileField1TSStruct::presenceOfPartialNodeDiscr(int& pos) const throw(INT
 
 //=
 
-MEDFileFastCellSupportComparator *MEDFileFastCellSupportComparator::New(const MEDFileMeshStruct *m, const MEDFileAnyTypeFieldMultiTS *ref) throw(INTERP_KERNEL::Exception)
+MEDFileFastCellSupportComparator *MEDFileFastCellSupportComparator::New(const MEDFileMeshStruct *m, const MEDFileAnyTypeFieldMultiTS *ref)
 {
   return new MEDFileFastCellSupportComparator(m,ref);
 }
@@ -1572,23 +1669,28 @@ MEDFileFastCellSupportComparator::MEDFileFastCellSupportComparator(const MEDFile
     }
 }
 
-std::size_t MEDFileFastCellSupportComparator::getHeapMemorySize() const
+std::size_t MEDFileFastCellSupportComparator::getHeapMemorySizeWithoutChildren() const
 {
-  std::size_t ret(0);
+  std::size_t ret(_f1ts_cmps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSStruct>));
+  return ret;
+}
+
+std::vector<const BigMemoryObject *> MEDFileFastCellSupportComparator::getDirectChildren() const
+{
+  std::vector<const BigMemoryObject *> ret;
   const MEDFileMeshStruct *mst(_mesh_comp);
   if(mst)
-    ret+=mst->getHeapMemorySize();
+    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+=cur->getHeapMemorySize()+sizeof(MEDFileField1TSStruct);
+        ret.push_back(cur);
     }
-  ret+=_f1ts_cmps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSStruct>);
   return ret;
 }
 
-bool MEDFileFastCellSupportComparator::isEqual(const MEDFileAnyTypeFieldMultiTS *other) throw(INTERP_KERNEL::Exception)
+bool MEDFileFastCellSupportComparator::isEqual(const MEDFileAnyTypeFieldMultiTS *other)
 {
   int nbPts=other->getNumberOfTS();
   if(nbPts!=(int)_f1ts_cmps.size())
@@ -1606,7 +1708,7 @@ bool MEDFileFastCellSupportComparator::isEqual(const MEDFileAnyTypeFieldMultiTS
   return true;
 }
 
-bool MEDFileFastCellSupportComparator::isCompatibleWithNodesDiscr(const MEDFileAnyTypeFieldMultiTS *other) throw(INTERP_KERNEL::Exception)
+bool MEDFileFastCellSupportComparator::isCompatibleWithNodesDiscr(const MEDFileAnyTypeFieldMultiTS *other)
 {
   int nbPts=other->getNumberOfTS();
   if(nbPts!=(int)_f1ts_cmps.size())
@@ -1623,7 +1725,7 @@ bool MEDFileFastCellSupportComparator::isCompatibleWithNodesDiscr(const MEDFileA
   return true;
 }
 
-MEDMeshMultiLev *MEDFileFastCellSupportComparator::buildFromScratchDataSetSupport(int timeStepId, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+MEDMeshMultiLev *MEDFileFastCellSupportComparator::buildFromScratchDataSetSupport(int timeStepId, const MEDFileFieldGlobsReal *globs) const
 {
   if(timeStepId<0 || timeStepId>=(int)_f1ts_cmps.size())
     {
@@ -1639,7 +1741,7 @@ MEDMeshMultiLev *MEDFileFastCellSupportComparator::buildFromScratchDataSetSuppor
   return obj->buildFromScratchDataSetSupport(_mesh_comp,globs);
 }
 
-bool MEDFileFastCellSupportComparator::isDataSetSupportEqualToThePreviousOne(int timeStepId, const MEDFileFieldGlobsReal *globs) const throw(INTERP_KERNEL::Exception)
+bool MEDFileFastCellSupportComparator::isDataSetSupportEqualToThePreviousOne(int timeStepId, const MEDFileFieldGlobsReal *globs) const
 {
   if(timeStepId<=0 || timeStepId>=(int)_f1ts_cmps.size())
     {