]> SALOME platform Git repositories - tools/medcoupling.git/blob - src/MEDCoupling/MEDCouplingUMesh.cxx
Salome HOME
Minor bug fix : convertDegeneratedCellsAndRemoveFlatOnes()
[tools/medcoupling.git] / src / MEDCoupling / MEDCouplingUMesh.cxx
1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Anthony Geay (EDF R&D)
20
21 #include "MEDCouplingUMesh.txx"
22 #include "MEDCouplingCMesh.hxx"
23 #include "MEDCoupling1GTUMesh.hxx"
24 #include "MEDCouplingFieldDouble.hxx"
25 #include "MEDCouplingSkyLineArray.hxx"
26 #include "CellModel.hxx"
27 #include "VolSurfUser.txx"
28 #include "InterpolationUtils.hxx"
29 #include "PointLocatorAlgos.txx"
30 #include "BBTree.txx"
31 #include "BBTreeDst.txx"
32 #include "SplitterTetra.hxx"
33 #include "DiameterCalculator.hxx"
34 #include "DirectedBoundingBox.hxx"
35 #include "InterpKernelMatrixTools.hxx"
36 #include "InterpKernelMeshQuality.hxx"
37 #include "InterpKernelCellSimplify.hxx"
38 #include "InterpKernelGeo2DEdgeArcCircle.hxx"
39 #include "InterpKernelAutoPtr.hxx"
40 #include "InterpKernelGeo2DNode.hxx"
41 #include "InterpKernelGeo2DEdgeLin.hxx"
42 #include "InterpKernelGeo2DEdgeArcCircle.hxx"
43 #include "InterpKernelGeo2DQuadraticPolygon.hxx"
44 #include "OrientationInverter.hxx"
45 #include "MEDCouplingUMesh_internal.hxx"
46
47 #include <sstream>
48 #include <fstream>
49 #include <numeric>
50 #include <cstring>
51 #include <limits>
52 #include <list>
53
54 using namespace MEDCoupling;
55
56 double MEDCouplingUMesh::EPS_FOR_POLYH_ORIENTATION=1.e-14;
57
58 /// @cond INTERNAL
59 const INTERP_KERNEL::NormalizedCellType MEDCouplingUMesh::MEDMEM_ORDER[N_MEDMEM_ORDER] = { INTERP_KERNEL::NORM_POINT1, INTERP_KERNEL::NORM_SEG2, INTERP_KERNEL::NORM_SEG3, INTERP_KERNEL::NORM_SEG4, INTERP_KERNEL::NORM_POLYL, INTERP_KERNEL::NORM_TRI3, INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_TRI6, INTERP_KERNEL::NORM_TRI7, INTERP_KERNEL::NORM_QUAD8, INTERP_KERNEL::NORM_QUAD9, INTERP_KERNEL::NORM_POLYGON, INTERP_KERNEL::NORM_QPOLYG, INTERP_KERNEL::NORM_TETRA4, INTERP_KERNEL::NORM_PYRA5, INTERP_KERNEL::NORM_PENTA6, INTERP_KERNEL::NORM_HEXA8, INTERP_KERNEL::NORM_HEXGP12, INTERP_KERNEL::NORM_TETRA10, INTERP_KERNEL::NORM_PYRA13, INTERP_KERNEL::NORM_PENTA15, INTERP_KERNEL::NORM_PENTA18, INTERP_KERNEL::NORM_HEXA20, INTERP_KERNEL::NORM_HEXA27, INTERP_KERNEL::NORM_POLYHED };
60 const int MEDCouplingUMesh::MEDCOUPLING2VTKTYPETRADUCER[INTERP_KERNEL::NORM_MAXTYPE+1]={1,3,21,5,9,7,22,34,23,28,-1,-1,-1,-1,10,14,13,-1,12,-1,24,-1,16,27,-1,26,-1,29,32,-1,25,42,36,4};
61 /// @endcond
62
63 MEDCouplingUMesh *MEDCouplingUMesh::New()
64 {
65   return new MEDCouplingUMesh;
66 }
67
68 MEDCouplingUMesh *MEDCouplingUMesh::New(const std::string& meshName, int meshDim)
69 {
70   MEDCouplingUMesh *ret=new MEDCouplingUMesh;
71   ret->setName(meshName);
72   ret->setMeshDimension(meshDim);
73   return ret;
74 }
75
76 /*!
77  * Returns a new MEDCouplingUMesh which is a full copy of \a this one. No data is shared
78  * between \a this and the new mesh.
79  *  \return MEDCouplingUMesh * - a new instance of MEDCouplingMesh. The caller is to
80  *          delete this mesh using decrRef() as it is no more needed. 
81  */
82 MEDCouplingUMesh *MEDCouplingUMesh::deepCopy() const
83 {
84   return clone(true);
85 }
86
87
88 /*!
89  * Returns a new MEDCouplingUMesh which is a copy of \a this one.
90  *  \param [in] recDeepCpy - if \a true, the copy is deep, else all data arrays of \a
91  * this mesh are shared by the new mesh.
92  *  \return MEDCouplingUMesh * - a new instance of MEDCouplingMesh. The caller is to
93  *          delete this mesh using decrRef() as it is no more needed. 
94  */
95 MEDCouplingUMesh *MEDCouplingUMesh::clone(bool recDeepCpy) const
96 {
97   return new MEDCouplingUMesh(*this,recDeepCpy);
98 }
99
100 /*!
101  * This method behaves mostly like MEDCouplingUMesh::deepCopy method, except that only nodal connectivity arrays are deeply copied.
102  * The coordinates are shared between \a this and the returned instance.
103  * 
104  * \return MEDCouplingUMesh * - A new object instance holding the copy of \a this (deep for connectivity, shallow for coordiantes)
105  * \sa MEDCouplingUMesh::deepCopy
106  */
107 MEDCouplingUMesh *MEDCouplingUMesh::deepCopyConnectivityOnly() const
108 {
109   checkConnectivityFullyDefined();
110   MCAuto<MEDCouplingUMesh> ret=clone(false);
111   MCAuto<DataArrayInt> c(getNodalConnectivity()->deepCopy()),ci(getNodalConnectivityIndex()->deepCopy());
112   ret->setConnectivity(c,ci);
113   return ret.retn();
114 }
115
116 void MEDCouplingUMesh::shallowCopyConnectivityFrom(const MEDCouplingPointSet *other)
117 {
118   if(!other)
119     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::shallowCopyConnectivityFrom : input pointer is null !");
120   const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
121   if(!otherC)
122     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::shallowCopyConnectivityFrom : input pointer is not an MEDCouplingUMesh instance !");
123   MEDCouplingUMesh *otherC2=const_cast<MEDCouplingUMesh *>(otherC);//sorry :(
124   setConnectivity(otherC2->getNodalConnectivity(),otherC2->getNodalConnectivityIndex(),true);
125 }
126
127 std::size_t MEDCouplingUMesh::getHeapMemorySizeWithoutChildren() const
128 {
129   std::size_t ret(MEDCouplingPointSet::getHeapMemorySizeWithoutChildren());
130   return ret;
131 }
132
133 std::vector<const BigMemoryObject *> MEDCouplingUMesh::getDirectChildrenWithNull() const
134 {
135   std::vector<const BigMemoryObject *> ret(MEDCouplingPointSet::getDirectChildrenWithNull());
136   ret.push_back(_nodal_connec);
137   ret.push_back(_nodal_connec_index);
138   return ret;
139 }
140
141 void MEDCouplingUMesh::updateTime() const
142 {
143   MEDCouplingPointSet::updateTime();
144   if(_nodal_connec)
145     {
146       updateTimeWith(*_nodal_connec);
147     }
148   if(_nodal_connec_index)
149     {
150       updateTimeWith(*_nodal_connec_index);
151     }
152 }
153
154 MEDCouplingUMesh::MEDCouplingUMesh():_mesh_dim(-2),_nodal_connec(0),_nodal_connec_index(0)
155 {
156 }
157
158 /*!
159  * Checks if \a this mesh is well defined. If no exception is thrown by this method,
160  * then \a this mesh is most probably is writable, exchangeable and available for most
161  * of algorithms. When a mesh is constructed from scratch, it is a good habit to call
162  * this method to check that all is in order with \a this mesh.
163  *  \throw If the mesh dimension is not set.
164  *  \throw If the coordinates array is not set (if mesh dimension != -1 ).
165  *  \throw If \a this mesh contains elements of dimension different from the mesh dimension.
166  *  \throw If the connectivity data array has more than one component.
167  *  \throw If the connectivity data array has a named component.
168  *  \throw If the connectivity index data array has more than one component.
169  *  \throw If the connectivity index data array has a named component.
170  */
171 void MEDCouplingUMesh::checkConsistencyLight() const
172 {
173   if(_mesh_dim<-1)
174     throw INTERP_KERNEL::Exception("No mesh dimension specified !");
175   if(_mesh_dim!=-1)
176     MEDCouplingPointSet::checkConsistencyLight();
177   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
178     {
179       if((int)INTERP_KERNEL::CellModel::GetCellModel(*iter).getDimension()!=_mesh_dim)
180         {
181           std::ostringstream message;
182           message << "Mesh invalid because dimension is " << _mesh_dim << " and there is presence of cell(s) with type " << (*iter);
183           throw INTERP_KERNEL::Exception(message.str().c_str());
184         }
185     }
186   if(_nodal_connec)
187     {
188       if(_nodal_connec->getNumberOfComponents()!=1)
189         throw INTERP_KERNEL::Exception("Nodal connectivity array is expected to be with number of components set to one !");
190       if(_nodal_connec->getInfoOnComponent(0)!="")
191         throw INTERP_KERNEL::Exception("Nodal connectivity array is expected to have no info on its single component !");
192     }
193   else
194     if(_mesh_dim!=-1)
195       throw INTERP_KERNEL::Exception("Nodal connectivity array is not defined !");
196   if(_nodal_connec_index)
197     {
198       if(_nodal_connec_index->getNumberOfComponents()!=1)
199         throw INTERP_KERNEL::Exception("Nodal connectivity index array is expected to be with number of components set to one !");
200       if(_nodal_connec_index->getInfoOnComponent(0)!="")
201         throw INTERP_KERNEL::Exception("Nodal connectivity index array is expected to have no info on its single component !");
202     }
203   else
204     if(_mesh_dim!=-1)
205       throw INTERP_KERNEL::Exception("Nodal connectivity index array is not defined !");
206 }
207
208 /*!
209  * Checks if \a this mesh is well defined. If no exception is thrown by this method,
210  * then \a this mesh is most probably is writable, exchangeable and available for all
211  * algorithms. <br> In addition to the checks performed by checkConsistencyLight(), this
212  * method thoroughly checks the nodal connectivity.
213  *  \param [in] eps - a not used parameter.
214  *  \throw If the mesh dimension is not set.
215  *  \throw If the coordinates array is not set (if mesh dimension != -1 ).
216  *  \throw If \a this mesh contains elements of dimension different from the mesh dimension.
217  *  \throw If the connectivity data array has more than one component.
218  *  \throw If the connectivity data array has a named component.
219  *  \throw If the connectivity index data array has more than one component.
220  *  \throw If the connectivity index data array has a named component.
221  *  \throw If number of nodes defining an element does not correspond to the type of element.
222  *  \throw If the nodal connectivity includes an invalid node id.
223  */
224 void MEDCouplingUMesh::checkConsistency(double eps) const
225 {
226   checkConsistencyLight();
227   if(_mesh_dim==-1)
228     return ;
229   int meshDim=getMeshDimension();
230   int nbOfNodes=getNumberOfNodes();
231   int nbOfCells=getNumberOfCells();
232   const int *ptr=_nodal_connec->getConstPointer();
233   const int *ptrI=_nodal_connec_index->getConstPointer();
234   for(int i=0;i<nbOfCells;i++)
235     {
236       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)ptr[ptrI[i]]);
237       if((int)cm.getDimension()!=meshDim)
238         {
239           std::ostringstream oss;
240           oss << "MEDCouplingUMesh::checkConsistency : cell << #" << i<< " with type Type " << cm.getRepr() << " in 'this' whereas meshdim == " << meshDim << " !";
241           throw INTERP_KERNEL::Exception(oss.str());
242         }
243       int nbOfNodesInCell=ptrI[i+1]-ptrI[i]-1;
244       if(!cm.isDynamic())
245         if(nbOfNodesInCell!=(int)cm.getNumberOfNodes())
246           {
247             std::ostringstream oss;
248             oss << "MEDCouplingUMesh::checkConsistency : cell #" << i << " with static Type '" << cm.getRepr() << "' has " <<  cm.getNumberOfNodes();
249             oss << " nodes whereas in connectivity there is " << nbOfNodesInCell << " nodes ! Looks very bad !";
250             throw INTERP_KERNEL::Exception(oss.str());
251           }
252       if(cm.isQuadratic() && cm.isDynamic() && meshDim == 2)
253         if (nbOfNodesInCell % 2 || nbOfNodesInCell < 4)
254           {
255             std::ostringstream oss;
256             oss << "MEDCouplingUMesh::checkConsistency : cell #" << i << " with quadratic type '" << cm.getRepr() << "' has " <<  nbOfNodesInCell;
257             oss << " nodes. This should be even, and greater or equal than 4!! Looks very bad!";
258             throw INTERP_KERNEL::Exception(oss.str());
259           }
260       for(const int *w=ptr+ptrI[i]+1;w!=ptr+ptrI[i+1];w++)
261         {
262           int nodeId=*w;
263           if(nodeId>=0)
264             {
265               if(nodeId>=nbOfNodes)
266                 {
267                   std::ostringstream oss; oss << "Cell #" << i << " is built with node #" << nodeId << " whereas there are only " << nbOfNodes << " nodes in the mesh !";
268                   throw INTERP_KERNEL::Exception(oss.str());
269                 }
270             }
271           else if(nodeId<-1)
272             {
273               std::ostringstream oss; oss << "Cell #" << i << " is built with node #" << nodeId << " in connectivity ! sounds bad !";
274               throw INTERP_KERNEL::Exception(oss.str());
275             }
276           else
277             {
278               if((INTERP_KERNEL::NormalizedCellType)(ptr[ptrI[i]])!=INTERP_KERNEL::NORM_POLYHED)
279                 {
280                   std::ostringstream oss; oss << "Cell #" << i << " is built with node #-1 in connectivity ! sounds bad !";
281                   throw INTERP_KERNEL::Exception(oss.str());
282                 }
283             }
284         }
285     }
286 }
287
288 /*!
289  * Sets dimension of \a this mesh. The mesh dimension in general depends on types of
290  * elements contained in the mesh. For more info on the mesh dimension see
291  * \ref MEDCouplingUMeshPage.
292  *  \param [in] meshDim - a new mesh dimension.
293  *  \throw If \a meshDim is invalid. A valid range is <em> -1 <= meshDim <= 3</em>.
294  */
295 void MEDCouplingUMesh::setMeshDimension(int meshDim)
296 {
297   if(meshDim<-1 || meshDim>3)
298     throw INTERP_KERNEL::Exception("Invalid meshDim specified ! Must be greater or equal to -1 and lower or equal to 3 !");
299   _mesh_dim=meshDim;
300   declareAsNew();
301 }
302
303 /*!
304  * Allocates memory to store an estimation of the given number of cells. 
305  * The closer the estimation to the number of cells effectively inserted, the less need the library requires
306  * to reallocate memory. If the number of cells to be inserted is not known simply assign 0 to this parameter.
307  * If a nodal connectivity previously existed before the call of this method, it will be reset.
308  *
309  *  \param [in] nbOfCells - estimation of the number of cell \a this mesh will contain.
310  *
311  *  \if ENABLE_EXAMPLES
312  *  \ref medcouplingcppexamplesUmeshStdBuild1 "Here is a C++ example".<br>
313  *  \ref medcouplingpyexamplesUmeshStdBuild1 "Here is a Python example".
314  *  \endif
315  */
316 void MEDCouplingUMesh::allocateCells(int nbOfCells)
317 {
318   if(nbOfCells<0)
319     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::allocateCells : the input number of cells should be >= 0 !");
320   if(_nodal_connec_index)
321     {
322       _nodal_connec_index->decrRef();
323     }
324   if(_nodal_connec)
325     {
326       _nodal_connec->decrRef();
327     }
328   _nodal_connec_index=DataArrayInt::New();
329   _nodal_connec_index->reserve(nbOfCells+1);
330   _nodal_connec_index->pushBackSilent(0);
331   _nodal_connec=DataArrayInt::New();
332   _nodal_connec->reserve(2*nbOfCells);
333   _types.clear();
334   declareAsNew();
335 }
336
337 /*!
338  * Appends a cell to the connectivity array. For deeper understanding what is
339  * happening see \ref MEDCouplingUMeshNodalConnectivity.
340  *  \param [in] type - type of cell to add.
341  *  \param [in] size - number of nodes constituting this cell.
342  *  \param [in] nodalConnOfCell - the connectivity of the cell to add.
343  * 
344  *  \if ENABLE_EXAMPLES
345  *  \ref medcouplingcppexamplesUmeshStdBuild1 "Here is a C++ example".<br>
346  *  \ref medcouplingpyexamplesUmeshStdBuild1 "Here is a Python example".
347  *  \endif
348  */
349 void MEDCouplingUMesh::insertNextCell(INTERP_KERNEL::NormalizedCellType type, int size, const int *nodalConnOfCell)
350 {
351   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
352   if(_nodal_connec_index==0)
353     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::insertNextCell : nodal connectivity not set ! invoke allocateCells before calling insertNextCell !");
354   if((int)cm.getDimension()==_mesh_dim)
355     {
356       if(!cm.isDynamic())
357         if(size!=(int)cm.getNumberOfNodes())
358           {
359             std::ostringstream oss; oss << "MEDCouplingUMesh::insertNextCell : Trying to push a " << cm.getRepr() << " cell with a size of " << size;
360             oss << " ! Expecting " << cm.getNumberOfNodes() << " !";
361             throw INTERP_KERNEL::Exception(oss.str());
362           }
363       int idx=_nodal_connec_index->back();
364       int val=idx+size+1;
365       _nodal_connec_index->pushBackSilent(val);
366       _nodal_connec->writeOnPlace(idx,type,nodalConnOfCell,size);
367       _types.insert(type);
368     }
369   else
370     {
371       std::ostringstream oss; oss << "MEDCouplingUMesh::insertNextCell : cell type " << cm.getRepr() << " has a dimension " << cm.getDimension();
372       oss << " whereas Mesh Dimension of current UMesh instance is set to " << _mesh_dim << " ! Please invoke \"setMeshDimension\" method before or invoke ";
373       oss << "\"MEDCouplingUMesh::New\" static method with 2 parameters name and meshDimension !";
374       throw INTERP_KERNEL::Exception(oss.str());
375     }
376 }
377
378 /*!
379  * Compacts data arrays to release unused memory. This method is to be called after
380  * finishing cell insertion using \a this->insertNextCell().
381  * 
382  *  \if ENABLE_EXAMPLES
383  *  \ref medcouplingcppexamplesUmeshStdBuild1 "Here is a C++ example".<br>
384  *  \ref medcouplingpyexamplesUmeshStdBuild1 "Here is a Python example".
385  *  \endif
386  */
387 void MEDCouplingUMesh::finishInsertingCells()
388 {
389   _nodal_connec->pack();
390   _nodal_connec_index->pack();
391   _nodal_connec->declareAsNew();
392   _nodal_connec_index->declareAsNew();
393   updateTime();
394 }
395
396 /*!
397  * Entry point for iteration over cells of this. Warning the returned cell iterator should be deallocated.
398  * Useful for python users.
399  */
400 MEDCouplingUMeshCellIterator *MEDCouplingUMesh::cellIterator()
401 {
402   return new MEDCouplingUMeshCellIterator(this);
403 }
404
405 /*!
406  * Entry point for iteration over cells groups geo types per geotypes. Warning the returned cell iterator should be deallocated.
407  * If \a this is not so that the cells are grouped by geo types, this method will throw an exception.
408  * In this case MEDCouplingUMesh::sortCellsInMEDFileFrmt or MEDCouplingUMesh::rearrange2ConsecutiveCellTypes methods for example can be called before invoking this method.
409  * Useful for python users.
410  */
411 MEDCouplingUMeshCellByTypeEntry *MEDCouplingUMesh::cellsByType()
412 {
413   if(!checkConsecutiveCellTypes())
414     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::cellsByType : this mesh is not sorted by type !");
415   return new MEDCouplingUMeshCellByTypeEntry(this);
416 }
417
418 /*!
419  * Returns a set of all cell types available in \a this mesh.
420  * \return std::set<INTERP_KERNEL::NormalizedCellType> - the set of cell types.
421  * \warning this method does not throw any exception even if \a this is not defined.
422  * \sa MEDCouplingUMesh::getAllGeoTypesSorted
423  */
424 std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingUMesh::getAllGeoTypes() const
425 {
426   return _types;
427 }
428
429 /*!
430  * This method returns the sorted list of geometric types in \a this.
431  * Sorted means in the same order than the cells in \a this. A single entry in return vector means the maximal chunk of consecutive cells in \a this
432  * having the same geometric type. So a same geometric type can appear more than once if the cells are not sorted per geometric type.
433  *
434  * \throw if connectivity in \a this is not correctly defined.
435  *  
436  * \sa MEDCouplingMesh::getAllGeoTypes
437  */
438 std::vector<INTERP_KERNEL::NormalizedCellType> MEDCouplingUMesh::getAllGeoTypesSorted() const
439 {
440   std::vector<INTERP_KERNEL::NormalizedCellType> ret;
441   checkConnectivityFullyDefined();
442   int nbOfCells(getNumberOfCells());
443   if(nbOfCells==0)
444     return ret;
445   if(getNodalConnectivityArrayLen()<1)
446     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getAllGeoTypesSorted : the connectivity in this seems invalid !");
447   const int *c(_nodal_connec->begin()),*ci(_nodal_connec_index->begin());
448   ret.push_back((INTERP_KERNEL::NormalizedCellType)c[*ci++]);
449   for(int i=1;i<nbOfCells;i++,ci++)
450     if(ret.back()!=((INTERP_KERNEL::NormalizedCellType)c[*ci]))
451       ret.push_back((INTERP_KERNEL::NormalizedCellType)c[*ci]);
452   return ret;
453 }
454
455 /*!
456  * This method is a method that compares \a this and \a other.
457  * This method compares \b all attributes, even names and component names.
458  */
459 bool MEDCouplingUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const
460 {
461   if(!other)
462     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::isEqualIfNotWhy : input other pointer is null !");
463   std::ostringstream oss; oss.precision(15);
464   const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
465   if(!otherC)
466     {
467       reason="mesh given in input is not castable in MEDCouplingUMesh !";
468       return false;
469     }
470   if(!MEDCouplingPointSet::isEqualIfNotWhy(other,prec,reason))
471     return false;
472   if(_mesh_dim!=otherC->_mesh_dim)
473     {
474       oss << "umesh dimension mismatch : this mesh dimension=" << _mesh_dim << " other mesh dimension=" <<  otherC->_mesh_dim;
475       reason=oss.str();
476       return false;
477     }
478   if(_types!=otherC->_types)
479     {
480       oss << "umesh geometric type mismatch :\nThis geometric types are :";
481       for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
482         { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*iter); oss << cm.getRepr() << ", "; }
483       oss << "\nOther geometric types are :";
484       for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=otherC->_types.begin();iter!=otherC->_types.end();iter++)
485         { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*iter); oss << cm.getRepr() << ", "; }
486       reason=oss.str();
487       return false;
488     }
489   if(_nodal_connec!=0 || otherC->_nodal_connec!=0)
490     if(_nodal_connec==0 || otherC->_nodal_connec==0)
491       {
492         reason="Only one UMesh between the two this and other has its nodal connectivity DataArrayInt defined !";
493         return false;
494       }
495   if(_nodal_connec!=otherC->_nodal_connec)
496     if(!_nodal_connec->isEqualIfNotWhy(*otherC->_nodal_connec,reason))
497       {
498         reason.insert(0,"Nodal connectivity DataArrayInt differ : ");
499         return false;
500       }
501   if(_nodal_connec_index!=0 || otherC->_nodal_connec_index!=0)
502     if(_nodal_connec_index==0 || otherC->_nodal_connec_index==0)
503       {
504         reason="Only one UMesh between the two this and other has its nodal connectivity index DataArrayInt defined !";
505         return false;
506       }
507   if(_nodal_connec_index!=otherC->_nodal_connec_index)
508     if(!_nodal_connec_index->isEqualIfNotWhy(*otherC->_nodal_connec_index,reason))
509       {
510         reason.insert(0,"Nodal connectivity index DataArrayInt differ : ");
511         return false;
512       }
513   return true;
514 }
515
516 /*!
517  * Checks if data arrays of this mesh (node coordinates, nodal
518  * connectivity of cells, etc) of two meshes are same. Textual data like name etc. are
519  * not considered.
520  *  \param [in] other - the mesh to compare with.
521  *  \param [in] prec - precision value used to compare node coordinates.
522  *  \return bool - \a true if the two meshes are same.
523  */
524 bool MEDCouplingUMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
525 {
526   const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
527   if(!otherC)
528     return false;
529   if(!MEDCouplingPointSet::isEqualWithoutConsideringStr(other,prec))
530     return false;
531   if(_mesh_dim!=otherC->_mesh_dim)
532     return false;
533   if(_types!=otherC->_types)
534     return false;
535   if(_nodal_connec!=0 || otherC->_nodal_connec!=0)
536     if(_nodal_connec==0 || otherC->_nodal_connec==0)
537       return false;
538   if(_nodal_connec!=otherC->_nodal_connec)
539     if(!_nodal_connec->isEqualWithoutConsideringStr(*otherC->_nodal_connec))
540       return false;
541   if(_nodal_connec_index!=0 || otherC->_nodal_connec_index!=0)
542     if(_nodal_connec_index==0 || otherC->_nodal_connec_index==0)
543       return false;
544   if(_nodal_connec_index!=otherC->_nodal_connec_index)
545     if(!_nodal_connec_index->isEqualWithoutConsideringStr(*otherC->_nodal_connec_index))
546       return false;
547   return true;
548 }
549
550 /*!
551  * Checks if \a this and \a other meshes are geometrically equivalent with high
552  * probability, else an exception is thrown. The meshes are considered equivalent if
553  * (1) meshes contain the same number of nodes and the same number of elements of the
554  * same types (2) three cells of the two meshes (first, last and middle) are based
555  * on coincident nodes (with a specified precision).
556  *  \param [in] other - the mesh to compare with.
557  *  \param [in] prec - the precision used to compare nodes of the two meshes.
558  *  \throw If the two meshes do not match.
559  */
560 void MEDCouplingUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const
561 {
562   MEDCouplingPointSet::checkFastEquivalWith(other,prec);
563   const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
564   if(!otherC)
565     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkFastEquivalWith : Two meshes are not not unstructured !"); 
566 }
567
568 /*!
569  * Returns the reverse nodal connectivity. The reverse nodal connectivity enumerates
570  * cells each node belongs to.
571  * \warning For speed reasons, this method does not check if node ids in the nodal
572  *          connectivity correspond to the size of node coordinates array.
573  * \param [in,out] revNodal - an array holding ids of cells sharing each node.
574  * \param [in,out] revNodalIndx - an array, of length \a this->getNumberOfNodes() + 1,
575  *        dividing cell ids in \a revNodal into groups each referring to one
576  *        node. Its every element (except the last one) is an index pointing to the
577  *         first id of a group of cells. For example cells sharing the node #1 are 
578  *        described by following range of indices: 
579  *        [ \a revNodalIndx[1], \a revNodalIndx[2] ) and the cell ids are
580  *        \a revNodal[ \a revNodalIndx[1] ], \a revNodal[ \a revNodalIndx[1] + 1], ...
581  *        Number of cells sharing the *i*-th node is
582  *        \a revNodalIndx[ *i*+1 ] - \a revNodalIndx[ *i* ].
583  * \throw If the coordinates array is not set.
584  * \throw If the nodal connectivity of cells is not defined.
585  * 
586  * \if ENABLE_EXAMPLES
587  * \ref cpp_mcumesh_getReverseNodalConnectivity "Here is a C++ example".<br>
588  * \ref  py_mcumesh_getReverseNodalConnectivity "Here is a Python example".
589  * \endif
590  */
591 void MEDCouplingUMesh::getReverseNodalConnectivity(DataArrayInt *revNodal, DataArrayInt *revNodalIndx) const
592 {
593   checkFullyDefined();
594   int nbOfNodes(getNumberOfNodes());
595   int *revNodalIndxPtr=(int *)malloc((nbOfNodes+1)*sizeof(int));
596   revNodalIndx->useArray(revNodalIndxPtr,true,C_DEALLOC,nbOfNodes+1,1);
597   std::fill(revNodalIndxPtr,revNodalIndxPtr+nbOfNodes+1,0);
598   const int *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
599   int nbOfCells(getNumberOfCells()),nbOfEltsInRevNodal(0);
600   for(int eltId=0;eltId<nbOfCells;eltId++)
601     {
602       const int *strtNdlConnOfCurCell(conn+connIndex[eltId]+1),*endNdlConnOfCurCell(conn+connIndex[eltId+1]);
603       for(const int *iter=strtNdlConnOfCurCell;iter!=endNdlConnOfCurCell;iter++)
604         if(*iter>=0)//for polyhedrons
605           {
606             nbOfEltsInRevNodal++;
607             revNodalIndxPtr[(*iter)+1]++;
608           }
609     }
610   std::transform(revNodalIndxPtr+1,revNodalIndxPtr+nbOfNodes+1,revNodalIndxPtr,revNodalIndxPtr+1,std::plus<int>());
611   int *revNodalPtr=(int *)malloc((nbOfEltsInRevNodal)*sizeof(int));
612   revNodal->useArray(revNodalPtr,true,C_DEALLOC,nbOfEltsInRevNodal,1);
613   std::fill(revNodalPtr,revNodalPtr+nbOfEltsInRevNodal,-1);
614   for(int eltId=0;eltId<nbOfCells;eltId++)
615     {
616       const int *strtNdlConnOfCurCell=conn+connIndex[eltId]+1;
617       const int *endNdlConnOfCurCell=conn+connIndex[eltId+1];
618       for(const int *iter=strtNdlConnOfCurCell;iter!=endNdlConnOfCurCell;iter++)
619         if(*iter>=0)//for polyhedrons
620           *std::find_if(revNodalPtr+revNodalIndxPtr[*iter],revNodalPtr+revNodalIndxPtr[*iter+1],std::bind2nd(std::equal_to<int>(),-1))=eltId;
621     }
622 }
623
624 /*!
625  * Creates a new MEDCouplingUMesh containing cells, of dimension one less than \a
626  * this->getMeshDimension(), that bound cells of \a this mesh. In addition arrays
627  * describing correspondence between cells of \a this and the result meshes are
628  * returned. The arrays \a desc and \a descIndx (\ref numbering-indirect) describe the descending connectivity,
629  * i.e. enumerate cells of the result mesh bounding each cell of \a this mesh. The
630  * arrays \a revDesc and \a revDescIndx (\ref numbering-indirect) describe the reverse descending connectivity,
631  * i.e. enumerate cells of  \a this mesh bounded by each cell of the result mesh. 
632  * \warning For speed reasons, this method does not check if node ids in the nodal
633  *          connectivity correspond to the size of node coordinates array.
634  * \warning Cells of the result mesh are \b not sorted by geometric type, hence,
635  *          to write this mesh to the MED file, its cells must be sorted using
636  *          sortCellsInMEDFileFrmt().
637  *  \param [in,out] desc - the array containing cell ids of the result mesh bounding
638  *         each cell of \a this mesh.
639  *  \param [in,out] descIndx - the array, of length \a this->getNumberOfCells() + 1,
640  *        dividing cell ids in \a desc into groups each referring to one
641  *        cell of \a this mesh. Its every element (except the last one) is an index
642  *        pointing to the first id of a group of cells. For example cells of the
643  *        result mesh bounding the cell #1 of \a this mesh are described by following
644  *        range of indices:
645  *        [ \a descIndx[1], \a descIndx[2] ) and the cell ids are
646  *        \a desc[ \a descIndx[1] ], \a desc[ \a descIndx[1] + 1], ...
647  *        Number of cells of the result mesh sharing the *i*-th cell of \a this mesh is
648  *        \a descIndx[ *i*+1 ] - \a descIndx[ *i* ].
649  *  \param [in,out] revDesc - the array containing cell ids of \a this mesh bounded
650  *         by each cell of the result mesh.
651  *  \param [in,out] revDescIndx - the array, of length one more than number of cells
652  *        in the result mesh,
653  *        dividing cell ids in \a revDesc into groups each referring to one
654  *        cell of the result mesh the same way as \a descIndx divides \a desc.
655  *  \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. The caller is to
656  *        delete this mesh using decrRef() as it is no more needed.
657  *  \throw If the coordinates array is not set.
658  *  \throw If the nodal connectivity of cells is node defined.
659  *  \throw If \a desc == NULL || \a descIndx == NULL || \a revDesc == NULL || \a
660  *         revDescIndx == NULL.
661  * 
662  *  \if ENABLE_EXAMPLES
663  *  \ref cpp_mcumesh_buildDescendingConnectivity "Here is a C++ example".<br>
664  *  \ref  py_mcumesh_buildDescendingConnectivity "Here is a Python example".
665  *  \endif
666  * \sa buildDescendingConnectivity2()
667  */
668 MEDCouplingUMesh *MEDCouplingUMesh::buildDescendingConnectivity(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const
669 {
670   return buildDescendingConnectivityGen<MinusOneSonsGenerator>(desc,descIndx,revDesc,revDescIndx,MEDCouplingFastNbrer);
671 }
672
673 /*!
674  * \a this has to have a mesh dimension equal to 3. If it is not the case an INTERP_KERNEL::Exception will be thrown.
675  * This behaves exactly as MEDCouplingUMesh::buildDescendingConnectivity does except that this method compute directly the transition from mesh dimension 3 to sub edges (dimension 1)
676  * in one shot. That is to say that this method is equivalent to 2 successive calls to MEDCouplingUMesh::buildDescendingConnectivity.
677  * This method returns 4 arrays and a mesh as MEDCouplingUMesh::buildDescendingConnectivity does.
678  * \sa MEDCouplingUMesh::buildDescendingConnectivity
679  */
680 MEDCouplingUMesh *MEDCouplingUMesh::explode3DMeshTo1D(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const
681 {
682   checkFullyDefined();
683   if(getMeshDimension()!=3)
684     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::explode3DMeshTo1D : This has to have a mesh dimension to 3 !");
685   return buildDescendingConnectivityGen<MinusTwoSonsGenerator>(desc,descIndx,revDesc,revDescIndx,MEDCouplingFastNbrer);
686 }
687
688 /*!
689  * This method computes the micro edges constituting each cell in \a this. Micro edge is an edge for non quadratic cells. Micro edge is an half edge for quadratic cells.
690  * This method works for both meshes with mesh dimension equal to 2 or 3. Dynamical cells are not supported (polygons, polyhedrons...)
691  * 
692  * \sa explode3DMeshTo1D, buildDescendingConnectiviy
693  */
694 MEDCouplingUMesh *MEDCouplingUMesh::explodeMeshIntoMicroEdges(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const
695 {
696    checkFullyDefined();
697    switch(getMeshDimension())
698      {
699      case 2:
700        return buildDescendingConnectivityGen<MicroEdgesGenerator2D>(desc,descIndx,revDesc,revDescIndx,MEDCouplingFastNbrer);
701      case 3:
702        return buildDescendingConnectivityGen<MicroEdgesGenerator2D>(desc,descIndx,revDesc,revDescIndx,MEDCouplingFastNbrer);
703      default:
704        throw INTERP_KERNEL::Exception("MEDCouplingUMesh::explodeMeshIntoMicroEdges : Only 2D and 3D supported !");
705      }
706 }
707
708 /*!
709  * Creates a new MEDCouplingUMesh containing cells, of dimension one less than \a
710  * this->getMeshDimension(), that bound cells of \a this mesh. In
711  * addition arrays describing correspondence between cells of \a this and the result
712  * meshes are returned. The arrays \a desc and \a descIndx (\ref numbering-indirect) describe the descending
713  * connectivity, i.e. enumerate cells of the result mesh bounding each cell of \a this
714  *  mesh. This method differs from buildDescendingConnectivity() in that apart
715  * from cell ids, \a desc returns mutual orientation of cells in \a this and the
716  * result meshes. So a positive id means that order of nodes in corresponding cells
717  * of two meshes is same, and a negative id means a reverse order of nodes. Since a
718  * cell with id #0 can't be negative, the array \a desc returns ids in FORTRAN mode,
719  * i.e. cell ids are one-based.
720  * Arrays \a revDesc and \a revDescIndx (\ref numbering-indirect) describe the reverse descending connectivity,
721  * i.e. enumerate cells of  \a this mesh bounded by each cell of the result mesh. 
722  * \warning For speed reasons, this method does not check if node ids in the nodal
723  *          connectivity correspond to the size of node coordinates array.
724  * \warning Cells of the result mesh are \b not sorted by geometric type, hence,
725  *          to write this mesh to the MED file, its cells must be sorted using
726  *          sortCellsInMEDFileFrmt().
727  *  \param [in,out] desc - the array containing cell ids of the result mesh bounding
728  *         each cell of \a this mesh.
729  *  \param [in,out] descIndx - the array, of length \a this->getNumberOfCells() + 1,
730  *        dividing cell ids in \a desc into groups each referring to one
731  *        cell of \a this mesh. Its every element (except the last one) is an index
732  *        pointing to the first id of a group of cells. For example cells of the
733  *        result mesh bounding the cell #1 of \a this mesh are described by following
734  *        range of indices:
735  *        [ \a descIndx[1], \a descIndx[2] ) and the cell ids are
736  *        \a desc[ \a descIndx[1] ], \a desc[ \a descIndx[1] + 1], ...
737  *        Number of cells of the result mesh sharing the *i*-th cell of \a this mesh is
738  *        \a descIndx[ *i*+1 ] - \a descIndx[ *i* ].
739  *  \param [in,out] revDesc - the array containing cell ids of \a this mesh bounded
740  *         by each cell of the result mesh.
741  *  \param [in,out] revDescIndx - the array, of length one more than number of cells
742  *        in the result mesh,
743  *        dividing cell ids in \a revDesc into groups each referring to one
744  *        cell of the result mesh the same way as \a descIndx divides \a desc.
745  *  \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. This result mesh
746  *        shares the node coordinates array with \a this mesh. The caller is to
747  *        delete this mesh using decrRef() as it is no more needed.
748  *  \throw If the coordinates array is not set.
749  *  \throw If the nodal connectivity of cells is node defined.
750  *  \throw If \a desc == NULL || \a descIndx == NULL || \a revDesc == NULL || \a
751  *         revDescIndx == NULL.
752  * 
753  *  \if ENABLE_EXAMPLES
754  *  \ref cpp_mcumesh_buildDescendingConnectivity2 "Here is a C++ example".<br>
755  *  \ref  py_mcumesh_buildDescendingConnectivity2 "Here is a Python example".
756  *  \endif
757  * \sa buildDescendingConnectivity()
758  */
759 MEDCouplingUMesh *MEDCouplingUMesh::buildDescendingConnectivity2(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const
760 {
761   return buildDescendingConnectivityGen<MinusOneSonsGenerator>(desc,descIndx,revDesc,revDescIndx,MEDCouplingOrientationSensitiveNbrer);
762 }
763
764 /*!
765  * \b WARNING this method do the assumption that connectivity lies on the coordinates set.
766  * For speed reasons no check of this will be done. This method calls
767  * MEDCouplingUMesh::buildDescendingConnectivity to compute the result.
768  * This method lists cell by cell in \b this which are its neighbors. To compute the result
769  * only connectivities are considered.
770  * The neighbor cells of cell having id 'cellId' are neighbors[neighborsIndx[cellId]:neighborsIndx[cellId+1]].
771  * The format of return is hence \ref numbering-indirect.
772  *
773  * \param [out] neighbors is an array storing all the neighbors of all cells in \b this. This array is newly
774  * allocated and should be dealt by the caller. \b neighborsIndx 2nd output
775  * parameter allows to select the right part in this array (\ref numbering-indirect). The number of tuples
776  * is equal to the last values in \b neighborsIndx.
777  * \param [out] neighborsIndx is an array of size this->getNumberOfCells()+1 newly allocated and should be
778  * dealt by the caller. This arrays allow to use the first output parameter \b neighbors (\ref numbering-indirect).
779  */
780 void MEDCouplingUMesh::computeNeighborsOfCells(DataArrayInt *&neighbors, DataArrayInt *&neighborsIndx) const
781 {
782   MCAuto<DataArrayInt> desc=DataArrayInt::New();
783   MCAuto<DataArrayInt> descIndx=DataArrayInt::New();
784   MCAuto<DataArrayInt> revDesc=DataArrayInt::New();
785   MCAuto<DataArrayInt> revDescIndx=DataArrayInt::New();
786   MCAuto<MEDCouplingUMesh> meshDM1=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
787   meshDM1=0;
788   ComputeNeighborsOfCellsAdv(desc,descIndx,revDesc,revDescIndx,neighbors,neighborsIndx);
789 }
790
791 void MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne(const DataArrayInt *nodeNeigh, const DataArrayInt *nodeNeighI, MCAuto<DataArrayInt>& cellNeigh, MCAuto<DataArrayInt>& cellNeighIndex) const
792 {
793   if(!nodeNeigh || !nodeNeighI)
794     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : null pointer !");
795   checkConsistencyLight();
796   nodeNeigh->checkAllocated(); nodeNeighI->checkAllocated();
797   nodeNeigh->checkNbOfComps(1,"MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : node neigh");
798   nodeNeighI->checkNbOfComps(1,"MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : node neigh index");
799   nodeNeighI->checkNbOfTuples(1+getNumberOfNodes(),"MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : invalid length");
800   int nbCells(getNumberOfCells());
801   const int *c(_nodal_connec->begin()),*ci(_nodal_connec_index->begin()),*ne(nodeNeigh->begin()),*nei(nodeNeighI->begin());
802   cellNeigh=DataArrayInt::New(); cellNeigh->alloc(0,1); cellNeighIndex=DataArrayInt::New(); cellNeighIndex->alloc(1,1); cellNeighIndex->setIJ(0,0,0);
803   for(int i=0;i<nbCells;i++)
804     {
805       std::set<int> s;
806       for(const int *it=c+ci[i]+1;it!=c+ci[i+1];it++)
807         if(*it>=0)
808           s.insert(ne+nei[*it],ne+nei[*it+1]);
809       s.erase(i);
810       cellNeigh->insertAtTheEnd(s.begin(),s.end());
811       cellNeighIndex->pushBackSilent(cellNeigh->getNumberOfTuples());
812     }
813 }
814
815 /*!
816  * This method is called by MEDCouplingUMesh::computeNeighborsOfCells. This methods performs the algorithm
817  * of MEDCouplingUMesh::computeNeighborsOfCells.
818  * This method is useful for users that want to reduce along a criterion the set of neighbours cell. This is
819  * typically the case to extract a set a neighbours,
820  * excluding a set of meshdim-1 cells in input descending connectivity.
821  * Typically \b desc, \b descIndx, \b revDesc and \b revDescIndx (\ref numbering-indirect) input params are
822  * the result of MEDCouplingUMesh::buildDescendingConnectivity.
823  * This method lists cell by cell in \b this which are its neighbors. To compute the result only connectivities
824  * are considered.
825  * The neighbor cells of cell having id 'cellId' are neighbors[neighborsIndx[cellId]:neighborsIndx[cellId+1]].
826  *
827  * \param [in] desc descending connectivity array.
828  * \param [in] descIndx descending connectivity index array used to walk through \b desc (\ref numbering-indirect).
829  * \param [in] revDesc reverse descending connectivity array.
830  * \param [in] revDescIndx reverse descending connectivity index array used to walk through \b revDesc (\ref numbering-indirect).
831  * \param [out] neighbors is an array storing all the neighbors of all cells in \b this. This array is newly allocated and should be dealt by the caller. \b neighborsIndx 2nd output
832  *                        parameter allows to select the right part in this array. The number of tuples is equal to the last values in \b neighborsIndx.
833  * \param [out] neighborsIndx is an array of size this->getNumberOfCells()+1 newly allocated and should be dealt by the caller. This arrays allow to use the first output parameter \b neighbors.
834  */
835 void MEDCouplingUMesh::ComputeNeighborsOfCellsAdv(const DataArrayInt *desc, const DataArrayInt *descIndx, const DataArrayInt *revDesc, const DataArrayInt *revDescIndx,
836                                                   DataArrayInt *&neighbors, DataArrayInt *&neighborsIndx)
837 {
838   if(!desc || !descIndx || !revDesc || !revDescIndx)
839     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeNeighborsOfCellsAdv some input array is empty !");
840   const int *descPtr=desc->begin();
841   const int *descIPtr=descIndx->begin();
842   const int *revDescPtr=revDesc->begin();
843   const int *revDescIPtr=revDescIndx->begin();
844   //
845   int nbCells=descIndx->getNumberOfTuples()-1;
846   MCAuto<DataArrayInt> out0=DataArrayInt::New();
847   MCAuto<DataArrayInt> out1=DataArrayInt::New(); out1->alloc(nbCells+1,1);
848   int *out1Ptr=out1->getPointer();
849   *out1Ptr++=0;
850   out0->reserve(desc->getNumberOfTuples());
851   for(int i=0;i<nbCells;i++,descIPtr++,out1Ptr++)
852     {
853       for(const int *w1=descPtr+descIPtr[0];w1!=descPtr+descIPtr[1];w1++)
854         {
855           std::set<int> s(revDescPtr+revDescIPtr[*w1],revDescPtr+revDescIPtr[(*w1)+1]);
856           s.erase(i);
857           out0->insertAtTheEnd(s.begin(),s.end());
858         }
859       *out1Ptr=out0->getNumberOfTuples();
860     }
861   neighbors=out0.retn();
862   neighborsIndx=out1.retn();
863 }
864
865 /*!
866  * Explodes \a this into edges whatever its dimension.
867  */
868 MCAuto<MEDCouplingUMesh> MEDCouplingUMesh::explodeIntoEdges(MCAuto<DataArrayInt>& desc, MCAuto<DataArrayInt>& descIndex, MCAuto<DataArrayInt>& revDesc, MCAuto<DataArrayInt>& revDescIndx) const
869 {
870   checkFullyDefined();
871   int mdim(getMeshDimension());
872   desc=DataArrayInt::New(); descIndex=DataArrayInt::New(); revDesc=DataArrayInt::New(); revDescIndx=DataArrayInt::New();
873   MCAuto<MEDCouplingUMesh> mesh1D;
874   switch(mdim)
875   {
876     case 3:
877       {
878         mesh1D=explode3DMeshTo1D(desc,descIndex,revDesc,revDescIndx);
879         break;
880       }
881     case 2:
882       {
883         mesh1D=buildDescendingConnectivity(desc,descIndex,revDesc,revDescIndx);
884         break;
885       }
886     default:
887       {
888         throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computeNeighborsOfNodes : Mesh dimension supported are [3,2] !");
889       }
890   }
891   return mesh1D;
892 }
893
894 /*!
895  * \b WARNING this method do the assumption that connectivity lies on the coordinates set.
896  * For speed reasons no check of this will be done. This method calls
897  * MEDCouplingUMesh::buildDescendingConnectivity to compute the result.
898  * This method lists node by node in \b this which are its neighbors. To compute the result
899  * only connectivities are considered.
900  * The neighbor nodes of node having id 'nodeId' are neighbors[neighborsIndx[cellId]:neighborsIndx[cellId+1]].
901  *
902  * \param [out] neighbors is an array storing all the neighbors of all nodes in \b this. This array
903  * is newly allocated and should be dealt by the caller. \b neighborsIndx 2nd output
904  * parameter allows to select the right part in this array (\ref numbering-indirect).
905  * The number of tuples is equal to the last values in \b neighborsIndx.
906  * \param [out] neighborsIdx is an array of size this->getNumberOfCells()+1 newly allocated and should
907  * be dealt by the caller. This arrays allow to use the first output parameter \b neighbors.
908  * 
909  * \sa MEDCouplingUMesh::computeEnlargedNeighborsOfNodes
910  */
911 void MEDCouplingUMesh::computeNeighborsOfNodes(DataArrayInt *&neighbors, DataArrayInt *&neighborsIdx) const
912 {
913   checkFullyDefined();
914   int mdim(getMeshDimension()),nbNodes(getNumberOfNodes());
915   MCAuto<DataArrayInt> desc(DataArrayInt::New()),descIndx(DataArrayInt::New()),revDesc(DataArrayInt::New()),revDescIndx(DataArrayInt::New());
916   MCConstAuto<MEDCouplingUMesh> mesh1D;
917   switch(mdim)
918   {
919     case 3:
920       {
921         mesh1D=explode3DMeshTo1D(desc,descIndx,revDesc,revDescIndx);
922         break;
923       }
924     case 2:
925       {
926         mesh1D=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
927         break;
928       }
929     case 1:
930       {
931         mesh1D.takeRef(this);
932         break;
933       }
934     default:
935       {
936         throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computeNeighborsOfNodes : Mesh dimension supported are [3,2,1] !");
937       }
938   }
939   desc=DataArrayInt::New(); descIndx=DataArrayInt::New(); revDesc=0; revDescIndx=0;
940   mesh1D->getReverseNodalConnectivity(desc,descIndx);
941   MCAuto<DataArrayInt> ret0(DataArrayInt::New());
942   ret0->alloc(desc->getNumberOfTuples(),1);
943   int *r0Pt(ret0->getPointer());
944   const int *c1DPtr(mesh1D->getNodalConnectivity()->begin()),*rn(desc->begin()),*rni(descIndx->begin());
945   for(int i=0;i<nbNodes;i++,rni++)
946     {
947       for(const int *oneDCellIt=rn+rni[0];oneDCellIt!=rn+rni[1];oneDCellIt++)
948         *r0Pt++=c1DPtr[3*(*oneDCellIt)+1]==i?c1DPtr[3*(*oneDCellIt)+2]:c1DPtr[3*(*oneDCellIt)+1];
949     }
950   neighbors=ret0.retn();
951   neighborsIdx=descIndx.retn();
952 }
953
954 /*!
955  * Computes enlarged neighbors for each nodes in \a this. The behavior of this method is close to MEDCouplingUMesh::computeNeighborsOfNodes except that the neighborhood of each node is wider here.
956  * A node j is considered to be in the neighborhood of i if and only if there is a cell in \a this containing in its nodal connectivity both i and j.
957  * This method is useful to find ghost cells of a part of a mesh with a code based on fields on nodes.
958  * 
959  * \sa MEDCouplingUMesh::computeNeighborsOfNodes
960  */
961 void MEDCouplingUMesh::computeEnlargedNeighborsOfNodes(MCAuto<DataArrayInt> &neighbors, MCAuto<DataArrayInt>& neighborsIdx) const
962 {
963   checkFullyDefined();
964   int nbOfNodes(getNumberOfNodes());
965   const int *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
966   int nbOfCells(getNumberOfCells());
967   std::vector< std::set<int> > st0(nbOfNodes);
968   for(int eltId=0;eltId<nbOfCells;eltId++)
969     {
970       const int *strtNdlConnOfCurCell(conn+connIndex[eltId]+1),*endNdlConnOfCurCell(conn+connIndex[eltId+1]);
971       std::set<int> s(strtNdlConnOfCurCell,endNdlConnOfCurCell); s.erase(-1); //for polyhedrons
972       for(std::set<int>::const_iterator iter2=s.begin();iter2!=s.end();iter2++)
973         st0[*iter2].insert(s.begin(),s.end());
974     }
975   neighborsIdx=DataArrayInt::New(); neighborsIdx->alloc(nbOfNodes+1,1); neighborsIdx->setIJ(0,0,0);
976   {
977     int *neighIdx(neighborsIdx->getPointer());
978     for(std::vector< std::set<int> >::const_iterator it=st0.begin();it!=st0.end();it++,neighIdx++)
979       {
980         if ((*it).empty())
981           neighIdx[1]=neighIdx[0];
982         else
983           neighIdx[1]=neighIdx[0]+(*it).size()-1;
984       }
985   }
986   neighbors=DataArrayInt::New(); neighbors->alloc(neighborsIdx->back(),1);
987   {
988     const int *neighIdx(neighborsIdx->begin());
989     int *neigh(neighbors->getPointer()),nodeId(0);
990     for(std::vector< std::set<int> >::const_iterator it=st0.begin();it!=st0.end();it++,neighIdx++,nodeId++)
991       {
992         std::set<int> s(*it); s.erase(nodeId);
993         std::copy(s.begin(),s.end(),neigh+*neighIdx);
994       }
995   }
996 }
997
998 /*!
999  * Converts specified cells to either polygons (if \a this is a 2D mesh) or
1000  * polyhedrons (if \a this is a 3D mesh). The cells to convert are specified by an
1001  * array of cell ids. Pay attention that after conversion all algorithms work slower
1002  * with \a this mesh than before conversion. <br> If an exception is thrown during the
1003  * conversion due presence of invalid ids in the array of cells to convert, as a
1004  * result \a this mesh contains some already converted elements. In this case the 2D
1005  * mesh remains valid but 3D mesh becomes \b inconsistent!
1006  *  \warning This method can significantly modify the order of geometric types in \a this,
1007  *          hence, to write this mesh to the MED file, its cells must be sorted using
1008  *          sortCellsInMEDFileFrmt().
1009  *  \param [in] cellIdsToConvertBg - the array holding ids of cells to convert.
1010  *  \param [in] cellIdsToConvertEnd - a pointer to the last-plus-one-th element of \a
1011  *         cellIdsToConvertBg.
1012  *  \throw If the coordinates array is not set.
1013  *  \throw If the nodal connectivity of cells is node defined.
1014  *  \throw If dimension of \a this mesh is not either 2 or 3.
1015  *
1016  *  \if ENABLE_EXAMPLES
1017  *  \ref cpp_mcumesh_convertToPolyTypes "Here is a C++ example".<br>
1018  *  \ref  py_mcumesh_convertToPolyTypes "Here is a Python example".
1019  *  \endif
1020  */
1021 void MEDCouplingUMesh::convertToPolyTypes(const int *cellIdsToConvertBg, const int *cellIdsToConvertEnd)
1022 {
1023   checkFullyDefined();
1024   int dim=getMeshDimension();
1025   if(dim<2 || dim>3)
1026     throw INTERP_KERNEL::Exception("Invalid mesh dimension : must be 2 or 3 !");
1027   int nbOfCells(getNumberOfCells());
1028   if(dim==2)
1029     {
1030       const int *connIndex=_nodal_connec_index->begin();
1031       int *conn=_nodal_connec->getPointer();
1032       for(const int *iter=cellIdsToConvertBg;iter!=cellIdsToConvertEnd;iter++)
1033         {
1034           if(*iter>=0 && *iter<nbOfCells)
1035             {
1036               const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[connIndex[*iter]]);
1037               if(!cm.isQuadratic())
1038                 conn[connIndex[*iter]]=INTERP_KERNEL::NORM_POLYGON;
1039               else
1040                 conn[connIndex[*iter]]=INTERP_KERNEL::NORM_QPOLYG;
1041             }
1042           else
1043             {
1044               std::ostringstream oss; oss << "MEDCouplingUMesh::convertToPolyTypes : On rank #" << std::distance(cellIdsToConvertBg,iter) << " value is " << *iter << " which is not";
1045               oss << " in range [0," << nbOfCells << ") !";
1046               throw INTERP_KERNEL::Exception(oss.str());
1047             }
1048         }
1049     }
1050   else
1051     {
1052       int *connIndex(_nodal_connec_index->getPointer());
1053       const int *connOld(_nodal_connec->getConstPointer());
1054       MCAuto<DataArrayInt> connNew(DataArrayInt::New()),connNewI(DataArrayInt::New()); connNew->alloc(0,1); connNewI->alloc(1,1); connNewI->setIJ(0,0,0);
1055       std::vector<bool> toBeDone(nbOfCells,false);
1056       for(const int *iter=cellIdsToConvertBg;iter!=cellIdsToConvertEnd;iter++)
1057         {
1058           if(*iter>=0 && *iter<nbOfCells)
1059             toBeDone[*iter]=true;
1060           else
1061             {
1062               std::ostringstream oss; oss << "MEDCouplingUMesh::convertToPolyTypes : On rank #" << std::distance(cellIdsToConvertBg,iter) << " value is " << *iter << " which is not";
1063               oss << " in range [0," << nbOfCells << ") !";
1064               throw INTERP_KERNEL::Exception(oss.str());
1065             }
1066         }
1067       for(int cellId=0;cellId<nbOfCells;cellId++)
1068         {
1069           int pos(connIndex[cellId]),posP1(connIndex[cellId+1]);
1070           int lgthOld(posP1-pos-1);
1071           if(toBeDone[cellId])
1072             {
1073               const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)connOld[pos]);
1074               unsigned nbOfFaces(cm.getNumberOfSons2(connOld+pos+1,lgthOld));
1075               int *tmp(new int[nbOfFaces*lgthOld+1]);
1076               int *work=tmp; *work++=INTERP_KERNEL::NORM_POLYHED;
1077               for(unsigned j=0;j<nbOfFaces;j++)
1078                 {
1079                   INTERP_KERNEL::NormalizedCellType type;
1080                   unsigned offset=cm.fillSonCellNodalConnectivity2(j,connOld+pos+1,lgthOld,work,type);
1081                   work+=offset;
1082                   *work++=-1;
1083                 }
1084               std::size_t newLgth(std::distance(tmp,work)-1);//-1 for last -1
1085               connNew->pushBackValsSilent(tmp,tmp+newLgth);
1086               connNewI->pushBackSilent(connNewI->back()+(int)newLgth);
1087               delete [] tmp;
1088             }
1089           else
1090             {
1091               connNew->pushBackValsSilent(connOld+pos,connOld+posP1);
1092               connNewI->pushBackSilent(connNewI->back()+posP1-pos);
1093             }
1094         }
1095       setConnectivity(connNew,connNewI,false);//false because computeTypes called just behind.
1096     }
1097   computeTypes();
1098 }
1099
1100 /*!
1101  * Converts all cells to either polygons (if \a this is a 2D mesh) or
1102  * polyhedrons (if \a this is a 3D mesh).
1103  *  \warning As this method is purely for user-friendliness and no optimization is
1104  *          done to avoid construction of a useless vector, this method can be costly
1105  *          in memory.
1106  *  \throw If the coordinates array is not set.
1107  *  \throw If the nodal connectivity of cells is node defined.
1108  *  \throw If dimension of \a this mesh is not either 2 or 3.
1109  */
1110 void MEDCouplingUMesh::convertAllToPoly()
1111 {
1112   int nbOfCells=getNumberOfCells();
1113   std::vector<int> cellIds(nbOfCells);
1114   for(int i=0;i<nbOfCells;i++)
1115     cellIds[i]=i;
1116   convertToPolyTypes(&cellIds[0],&cellIds[0]+cellIds.size());
1117 }
1118
1119 /*!
1120  * Fixes nodal connectivity of invalid cells of type NORM_POLYHED. This method
1121  * expects that all NORM_POLYHED cells have connectivity similar to that of prismatic
1122  * volumes like NORM_HEXA8, NORM_PENTA6 etc., i.e. the first half of nodes describes a
1123  * base facet of the volume and the second half of nodes describes an opposite facet
1124  * having the same number of nodes as the base one. This method converts such
1125  * connectivity to a valid polyhedral format where connectivity of each facet is
1126  * explicitly described and connectivity of facets are separated by -1. If \a this mesh
1127  * contains a NORM_POLYHED cell with a valid connectivity, or an invalid connectivity is
1128  * not as expected, an exception is thrown and the mesh remains unchanged. Care of
1129  * a correct orientation of the first facet of a polyhedron, else orientation of a
1130  * corrected cell is reverse.<br>
1131  * This method is useful to build an extruded unstructured mesh with polyhedrons as
1132  * it releases the user from boring description of polyhedra connectivity in the valid
1133  * format.
1134  *  \throw If \a this->getMeshDimension() != 3.
1135  *  \throw If \a this->getSpaceDimension() != 3.
1136  *  \throw If the nodal connectivity of cells is not defined.
1137  *  \throw If the coordinates array is not set.
1138  *  \throw If \a this mesh contains polyhedrons with the valid connectivity.
1139  *  \throw If \a this mesh contains polyhedrons with odd number of nodes.
1140  *
1141  *  \if ENABLE_EXAMPLES
1142  *  \ref cpp_mcumesh_arePolyhedronsNotCorrectlyOriented "Here is a C++ example".<br>
1143  *  \ref  py_mcumesh_arePolyhedronsNotCorrectlyOriented "Here is a Python example".
1144  *  \endif
1145  */
1146 void MEDCouplingUMesh::convertExtrudedPolyhedra()
1147 {
1148   checkFullyDefined();
1149   if(getMeshDimension()!=3 || getSpaceDimension()!=3)
1150     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertExtrudedPolyhedra works on umeshes with meshdim equal to 3 and spaceDim equal to 3 too!");
1151   int nbOfCells=getNumberOfCells();
1152   MCAuto<DataArrayInt> newCi=DataArrayInt::New();
1153   newCi->alloc(nbOfCells+1,1);
1154   int *newci=newCi->getPointer();
1155   const int *ci=_nodal_connec_index->getConstPointer();
1156   const int *c=_nodal_connec->getConstPointer();
1157   newci[0]=0;
1158   for(int i=0;i<nbOfCells;i++)
1159     {
1160       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[i]];
1161       if(type==INTERP_KERNEL::NORM_POLYHED)
1162         {
1163           if(std::count(c+ci[i]+1,c+ci[i+1],-1)!=0)
1164             {
1165               std::ostringstream oss; oss << "MEDCouplingUMesh::convertExtrudedPolyhedra : cell # " << i << " is a polhedron BUT it has NOT exactly 1 face !";
1166               throw INTERP_KERNEL::Exception(oss.str());
1167             }
1168           std::size_t n2=std::distance(c+ci[i]+1,c+ci[i+1]);
1169           if(n2%2!=0)
1170             {
1171               std::ostringstream oss; oss << "MEDCouplingUMesh::convertExtrudedPolyhedra : cell # " << i << " is a polhedron with 1 face but there is a mismatch of number of nodes in face should be even !";
1172               throw INTERP_KERNEL::Exception(oss.str());
1173             }
1174           int n1=(int)(n2/2);
1175           newci[i+1]=7*n1+2+newci[i];//6*n1 (nodal length) + n1+2 (number of faces) - 1 (number of '-1' separator is equal to number of faces -1) + 1 (for cell type)
1176         }
1177       else
1178         newci[i+1]=(ci[i+1]-ci[i])+newci[i];
1179     }
1180   MCAuto<DataArrayInt> newC=DataArrayInt::New();
1181   newC->alloc(newci[nbOfCells],1);
1182   int *newc=newC->getPointer();
1183   for(int i=0;i<nbOfCells;i++)
1184     {
1185       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[i]];
1186       if(type==INTERP_KERNEL::NORM_POLYHED)
1187         {
1188           std::size_t n1=std::distance(c+ci[i]+1,c+ci[i+1])/2;
1189           newc=std::copy(c+ci[i],c+ci[i]+n1+1,newc);
1190           *newc++=-1;
1191           for(std::size_t j=0;j<n1;j++)
1192             {
1193               newc[j]=c[ci[i]+1+n1+(n1-j)%n1];
1194               newc[n1+5*j]=-1;
1195               newc[n1+5*j+1]=c[ci[i]+1+j];
1196               newc[n1+5*j+2]=c[ci[i]+1+j+n1];
1197               newc[n1+5*j+3]=c[ci[i]+1+(j+1)%n1+n1];
1198               newc[n1+5*j+4]=c[ci[i]+1+(j+1)%n1];
1199             }
1200           newc+=n1*6;
1201         }
1202       else
1203         newc=std::copy(c+ci[i],c+ci[i+1],newc);
1204     }
1205   _nodal_connec_index->decrRef(); _nodal_connec_index=newCi.retn();
1206   _nodal_connec->decrRef(); _nodal_connec=newC.retn();
1207 }
1208
1209
1210 /*!
1211  * Converts all polygons (if \a this is a 2D mesh) or polyhedrons (if \a this is a 3D
1212  * mesh) to cells of classical types. This method is opposite to convertToPolyTypes().
1213  * \warning Cells of the result mesh are \b not sorted by geometric type, hence,
1214  *          to write this mesh to the MED file, its cells must be sorted using
1215  *          sortCellsInMEDFileFrmt().
1216  * \warning Cells (and most notably polyhedrons) must be correctly oriented for this to work
1217  *          properly. See orientCorrectlyPolyhedrons() and arePolyhedronsNotCorrectlyOriented().
1218  * \return \c true if at least one cell has been converted, \c false else. In the
1219  *         last case the nodal connectivity remains unchanged.
1220  * \throw If the coordinates array is not set.
1221  * \throw If the nodal connectivity of cells is not defined.
1222  * \throw If \a this->getMeshDimension() < 0.
1223  */
1224 bool MEDCouplingUMesh::unPolyze()
1225 {
1226   checkFullyDefined();
1227   int mdim=getMeshDimension();
1228   if(mdim<0)
1229     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::unPolyze works on umeshes with meshdim equals to 0, 1 2 or 3 !");
1230   if(mdim<=1)
1231     return false;
1232   int nbOfCells=getNumberOfCells();
1233   if(nbOfCells<1)
1234     return false;
1235   int initMeshLgth=getNodalConnectivityArrayLen();
1236   int *conn=_nodal_connec->getPointer();
1237   int *index=_nodal_connec_index->getPointer();
1238   int posOfCurCell=0;
1239   int newPos=0;
1240   int lgthOfCurCell;
1241   bool ret=false;
1242   for(int i=0;i<nbOfCells;i++)
1243     {
1244       lgthOfCurCell=index[i+1]-posOfCurCell;
1245       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
1246       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
1247       INTERP_KERNEL::NormalizedCellType newType=INTERP_KERNEL::NORM_ERROR;
1248       int newLgth;
1249       if(cm.isDynamic())
1250         {
1251           switch(cm.getDimension())
1252           {
1253             case 2:
1254               {
1255                 INTERP_KERNEL::AutoPtr<int> tmp=new int[lgthOfCurCell-1];
1256                 std::copy(conn+posOfCurCell+1,conn+posOfCurCell+lgthOfCurCell,(int *)tmp);
1257                 newType=INTERP_KERNEL::CellSimplify::tryToUnPoly2D(cm.isQuadratic(),tmp,lgthOfCurCell-1,conn+newPos+1,newLgth);
1258                 break;
1259               }
1260             case 3:
1261               {
1262                 int nbOfFaces,lgthOfPolyhConn;
1263                 INTERP_KERNEL::AutoPtr<int> zipFullReprOfPolyh=INTERP_KERNEL::CellSimplify::getFullPolyh3DCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,nbOfFaces,lgthOfPolyhConn);
1264                 newType=INTERP_KERNEL::CellSimplify::tryToUnPoly3D(zipFullReprOfPolyh,nbOfFaces,lgthOfPolyhConn,conn+newPos+1,newLgth);
1265                 break;
1266               }
1267             case 1:
1268               {
1269                 newType=(lgthOfCurCell==3)?INTERP_KERNEL::NORM_SEG2:INTERP_KERNEL::NORM_POLYL;
1270                 break;
1271               }
1272           }
1273           ret=ret || (newType!=type);
1274           conn[newPos]=newType;
1275           newPos+=newLgth+1;
1276           posOfCurCell=index[i+1];
1277           index[i+1]=newPos;
1278         }
1279       else
1280         {
1281           std::copy(conn+posOfCurCell,conn+posOfCurCell+lgthOfCurCell,conn+newPos);
1282           newPos+=lgthOfCurCell;
1283           posOfCurCell+=lgthOfCurCell;
1284           index[i+1]=newPos;
1285         }
1286     }
1287   if(newPos!=initMeshLgth)
1288     _nodal_connec->reAlloc(newPos);
1289   if(ret)
1290     computeTypes();
1291   return ret;
1292 }
1293
1294 /*!
1295  * This method expects that spaceDimension is equal to 3 and meshDimension equal to 3.
1296  * This method performs operation only on polyhedrons in \b this. If no polyhedrons exists in \b this, \b this remains unchanged.
1297  * This method allows to merge if any coplanar 3DSurf cells that may appear in some polyhedrons cells. 
1298  *
1299  * \param [in] eps is a relative precision that allows to establish if some 3D plane are coplanar or not. This epsilon is used to recenter around origin to have maximal 
1300  *             precision.
1301  */
1302 void MEDCouplingUMesh::simplifyPolyhedra(double eps)
1303 {
1304   checkFullyDefined();
1305   if(getMeshDimension()!=3 || getSpaceDimension()!=3)
1306     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::simplifyPolyhedra : works on meshdimension 3 and spaceDimension 3 !");
1307   MCAuto<DataArrayDouble> coords=getCoords()->deepCopy();
1308   coords->recenterForMaxPrecision(eps);
1309   //
1310   int nbOfCells=getNumberOfCells();
1311   const int *conn=_nodal_connec->getConstPointer();
1312   const int *index=_nodal_connec_index->getConstPointer();
1313   MCAuto<DataArrayInt> connINew=DataArrayInt::New();
1314   connINew->alloc(nbOfCells+1,1);
1315   int *connINewPtr=connINew->getPointer(); *connINewPtr++=0;
1316   MCAuto<DataArrayInt> connNew=DataArrayInt::New(); connNew->alloc(0,1);
1317   MCAuto<DataArrayInt> E_Fi(DataArrayInt::New()), E_F(DataArrayInt::New()), F_Ei(DataArrayInt::New()), F_E(DataArrayInt::New());
1318   MCAuto<MEDCouplingUMesh> m_faces(buildDescendingConnectivity(E_F, E_Fi, F_E, F_Ei));
1319   bool changed=false;
1320   for(int i=0;i<nbOfCells;i++,connINewPtr++)
1321     {
1322       if(conn[index[i]]==(int)INTERP_KERNEL::NORM_POLYHED)
1323         {
1324           SimplifyPolyhedronCell(eps,coords, i,connNew, m_faces, E_Fi, E_F, F_Ei, F_E);
1325           changed=true;
1326         }
1327       else
1328         connNew->insertAtTheEnd(conn+index[i],conn+index[i+1]);
1329       *connINewPtr=connNew->getNumberOfTuples();
1330     }
1331   if(changed)
1332     setConnectivity(connNew,connINew,false);
1333 }
1334
1335 /*!
1336  * This method returns all node ids used in the connectivity of \b this. The data array returned has to be dealt by the caller.
1337  * The returned node ids are sorted ascendingly. This method is close to MEDCouplingUMesh::getNodeIdsInUse except
1338  * the format of the returned DataArrayInt instance.
1339  * 
1340  * \return a newly allocated DataArrayInt sorted ascendingly of fetched node ids.
1341  * \sa MEDCouplingUMesh::getNodeIdsInUse, areAllNodesFetched
1342  */
1343 DataArrayInt *MEDCouplingUMesh::computeFetchedNodeIds() const
1344 {
1345   checkConnectivityFullyDefined();
1346   const int *maxEltPt(std::max_element(_nodal_connec->begin(),_nodal_connec->end()));
1347   int maxElt(maxEltPt==_nodal_connec->end()?0:std::abs(*maxEltPt)+1);
1348   std::vector<bool> retS(maxElt,false);
1349   computeNodeIdsAlg(retS);
1350   return DataArrayInt::BuildListOfSwitchedOn(retS);
1351 }
1352
1353 /*!
1354  * \param [in,out] nodeIdsInUse an array of size typically equal to nbOfNodes.
1355  * \sa MEDCouplingUMesh::getNodeIdsInUse, areAllNodesFetched
1356  */
1357 void MEDCouplingUMesh::computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const
1358 {
1359   int nbOfNodes((int)nodeIdsInUse.size()),nbOfCells(getNumberOfCells());
1360   const int *connIndex(_nodal_connec_index->getConstPointer()),*conn(_nodal_connec->getConstPointer());
1361   for(int i=0;i<nbOfCells;i++)
1362     for(int j=connIndex[i]+1;j<connIndex[i+1];j++)
1363       if(conn[j]>=0)
1364         {
1365           if(conn[j]<nbOfNodes)
1366             nodeIdsInUse[conn[j]]=true;
1367           else
1368             {
1369               std::ostringstream oss; oss << "MEDCouplingUMesh::computeNodeIdsAlg : In cell #" << i  << " presence of node id " <<  conn[j] << " not in [0," << nbOfNodes << ") !";
1370               throw INTERP_KERNEL::Exception(oss.str());
1371             }
1372         }
1373 }
1374
1375 /// @cond INTERNAL
1376
1377 struct MEDCouplingAccVisit
1378 {
1379   MEDCouplingAccVisit():_new_nb_of_nodes(0) { }
1380   int operator()(int val) { if(val!=-1) return _new_nb_of_nodes++; else return -1; }
1381   int _new_nb_of_nodes;
1382 };
1383
1384 /// @endcond
1385
1386 /*!
1387  * Finds nodes not used in any cell and returns an array giving a new id to every node
1388  * by excluding the unused nodes, for which the array holds -1. The result array is
1389  * a mapping in "Old to New" mode. 
1390  *  \param [out] nbrOfNodesInUse - number of node ids present in the nodal connectivity.
1391  *  \return DataArrayInt * - a new instance of DataArrayInt. Its length is \a
1392  *          this->getNumberOfNodes(). It holds for each node of \a this mesh either -1
1393  *          if the node is unused or a new id else. The caller is to delete this
1394  *          array using decrRef() as it is no more needed.  
1395  *  \throw If the coordinates array is not set.
1396  *  \throw If the nodal connectivity of cells is not defined.
1397  *  \throw If the nodal connectivity includes an invalid id.
1398  *
1399  *  \if ENABLE_EXAMPLES
1400  *  \ref cpp_mcumesh_getNodeIdsInUse "Here is a C++ example".<br>
1401  *  \ref  py_mcumesh_getNodeIdsInUse "Here is a Python example".
1402  *  \endif
1403  * \sa computeFetchedNodeIds, computeNodeIdsAlg()
1404  */
1405 DataArrayInt *MEDCouplingUMesh::getNodeIdsInUse(int& nbrOfNodesInUse) const
1406 {
1407   nbrOfNodesInUse=-1;
1408   int nbOfNodes(getNumberOfNodes());
1409   MCAuto<DataArrayInt> ret=DataArrayInt::New();
1410   ret->alloc(nbOfNodes,1);
1411   int *traducer=ret->getPointer();
1412   std::fill(traducer,traducer+nbOfNodes,-1);
1413   int nbOfCells=getNumberOfCells();
1414   const int *connIndex=_nodal_connec_index->getConstPointer();
1415   const int *conn=_nodal_connec->getConstPointer();
1416   for(int i=0;i<nbOfCells;i++)
1417     for(int j=connIndex[i]+1;j<connIndex[i+1];j++)
1418       if(conn[j]>=0)
1419         {
1420           if(conn[j]<nbOfNodes)
1421             traducer[conn[j]]=1;
1422           else
1423             {
1424               std::ostringstream oss; oss << "MEDCouplingUMesh::getNodeIdsInUse : In cell #" << i  << " presence of node id " <<  conn[j] << " not in [0," << nbOfNodes << ") !";
1425               throw INTERP_KERNEL::Exception(oss.str());
1426             }
1427         }
1428   nbrOfNodesInUse=(int)std::count(traducer,traducer+nbOfNodes,1);
1429   std::transform(traducer,traducer+nbOfNodes,traducer,MEDCouplingAccVisit());
1430   return ret.retn();
1431 }
1432
1433 /*!
1434  * This method returns a newly allocated array containing this->getNumberOfCells() tuples and 1 component.
1435  * For each cell in \b this the number of nodes constituting cell is computed.
1436  * For each polyhedron cell, the sum of the number of nodes of each face constituting polyhedron cell is returned.
1437  * So for pohyhedrons some nodes can be counted several times in the returned result.
1438  * 
1439  * \return a newly allocated array
1440  * \sa MEDCouplingUMesh::computeEffectiveNbOfNodesPerCell
1441  */
1442 DataArrayInt *MEDCouplingUMesh::computeNbOfNodesPerCell() const
1443 {
1444   checkConnectivityFullyDefined();
1445   int nbOfCells=getNumberOfCells();
1446   MCAuto<DataArrayInt> ret=DataArrayInt::New();
1447   ret->alloc(nbOfCells,1);
1448   int *retPtr=ret->getPointer();
1449   const int *conn=getNodalConnectivity()->getConstPointer();
1450   const int *connI=getNodalConnectivityIndex()->getConstPointer();
1451   for(int i=0;i<nbOfCells;i++,retPtr++)
1452     {
1453       if(conn[connI[i]]!=(int)INTERP_KERNEL::NORM_POLYHED)
1454         *retPtr=connI[i+1]-connI[i]-1;
1455       else
1456         *retPtr=connI[i+1]-connI[i]-1-std::count(conn+connI[i]+1,conn+connI[i+1],-1);
1457     }
1458   return ret.retn();
1459 }
1460
1461 /*!
1462  * This method computes effective number of nodes per cell. That is to say nodes appearing several times in nodal connectivity of a cell,
1463  * will be counted only once here whereas it will be counted several times in MEDCouplingUMesh::computeNbOfNodesPerCell method.
1464  *
1465  * \return DataArrayInt * - new object to be deallocated by the caller.
1466  * \sa MEDCouplingUMesh::computeNbOfNodesPerCell
1467  */
1468 DataArrayInt *MEDCouplingUMesh::computeEffectiveNbOfNodesPerCell() const
1469 {
1470   checkConnectivityFullyDefined();
1471   int nbOfCells=getNumberOfCells();
1472   MCAuto<DataArrayInt> ret=DataArrayInt::New();
1473   ret->alloc(nbOfCells,1);
1474   int *retPtr=ret->getPointer();
1475   const int *conn=getNodalConnectivity()->getConstPointer();
1476   const int *connI=getNodalConnectivityIndex()->getConstPointer();
1477   for(int i=0;i<nbOfCells;i++,retPtr++)
1478     {
1479       std::set<int> s(conn+connI[i]+1,conn+connI[i+1]);
1480       if(conn[connI[i]]!=(int)INTERP_KERNEL::NORM_POLYHED)
1481         *retPtr=(int)s.size();
1482       else
1483         {
1484           s.erase(-1);
1485           *retPtr=(int)s.size();
1486         }
1487     }
1488   return ret.retn();
1489 }
1490
1491 /*!
1492  * This method returns a newly allocated array containing this->getNumberOfCells() tuples and 1 component.
1493  * For each cell in \b this the number of faces constituting (entity of dimension this->getMeshDimension()-1) cell is computed.
1494  * 
1495  * \return a newly allocated array
1496  */
1497 DataArrayInt *MEDCouplingUMesh::computeNbOfFacesPerCell() const
1498 {
1499   checkConnectivityFullyDefined();
1500   int nbOfCells=getNumberOfCells();
1501   MCAuto<DataArrayInt> ret=DataArrayInt::New();
1502   ret->alloc(nbOfCells,1);
1503   int *retPtr=ret->getPointer();
1504   const int *conn=getNodalConnectivity()->getConstPointer();
1505   const int *connI=getNodalConnectivityIndex()->getConstPointer();
1506   for(int i=0;i<nbOfCells;i++,retPtr++,connI++)
1507     {
1508       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[*connI]);
1509       *retPtr=cm.getNumberOfSons2(conn+connI[0]+1,connI[1]-connI[0]-1);
1510     }
1511   return ret.retn();
1512 }
1513
1514 /*!
1515  * Removes unused nodes (the node coordinates array is shorten) and returns an array
1516  * mapping between new and old node ids in "Old to New" mode. -1 values in the returned
1517  * array mean that the corresponding old node is no more used. 
1518  *  \return DataArrayInt * - a new instance of DataArrayInt of length \a
1519  *           this->getNumberOfNodes() before call of this method. The caller is to
1520  *           delete this array using decrRef() as it is no more needed. 
1521  *  \throw If the coordinates array is not set.
1522  *  \throw If the nodal connectivity of cells is not defined.
1523  *  \throw If the nodal connectivity includes an invalid id.
1524  *  \sa areAllNodesFetched
1525  *
1526  *  \if ENABLE_EXAMPLES
1527  *  \ref cpp_mcumesh_zipCoordsTraducer "Here is a C++ example".<br>
1528  *  \ref  py_mcumesh_zipCoordsTraducer "Here is a Python example".
1529  *  \endif
1530  */
1531 DataArrayInt *MEDCouplingUMesh::zipCoordsTraducer()
1532 {
1533   return MEDCouplingPointSet::zipCoordsTraducer();
1534 }
1535
1536 /*!
1537  * This method stands if 'cell1' and 'cell2' are equals regarding 'compType' policy.
1538  * The semantic of 'compType' is specified in MEDCouplingPointSet::zipConnectivityTraducer method.
1539  */
1540 int MEDCouplingUMesh::AreCellsEqual(const int *conn, const int *connI, int cell1, int cell2, int compType)
1541 {
1542   switch(compType)
1543   {
1544     case 0:
1545       return AreCellsEqualPolicy0(conn,connI,cell1,cell2);
1546     case 1:
1547       return AreCellsEqualPolicy1(conn,connI,cell1,cell2);
1548     case 2:
1549       return AreCellsEqualPolicy2(conn,connI,cell1,cell2);
1550     case 3:
1551       return AreCellsEqualPolicy2NoType(conn,connI,cell1,cell2);
1552     case 7:
1553       return AreCellsEqualPolicy7(conn,connI,cell1,cell2);
1554   }
1555   throw INTERP_KERNEL::Exception("Unknown comparison asked ! Must be in 0,1,2,3 or 7.");
1556 }
1557
1558 /*!
1559  * This method is the last step of the MEDCouplingPointSet::zipConnectivityTraducer with policy 0.
1560  */
1561 int MEDCouplingUMesh::AreCellsEqualPolicy0(const int *conn, const int *connI, int cell1, int cell2)
1562 {
1563   if(connI[cell1+1]-connI[cell1]==connI[cell2+1]-connI[cell2])
1564     return std::equal(conn+connI[cell1]+1,conn+connI[cell1+1],conn+connI[cell2]+1)?1:0;
1565   return 0;
1566 }
1567
1568 /*!
1569  * This method is the last step of the MEDCouplingPointSet::zipConnectivityTraducer with policy 1.
1570  */
1571 int MEDCouplingUMesh::AreCellsEqualPolicy1(const int *conn, const int *connI, int cell1, int cell2)
1572 {
1573   int sz=connI[cell1+1]-connI[cell1];
1574   if(sz==connI[cell2+1]-connI[cell2])
1575     {
1576       if(conn[connI[cell1]]==conn[connI[cell2]])
1577         {
1578           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[connI[cell1]]);
1579           unsigned dim=cm.getDimension();
1580           if(dim!=3)
1581             {
1582               if(dim!=1)
1583                 {
1584                   int sz1=2*(sz-1);
1585                   INTERP_KERNEL::AutoPtr<int> tmp=new int[sz1];
1586                   int *work=std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],(int *)tmp);
1587                   std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],work);
1588                   work=std::search((int *)tmp,(int *)tmp+sz1,conn+connI[cell2]+1,conn+connI[cell2+1]);
1589                   return work!=tmp+sz1?1:0;
1590                 }
1591               else
1592                 return std::equal(conn+connI[cell1]+1,conn+connI[cell1+1],conn+connI[cell2]+1)?1:0;//case of SEG2 and SEG3
1593             }
1594           else
1595             throw INTERP_KERNEL::Exception("MEDCouplingUMesh::AreCellsEqualPolicy1 : not implemented yet for meshdim == 3 !");
1596         }
1597     }
1598   return 0;
1599 }
1600
1601 /*!
1602  * This method is the last step of the MEDCouplingPointSet::zipConnectivityTraducer with policy 2.
1603  */
1604 int MEDCouplingUMesh::AreCellsEqualPolicy2(const int *conn, const int *connI, int cell1, int cell2)
1605 {
1606   if(connI[cell1+1]-connI[cell1]==connI[cell2+1]-connI[cell2])
1607     {
1608       if(conn[connI[cell1]]==conn[connI[cell2]])
1609         {
1610           std::set<int> s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
1611           std::set<int> s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
1612           return s1==s2?1:0;
1613         }
1614     }
1615   return 0;
1616 }
1617
1618 /*!
1619  * This method is less restrictive than AreCellsEqualPolicy2. Here the geometric type is absolutely not taken into account !
1620  */
1621 int MEDCouplingUMesh::AreCellsEqualPolicy2NoType(const int *conn, const int *connI, int cell1, int cell2)
1622 {
1623   if(connI[cell1+1]-connI[cell1]==connI[cell2+1]-connI[cell2])
1624     {
1625       std::set<int> s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
1626       std::set<int> s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
1627       return s1==s2?1:0;
1628     }
1629   return 0;
1630 }
1631
1632 /*!
1633  * This method is the last step of the MEDCouplingPointSet::zipConnectivityTraducer with policy 7.
1634  */
1635 int MEDCouplingUMesh::AreCellsEqualPolicy7(const int *conn, const int *connI, int cell1, int cell2)
1636 {
1637   int sz=connI[cell1+1]-connI[cell1];
1638   if(sz==connI[cell2+1]-connI[cell2])
1639     {
1640       if(conn[connI[cell1]]==conn[connI[cell2]])
1641         {
1642           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[connI[cell1]]);
1643           unsigned dim=cm.getDimension();
1644           if(dim!=3)
1645             {
1646               if(dim!=1)
1647                 {
1648                   int sz1=2*(sz-1);
1649                   INTERP_KERNEL::AutoPtr<int> tmp=new int[sz1];
1650                   int *work=std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],(int *)tmp);
1651                   std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],work);
1652                   work=std::search((int *)tmp,(int *)tmp+sz1,conn+connI[cell2]+1,conn+connI[cell2+1]);
1653                   if(work!=tmp+sz1)
1654                     return 1;
1655                   else
1656                     {
1657                       std::reverse_iterator<int *> it1((int *)tmp+sz1);
1658                       std::reverse_iterator<int *> it2((int *)tmp);
1659                       if(std::search(it1,it2,conn+connI[cell2]+1,conn+connI[cell2+1])!=it2)
1660                         return 2;
1661                       else
1662                         return 0;
1663                     }
1664
1665                   return work!=tmp+sz1?1:0;
1666                 }
1667               else
1668                 {//case of SEG2 and SEG3
1669                   if(std::equal(conn+connI[cell1]+1,conn+connI[cell1+1],conn+connI[cell2]+1))
1670                     return 1;
1671                   if(!cm.isQuadratic())
1672                     {
1673                       std::reverse_iterator<const int *> it1(conn+connI[cell1+1]);
1674                       std::reverse_iterator<const int *> it2(conn+connI[cell1]+1);
1675                       if(std::equal(it1,it2,conn+connI[cell2]+1))
1676                         return 2;
1677                       return 0;
1678                     }
1679                   else
1680                     {
1681                       if(conn[connI[cell1]+1]==conn[connI[cell2]+2] && conn[connI[cell1]+2]==conn[connI[cell2]+1] && conn[connI[cell1]+3]==conn[connI[cell2]+3])
1682                         return 2;
1683                       return 0;
1684                     }
1685                 }
1686             }
1687           else
1688             throw INTERP_KERNEL::Exception("MEDCouplingUMesh::AreCellsEqualPolicy7 : not implemented yet for meshdim == 3 !");
1689         }
1690     }
1691   return 0;
1692 }
1693
1694
1695 /*!
1696  * This method find cells that are equal (regarding \a compType) in \a this. The comparison is specified
1697  * by \a compType.
1698  * This method keeps the coordiantes of \a this. This method is time consuming.
1699  *
1700  * \param [in] compType input specifying the technique used to compare cells each other.
1701  *   - 0 : exactly. A cell is detected to be the same if and only if the connectivity is exactly the same without permutation and types same too. This is the strongest policy.
1702  *   - 1 : permutation same orientation. cell1 and cell2 are considered equal if the connectivity of cell2 can be deduced by those of cell1 by direct permutation (with exactly the same orientation)
1703  * and their type equal. For 1D mesh the policy 1 is equivalent to 0.
1704  *   - 2 : nodal. cell1 and cell2 are equal if and only if cell1 and cell2 have same type and have the same nodes constituting connectivity. This is the laziest policy. This policy
1705  * can be used for users not sensitive to orientation of cell
1706  * \param [in] startCellId specifies the cellId starting from which the equality computation will be carried out. By default it is 0, which it means that all cells in \a this will be scanned.
1707  * \param [out] commonCellsArr common cells ids (\ref numbering-indirect)
1708  * \param [out] commonCellsIArr common cells ids (\ref numbering-indirect)
1709  * \return the correspondence array old to new in a newly allocated array.
1710  * 
1711  */
1712 void MEDCouplingUMesh::findCommonCells(int compType, int startCellId, DataArrayInt *& commonCellsArr, DataArrayInt *& commonCellsIArr) const
1713 {
1714   MCAuto<DataArrayInt> revNodal=DataArrayInt::New(),revNodalI=DataArrayInt::New();
1715   getReverseNodalConnectivity(revNodal,revNodalI);
1716   FindCommonCellsAlg(compType,startCellId,_nodal_connec,_nodal_connec_index,revNodal,revNodalI,commonCellsArr,commonCellsIArr);
1717 }
1718
1719 void MEDCouplingUMesh::FindCommonCellsAlg(int compType, int startCellId, const DataArrayInt *nodal, const DataArrayInt *nodalI, const DataArrayInt *revNodal, const DataArrayInt *revNodalI,
1720                                           DataArrayInt *& commonCellsArr, DataArrayInt *& commonCellsIArr)
1721 {
1722   MCAuto<DataArrayInt> commonCells=DataArrayInt::New(),commonCellsI=DataArrayInt::New(); commonCells->alloc(0,1);
1723   int nbOfCells=nodalI->getNumberOfTuples()-1;
1724   commonCellsI->reserve(1); commonCellsI->pushBackSilent(0);
1725   const int *revNodalPtr=revNodal->getConstPointer(),*revNodalIPtr=revNodalI->getConstPointer();
1726   const int *connPtr=nodal->getConstPointer(),*connIPtr=nodalI->getConstPointer();
1727   std::vector<bool> isFetched(nbOfCells,false);
1728   if(startCellId==0)
1729     {
1730       for(int i=0;i<nbOfCells;i++)
1731         {
1732           if(!isFetched[i])
1733             {
1734               const int *connOfNode=std::find_if(connPtr+connIPtr[i]+1,connPtr+connIPtr[i+1],std::bind2nd(std::not_equal_to<int>(),-1));
1735               std::vector<int> v,v2;
1736               if(connOfNode!=connPtr+connIPtr[i+1])
1737                 {
1738                   const int *locRevNodal=std::find(revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],i);
1739                   v2.insert(v2.end(),locRevNodal,revNodalPtr+revNodalIPtr[*connOfNode+1]);
1740                   connOfNode++;
1741                 }
1742               for(;connOfNode!=connPtr+connIPtr[i+1] && v2.size()>1;connOfNode++)
1743                 if(*connOfNode>=0)
1744                   {
1745                     v=v2;
1746                     const int *locRevNodal=std::find(revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],i);
1747                     std::vector<int>::iterator it=std::set_intersection(v.begin(),v.end(),locRevNodal,revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
1748                     v2.resize(std::distance(v2.begin(),it));
1749                   }
1750               if(v2.size()>1)
1751                 {
1752                   if(AreCellsEqualInPool(v2,compType,connPtr,connIPtr,commonCells))
1753                     {
1754                       int pos=commonCellsI->back();
1755                       commonCellsI->pushBackSilent(commonCells->getNumberOfTuples());
1756                       for(const int *it=commonCells->begin()+pos;it!=commonCells->end();it++)
1757                         isFetched[*it]=true;
1758                     }
1759                 }
1760             }
1761         }
1762     }
1763   else
1764     {
1765       for(int i=startCellId;i<nbOfCells;i++)
1766         {
1767           if(!isFetched[i])
1768             {
1769               const int *connOfNode=std::find_if(connPtr+connIPtr[i]+1,connPtr+connIPtr[i+1],std::bind2nd(std::not_equal_to<int>(),-1));
1770               std::vector<int> v,v2;
1771               if(connOfNode!=connPtr+connIPtr[i+1])
1772                 {
1773                   v2.insert(v2.end(),revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1]);
1774                   connOfNode++;
1775                 }
1776               for(;connOfNode!=connPtr+connIPtr[i+1] && v2.size()>1;connOfNode++)
1777                 if(*connOfNode>=0)
1778                   {
1779                     v=v2;
1780                     std::vector<int>::iterator it=std::set_intersection(v.begin(),v.end(),revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
1781                     v2.resize(std::distance(v2.begin(),it));
1782                   }
1783               if(v2.size()>1)
1784                 {
1785                   if(AreCellsEqualInPool(v2,compType,connPtr,connIPtr,commonCells))
1786                     {
1787                       int pos=commonCellsI->back();
1788                       commonCellsI->pushBackSilent(commonCells->getNumberOfTuples());
1789                       for(const int *it=commonCells->begin()+pos;it!=commonCells->end();it++)
1790                         isFetched[*it]=true;
1791                     }
1792                 }
1793             }
1794         }
1795     }
1796   commonCellsArr=commonCells.retn();
1797   commonCellsIArr=commonCellsI.retn();
1798 }
1799
1800 /*!
1801  * Checks if \a this mesh includes all cells of an \a other mesh, and returns an array
1802  * giving for each cell of the \a other an id of a cell in \a this mesh. A value larger
1803  * than \a this->getNumberOfCells() in the returned array means that there is no
1804  * corresponding cell in \a this mesh.
1805  * It is expected that \a this and \a other meshes share the same node coordinates
1806  * array, if it is not so an exception is thrown. 
1807  *  \param [in] other - the mesh to compare with.
1808  *  \param [in] compType - specifies a cell comparison technique. For meaning of its
1809  *         valid values [0,1,2], see zipConnectivityTraducer().
1810  *  \param [out] arr - a new instance of DataArrayInt returning correspondence
1811  *         between cells of the two meshes. It contains \a other->getNumberOfCells()
1812  *         values. The caller is to delete this array using
1813  *         decrRef() as it is no more needed.
1814  *  \return bool - \c true if all cells of \a other mesh are present in the \a this
1815  *         mesh.
1816  *
1817  *  \if ENABLE_EXAMPLES
1818  *  \ref cpp_mcumesh_areCellsIncludedIn "Here is a C++ example".<br>
1819  *  \ref  py_mcumesh_areCellsIncludedIn "Here is a Python example".
1820  *  \endif
1821  *  \sa checkDeepEquivalOnSameNodesWith()
1822  *  \sa checkGeoEquivalWith()
1823  */
1824 bool MEDCouplingUMesh::areCellsIncludedIn(const MEDCouplingUMesh *other, int compType, DataArrayInt *& arr) const
1825 {
1826   MCAuto<MEDCouplingUMesh> mesh=MergeUMeshesOnSameCoords(this,other);
1827   int nbOfCells=getNumberOfCells();
1828   static const int possibleCompType[]={0,1,2};
1829   if(std::find(possibleCompType,possibleCompType+sizeof(possibleCompType)/sizeof(int),compType)==possibleCompType+sizeof(possibleCompType)/sizeof(int))
1830     {
1831       std::ostringstream oss; oss << "MEDCouplingUMesh::areCellsIncludedIn : only following policies are possible : ";
1832       std::copy(possibleCompType,possibleCompType+sizeof(possibleCompType)/sizeof(int),std::ostream_iterator<int>(oss," "));
1833       oss << " !";
1834       throw INTERP_KERNEL::Exception(oss.str());
1835     }
1836   MCAuto<DataArrayInt> o2n=mesh->zipConnectivityTraducer(compType,nbOfCells);
1837   arr=o2n->subArray(nbOfCells);
1838   arr->setName(other->getName());
1839   int tmp;
1840   if(other->getNumberOfCells()==0)
1841     return true;
1842   return arr->getMaxValue(tmp)<nbOfCells;
1843 }
1844
1845 /*!
1846  * This method makes the assumption that \a this and \a other share the same coords. If not an exception will be thrown !
1847  * This method tries to determine if \b other is fully included in \b this.
1848  * The main difference is that this method is not expected to throw exception.
1849  * This method has two outputs :
1850  *
1851  * \param other other mesh
1852  * \param arr is an output parameter that returns a \b newly created instance. This array is of size 'other->getNumberOfCells()'.
1853  * \return If \a other is fully included in 'this 'true is returned. If not false is returned.
1854  */
1855 bool MEDCouplingUMesh::areCellsIncludedInPolicy7(const MEDCouplingUMesh *other, DataArrayInt *& arr) const
1856 {
1857   MCAuto<MEDCouplingUMesh> mesh=MergeUMeshesOnSameCoords(this,other);
1858   DataArrayInt *commonCells=0,*commonCellsI=0;
1859   int thisNbCells=getNumberOfCells();
1860   mesh->findCommonCells(7,thisNbCells,commonCells,commonCellsI);
1861   MCAuto<DataArrayInt> commonCellsTmp(commonCells),commonCellsITmp(commonCellsI);
1862   const int *commonCellsPtr=commonCells->getConstPointer(),*commonCellsIPtr=commonCellsI->getConstPointer();
1863   int otherNbCells=other->getNumberOfCells();
1864   MCAuto<DataArrayInt> arr2=DataArrayInt::New();
1865   arr2->alloc(otherNbCells,1);
1866   arr2->fillWithZero();
1867   int *arr2Ptr=arr2->getPointer();
1868   int nbOfCommon=commonCellsI->getNumberOfTuples()-1;
1869   for(int i=0;i<nbOfCommon;i++)
1870     {
1871       int start=commonCellsPtr[commonCellsIPtr[i]];
1872       if(start<thisNbCells)
1873         {
1874           for(int j=commonCellsIPtr[i]+1;j!=commonCellsIPtr[i+1];j++)
1875             {
1876               int sig=commonCellsPtr[j]>0?1:-1;
1877               int val=std::abs(commonCellsPtr[j])-1;
1878               if(val>=thisNbCells)
1879                 arr2Ptr[val-thisNbCells]=sig*(start+1);
1880             }
1881         }
1882     }
1883   arr2->setName(other->getName());
1884   if(arr2->presenceOfValue(0))
1885     return false;
1886   arr=arr2.retn();
1887   return true;
1888 }
1889
1890 MEDCouplingUMesh *MEDCouplingUMesh::mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const
1891 {
1892   if(!other)
1893     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::mergeMyselfWithOnSameCoords : input other is null !");
1894   const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
1895   if(!otherC)
1896     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::mergeMyselfWithOnSameCoords : the input other mesh is not of type unstructured !");
1897   std::vector<const MEDCouplingUMesh *> ms(2);
1898   ms[0]=this;
1899   ms[1]=otherC;
1900   return MergeUMeshesOnSameCoords(ms);
1901 }
1902
1903 /*!
1904  * Build a sub part of \b this lying or not on the same coordinates than \b this (regarding value of \b keepCoords).
1905  * By default coordinates are kept. This method is close to MEDCouplingUMesh::buildPartOfMySelf except that here input
1906  * cellIds is not given explicitly but by a range python like.
1907  * 
1908  * \param start
1909  * \param end
1910  * \param step
1911  * \param keepCoords that specifies if you want or not to keep coords as this or zip it (see MEDCoupling::MEDCouplingUMesh::zipCoords). If true zipCoords is \b NOT called, if false, zipCoords is called.
1912  * \return a newly allocated
1913  * 
1914  * \warning This method modifies can generate an unstructured mesh whose cells are not sorted by geometric type order.
1915  * In view of the MED file writing, a renumbering of cells of returned unstructured mesh (using MEDCouplingUMesh::sortCellsInMEDFileFrmt) should be necessary.
1916  */
1917 MEDCouplingUMesh *MEDCouplingUMesh::buildPartOfMySelfSlice(int start, int end, int step, bool keepCoords) const
1918 {
1919   if(getMeshDimension()!=-1)
1920     return static_cast<MEDCouplingUMesh *>(MEDCouplingPointSet::buildPartOfMySelfSlice(start,end,step,keepCoords));
1921   else
1922     {
1923       int newNbOfCells=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::buildPartOfMySelfSlice for -1 dimension mesh ");
1924       if(newNbOfCells!=1)
1925         throw INTERP_KERNEL::Exception("-1D mesh has only one cell !");
1926       if(start!=0)
1927         throw INTERP_KERNEL::Exception("-1D mesh has only one cell : 0 !");
1928       incrRef();
1929       return const_cast<MEDCouplingUMesh *>(this);
1930     }
1931 }
1932
1933 /*!
1934  * Creates a new MEDCouplingUMesh containing specified cells of \a this mesh.
1935  * The result mesh shares or not the node coordinates array with \a this mesh depending
1936  * on \a keepCoords parameter.
1937  *  \warning Cells of the result mesh can be \b not sorted by geometric type, hence,
1938  *           to write this mesh to the MED file, its cells must be sorted using
1939  *           sortCellsInMEDFileFrmt().
1940  *  \param [in] begin - an array of cell ids to include to the new mesh.
1941  *  \param [in] end - a pointer to last-plus-one-th element of \a begin.
1942  *  \param [in] keepCoords - if \c true, the result mesh shares the node coordinates
1943  *         array of \a this mesh, else "free" nodes are removed from the result mesh
1944  *         by calling zipCoords().
1945  *  \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. The caller is
1946  *         to delete this mesh using decrRef() as it is no more needed. 
1947  *  \throw If the coordinates array is not set.
1948  *  \throw If the nodal connectivity of cells is not defined.
1949  *  \throw If any cell id in the array \a begin is not valid.
1950  *
1951  *  \if ENABLE_EXAMPLES
1952  *  \ref cpp_mcumesh_buildPartOfMySelf "Here is a C++ example".<br>
1953  *  \ref  py_mcumesh_buildPartOfMySelf "Here is a Python example".
1954  *  \endif
1955  */
1956 MEDCouplingUMesh *MEDCouplingUMesh::buildPartOfMySelf(const int *begin, const int *end, bool keepCoords) const
1957 {
1958   if(getMeshDimension()!=-1)
1959     return static_cast<MEDCouplingUMesh *>(MEDCouplingPointSet::buildPartOfMySelf(begin,end,keepCoords));
1960   else
1961     {
1962       if(end-begin!=1)
1963         throw INTERP_KERNEL::Exception("-1D mesh has only one cell !");
1964       if(begin[0]!=0)
1965         throw INTERP_KERNEL::Exception("-1D mesh has only one cell : 0 !");
1966       incrRef();
1967       return const_cast<MEDCouplingUMesh *>(this);
1968     }
1969 }
1970
1971 /*!
1972  * This method operates only on nodal connectivity on \b this. Coordinates of \b this is completely ignored here.
1973  *
1974  * This method allows to partially modify some cells in \b this (whose list is specified by [ \b cellIdsBg, \b cellIdsEnd ) ) with cells coming in \b otherOnSameCoordsThanThis.
1975  * Size of [ \b cellIdsBg, \b cellIdsEnd ) ) must be equal to the number of cells of otherOnSameCoordsThanThis.
1976  * The number of cells of \b this will remain the same with this method.
1977  *
1978  * \param [in] cellIdsBg begin of cell ids (included) of cells in this to assign
1979  * \param [in] cellIdsEnd end of cell ids (excluded) of cells in this to assign
1980  * \param [in] otherOnSameCoordsThanThis an another mesh with same meshdimension than \b this with exactly the same number of cells than cell ids list in [\b cellIdsBg, \b cellIdsEnd ).
1981  *             Coordinate pointer of \b this and those of \b otherOnSameCoordsThanThis must be the same
1982  */
1983 void MEDCouplingUMesh::setPartOfMySelf(const int *cellIdsBg, const int *cellIdsEnd, const MEDCouplingUMesh& otherOnSameCoordsThanThis)
1984 {
1985   checkConnectivityFullyDefined();
1986   otherOnSameCoordsThanThis.checkConnectivityFullyDefined();
1987   if(getCoords()!=otherOnSameCoordsThanThis.getCoords())
1988     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::setPartOfMySelf : coordinates pointer are not the same ! Invoke setCoords or call tryToShareSameCoords method !");
1989   if(getMeshDimension()!=otherOnSameCoordsThanThis.getMeshDimension())
1990     {
1991       std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelf : Mismatch of meshdimensions ! this is equal to " << getMeshDimension();
1992       oss << ", whereas other mesh dimension is set equal to " << otherOnSameCoordsThanThis.getMeshDimension() << " !";
1993       throw INTERP_KERNEL::Exception(oss.str());
1994     }
1995   std::size_t nbOfCellsToModify(std::distance(cellIdsBg,cellIdsEnd));
1996   if(nbOfCellsToModify!=otherOnSameCoordsThanThis.getNumberOfCells())
1997     {
1998       std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelf : cells ids length (" <<  nbOfCellsToModify << ") do not match the number of cells of other mesh (" << otherOnSameCoordsThanThis.getNumberOfCells() << ") !";
1999       throw INTERP_KERNEL::Exception(oss.str());
2000     }
2001   std::size_t nbOfCells(getNumberOfCells());
2002   bool easyAssign(true);
2003   const int *connI(_nodal_connec_index->begin());
2004   const int *connIOther=otherOnSameCoordsThanThis._nodal_connec_index->begin();
2005   for(const int *it=cellIdsBg;it!=cellIdsEnd && easyAssign;it++,connIOther++)
2006     {
2007       if(*it>=0 && *it<(int)nbOfCells)
2008         {
2009           easyAssign=(connIOther[1]-connIOther[0])==(connI[*it+1]-connI[*it]);
2010         }
2011       else
2012         {
2013           std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelf : On pos #" << std::distance(cellIdsBg,it) << " id is equal to " << *it << " which is not in [0," << nbOfCells << ") !";
2014           throw INTERP_KERNEL::Exception(oss.str());
2015         }
2016     }
2017   if(easyAssign)
2018     {
2019       MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx(cellIdsBg,cellIdsEnd,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index);
2020       computeTypes();
2021     }
2022   else
2023     {
2024       DataArrayInt *arrOut=0,*arrIOut=0;
2025       MEDCouplingUMesh::SetPartOfIndexedArrays(cellIdsBg,cellIdsEnd,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index,
2026                                                arrOut,arrIOut);
2027       MCAuto<DataArrayInt> arrOutAuto(arrOut),arrIOutAuto(arrIOut);
2028       setConnectivity(arrOut,arrIOut,true);
2029     }
2030 }
2031
2032 void MEDCouplingUMesh::setPartOfMySelfSlice(int start, int end, int step, const MEDCouplingUMesh& otherOnSameCoordsThanThis)
2033 {
2034   checkConnectivityFullyDefined();
2035   otherOnSameCoordsThanThis.checkConnectivityFullyDefined();
2036   if(getCoords()!=otherOnSameCoordsThanThis.getCoords())
2037     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::setPartOfMySelfSlice : coordinates pointer are not the same ! Invoke setCoords or call tryToShareSameCoords method !");
2038   if(getMeshDimension()!=otherOnSameCoordsThanThis.getMeshDimension())
2039     {
2040       std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelfSlice : Mismatch of meshdimensions ! this is equal to " << getMeshDimension();
2041       oss << ", whereas other mesh dimension is set equal to " << otherOnSameCoordsThanThis.getMeshDimension() << " !";
2042       throw INTERP_KERNEL::Exception(oss.str());
2043     }
2044   int nbOfCellsToModify=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::setPartOfMySelfSlice : ");
2045   if(nbOfCellsToModify!=(int)otherOnSameCoordsThanThis.getNumberOfCells())
2046     {
2047       std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelfSlice : cells ids length (" <<  nbOfCellsToModify << ") do not match the number of cells of other mesh (" << otherOnSameCoordsThanThis.getNumberOfCells() << ") !";
2048       throw INTERP_KERNEL::Exception(oss.str());
2049     }
2050   int nbOfCells=getNumberOfCells();
2051   bool easyAssign=true;
2052   const int *connI=_nodal_connec_index->getConstPointer();
2053   const int *connIOther=otherOnSameCoordsThanThis._nodal_connec_index->getConstPointer();
2054   int it=start;
2055   for(int i=0;i<nbOfCellsToModify && easyAssign;i++,it+=step,connIOther++)
2056     {
2057       if(it>=0 && it<nbOfCells)
2058         {
2059           easyAssign=(connIOther[1]-connIOther[0])==(connI[it+1]-connI[it]);
2060         }
2061       else
2062         {
2063           std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelfSlice : On pos #" << i << " id is equal to " << it << " which is not in [0," << nbOfCells << ") !";
2064           throw INTERP_KERNEL::Exception(oss.str());
2065         }
2066     }
2067   if(easyAssign)
2068     {
2069       MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice(start,end,step,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index);
2070       computeTypes();
2071     }
2072   else
2073     {
2074       DataArrayInt *arrOut=0,*arrIOut=0;
2075       MEDCouplingUMesh::SetPartOfIndexedArraysSlice(start,end,step,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index,
2076                                                 arrOut,arrIOut);
2077       MCAuto<DataArrayInt> arrOutAuto(arrOut),arrIOutAuto(arrIOut);
2078       setConnectivity(arrOut,arrIOut,true);
2079     }
2080 }                      
2081
2082
2083 /*!
2084  * Creates a new MEDCouplingUMesh containing cells, of dimension one less than \a
2085  * this->getMeshDimension(), that bound some cells of \a this mesh.
2086  * The cells of lower dimension to include to the result mesh are selected basing on
2087  * specified node ids and the value of \a fullyIn parameter. If \a fullyIn ==\c true, a
2088  * cell is copied if its all nodes are in the array \a begin of node ids. If \a fullyIn
2089  * ==\c false, a cell is copied if any its node is in the array of node ids. The
2090  * created mesh shares the node coordinates array with \a this mesh. 
2091  *  \param [in] begin - the array of node ids.
2092  *  \param [in] end - a pointer to the (last+1)-th element of \a begin.
2093  *  \param [in] fullyIn - if \c true, then cells whose all nodes are in the
2094  *         array \a begin are added, else cells whose any node is in the
2095  *         array \a begin are added.
2096  *  \return MEDCouplingUMesh * - new instance of MEDCouplingUMesh. The caller is
2097  *         to delete this mesh using decrRef() as it is no more needed. 
2098  *  \throw If the coordinates array is not set.
2099  *  \throw If the nodal connectivity of cells is not defined.
2100  *  \throw If any node id in \a begin is not valid.
2101  *
2102  *  \if ENABLE_EXAMPLES
2103  *  \ref cpp_mcumesh_buildFacePartOfMySelfNode "Here is a C++ example".<br>
2104  *  \ref  py_mcumesh_buildFacePartOfMySelfNode "Here is a Python example".
2105  *  \endif
2106  */
2107 MEDCouplingUMesh *MEDCouplingUMesh::buildFacePartOfMySelfNode(const int *begin, const int *end, bool fullyIn) const
2108 {
2109   MCAuto<DataArrayInt> desc,descIndx,revDesc,revDescIndx;
2110   desc=DataArrayInt::New(); descIndx=DataArrayInt::New(); revDesc=DataArrayInt::New(); revDescIndx=DataArrayInt::New();
2111   MCAuto<MEDCouplingUMesh> subMesh=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
2112   desc=0; descIndx=0; revDesc=0; revDescIndx=0;
2113   return static_cast<MEDCouplingUMesh*>(subMesh->buildPartOfMySelfNode(begin,end,fullyIn));
2114 }
2115
2116 /*!
2117  * Creates a new MEDCouplingUMesh containing cells, of dimension one less than \a
2118  * this->getMeshDimension(), which bound only one cell of \a this mesh.
2119  *  \param [in] keepCoords - if \c true, the result mesh shares the node coordinates
2120  *         array of \a this mesh, else "free" nodes are removed from the result mesh
2121  *         by calling zipCoords().
2122  *  \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. The caller is
2123  *         to delete this mesh using decrRef() as it is no more needed. 
2124  *  \throw If the coordinates array is not set.
2125  *  \throw If the nodal connectivity of cells is not defined.
2126  *
2127  *  \if ENABLE_EXAMPLES
2128  *  \ref cpp_mcumesh_buildBoundaryMesh "Here is a C++ example".<br>
2129  *  \ref  py_mcumesh_buildBoundaryMesh "Here is a Python example".
2130  *  \endif
2131  */
2132 MEDCouplingUMesh *MEDCouplingUMesh::buildBoundaryMesh(bool keepCoords) const
2133 {
2134   DataArrayInt *desc=DataArrayInt::New();
2135   DataArrayInt *descIndx=DataArrayInt::New();
2136   DataArrayInt *revDesc=DataArrayInt::New();
2137   DataArrayInt *revDescIndx=DataArrayInt::New();
2138   //
2139   MCAuto<MEDCouplingUMesh> meshDM1=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
2140   revDesc->decrRef();
2141   desc->decrRef();
2142   descIndx->decrRef();
2143   int nbOfCells=meshDM1->getNumberOfCells();
2144   const int *revDescIndxC=revDescIndx->getConstPointer();
2145   std::vector<int> boundaryCells;
2146   for(int i=0;i<nbOfCells;i++)
2147     if(revDescIndxC[i+1]-revDescIndxC[i]==1)
2148       boundaryCells.push_back(i);
2149   revDescIndx->decrRef();
2150   MEDCouplingUMesh *ret=meshDM1->buildPartOfMySelf(&boundaryCells[0],&boundaryCells[0]+boundaryCells.size(),keepCoords);
2151   return ret;
2152 }
2153
2154 /*!
2155  * This method returns a newly created DataArrayInt instance containing ids of cells located in boundary.
2156  * A cell is detected to be on boundary if it contains one or more than one face having only one father.
2157  * This method makes the assumption that \a this is fully defined (coords,connectivity). If not an exception will be thrown. 
2158  */
2159 DataArrayInt *MEDCouplingUMesh::findCellIdsOnBoundary() const
2160 {
2161   checkFullyDefined();
2162   MCAuto<DataArrayInt> desc=DataArrayInt::New();
2163   MCAuto<DataArrayInt> descIndx=DataArrayInt::New();
2164   MCAuto<DataArrayInt> revDesc=DataArrayInt::New();
2165   MCAuto<DataArrayInt> revDescIndx=DataArrayInt::New();
2166   //
2167   buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx)->decrRef();
2168   desc=(DataArrayInt*)0; descIndx=(DataArrayInt*)0;
2169   //
2170   MCAuto<DataArrayInt> tmp=revDescIndx->deltaShiftIndex();
2171   MCAuto<DataArrayInt> faceIds=tmp->findIdsEqual(1); tmp=(DataArrayInt*)0;
2172   const int *revDescPtr=revDesc->getConstPointer();
2173   const int *revDescIndxPtr=revDescIndx->getConstPointer();
2174   int nbOfCells=getNumberOfCells();
2175   std::vector<bool> ret1(nbOfCells,false);
2176   int sz=0;
2177   for(const int *pt=faceIds->begin();pt!=faceIds->end();pt++)
2178     if(!ret1[revDescPtr[revDescIndxPtr[*pt]]])
2179       { ret1[revDescPtr[revDescIndxPtr[*pt]]]=true; sz++; }
2180   //
2181   DataArrayInt *ret2=DataArrayInt::New();
2182   ret2->alloc(sz,1);
2183   int *ret2Ptr=ret2->getPointer();
2184   sz=0;
2185   for(std::vector<bool>::const_iterator it=ret1.begin();it!=ret1.end();it++,sz++)
2186     if(*it)
2187       *ret2Ptr++=sz;
2188   ret2->setName("BoundaryCells");
2189   return ret2;
2190 }
2191
2192 /*!
2193  * This method finds in \b this the cell ids that lie on mesh \b otherDimM1OnSameCoords.
2194  * \b this and \b otherDimM1OnSameCoords have to lie on the same coordinate array pointer. The coherency of that coords array with connectivity
2195  * of \b this and \b otherDimM1OnSameCoords is not important here because this method works only on connectivity.
2196  * this->getMeshDimension() - 1 must be equal to otherDimM1OnSameCoords.getMeshDimension()
2197  *
2198  * s0 is the cell ids set in \b this lying on at least one node in the fetched nodes in \b otherDimM1OnSameCoords.
2199  * This method also returns the cells ids set s1 which contains the cell ids in \b this for which one of the dim-1 constituent
2200  * equals a cell in \b otherDimM1OnSameCoords.
2201  *
2202  * \throw if \b otherDimM1OnSameCoords is not part of constituent of \b this, or if coordinate pointer of \b this and \b otherDimM1OnSameCoords
2203  *        are not same, or if this->getMeshDimension()-1!=otherDimM1OnSameCoords.getMeshDimension()
2204  *
2205  * \param [in] otherDimM1OnSameCoords
2206  * \param [out] cellIdsRk0 a newly allocated array containing the cell ids of s0 (which are cell ids of \b this) in the above algorithm.
2207  * \param [out] cellIdsRk1 a newly allocated array containing the cell ids of s1 \b indexed into the \b cellIdsRk0 subset. To get the absolute ids of s1, simply invoke
2208  *              cellIdsRk1->transformWithIndArr(cellIdsRk0->begin(),cellIdsRk0->end());
2209  */
2210 void MEDCouplingUMesh::findCellIdsLyingOn(const MEDCouplingUMesh& otherDimM1OnSameCoords, DataArrayInt *&cellIdsRk0, DataArrayInt *&cellIdsRk1) const
2211 {
2212   if(getCoords()!=otherDimM1OnSameCoords.getCoords())
2213     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellIdsLyingOn : coordinates pointer are not the same ! Use tryToShareSameCoords method !");
2214   checkConnectivityFullyDefined();
2215   otherDimM1OnSameCoords.checkConnectivityFullyDefined();
2216   if(getMeshDimension()-1!=otherDimM1OnSameCoords.getMeshDimension())
2217     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellIdsLyingOn : invalid mesh dimension of input mesh regarding meshdimesion of this !");
2218   MCAuto<DataArrayInt> fetchedNodeIds1=otherDimM1OnSameCoords.computeFetchedNodeIds();
2219   MCAuto<DataArrayInt> s0arr=getCellIdsLyingOnNodes(fetchedNodeIds1->begin(),fetchedNodeIds1->end(),false);
2220   MCAuto<MEDCouplingUMesh> thisPart=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(s0arr->begin(),s0arr->end(),true));
2221   MCAuto<DataArrayInt> descThisPart=DataArrayInt::New(),descIThisPart=DataArrayInt::New(),revDescThisPart=DataArrayInt::New(),revDescIThisPart=DataArrayInt::New();
2222   MCAuto<MEDCouplingUMesh> thisPartConsti=thisPart->buildDescendingConnectivity(descThisPart,descIThisPart,revDescThisPart,revDescIThisPart);
2223   const int *revDescThisPartPtr=revDescThisPart->getConstPointer(),*revDescIThisPartPtr=revDescIThisPart->getConstPointer();
2224   DataArrayInt *idsOtherInConsti=0;
2225   bool b=thisPartConsti->areCellsIncludedIn(&otherDimM1OnSameCoords,2,idsOtherInConsti);
2226   MCAuto<DataArrayInt> idsOtherInConstiAuto(idsOtherInConsti);
2227   if(!b)
2228     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellIdsLyingOn : the given mdim-1 mesh in other is not a constituent of this !");
2229   std::set<int> s1;
2230   for(const int *idOther=idsOtherInConsti->begin();idOther!=idsOtherInConsti->end();idOther++)
2231     s1.insert(revDescThisPartPtr+revDescIThisPartPtr[*idOther],revDescThisPartPtr+revDescIThisPartPtr[*idOther+1]);
2232   MCAuto<DataArrayInt> s1arr_renum1=DataArrayInt::New(); s1arr_renum1->alloc((int)s1.size(),1); std::copy(s1.begin(),s1.end(),s1arr_renum1->getPointer());
2233   s1arr_renum1->sort();
2234   cellIdsRk0=s0arr.retn();
2235   //cellIdsRk1=s_renum1.retn();
2236   cellIdsRk1=s1arr_renum1.retn();
2237 }
2238
2239 /*!
2240  * This method computes the skin of \b this. That is to say the consituting meshdim-1 mesh is built and only the boundary subpart is
2241  * returned. This subpart of meshdim-1 mesh is built using meshdim-1 cells in it shared only one cell in \b this.
2242  * 
2243  * \return a newly allocated mesh lying on the same coordinates than \b this. The caller has to deal with returned mesh.
2244  */
2245 MEDCouplingUMesh *MEDCouplingUMesh::computeSkin() const
2246 {
2247   MCAuto<DataArrayInt> desc=DataArrayInt::New();
2248   MCAuto<DataArrayInt> descIndx=DataArrayInt::New();
2249   MCAuto<DataArrayInt> revDesc=DataArrayInt::New();
2250   MCAuto<DataArrayInt> revDescIndx=DataArrayInt::New();
2251   //
2252   MCAuto<MEDCouplingUMesh> meshDM1=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
2253   revDesc=0; desc=0; descIndx=0;
2254   MCAuto<DataArrayInt> revDescIndx2=revDescIndx->deltaShiftIndex();
2255   MCAuto<DataArrayInt> part=revDescIndx2->findIdsEqual(1);
2256   return static_cast<MEDCouplingUMesh *>(meshDM1->buildPartOfMySelf(part->begin(),part->end(),true));
2257 }
2258
2259 /*!
2260  * Finds nodes lying on the boundary of \a this mesh.
2261  *  \return DataArrayInt * - a new instance of DataArrayInt holding ids of found
2262  *          nodes. The caller is to delete this array using decrRef() as it is no
2263  *          more needed.
2264  *  \throw If the coordinates array is not set.
2265  *  \throw If the nodal connectivity of cells is node defined.
2266  *
2267  *  \if ENABLE_EXAMPLES
2268  *  \ref cpp_mcumesh_findBoundaryNodes "Here is a C++ example".<br>
2269  *  \ref  py_mcumesh_findBoundaryNodes "Here is a Python example".
2270  *  \endif
2271  */
2272 DataArrayInt *MEDCouplingUMesh::findBoundaryNodes() const
2273 {
2274   MCAuto<MEDCouplingUMesh> skin=computeSkin();
2275   return skin->computeFetchedNodeIds();
2276 }
2277
2278 MEDCouplingUMesh *MEDCouplingUMesh::buildUnstructured() const
2279 {
2280   incrRef();
2281   return const_cast<MEDCouplingUMesh *>(this);
2282 }
2283
2284 /*!
2285  * This method expects that \b this and \b otherDimM1OnSameCoords share the same coordinates array.
2286  * otherDimM1OnSameCoords->getMeshDimension() is expected to be equal to this->getMeshDimension()-1.
2287  * This method searches for nodes needed to be duplicated. These nodes are nodes fetched by \b otherDimM1OnSameCoords which are not part of the boundary of \b otherDimM1OnSameCoords.
2288  * If a node is in the boundary of \b this \b and in the boundary of \b otherDimM1OnSameCoords this node is considered as needed to be duplicated.
2289  * When the set of node ids \b nodeIdsToDuplicate is computed, cell ids in \b this is searched so that their connectivity includes at least 1 node in \b nodeIdsToDuplicate.
2290  *
2291  * \param [in] otherDimM1OnSameCoords a mesh lying on the same coords than \b this and with a mesh dimension equal to those of \b this minus 1. WARNING this input
2292  *             parameter is altered during the call.
2293  * \param [out] nodeIdsToDuplicate node ids needed to be duplicated following the algorithm explain above.
2294  * \param [out] cellIdsNeededToBeRenum cell ids in \b this in which the renumber of nodes should be performed.
2295  * \param [out] cellIdsNotModified cell ids int \b this that lies on \b otherDimM1OnSameCoords mesh whose connectivity do \b not need to be modified as it is the case for \b cellIdsNeededToBeRenum.
2296  *
2297  * \warning This method modifies param \b otherDimM1OnSameCoords (for speed reasons).
2298  */
2299 void MEDCouplingUMesh::findNodesToDuplicate(const MEDCouplingUMesh& otherDimM1OnSameCoords, DataArrayInt *& nodeIdsToDuplicate,
2300                                             DataArrayInt *& cellIdsNeededToBeRenum, DataArrayInt *& cellIdsNotModified) const
2301 {
2302   typedef MCAuto<DataArrayInt> DAInt;
2303   typedef MCAuto<MEDCouplingUMesh> MCUMesh;
2304
2305   checkFullyDefined();
2306   otherDimM1OnSameCoords.checkFullyDefined();
2307   if(getCoords()!=otherDimM1OnSameCoords.getCoords())
2308     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findNodesToDuplicate : meshes do not share the same coords array !");
2309   if(otherDimM1OnSameCoords.getMeshDimension()!=getMeshDimension()-1)
2310     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findNodesToDuplicate : the mesh given in other parameter must have this->getMeshDimension()-1 !");
2311
2312   // Checking star-shaped M1 group:
2313   DAInt dt0=DataArrayInt::New(),dit0=DataArrayInt::New(),rdt0=DataArrayInt::New(),rdit0=DataArrayInt::New();
2314   MCUMesh meshM2 = otherDimM1OnSameCoords.buildDescendingConnectivity(dt0, dit0, rdt0, rdit0);
2315   DAInt dsi = rdit0->deltaShiftIndex();
2316   DAInt idsTmp0 = dsi->findIdsNotInRange(-1, 3);
2317   if(idsTmp0->getNumberOfTuples())
2318     throw INTERP_KERNEL::Exception("MEDFileUMesh::buildInnerBoundaryAlongM1Group: group is too complex: some points (or edges) have more than two connected segments (or faces)!");
2319   dt0=0; dit0=0; rdt0=0; rdit0=0; idsTmp0=0;
2320
2321   // Get extreme nodes from the group (they won't be duplicated), ie nodes belonging to boundary cells of M1
2322   DAInt xtremIdsM2 = dsi->findIdsEqual(1); dsi = 0;
2323   MCUMesh meshM2Part = static_cast<MEDCouplingUMesh *>(meshM2->buildPartOfMySelf(xtremIdsM2->begin(), xtremIdsM2->end(),true));
2324   DAInt xtrem = meshM2Part->computeFetchedNodeIds();
2325   // Remove from the list points on the boundary of the M0 mesh (those need duplication!)
2326   dt0=DataArrayInt::New(),dit0=DataArrayInt::New(),rdt0=DataArrayInt::New(),rdit0=DataArrayInt::New();
2327   MCUMesh m0desc = buildDescendingConnectivity(dt0, dit0, rdt0, rdit0); dt0=0; dit0=0; rdt0=0;
2328   dsi = rdit0->deltaShiftIndex();
2329   DAInt boundSegs = dsi->findIdsEqual(1);   // boundary segs/faces of the M0 mesh
2330   MCUMesh m0descSkin = static_cast<MEDCouplingUMesh *>(m0desc->buildPartOfMySelf(boundSegs->begin(),boundSegs->end(), true));
2331   DAInt fNodes = m0descSkin->computeFetchedNodeIds();
2332   // In 3D, some points on the boundary of M0 still need duplication:
2333   DAInt notDup = 0;
2334   if (getMeshDimension() == 3)
2335     {
2336       DAInt dnu1=DataArrayInt::New(), dnu2=DataArrayInt::New(), dnu3=DataArrayInt::New(), dnu4=DataArrayInt::New();
2337       MCUMesh m0descSkinDesc = m0descSkin->buildDescendingConnectivity(dnu1, dnu2, dnu3, dnu4);
2338       dnu1=0;dnu2=0;dnu3=0;dnu4=0;
2339       DataArrayInt * corresp=0;
2340       meshM2->areCellsIncludedIn(m0descSkinDesc,2,corresp);
2341       DAInt validIds = corresp->findIdsInRange(0, meshM2->getNumberOfCells());
2342       corresp->decrRef();
2343       if (validIds->getNumberOfTuples())
2344         {
2345           MCUMesh m1IntersecSkin = static_cast<MEDCouplingUMesh *>(m0descSkinDesc->buildPartOfMySelf(validIds->begin(), validIds->end(), true));
2346           DAInt notDuplSkin = m1IntersecSkin->findBoundaryNodes();
2347           DAInt fNodes1 = fNodes->buildSubstraction(notDuplSkin);
2348           notDup = xtrem->buildSubstraction(fNodes1);
2349         }
2350       else
2351         notDup = xtrem->buildSubstraction(fNodes);
2352     }
2353   else
2354     notDup = xtrem->buildSubstraction(fNodes);
2355
2356   // Now compute cells around group (i.e. cells where we will do the propagation to identify the two sub-sets delimited by the group)
2357   DAInt m1Nodes = otherDimM1OnSameCoords.computeFetchedNodeIds();
2358   DAInt dupl = m1Nodes->buildSubstraction(notDup);
2359   DAInt cellsAroundGroup = getCellIdsLyingOnNodes(dupl->begin(), dupl->end(), false);  // false= take cell in, even if not all nodes are in notDup
2360
2361   //
2362   MCUMesh m0Part2=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(cellsAroundGroup->begin(),cellsAroundGroup->end(),true));
2363   int nCells2 = m0Part2->getNumberOfCells();
2364   DAInt desc00=DataArrayInt::New(),descI00=DataArrayInt::New(),revDesc00=DataArrayInt::New(),revDescI00=DataArrayInt::New();
2365   MCUMesh m01=m0Part2->buildDescendingConnectivity(desc00,descI00,revDesc00,revDescI00);
2366
2367   // Neighbor information of the mesh without considering the crack (serves to count how many connex pieces it is made of)
2368   DataArrayInt *tmp00=0,*tmp11=0;
2369   MEDCouplingUMesh::ComputeNeighborsOfCellsAdv(desc00,descI00,revDesc00,revDescI00, tmp00, tmp11);
2370   DAInt neighInit00(tmp00);
2371   DAInt neighIInit00(tmp11);
2372   // Neighbor information of the mesh WITH the crack (some neighbors are removed):
2373   DataArrayInt *idsTmp=0;
2374   m01->areCellsIncludedIn(&otherDimM1OnSameCoords,2,idsTmp);
2375   DAInt ids(idsTmp);
2376   // In the neighbor information remove the connection between high dimension cells and its low level constituents which are part
2377   // of the frontier given in parameter (i.e. the cells of low dimension from the group delimiting the crack):
2378   MEDCouplingUMesh::RemoveIdsFromIndexedArrays(ids->begin(),ids->end(),desc00,descI00);
2379   DataArrayInt *tmp0=0,*tmp1=0;
2380   // Compute the neighbor of each cell in m0Part2, taking into account the broken link above. Two
2381   // cells on either side of the crack (defined by the mesh of low dimension) are not neighbor anymore.
2382   ComputeNeighborsOfCellsAdv(desc00,descI00,revDesc00,revDescI00,tmp0,tmp1);
2383   DAInt neigh00(tmp0);
2384   DAInt neighI00(tmp1);
2385
2386   // For each initial connex part of the sub-mesh (or said differently for each independent crack):
2387   int seed = 0, nIter = 0;
2388   int nIterMax = nCells2+1; // Safety net for the loop
2389   DAInt hitCells = DataArrayInt::New(); hitCells->alloc(nCells2);
2390   hitCells->fillWithValue(-1);
2391   DAInt cellsToModifyConn0_torenum = DataArrayInt::New();
2392   cellsToModifyConn0_torenum->alloc(0,1);
2393   while (nIter < nIterMax)
2394     {
2395       DAInt t = hitCells->findIdsEqual(-1);
2396       if (!t->getNumberOfTuples())
2397         break;
2398       // Connex zone without the crack (to compute the next seed really)
2399       int dnu;
2400       DAInt connexCheck = MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(&seed, &seed+1, neighInit00,neighIInit00, -1, dnu);
2401       std::size_t cnt(0);
2402       for (int * ptr = connexCheck->getPointer(); cnt < connexCheck->getNumberOfTuples(); ptr++, cnt++)
2403         hitCells->setIJ(*ptr,0,1);
2404       // Connex zone WITH the crack (to identify cells lying on either part of the crack)
2405       DAInt spreadZone = MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(&seed, &seed+1, neigh00,neighI00, -1, dnu);
2406       cellsToModifyConn0_torenum = DataArrayInt::Aggregate(cellsToModifyConn0_torenum, spreadZone, 0);
2407       // Compute next seed, i.e. a cell in another connex part, which was not covered by the previous iterations
2408       DAInt comple = cellsToModifyConn0_torenum->buildComplement(nCells2);
2409       DAInt nonHitCells = hitCells->findIdsEqual(-1);
2410       DAInt intersec = nonHitCells->buildIntersection(comple);
2411       if (intersec->getNumberOfTuples())
2412         { seed = intersec->getIJ(0,0); }
2413       else
2414         { break; }
2415       nIter++;
2416     }
2417   if (nIter >= nIterMax)
2418     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findNodesToDuplicate(): internal error - too many iterations.");
2419
2420   DAInt cellsToModifyConn1_torenum=cellsToModifyConn0_torenum->buildComplement(neighI00->getNumberOfTuples()-1);
2421   cellsToModifyConn0_torenum->transformWithIndArr(cellsAroundGroup->begin(),cellsAroundGroup->end());
2422   cellsToModifyConn1_torenum->transformWithIndArr(cellsAroundGroup->begin(),cellsAroundGroup->end());
2423   //
2424   cellIdsNeededToBeRenum=cellsToModifyConn0_torenum.retn();
2425   cellIdsNotModified=cellsToModifyConn1_torenum.retn();
2426   nodeIdsToDuplicate=dupl.retn();
2427 }
2428
2429 /*!
2430  * This method operates a modification of the connectivity and coords in \b this.
2431  * Every time that a node id in [ \b nodeIdsToDuplicateBg, \b nodeIdsToDuplicateEnd ) will append in nodal connectivity of \b this 
2432  * its ids will be modified to id this->getNumberOfNodes()+std::distance(nodeIdsToDuplicateBg,std::find(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd,id)).
2433  * More explicitly the renumber array in nodes is not explicitly given in old2new to avoid to build a big array of renumbering whereas typically few node ids needs to be
2434  * renumbered. The node id nodeIdsToDuplicateBg[0] will have id this->getNumberOfNodes()+0, node id nodeIdsToDuplicateBg[1] will have id this->getNumberOfNodes()+1,
2435  * node id nodeIdsToDuplicateBg[2] will have id this->getNumberOfNodes()+2...
2436  * 
2437  * As a consequence nodal connectivity array length will remain unchanged by this method, and nodal connectivity index array will remain unchanged by this method.
2438  * 
2439  * \param [in] nodeIdsToDuplicateBg begin of node ids (included) to be duplicated in connectivity only
2440  * \param [in] nodeIdsToDuplicateEnd end of node ids (excluded) to be duplicated in connectivity only
2441  */
2442 void MEDCouplingUMesh::duplicateNodes(const int *nodeIdsToDuplicateBg, const int *nodeIdsToDuplicateEnd)
2443 {
2444   int nbOfNodes=getNumberOfNodes();
2445   duplicateNodesInCoords(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd);
2446   duplicateNodesInConn(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd,nbOfNodes);
2447 }
2448
2449 /*!
2450  * This method renumbers only nodal connectivity in \a this. The renumbering is only an offset applied. So this method is a specialization of
2451  * \a renumberNodesInConn. \b WARNING, this method does not check that the resulting node ids in the nodal connectivity is in a valid range !
2452  *
2453  * \param [in] offset - specifies the offset to be applied on each element of connectivity.
2454  *
2455  * \sa renumberNodesInConn
2456  */
2457 void MEDCouplingUMesh::renumberNodesWithOffsetInConn(int offset)
2458 {
2459   checkConnectivityFullyDefined();
2460   int *conn(getNodalConnectivity()->getPointer());
2461   const int *connIndex(getNodalConnectivityIndex()->getConstPointer());
2462   int nbOfCells(getNumberOfCells());
2463   for(int i=0;i<nbOfCells;i++)
2464     for(int iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
2465       {
2466         int& node=conn[iconn];
2467         if(node>=0)//avoid polyhedron separator
2468           {
2469             node+=offset;
2470           }
2471       }
2472   _nodal_connec->declareAsNew();
2473   updateTime();
2474 }
2475
2476 /*!
2477  *  Same than renumberNodesInConn(const int *) except that here the format of old-to-new traducer is using map instead
2478  *  of array. This method is dedicated for renumbering from a big set of nodes the a tiny set of nodes which is the case during extraction
2479  *  of a big mesh.
2480  */
2481 void MEDCouplingUMesh::renumberNodesInConn(const INTERP_KERNEL::HashMap<int,int>& newNodeNumbersO2N)
2482 {
2483   this->renumberNodesInConnT< INTERP_KERNEL::HashMap<int,int> >(newNodeNumbersO2N);
2484 }
2485
2486 /*!
2487  *  Same than renumberNodesInConn(const int *) except that here the format of old-to-new traducer is using map instead
2488  *  of array. This method is dedicated for renumbering from a big set of nodes the a tiny set of nodes which is the case during extraction
2489  *  of a big mesh.
2490  */
2491 void MEDCouplingUMesh::renumberNodesInConn(const std::map<int,int>& newNodeNumbersO2N)
2492 {
2493   this->renumberNodesInConnT< std::map<int,int> >(newNodeNumbersO2N);
2494 }
2495
2496 /*!
2497  * Changes ids of nodes within the nodal connectivity arrays according to a permutation
2498  * array in "Old to New" mode. The node coordinates array is \b not changed by this method.
2499  * This method is a generalization of shiftNodeNumbersInConn().
2500  *  \warning This method performs no check of validity of new ids. **Use it with care !**
2501  *  \param [in] newNodeNumbersO2N - a permutation array, of length \a
2502  *         this->getNumberOfNodes(), in "Old to New" mode. 
2503  *         See \ref numbering for more info on renumbering modes.
2504  *  \throw If the nodal connectivity of cells is not defined.
2505  *
2506  *  \if ENABLE_EXAMPLES
2507  *  \ref cpp_mcumesh_renumberNodesInConn "Here is a C++ example".<br>
2508  *  \ref  py_mcumesh_renumberNodesInConn "Here is a Python example".
2509  *  \endif
2510  */
2511 void MEDCouplingUMesh::renumberNodesInConn(const int *newNodeNumbersO2N)
2512 {
2513   checkConnectivityFullyDefined();
2514   int *conn=getNodalConnectivity()->getPointer();
2515   const int *connIndex=getNodalConnectivityIndex()->getConstPointer();
2516   int nbOfCells(getNumberOfCells());
2517   for(int i=0;i<nbOfCells;i++)
2518     for(int iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
2519       {
2520         int& node=conn[iconn];
2521         if(node>=0)//avoid polyhedron separator
2522           {
2523             node=newNodeNumbersO2N[node];
2524           }
2525       }
2526   _nodal_connec->declareAsNew();
2527   updateTime();
2528 }
2529
2530 /*!
2531  * This method renumbers nodes \b in \b connectivity \b only \b without \b any \b reference \b to \b coords.
2532  * This method performs no check on the fact that new coordinate ids are valid. \b Use \b it \b with \b care !
2533  * This method is an specialization of \ref MEDCoupling::MEDCouplingUMesh::renumberNodesInConn "renumberNodesInConn method".
2534  * 
2535  * \param [in] delta specifies the shift size applied to nodeId in nodal connectivity in \b this.
2536  */
2537 void MEDCouplingUMesh::shiftNodeNumbersInConn(int delta)
2538 {
2539   checkConnectivityFullyDefined();
2540   int *conn=getNodalConnectivity()->getPointer();
2541   const int *connIndex=getNodalConnectivityIndex()->getConstPointer();
2542   int nbOfCells=getNumberOfCells();
2543   for(int i=0;i<nbOfCells;i++)
2544     for(int iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
2545       {
2546         int& node=conn[iconn];
2547         if(node>=0)//avoid polyhedron separator
2548           {
2549             node+=delta;
2550           }
2551       }
2552   _nodal_connec->declareAsNew();
2553   updateTime();
2554 }
2555
2556 /*!
2557  * This method operates a modification of the connectivity in \b this.
2558  * Coordinates are \b NOT considered here and will remain unchanged by this method. this->_coords can ever been null for the needs of this method.
2559  * Every time that a node id in [ \b nodeIdsToDuplicateBg, \b nodeIdsToDuplicateEnd ) will append in nodal connectivity of \b this 
2560  * its ids will be modified to id offset+std::distance(nodeIdsToDuplicateBg,std::find(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd,id)).
2561  * More explicitly the renumber array in nodes is not explicitly given in old2new to avoid to build a big array of renumbering whereas typically few node ids needs to be
2562  * renumbered. The node id nodeIdsToDuplicateBg[0] will have id offset+0, node id nodeIdsToDuplicateBg[1] will have id offset+1,
2563  * node id nodeIdsToDuplicateBg[2] will have id offset+2...
2564  * 
2565  * As a consequence nodal connectivity array length will remain unchanged by this method, and nodal connectivity index array will remain unchanged by this method.
2566  * As an another consequense after the call of this method \b this can be transiently non cohrent.
2567  * 
2568  * \param [in] nodeIdsToDuplicateBg begin of node ids (included) to be duplicated in connectivity only
2569  * \param [in] nodeIdsToDuplicateEnd end of node ids (excluded) to be duplicated in connectivity only
2570  * \param [in] offset the offset applied to all node ids in connectivity that are in [ \a nodeIdsToDuplicateBg, \a nodeIdsToDuplicateEnd ). 
2571  */
2572 void MEDCouplingUMesh::duplicateNodesInConn(const int *nodeIdsToDuplicateBg, const int *nodeIdsToDuplicateEnd, int offset)
2573 {
2574   checkConnectivityFullyDefined();
2575   std::map<int,int> m;
2576   int val=offset;
2577   for(const int *work=nodeIdsToDuplicateBg;work!=nodeIdsToDuplicateEnd;work++,val++)
2578     m[*work]=val;
2579   int *conn=getNodalConnectivity()->getPointer();
2580   const int *connIndex=getNodalConnectivityIndex()->getConstPointer();
2581   int nbOfCells=getNumberOfCells();
2582   for(int i=0;i<nbOfCells;i++)
2583     for(int iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
2584       {
2585         int& node=conn[iconn];
2586         if(node>=0)//avoid polyhedron separator
2587           {
2588             std::map<int,int>::iterator it=m.find(node);
2589             if(it!=m.end())
2590               node=(*it).second;
2591           }
2592       }
2593   updateTime();
2594 }
2595
2596 /*!
2597  * This method renumbers cells of \a this using the array specified by [old2NewBg;old2NewBg+getNumberOfCells())
2598  *
2599  * Contrary to MEDCouplingPointSet::renumberNodes, this method makes a permutation without any fuse of cell.
2600  * After the call of this method the number of cells remains the same as before.
2601  *
2602  * If 'check' equals true the method will check that any elements in [ \a old2NewBg; \a old2NewEnd ) is unique ; if not
2603  * an INTERP_KERNEL::Exception will be thrown. When 'check' equals true [ \a old2NewBg ; \a old2NewEnd ) is not expected to
2604  * be strictly in [0;this->getNumberOfCells()).
2605  *
2606  * If 'check' equals false the method will not check the content of [ \a old2NewBg ; \a old2NewEnd ).
2607  * To avoid any throw of SIGSEGV when 'check' equals false, the elements in [ \a old2NewBg ; \a old2NewEnd ) should be unique and
2608  * should be contained in[0;this->getNumberOfCells()).
2609  * 
2610  * \param [in] old2NewBg is expected to be a dynamically allocated pointer of size at least equal to this->getNumberOfCells()
2611  * \param check
2612  */
2613 void MEDCouplingUMesh::renumberCells(const int *old2NewBg, bool check)
2614 {
2615   checkConnectivityFullyDefined();
2616   int nbCells=getNumberOfCells();
2617   const int *array=old2NewBg;
2618   if(check)
2619     array=DataArrayInt::CheckAndPreparePermutation(old2NewBg,old2NewBg+nbCells);
2620   //
2621   const int *conn=_nodal_connec->getConstPointer();
2622   const int *connI=_nodal_connec_index->getConstPointer();
2623   MCAuto<DataArrayInt> o2n=DataArrayInt::New(); o2n->useArray(array,false,C_DEALLOC,nbCells,1);
2624   MCAuto<DataArrayInt> n2o=o2n->invertArrayO2N2N2O(nbCells);
2625   const int *n2oPtr=n2o->begin();
2626   MCAuto<DataArrayInt> newConn=DataArrayInt::New();
2627   newConn->alloc(_nodal_connec->getNumberOfTuples(),_nodal_connec->getNumberOfComponents());
2628   newConn->copyStringInfoFrom(*_nodal_connec);
2629   MCAuto<DataArrayInt> newConnI=DataArrayInt::New();
2630   newConnI->alloc(_nodal_connec_index->getNumberOfTuples(),_nodal_connec_index->getNumberOfComponents());
2631   newConnI->copyStringInfoFrom(*_nodal_connec_index);
2632   //
2633   int *newC=newConn->getPointer();
2634   int *newCI=newConnI->getPointer();
2635   int loc=0;
2636   newCI[0]=loc;
2637   for(int i=0;i<nbCells;i++)
2638     {
2639       int pos=n2oPtr[i];
2640       int nbOfElts=connI[pos+1]-connI[pos];
2641       newC=std::copy(conn+connI[pos],conn+connI[pos+1],newC);
2642       loc+=nbOfElts;
2643       newCI[i+1]=loc;
2644     }
2645   //
2646   setConnectivity(newConn,newConnI);
2647   if(check)
2648     free(const_cast<int *>(array));
2649 }
2650
2651 /*!
2652  * Finds cells whose bounding boxes intersect a given bounding box.
2653  *  \param [in] bbox - an array defining the bounding box via coordinates of its
2654  *         extremum points in "no interlace" mode, i.e. xMin, xMax, yMin, yMax, zMin,
2655  *         zMax (if in 3D). 
2656  *  \param [in] eps - a factor used to increase size of the bounding box of cell
2657  *         before comparing it with \a bbox. This factor is multiplied by the maximal
2658  *         extent of the bounding box of cell to produce an addition to this bounding box.
2659  *  \return DataArrayInt * - a new instance of DataArrayInt holding ids for found
2660  *         cells. The caller is to delete this array using decrRef() as it is no more
2661  *         needed. 
2662  *  \throw If the coordinates array is not set.
2663  *  \throw If the nodal connectivity of cells is not defined.
2664  *
2665  *  \if ENABLE_EXAMPLES
2666  *  \ref cpp_mcumesh_getCellsInBoundingBox "Here is a C++ example".<br>
2667  *  \ref  py_mcumesh_getCellsInBoundingBox "Here is a Python example".
2668  *  \endif
2669  */
2670 DataArrayInt *MEDCouplingUMesh::getCellsInBoundingBox(const double *bbox, double eps) const
2671 {
2672   MCAuto<DataArrayInt> elems=DataArrayInt::New(); elems->alloc(0,1);
2673   if(getMeshDimension()==-1)
2674     {
2675       elems->pushBackSilent(0);
2676       return elems.retn();
2677     }
2678   int dim=getSpaceDimension();
2679   INTERP_KERNEL::AutoPtr<double> elem_bb=new double[2*dim];
2680   const int* conn      = getNodalConnectivity()->getConstPointer();
2681   const int* conn_index= getNodalConnectivityIndex()->getConstPointer();
2682   const double* coords = getCoords()->getConstPointer();
2683   int nbOfCells=getNumberOfCells();
2684   for ( int ielem=0; ielem<nbOfCells;ielem++ )
2685     {
2686       for (int i=0; i<dim; i++)
2687         {
2688           elem_bb[i*2]=std::numeric_limits<double>::max();
2689           elem_bb[i*2+1]=-std::numeric_limits<double>::max();
2690         }
2691
2692       for (int inode=conn_index[ielem]+1; inode<conn_index[ielem+1]; inode++)//+1 due to offset of cell type.
2693         {
2694           int node= conn[inode];
2695           if(node>=0)//avoid polyhedron separator
2696             {
2697               for (int idim=0; idim<dim; idim++)
2698                 {
2699                   if ( coords[node*dim+idim] < elem_bb[idim*2] )
2700                     {
2701                       elem_bb[idim*2] = coords[node*dim+idim] ;
2702                     }
2703                   if ( coords[node*dim+idim] > elem_bb[idim*2+1] )
2704                     {
2705                       elem_bb[idim*2+1] = coords[node*dim+idim] ;
2706                     }
2707                 }
2708             }
2709         }
2710       if (intersectsBoundingBox(elem_bb, bbox, dim, eps))
2711         elems->pushBackSilent(ielem);
2712     }
2713   return elems.retn();
2714 }
2715
2716 /*!
2717  * Given a boundary box 'bbox' returns elements 'elems' contained in this 'bbox' or touching 'bbox' (within 'eps' distance).
2718  * Warning 'elems' is incremented during the call so if elems is not empty before call returned elements will be
2719  * added in 'elems' parameter.
2720  */
2721 DataArrayInt *MEDCouplingUMesh::getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps)
2722 {
2723   MCAuto<DataArrayInt> elems=DataArrayInt::New(); elems->alloc(0,1);
2724   if(getMeshDimension()==-1)
2725     {
2726       elems->pushBackSilent(0);
2727       return elems.retn();
2728     }
2729   int dim=getSpaceDimension();
2730   INTERP_KERNEL::AutoPtr<double> elem_bb=new double[2*dim];
2731   const int* conn      = getNodalConnectivity()->getConstPointer();
2732   const int* conn_index= getNodalConnectivityIndex()->getConstPointer();
2733   const double* coords = getCoords()->getConstPointer();
2734   int nbOfCells=getNumberOfCells();
2735   for ( int ielem=0; ielem<nbOfCells;ielem++ )
2736     {
2737       for (int i=0; i<dim; i++)
2738         {
2739           elem_bb[i*2]=std::numeric_limits<double>::max();
2740           elem_bb[i*2+1]=-std::numeric_limits<double>::max();
2741         }
2742
2743       for (int inode=conn_index[ielem]+1; inode<conn_index[ielem+1]; inode++)//+1 due to offset of cell type.
2744         {
2745           int node= conn[inode];
2746           if(node>=0)//avoid polyhedron separator
2747             {
2748               for (int idim=0; idim<dim; idim++)
2749                 {
2750                   if ( coords[node*dim+idim] < elem_bb[idim*2] )
2751                     {
2752                       elem_bb[idim*2] = coords[node*dim+idim] ;
2753                     }
2754                   if ( coords[node*dim+idim] > elem_bb[idim*2+1] )
2755                     {
2756                       elem_bb[idim*2+1] = coords[node*dim+idim] ;
2757                     }
2758                 }
2759             }
2760         }
2761       if(intersectsBoundingBox(bbox, elem_bb, dim, eps))
2762         elems->pushBackSilent(ielem);
2763     }
2764   return elems.retn();
2765 }
2766
2767 /*!
2768  * Returns a type of a cell by its id.
2769  *  \param [in] cellId - the id of the cell of interest.
2770  *  \return INTERP_KERNEL::NormalizedCellType - enumeration item describing the cell type.
2771  *  \throw If \a cellId is invalid. Valid range is [0, \a this->getNumberOfCells() ).
2772  */
2773 INTERP_KERNEL::NormalizedCellType MEDCouplingUMesh::getTypeOfCell(std::size_t cellId) const
2774 {
2775   const int *ptI(_nodal_connec_index->begin()),*pt(_nodal_connec->begin());
2776   if(cellId<_nodal_connec_index->getNbOfElems()-1)
2777     return (INTERP_KERNEL::NormalizedCellType) pt[ptI[cellId]];
2778   else
2779     {
2780       std::ostringstream oss; oss << "MEDCouplingUMesh::getTypeOfCell : Requesting type of cell #" << cellId << " but it should be in [0," << _nodal_connec_index->getNbOfElems()-1 << ") !";
2781       throw INTERP_KERNEL::Exception(oss.str());
2782     }
2783 }
2784
2785 /*!
2786  * This method returns a newly allocated array containing cell ids (ascendingly sorted) whose geometric type are equal to type.
2787  * This method does not throw exception if geometric type \a type is not in \a this.
2788  * This method throws an INTERP_KERNEL::Exception if meshdimension of \b this is not equal to those of \b type.
2789  * The coordinates array is not considered here.
2790  *
2791  * \param [in] type the geometric type
2792  * \return cell ids in this having geometric type \a type.
2793  */
2794 DataArrayInt *MEDCouplingUMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
2795 {
2796
2797   MCAuto<DataArrayInt> ret=DataArrayInt::New();
2798   ret->alloc(0,1);
2799   checkConnectivityFullyDefined();
2800   int nbCells=getNumberOfCells();
2801   int mdim=getMeshDimension();
2802   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
2803   if(mdim!=(int)cm.getDimension())
2804     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::giveCellsWithType : Mismatch between mesh dimension and dimension of the cell !");
2805   const int *ptI=_nodal_connec_index->getConstPointer();
2806   const int *pt=_nodal_connec->getConstPointer();
2807   for(int i=0;i<nbCells;i++)
2808     {
2809       if((INTERP_KERNEL::NormalizedCellType)pt[ptI[i]]==type)
2810         ret->pushBackSilent(i);
2811     }
2812   return ret.retn();
2813 }
2814
2815 /*!
2816  * Returns nb of cells having the geometric type \a type. No throw if no cells in \a this has the geometric type \a type.
2817  */
2818 std::size_t MEDCouplingUMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
2819 {
2820   const int *ptI(_nodal_connec_index->begin()),*pt(_nodal_connec->begin());
2821   std::size_t nbOfCells(getNumberOfCells()),ret(0);
2822   for(std::size_t i=0;i<nbOfCells;i++)
2823     if((INTERP_KERNEL::NormalizedCellType) pt[ptI[i]]==type)
2824       ret++;
2825   return ret;
2826 }
2827
2828 /*!
2829  * Returns the nodal connectivity of a given cell.
2830  * The separator of faces within polyhedron connectivity (-1) is not returned, thus
2831  * all returned node ids can be used in getCoordinatesOfNode().
2832  *  \param [in] cellId - an id of the cell of interest.
2833  *  \param [in,out] conn - a vector where the node ids are appended. It is not
2834  *         cleared before the appending.
2835  *  \throw If \a cellId is invalid. Valid range is [0, \a this->getNumberOfCells() ).
2836  */
2837 void MEDCouplingUMesh::getNodeIdsOfCell(std::size_t cellId, std::vector<int>& conn) const
2838 {
2839   const int *ptI(_nodal_connec_index->begin()),*pt(_nodal_connec->begin());
2840   for(const int *w=pt+ptI[cellId]+1;w!=pt+ptI[cellId+1];w++)
2841     if(*w>=0)
2842       conn.push_back(*w);
2843 }
2844
2845 std::string MEDCouplingUMesh::simpleRepr() const
2846 {
2847   static const char msg0[]="No coordinates specified !";
2848   std::ostringstream ret;
2849   ret << "Unstructured mesh with name : \"" << getName() << "\"\n";
2850   ret << "Description of mesh : \"" << getDescription() << "\"\n";
2851   int tmpp1,tmpp2;
2852   double tt=getTime(tmpp1,tmpp2);
2853   ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
2854   ret << "Iteration : " << tmpp1  << " Order : " << tmpp2 << "\n";
2855   if(_mesh_dim>=-1)
2856     { ret << "Mesh dimension : " << _mesh_dim << "\nSpace dimension : "; }
2857   else
2858     { ret << " Mesh dimension has not been set or is invalid !"; }
2859   if(_coords!=0)
2860     {
2861       const int spaceDim=getSpaceDimension();
2862       ret << spaceDim << "\nInfo attached on space dimension : ";
2863       for(int i=0;i<spaceDim;i++)
2864         ret << "\"" << _coords->getInfoOnComponent(i) << "\" ";
2865       ret << "\n";
2866     }
2867   else
2868     ret << msg0 << "\n";
2869   ret << "Number of nodes : ";
2870   if(_coords!=0)
2871     ret << getNumberOfNodes() << "\n";
2872   else
2873     ret << msg0 << "\n";
2874   ret << "Number of cells : ";
2875   if(_nodal_connec!=0 && _nodal_connec_index!=0)
2876     ret << getNumberOfCells() << "\n";
2877   else
2878     ret << "No connectivity specified !" << "\n";
2879   ret << "Cell types present : ";
2880   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
2881     {
2882       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*iter);
2883       ret << cm.getRepr() << " ";
2884     }
2885   ret << "\n";
2886   return ret.str();
2887 }
2888
2889 std::string MEDCouplingUMesh::advancedRepr() const
2890 {
2891   std::ostringstream ret;
2892   ret << simpleRepr();
2893   ret << "\nCoordinates array : \n___________________\n\n";
2894   if(_coords)
2895     _coords->reprWithoutNameStream(ret);
2896   else
2897     ret << "No array set !\n";
2898   ret << "\n\nConnectivity arrays : \n_____________________\n\n";
2899   reprConnectivityOfThisLL(ret);
2900   return ret.str();
2901 }
2902
2903 /*!
2904  * This method returns a C++ code that is a dump of \a this.
2905  * This method will throw if this is not fully defined.
2906  */
2907 std::string MEDCouplingUMesh::cppRepr() const
2908 {
2909   static const char coordsName[]="coords";
2910   static const char connName[]="conn";
2911   static const char connIName[]="connI";
2912   checkFullyDefined();
2913   std::ostringstream ret; ret << "// coordinates" << std::endl;
2914   _coords->reprCppStream(coordsName,ret); ret << std::endl << "// connectivity" << std::endl;
2915   _nodal_connec->reprCppStream(connName,ret); ret << std::endl;
2916   _nodal_connec_index->reprCppStream(connIName,ret); ret << std::endl;
2917   ret << "MEDCouplingUMesh *mesh=MEDCouplingUMesh::New(\"" << getName() << "\"," << getMeshDimension() << ");" << std::endl;
2918   ret << "mesh->setCoords(" << coordsName << ");" << std::endl;
2919   ret << "mesh->setConnectivity(" << connName << "," << connIName << ",true);" << std::endl;
2920   ret << coordsName << "->decrRef(); " << connName << "->decrRef(); " << connIName << "->decrRef();" << std::endl;
2921   return ret.str();
2922 }
2923
2924 std::string MEDCouplingUMesh::reprConnectivityOfThis() const
2925 {
2926   std::ostringstream ret;
2927   reprConnectivityOfThisLL(ret);
2928   return ret.str();
2929 }
2930
2931 /*!
2932  * This method builds a newly allocated instance (with the same name than \a this) that the caller has the responsibility to deal with.
2933  * This method returns an instance with all arrays allocated (connectivity, connectivity index, coordinates)
2934  * but with length of these arrays set to 0. It allows to define an "empty" mesh (with nor cells nor nodes but compliant with
2935  * some algos).
2936  * 
2937  * This method expects that \a this has a mesh dimension set and higher or equal to 0. If not an exception will be thrown.
2938  * This method analyzes the 3 arrays of \a this. For each the following behaviour is done : if the array is null a newly one is created
2939  * with number of tuples set to 0, if not the array is taken as this in the returned instance.
2940  */
2941 MEDCouplingUMesh *MEDCouplingUMesh::buildSetInstanceFromThis(int spaceDim) const
2942 {
2943   int mdim=getMeshDimension();
2944   if(mdim<0)
2945     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSetInstanceFromThis : invalid mesh dimension ! Should be >= 0 !");
2946   MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New(getName(),mdim);
2947   MCAuto<DataArrayInt> tmp1,tmp2;
2948   bool needToCpyCT=true;
2949   if(!_nodal_connec)
2950     {
2951       tmp1=DataArrayInt::New(); tmp1->alloc(0,1);
2952       needToCpyCT=false;
2953     }
2954   else
2955     {
2956       tmp1=_nodal_connec;
2957       tmp1->incrRef();
2958     }
2959   if(!_nodal_connec_index)
2960     {
2961       tmp2=DataArrayInt::New(); tmp2->alloc(1,1); tmp2->setIJ(0,0,0);
2962       needToCpyCT=false;
2963     }
2964   else
2965     {
2966       tmp2=_nodal_connec_index;
2967       tmp2->incrRef();
2968     }
2969   ret->setConnectivity(tmp1,tmp2,false);
2970   if(needToCpyCT)
2971     ret->_types=_types;
2972   if(!_coords)
2973     {
2974       MCAuto<DataArrayDouble> coords=DataArrayDouble::New(); coords->alloc(0,spaceDim);
2975       ret->setCoords(coords);
2976     }
2977   else
2978     ret->setCoords(_coords);
2979   return ret.retn();
2980 }
2981
2982 int MEDCouplingUMesh::getNumberOfNodesInCell(int cellId) const
2983 {
2984   const int *ptI=_nodal_connec_index->getConstPointer();
2985   const int *pt=_nodal_connec->getConstPointer();
2986   if(pt[ptI[cellId]]!=INTERP_KERNEL::NORM_POLYHED)
2987     return ptI[cellId+1]-ptI[cellId]-1;
2988   else
2989     return (int)std::count_if(pt+ptI[cellId]+1,pt+ptI[cellId+1],std::bind2nd(std::not_equal_to<int>(),-1));
2990 }
2991
2992 /*!
2993  * Returns types of cells of the specified part of \a this mesh.
2994  * This method avoids computing sub-mesh explicitly to get its types.
2995  *  \param [in] begin - an array of cell ids of interest.
2996  *  \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element.
2997  *  \return std::set<INTERP_KERNEL::NormalizedCellType> - a set of enumeration items
2998  *         describing the cell types. 
2999  *  \throw If the coordinates array is not set.
3000  *  \throw If the nodal connectivity of cells is not defined.
3001  *  \sa getAllGeoTypes()
3002  */
3003 std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingUMesh::getTypesOfPart(const int *begin, const int *end) const
3004 {
3005   checkFullyDefined();
3006   std::set<INTERP_KERNEL::NormalizedCellType> ret;
3007   const int *conn=_nodal_connec->getConstPointer();
3008   const int *connIndex=_nodal_connec_index->getConstPointer();
3009   for(const int *w=begin;w!=end;w++)
3010     ret.insert((INTERP_KERNEL::NormalizedCellType)conn[connIndex[*w]]);
3011   return ret;
3012 }
3013
3014 /*!
3015  * Defines the nodal connectivity using given connectivity arrays in \ref numbering-indirect format.
3016  * Optionally updates
3017  * a set of types of cells constituting \a this mesh. 
3018  * This method is for advanced users having prepared their connectivity before. For
3019  * more info on using this method see \ref MEDCouplingUMeshAdvBuild.
3020  *  \param [in] conn - the nodal connectivity array. 
3021  *  \param [in] connIndex - the nodal connectivity index array.
3022  *  \param [in] isComputingTypes - if \c true, the set of types constituting \a this
3023  *         mesh is updated.
3024  */
3025 void MEDCouplingUMesh::setConnectivity(DataArrayInt *conn, DataArrayInt *connIndex, bool isComputingTypes)
3026 {
3027   DataArrayInt::SetArrayIn(conn,_nodal_connec);
3028   DataArrayInt::SetArrayIn(connIndex,_nodal_connec_index);
3029   if(isComputingTypes)
3030     computeTypes();
3031   declareAsNew();
3032 }
3033
3034 /*!
3035  * Copy constructor. If 'deepCopy' is false \a this is a shallow copy of other.
3036  * If 'deeCpy' is true all arrays (coordinates and connectivities) are deeply copied.
3037  */
3038 MEDCouplingUMesh::MEDCouplingUMesh(const MEDCouplingUMesh& other, bool deepCpy):MEDCouplingPointSet(other,deepCpy),_mesh_dim(other._mesh_dim),
3039     _nodal_connec(0),_nodal_connec_index(0),
3040     _types(other._types)
3041 {
3042   if(other._nodal_connec)
3043     _nodal_connec=other._nodal_connec->performCopyOrIncrRef(deepCpy);
3044   if(other._nodal_connec_index)
3045     _nodal_connec_index=other._nodal_connec_index->performCopyOrIncrRef(deepCpy);
3046 }
3047
3048 MEDCouplingUMesh::~MEDCouplingUMesh()
3049 {
3050   if(_nodal_connec)
3051     _nodal_connec->decrRef();
3052   if(_nodal_connec_index)
3053     _nodal_connec_index->decrRef();
3054 }
3055
3056 /*!
3057  * Recomputes a set of cell types of \a this mesh. For more info see
3058  * \ref MEDCouplingUMeshNodalConnectivity.
3059  */
3060 void MEDCouplingUMesh::computeTypes()
3061 {
3062   ComputeAllTypesInternal(_types,_nodal_connec,_nodal_connec_index);
3063 }
3064
3065
3066 /*!
3067  * Returns a number of cells constituting \a this mesh. 
3068  *  \return int - the number of cells in \a this mesh.
3069  *  \throw If the nodal connectivity of cells is not defined.
3070  */
3071 std::size_t MEDCouplingUMesh::getNumberOfCells() const
3072
3073   if(_nodal_connec_index)
3074     return _nodal_connec_index->getNumberOfTuples()-1;
3075   else
3076     if(_mesh_dim==-1)
3077       return 1;
3078     else
3079       throw INTERP_KERNEL::Exception("Unable to get number of cells because no connectivity specified !");
3080 }
3081
3082 /*!
3083  * Returns a dimension of \a this mesh, i.e. a dimension of cells constituting \a this
3084  * mesh. For more info see \ref meshes.
3085  *  \return int - the dimension of \a this mesh.
3086  *  \throw If the mesh dimension is not defined using setMeshDimension().
3087  */
3088 int MEDCouplingUMesh::getMeshDimension() const
3089 {
3090   if(_mesh_dim<-1)
3091     throw INTERP_KERNEL::Exception("No mesh dimension specified !");
3092   return _mesh_dim;
3093 }
3094
3095 /*!
3096  * Returns a length of the nodal connectivity array.
3097  * This method is for test reason. Normally the integer returned is not useable by
3098  * user.  For more info see \ref MEDCouplingUMeshNodalConnectivity.
3099  *  \return int - the length of the nodal connectivity array.
3100  */
3101 int MEDCouplingUMesh::getNodalConnectivityArrayLen() const
3102 {
3103   return _nodal_connec->getNbOfElems();
3104 }
3105
3106 /*!
3107  * First step of serialization process. Used by ParaMEDMEM and MEDCouplingCorba to transfert data between process.
3108  */
3109 void MEDCouplingUMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<int>& tinyInfo, std::vector<std::string>& littleStrings) const
3110 {
3111   MEDCouplingPointSet::getTinySerializationInformation(tinyInfoD,tinyInfo,littleStrings);
3112   tinyInfo.push_back(getMeshDimension());
3113   tinyInfo.push_back(getNumberOfCells());
3114   if(_nodal_connec)
3115     tinyInfo.push_back(getNodalConnectivityArrayLen());
3116   else
3117     tinyInfo.push_back(-1);
3118 }
3119
3120 /*!
3121  * First step of unserialization process.
3122  */
3123 bool MEDCouplingUMesh::isEmptyMesh(const std::vector<int>& tinyInfo) const
3124 {
3125   return tinyInfo[6]<=0;
3126 }
3127
3128 /*!
3129  * Second step of serialization process.
3130  * \param tinyInfo must be equal to the result given by getTinySerializationInformation method.
3131  * \param a1
3132  * \param a2
3133  * \param littleStrings
3134  */
3135 void MEDCouplingUMesh::resizeForUnserialization(const std::vector<int>& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
3136 {
3137   MEDCouplingPointSet::resizeForUnserialization(tinyInfo,a1,a2,littleStrings);
3138   if(tinyInfo[5]!=-1)
3139     a1->alloc(tinyInfo[7]+tinyInfo[6]+1,1);
3140 }
3141
3142 /*!
3143  * Third and final step of serialization process.
3144  */
3145 void MEDCouplingUMesh::serialize(DataArrayInt *&a1, DataArrayDouble *&a2) const
3146 {
3147   MEDCouplingPointSet::serialize(a1,a2);
3148   if(getMeshDimension()>-1)
3149     {
3150       a1=DataArrayInt::New();
3151       a1->alloc(getNodalConnectivityArrayLen()+getNumberOfCells()+1,1);
3152       int *ptA1=a1->getPointer();
3153       const int *conn=getNodalConnectivity()->getConstPointer();
3154       const int *index=getNodalConnectivityIndex()->getConstPointer();
3155       ptA1=std::copy(index,index+getNumberOfCells()+1,ptA1);
3156       std::copy(conn,conn+getNodalConnectivityArrayLen(),ptA1);
3157     }
3158   else
3159     a1=0;
3160 }
3161
3162 /*!
3163  * Second and final unserialization process.
3164  * \param tinyInfo must be equal to the result given by getTinySerializationInformation method.
3165  */
3166 void MEDCouplingUMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<int>& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
3167 {
3168   MEDCouplingPointSet::unserialization(tinyInfoD,tinyInfo,a1,a2,littleStrings);
3169   setMeshDimension(tinyInfo[5]);
3170   if(tinyInfo[7]!=-1)
3171     {
3172       // Connectivity
3173       const int *recvBuffer=a1->getConstPointer();
3174       MCAuto<DataArrayInt> myConnecIndex=DataArrayInt::New();
3175       myConnecIndex->alloc(tinyInfo[6]+1,1);
3176       std::copy(recvBuffer,recvBuffer+tinyInfo[6]+1,myConnecIndex->getPointer());
3177       MCAuto<DataArrayInt> myConnec=DataArrayInt::New();
3178       myConnec->alloc(tinyInfo[7],1);
3179       std::copy(recvBuffer+tinyInfo[6]+1,recvBuffer+tinyInfo[6]+1+tinyInfo[7],myConnec->getPointer());
3180       setConnectivity(myConnec, myConnecIndex);
3181     }
3182 }
3183
3184
3185
3186 /*!
3187  * Returns a new MEDCouplingFieldDouble containing volumes of cells constituting \a this
3188  * mesh.<br>
3189  * For 1D cells, the returned field contains lengths.<br>
3190  * For 2D cells, the returned field contains areas.<br>
3191  * For 3D cells, the returned field contains volumes.
3192  *  \param [in] isAbs - if \c true, the computed cell volume does not reflect cell
3193  *         orientation, i.e. the volume is always positive.
3194  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on cells
3195  *         and one time . The caller is to delete this field using decrRef() as it is no
3196  *         more needed.
3197  */
3198 MEDCouplingFieldDouble *MEDCouplingUMesh::getMeasureField(bool isAbs) const
3199 {
3200   std::string name="MeasureOfMesh_";
3201   name+=getName();
3202   int nbelem=getNumberOfCells();
3203   MCAuto<MEDCouplingFieldDouble> field=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
3204   field->setName(name);
3205   MCAuto<DataArrayDouble> array=DataArrayDouble::New();
3206   array->alloc(nbelem,1);
3207   double *area_vol=array->getPointer();
3208   field->setArray(array) ; array=0;
3209   field->setMesh(const_cast<MEDCouplingUMesh *>(this));
3210   field->synchronizeTimeWithMesh();
3211   if(getMeshDimension()!=-1)
3212     {
3213       int ipt;
3214       INTERP_KERNEL::NormalizedCellType type;
3215       int dim_space=getSpaceDimension();
3216       const double *coords=getCoords()->getConstPointer();
3217       const int *connec=getNodalConnectivity()->getConstPointer();
3218       const int *connec_index=getNodalConnectivityIndex()->getConstPointer();
3219       for(int iel=0;iel<nbelem;iel++)
3220         {
3221           ipt=connec_index[iel];
3222           type=(INTERP_KERNEL::NormalizedCellType)connec[ipt];
3223           area_vol[iel]=INTERP_KERNEL::computeVolSurfOfCell2<int,INTERP_KERNEL::ALL_C_MODE>(type,connec+ipt+1,connec_index[iel+1]-ipt-1,coords,dim_space);
3224         }
3225       if(isAbs)
3226         std::transform(area_vol,area_vol+nbelem,area_vol,std::ptr_fun<double,double>(fabs));
3227     }
3228   else
3229     {
3230       area_vol[0]=std::numeric_limits<double>::max();
3231     }
3232   return field.retn();
3233 }
3234
3235 /*!
3236  * Returns a new DataArrayDouble containing volumes of specified cells of \a this
3237  * mesh.<br>
3238  * For 1D cells, the returned array contains lengths.<br>
3239  * For 2D cells, the returned array contains areas.<br>
3240  * For 3D cells, the returned array contains volumes.
3241  * This method avoids building explicitly a part of \a this mesh to perform the work.
3242  *  \param [in] isAbs - if \c true, the computed cell volume does not reflect cell
3243  *         orientation, i.e. the volume is always positive.
3244  *  \param [in] begin - an array of cell ids of interest.
3245  *  \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element.
3246  *  \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
3247  *          delete this array using decrRef() as it is no more needed.
3248  * 
3249  *  \if ENABLE_EXAMPLES
3250  *  \ref cpp_mcumesh_getPartMeasureField "Here is a C++ example".<br>
3251  *  \ref  py_mcumesh_getPartMeasureField "Here is a Python example".
3252  *  \endif
3253  *  \sa getMeasureField()
3254  */
3255 DataArrayDouble *MEDCouplingUMesh::getPartMeasureField(bool isAbs, const int *begin, const int *end) const
3256 {
3257   std::string name="PartMeasureOfMesh_";
3258   name+=getName();
3259   int nbelem=(int)std::distance(begin,end);
3260   MCAuto<DataArrayDouble> array=DataArrayDouble::New();
3261   array->setName(name);
3262   array->alloc(nbelem,1);
3263   double *area_vol=array->getPointer();
3264   if(getMeshDimension()!=-1)
3265     {
3266       int ipt;
3267       INTERP_KERNEL::NormalizedCellType type;
3268       int dim_space=getSpaceDimension();
3269       const double *coords=getCoords()->getConstPointer();
3270       const int *connec=getNodalConnectivity()->getConstPointer();
3271       const int *connec_index=getNodalConnectivityIndex()->getConstPointer();
3272       for(const int *iel=begin;iel!=end;iel++)
3273         {
3274           ipt=connec_index[*iel];
3275           type=(INTERP_KERNEL::NormalizedCellType)connec[ipt];
3276           *area_vol++=INTERP_KERNEL::computeVolSurfOfCell2<int,INTERP_KERNEL::ALL_C_MODE>(type,connec+ipt+1,connec_index[*iel+1]-ipt-1,coords,dim_space);
3277         }
3278       if(isAbs)
3279         std::transform(array->getPointer(),area_vol,array->getPointer(),std::ptr_fun<double,double>(fabs));
3280     }
3281   else
3282     {
3283       area_vol[0]=std::numeric_limits<double>::max();
3284     }
3285   return array.retn();
3286 }
3287
3288 /*!
3289  * Returns a new MEDCouplingFieldDouble containing volumes of cells of a dual mesh of
3290  * \a this one. The returned field contains the dual cell volume for each corresponding
3291  * node in \a this mesh. In other words, the field returns the getMeasureField() of
3292  *  the dual mesh in P1 sens of \a this.<br>
3293  * For 1D cells, the returned field contains lengths.<br>
3294  * For 2D cells, the returned field contains areas.<br>
3295  * For 3D cells, the returned field contains volumes.
3296  * This method is useful to check "P1*" conservative interpolators.
3297  *  \param [in] isAbs - if \c true, the computed cell volume does not reflect cell
3298  *         orientation, i.e. the volume is always positive.
3299  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
3300  *          nodes and one time. The caller is to delete this array using decrRef() as
3301  *          it is no more needed.
3302  */
3303 MEDCouplingFieldDouble *MEDCouplingUMesh::getMeasureFieldOnNode(bool isAbs) const
3304 {
3305   MCAuto<MEDCouplingFieldDouble> tmp=getMeasureField(isAbs);
3306   std::string name="MeasureOnNodeOfMesh_";
3307   name+=getName();
3308   int nbNodes=getNumberOfNodes();
3309   MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_NODES);
3310   double cst=1./((double)getMeshDimension()+1.);
3311   MCAuto<DataArrayDouble> array=DataArrayDouble::New();
3312   array->alloc(nbNodes,1);
3313   double *valsToFill=array->getPointer();
3314   std::fill(valsToFill,valsToFill+nbNodes,0.);
3315   const double *values=tmp->getArray()->getConstPointer();
3316   MCAuto<DataArrayInt> da=DataArrayInt::New();
3317   MCAuto<DataArrayInt> daInd=DataArrayInt::New();
3318   getReverseNodalConnectivity(da,daInd);
3319   const int *daPtr=da->getConstPointer();
3320   const int *daIPtr=daInd->getConstPointer();
3321   for(int i=0;i<nbNodes;i++)
3322     for(const int *cell=daPtr+daIPtr[i];cell!=daPtr+daIPtr[i+1];cell++)
3323       valsToFill[i]+=cst*values[*cell];
3324   ret->setMesh(this);
3325   ret->setArray(array);
3326   return ret.retn();
3327 }
3328
3329 /*!
3330  * Returns a new MEDCouplingFieldDouble holding normal vectors to cells of \a this
3331  * mesh. The returned normal vectors to each cell have a norm2 equal to 1.
3332  * The computed vectors have <em> this->getMeshDimension()+1 </em> components
3333  * and are normalized.
3334  * <br> \a this can be either 
3335  * - a  2D mesh in 2D or 3D space or 
3336  * - an 1D mesh in 2D space.
3337  * 
3338  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
3339  *          cells and one time. The caller is to delete this field using decrRef() as
3340  *          it is no more needed.
3341  *  \throw If the nodal connectivity of cells is not defined.
3342  *  \throw If the coordinates array is not set.
3343  *  \throw If the mesh dimension is not set.
3344  *  \throw If the mesh and space dimension is not as specified above.
3345  */
3346 MEDCouplingFieldDouble *MEDCouplingUMesh::buildOrthogonalField() const
3347 {
3348   if((getMeshDimension()!=2) && (getMeshDimension()!=1 || getSpaceDimension()!=2))
3349     throw INTERP_KERNEL::Exception("Expected a umesh with ( meshDim == 2 spaceDim == 2 or 3 ) or ( meshDim == 1 spaceDim == 2 ) !");
3350   MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
3351   MCAuto<DataArrayDouble> array=DataArrayDouble::New();
3352   int nbOfCells=getNumberOfCells();
3353   int nbComp=getMeshDimension()+1;
3354   array->alloc(nbOfCells,nbComp);
3355   double *vals=array->getPointer();
3356   const int *connI=_nodal_connec_index->getConstPointer();
3357   const int *conn=_nodal_connec->getConstPointer();
3358   const double *coords=_coords->getConstPointer();
3359   if(getMeshDimension()==2)
3360     {
3361       if(getSpaceDimension()==3)
3362         {
3363           MCAuto<DataArrayDouble> loc=computeCellCenterOfMass();
3364           const double *locPtr=loc->getConstPointer();
3365           for(int i=0;i<nbOfCells;i++,vals+=3)
3366             {
3367               int offset=connI[i];
3368               INTERP_KERNEL::crossprod<3>(locPtr+3*i,coords+3*conn[offset+1],coords+3*conn[offset+2],vals);
3369               double n=INTERP_KERNEL::norm<3>(vals);
3370               std::transform(vals,vals+3,vals,std::bind2nd(std::multiplies<double>(),1./n));
3371             }
3372         }
3373       else
3374         {
3375           MCAuto<MEDCouplingFieldDouble> isAbs=getMeasureField(false);
3376           const double *isAbsPtr=isAbs->getArray()->begin();
3377           for(int i=0;i<nbOfCells;i++,isAbsPtr++)
3378             { vals[3*i]=0.; vals[3*i+1]=0.; vals[3*i+2]=*isAbsPtr>0.?1.:-1.; }
3379         }
3380     }
3381   else//meshdimension==1
3382     {
3383       double tmp[2];
3384       for(int i=0;i<nbOfCells;i++)
3385         {
3386           int offset=connI[i];
3387           std::transform(coords+2*conn[offset+2],coords+2*conn[offset+2]+2,coords+2*conn[offset+1],tmp,std::minus<double>());
3388           double n=INTERP_KERNEL::norm<2>(tmp);
3389           std::transform(tmp,tmp+2,tmp,std::bind2nd(std::multiplies<double>(),1./n));
3390           *vals++=-tmp[1];
3391           *vals++=tmp[0];
3392         }
3393     }
3394   ret->setArray(array);
3395   ret->setMesh(this);
3396   ret->synchronizeTimeWithSupport();
3397   return ret.retn();
3398 }
3399
3400 /*!
3401  * Returns a new MEDCouplingFieldDouble holding normal vectors to specified cells of
3402  * \a this mesh. The computed vectors have <em> this->getMeshDimension()+1 </em> components
3403  * and are normalized.
3404  * <br> \a this can be either 
3405  * - a  2D mesh in 2D or 3D space or 
3406  * - an 1D mesh in 2D space.
3407  * 
3408  * This method avoids building explicitly a part of \a this mesh to perform the work.
3409  *  \param [in] begin - an array of cell ids of interest.
3410  *  \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element.
3411  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
3412  *          cells and one time. The caller is to delete this field using decrRef() as
3413  *          it is no more needed.
3414  *  \throw If the nodal connectivity of cells is not defined.
3415  *  \throw If the coordinates array is not set.
3416  *  \throw If the mesh dimension is not set.
3417  *  \throw If the mesh and space dimension is not as specified above.
3418  *  \sa buildOrthogonalField()
3419  *
3420  *  \if ENABLE_EXAMPLES
3421  *  \ref cpp_mcumesh_buildPartOrthogonalField "Here is a C++ example".<br>
3422  *  \ref  py_mcumesh_buildPartOrthogonalField "Here is a Python example".
3423  *  \endif
3424  */
3425 MEDCouplingFieldDouble *MEDCouplingUMesh::buildPartOrthogonalField(const int *begin, const int *end) const
3426 {
3427   if((getMeshDimension()!=2) && (getMeshDimension()!=1 || getSpaceDimension()!=2))
3428     throw INTERP_KERNEL::Exception("Expected a umesh with ( meshDim == 2 spaceDim == 2 or 3 ) or ( meshDim == 1 spaceDim == 2 ) !");
3429   MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
3430   MCAuto<DataArrayDouble> array=DataArrayDouble::New();
3431   std::size_t nbelems=std::distance(begin,end);
3432   int nbComp=getMeshDimension()+1;
3433   array->alloc((int)nbelems,nbComp);
3434   double *vals=array->getPointer();
3435   const int *connI=_nodal_connec_index->getConstPointer();
3436   const int *conn=_nodal_connec->getConstPointer();
3437   const double *coords=_coords->getConstPointer();
3438   if(getMeshDimension()==2)
3439     {
3440       if(getSpaceDimension()==3)
3441         {
3442           MCAuto<DataArrayDouble> loc=getPartBarycenterAndOwner(begin,end);
3443           const double *locPtr=loc->getConstPointer();
3444           for(const int *i=begin;i!=end;i++,vals+=3,locPtr+=3)
3445             {
3446               int offset=connI[*i];
3447               INTERP_KERNEL::crossprod<3>(locPtr,coords+3*conn[offset+1],coords+3*conn[offset+2],vals);
3448               double n=INTERP_KERNEL::norm<3>(vals);
3449               std::transform(vals,vals+3,vals,std::bind2nd(std::multiplies<double>(),1./n));
3450             }
3451         }
3452       else
3453         {
3454           for(std::size_t i=0;i<nbelems;i++)
3455             { vals[3*i]=0.; vals[3*i+1]=0.; vals[3*i+2]=1.; }
3456         }
3457     }
3458   else//meshdimension==1
3459     {
3460       double tmp[2];
3461       for(const int *i=begin;i!=end;i++)
3462         {
3463           int offset=connI[*i];
3464           std::transform(coords+2*conn[offset+2],coords+2*conn[offset+2]+2,coords+2*conn[offset+1],tmp,std::minus<double>());
3465           double n=INTERP_KERNEL::norm<2>(tmp);
3466           std::transform(tmp,tmp+2,tmp,std::bind2nd(std::multiplies<double>(),1./n));
3467           *vals++=-tmp[1];
3468           *vals++=tmp[0];
3469         }
3470     }
3471   ret->setArray(array);
3472   ret->setMesh(this);
3473   ret->synchronizeTimeWithSupport();
3474   return ret.retn();
3475 }
3476
3477 /*!
3478  * Returns a new MEDCouplingFieldDouble holding a direction vector for each SEG2 in \a
3479  * this 1D mesh. The computed vectors have <em> this->getSpaceDimension() </em> components
3480  * and are \b not normalized.
3481  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
3482  *          cells and one time. The caller is to delete this field using decrRef() as
3483  *          it is no more needed.
3484  *  \throw If the nodal connectivity of cells is not defined.
3485  *  \throw If the coordinates array is not set.
3486  *  \throw If \a this->getMeshDimension() != 1.
3487  *  \throw If \a this mesh includes cells of type other than SEG2.
3488  */
3489 MEDCouplingFieldDouble *MEDCouplingUMesh::buildDirectionVectorField() const
3490 {
3491   if(getMeshDimension()!=1)
3492     throw INTERP_KERNEL::Exception("Expected a umesh with meshDim == 1 for buildDirectionVectorField !");
3493   if(_types.size()!=1 || *(_types.begin())!=INTERP_KERNEL::NORM_SEG2)
3494     throw INTERP_KERNEL::Exception("Expected a umesh with only NORM_SEG2 type of elements for buildDirectionVectorField !");
3495   MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
3496   MCAuto<DataArrayDouble> array=DataArrayDouble::New();
3497   int nbOfCells=getNumberOfCells();
3498   int spaceDim=getSpaceDimension();
3499   array->alloc(nbOfCells,spaceDim);
3500   double *pt=array->getPointer();
3501   const double *coo=getCoords()->getConstPointer();
3502   std::vector<int> conn;
3503   conn.reserve(2);
3504   for(int i=0;i<nbOfCells;i++)
3505     {
3506       conn.resize(0);
3507       getNodeIdsOfCell(i,conn);
3508       pt=std::transform(coo+conn[1]*spaceDim,coo+(conn[1]+1)*spaceDim,coo+conn[0]*spaceDim,pt,std::minus<double>());
3509     }
3510   ret->setArray(array);
3511   ret->setMesh(this);
3512   ret->synchronizeTimeWithSupport();
3513   return ret.retn();
3514 }
3515
3516 /*!
3517  * Creates a 2D mesh by cutting \a this 3D mesh with a plane. In addition to the mesh,
3518  * returns a new DataArrayInt, of length equal to the number of 2D cells in the result
3519  * mesh, holding, for each cell in the result mesh, an id of a 3D cell it comes
3520  * from. If a result face is shared by two 3D cells, then the face in included twice in
3521  * the result mesh.
3522  *  \param [in] origin - 3 components of a point defining location of the plane.
3523  *  \param [in] vec - 3 components of a vector normal to the plane. Vector magnitude
3524  *         must be greater than 1e-6.
3525  *  \param [in] eps - half-thickness of the plane.
3526  *  \param [out] cellIds - a new instance of DataArrayInt holding ids of 3D cells
3527  *         producing correspondent 2D cells. The caller is to delete this array
3528  *         using decrRef() as it is no more needed.
3529  *  \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. This mesh does
3530  *         not share the node coordinates array with \a this mesh. The caller is to
3531  *         delete this mesh using decrRef() as it is no more needed.  
3532  *  \throw If the coordinates array is not set.
3533  *  \throw If the nodal connectivity of cells is not defined.
3534  *  \throw If \a this->getMeshDimension() != 3 or \a this->getSpaceDimension() != 3.
3535  *  \throw If magnitude of \a vec is less than 1e-6.
3536  *  \throw If the plane does not intersect any 3D cell of \a this mesh.
3537  *  \throw If \a this includes quadratic cells.
3538  */
3539 MEDCouplingUMesh *MEDCouplingUMesh::buildSlice3D(const double *origin, const double *vec, double eps, DataArrayInt *&cellIds) const
3540 {
3541   checkFullyDefined();
3542   if(getMeshDimension()!=3 || getSpaceDimension()!=3)
3543     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D works on umeshes with meshdim equal to 3 and spaceDim equal to 3 too!");
3544   MCAuto<DataArrayInt> candidates=getCellIdsCrossingPlane(origin,vec,eps);
3545   if(candidates->empty())
3546     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D : No 3D cells in this intercepts the specified plane considering bounding boxes !");
3547   std::vector<int> nodes;
3548   DataArrayInt *cellIds1D=0;
3549   MCAuto<MEDCouplingUMesh> subMesh=static_cast<MEDCouplingUMesh*>(buildPartOfMySelf(candidates->begin(),candidates->end(),false));
3550   subMesh->findNodesOnPlane(origin,vec,eps,nodes);
3551   MCAuto<DataArrayInt> desc1=DataArrayInt::New(),desc2=DataArrayInt::New();
3552   MCAuto<DataArrayInt> descIndx1=DataArrayInt::New(),descIndx2=DataArrayInt::New();
3553   MCAuto<DataArrayInt> revDesc1=DataArrayInt::New(),revDesc2=DataArrayInt::New();
3554   MCAuto<DataArrayInt> revDescIndx1=DataArrayInt::New(),revDescIndx2=DataArrayInt::New();
3555   MCAuto<MEDCouplingUMesh> mDesc2=subMesh->buildDescendingConnectivity(desc2,descIndx2,revDesc2,revDescIndx2);//meshDim==2 spaceDim==3
3556   revDesc2=0; revDescIndx2=0;
3557   MCAuto<MEDCouplingUMesh> mDesc1=mDesc2->buildDescendingConnectivity(desc1,descIndx1,revDesc1,revDescIndx1);//meshDim==1 spaceDim==3
3558   revDesc1=0; revDescIndx1=0;
3559   mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),true,cellIds1D);
3560   MCAuto<DataArrayInt> cellIds1DTmp(cellIds1D);
3561   //
3562   std::vector<int> cut3DCurve(mDesc1->getNumberOfCells(),-2);
3563   for(const int *it=cellIds1D->begin();it!=cellIds1D->end();it++)
3564     cut3DCurve[*it]=-1;
3565   mDesc1->split3DCurveWithPlane(origin,vec,eps,cut3DCurve);
3566   std::vector< std::pair<int,int> > cut3DSurf(mDesc2->getNumberOfCells());
3567   AssemblyForSplitFrom3DCurve(cut3DCurve,nodes,mDesc2->getNodalConnectivity()->getConstPointer(),mDesc2->getNodalConnectivityIndex()->getConstPointer(),
3568                               mDesc1->getNodalConnectivity()->getConstPointer(),mDesc1->getNodalConnectivityIndex()->getConstPointer(),
3569                               desc1->getConstPointer(),descIndx1->getConstPointer(),cut3DSurf);
3570   MCAuto<DataArrayInt> conn(DataArrayInt::New()),connI(DataArrayInt::New()),cellIds2(DataArrayInt::New());
3571   connI->pushBackSilent(0); conn->alloc(0,1); cellIds2->alloc(0,1);
3572   subMesh->assemblyForSplitFrom3DSurf(cut3DSurf,desc2->getConstPointer(),descIndx2->getConstPointer(),conn,connI,cellIds2);
3573   if(cellIds2->empty())
3574     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D : No 3D cells in this intercepts the specified plane !");
3575   MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New("Slice3D",2);
3576   ret->setCoords(mDesc1->getCoords());
3577   ret->setConnectivity(conn,connI,true);
3578   cellIds=candidates->selectByTupleId(cellIds2->begin(),cellIds2->end());
3579   return ret.retn();
3580 }
3581
3582 /*!
3583  * Creates an 1D mesh by cutting \a this 2D mesh in 3D space with a plane. In
3584 addition to the mesh, returns a new DataArrayInt, of length equal to the number of 1D cells in the result mesh, holding, for each cell in the result mesh, an id of a 2D cell it comes
3585 from. If a result segment is shared by two 2D cells, then the segment in included twice in
3586 the result mesh.
3587  *  \param [in] origin - 3 components of a point defining location of the plane.
3588  *  \param [in] vec - 3 components of a vector normal to the plane. Vector magnitude
3589  *         must be greater than 1e-6.
3590  *  \param [in] eps - half-thickness of the plane.
3591  *  \param [out] cellIds - a new instance of DataArrayInt holding ids of faces
3592  *         producing correspondent segments. The caller is to delete this array
3593  *         using decrRef() as it is no more needed.
3594  *  \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. This is an 1D
3595  *         mesh in 3D space. This mesh does not share the node coordinates array with
3596  *         \a this mesh. The caller is to delete this mesh using decrRef() as it is
3597  *         no more needed. 
3598  *  \throw If the coordinates array is not set.
3599  *  \throw If the nodal connectivity of cells is not defined.
3600  *  \throw If \a this->getMeshDimension() != 2 or \a this->getSpaceDimension() != 3.
3601  *  \throw If magnitude of \a vec is less than 1e-6.
3602  *  \throw If the plane does not intersect any 2D cell of \a this mesh.
3603  *  \throw If \a this includes quadratic cells.
3604  */
3605 MEDCouplingUMesh *MEDCouplingUMesh::buildSlice3DSurf(const double *origin, const double *vec, double eps, DataArrayInt *&cellIds) const
3606 {
3607   checkFullyDefined();
3608   if(getMeshDimension()!=2 || getSpaceDimension()!=3)
3609     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3DSurf works on umeshes with meshdim equal to 2 and spaceDim equal to 3 !");
3610   MCAuto<DataArrayInt> candidates(getCellIdsCrossingPlane(origin,vec,eps));
3611   if(candidates->empty())
3612     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3DSurf : No 3D surf cells in this intercepts the specified plane considering bounding boxes !");
3613   std::vector<int> nodes;
3614   DataArrayInt *cellIds1D(0);
3615   MCAuto<MEDCouplingUMesh> subMesh(buildPartOfMySelf(candidates->begin(),candidates->end(),false));
3616   subMesh->findNodesOnPlane(origin,vec,eps,nodes);
3617   MCAuto<DataArrayInt> desc1(DataArrayInt::New()),descIndx1(DataArrayInt::New()),revDesc1(DataArrayInt::New()),revDescIndx1(DataArrayInt::New());
3618   MCAuto<MEDCouplingUMesh> mDesc1(subMesh->buildDescendingConnectivity(desc1,descIndx1,revDesc1,revDescIndx1));//meshDim==1 spaceDim==3
3619   mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),true,cellIds1D);
3620   MCAuto<DataArrayInt> cellIds1DTmp(cellIds1D);
3621   //
3622   std::vector<int> cut3DCurve(mDesc1->getNumberOfCells(),-2);
3623   for(const int *it=cellIds1D->begin();it!=cellIds1D->end();it++)
3624     cut3DCurve[*it]=-1;
3625   mDesc1->split3DCurveWithPlane(origin,vec,eps,cut3DCurve);
3626   int ncellsSub=subMesh->getNumberOfCells();
3627   std::vector< std::pair<int,int> > cut3DSurf(ncellsSub);
3628   AssemblyForSplitFrom3DCurve(cut3DCurve,nodes,subMesh->getNodalConnectivity()->getConstPointer(),subMesh->getNodalConnectivityIndex()->getConstPointer(),
3629                               mDesc1->getNodalConnectivity()->getConstPointer(),mDesc1->getNodalConnectivityIndex()->getConstPointer(),
3630                               desc1->getConstPointer(),descIndx1->getConstPointer(),cut3DSurf);
3631   MCAuto<DataArrayInt> conn(DataArrayInt::New()),connI(DataArrayInt::New()),cellIds2(DataArrayInt::New()); connI->pushBackSilent(0);
3632   conn->alloc(0,1);
3633   const int *nodal=subMesh->getNodalConnectivity()->getConstPointer();
3634   const int *nodalI=subMesh->getNodalConnectivityIndex()->getConstPointer();
3635   for(int i=0;i<ncellsSub;i++)
3636     {
3637       if(cut3DSurf[i].first!=-1 && cut3DSurf[i].second!=-1)
3638         {
3639           if(cut3DSurf[i].first!=-2)
3640             {
3641               conn->pushBackSilent((int)INTERP_KERNEL::NORM_SEG2); conn->pushBackSilent(cut3DSurf[i].first); conn->pushBackSilent(cut3DSurf[i].second);
3642               connI->pushBackSilent(conn->getNumberOfTuples());
3643               cellIds2->pushBackSilent(i);
3644             }
3645           else
3646             {
3647               int cellId3DSurf=cut3DSurf[i].second;
3648               int offset=nodalI[cellId3DSurf]+1;
3649               int nbOfEdges=nodalI[cellId3DSurf+1]-offset;
3650               for(int j=0;j<nbOfEdges;j++)
3651                 {
3652                   conn->pushBackSilent((int)INTERP_KERNEL::NORM_SEG2); conn->pushBackSilent(nodal[offset+j]); conn->pushBackSilent(nodal[offset+(j+1)%nbOfEdges]);
3653                   connI->pushBackSilent(conn->getNumberOfTuples());
3654                   cellIds2->pushBackSilent(cellId3DSurf);
3655                 }
3656             }
3657         }
3658     }
3659   if(cellIds2->empty())
3660     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3DSurf : No 3DSurf cells in this intercepts the specified plane !");
3661   MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New("Slice3DSurf",1);
3662   ret->setCoords(mDesc1->getCoords());
3663   ret->setConnectivity(conn,connI,true);
3664   cellIds=candidates->selectByTupleId(cellIds2->begin(),cellIds2->end());
3665   return ret.retn();
3666 }
3667
3668 MCAuto<MEDCouplingUMesh> MEDCouplingUMesh::clipSingle3DCellByPlane(const double origin[3], const double vec[3], double eps) const
3669 {
3670   checkFullyDefined();
3671   if(getMeshDimension()!=3 || getSpaceDimension()!=3)
3672     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::clipSingle3DCellByPlane works on umeshes with meshdim equal to 3 and spaceDim equal to 3 too!");
3673   if(getNumberOfCells()!=1)
3674     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::clipSingle3DCellByPlane works only on mesh containing exactly one cell !");
3675   //
3676   std::vector<int> nodes;
3677   findNodesOnPlane(origin,vec,eps,nodes);
3678   MCAuto<DataArrayInt> desc1(DataArrayInt::New()),desc2(DataArrayInt::New()),descIndx1(DataArrayInt::New()),descIndx2(DataArrayInt::New()),revDesc1(DataArrayInt::New()),revDesc2(DataArrayInt::New()),revDescIndx1(DataArrayInt::New()),revDescIndx2(DataArrayInt::New());
3679   MCAuto<MEDCouplingUMesh> mDesc2(buildDescendingConnectivity(desc2,descIndx2,revDesc2,revDescIndx2));//meshDim==2 spaceDim==3
3680   revDesc2=0; revDescIndx2=0;
3681   MCAuto<MEDCouplingUMesh> mDesc1(mDesc2->buildDescendingConnectivity(desc1,descIndx1,revDesc1,revDescIndx1));//meshDim==1 spaceDim==3
3682   revDesc1=0; revDescIndx1=0;
3683   DataArrayInt *cellIds1D(0);
3684   mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),true,cellIds1D);
3685   MCAuto<DataArrayInt> cellIds1DTmp(cellIds1D);
3686   std::vector<int> cut3DCurve(mDesc1->getNumberOfCells(),-2);
3687   for(const int *it=cellIds1D->begin();it!=cellIds1D->end();it++)
3688     cut3DCurve[*it]=-1;
3689   bool sameNbNodes;
3690   {
3691     int oldNbNodes(mDesc1->getNumberOfNodes());
3692     mDesc1->split3DCurveWithPlane(origin,vec,eps,cut3DCurve);
3693     sameNbNodes=(mDesc1->getNumberOfNodes()==oldNbNodes);
3694   }
3695   std::vector< std::pair<int,int> > cut3DSurf(mDesc2->getNumberOfCells());
3696   AssemblyForSplitFrom3DCurve(cut3DCurve,nodes,mDesc2->getNodalConnectivity()->begin(),mDesc2->getNodalConnectivityIndex()->begin(),
3697                               mDesc1->getNodalConnectivity()->begin(),mDesc1->getNodalConnectivityIndex()->begin(),
3698                               desc1->begin(),descIndx1->begin(),cut3DSurf);
3699   MCAuto<DataArrayInt> conn(DataArrayInt::New()),connI(DataArrayInt::New());
3700   connI->pushBackSilent(0); conn->alloc(0,1);
3701   {
3702     MCAuto<DataArrayInt> cellIds2(DataArrayInt::New()); cellIds2->alloc(0,1);
3703     assemblyForSplitFrom3DSurf(cut3DSurf,desc2->begin(),descIndx2->begin(),conn,connI,cellIds2);
3704     if(cellIds2->empty())
3705       throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D : No 3D cells in this intercepts the specified plane !");
3706   }
3707   std::vector<std::vector<int> > res;
3708   buildSubCellsFromCut(cut3DSurf,desc2->begin(),descIndx2->begin(),mDesc1->getCoords()->begin(),eps,res);
3709   std::size_t sz(res.size());
3710   if(res.size()==mDesc1->getNumberOfCells() && sameNbNodes)
3711     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::clipSingle3DCellByPlane : cell is not clipped !");
3712   for(std::size_t i=0;i<sz;i++)
3713     {
3714       conn->pushBackSilent((int)INTERP_KERNEL::NORM_POLYGON);
3715       conn->insertAtTheEnd(res[i].begin(),res[i].end());
3716       connI->pushBackSilent(conn->getNumberOfTuples());
3717     }
3718   MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::New("",2));
3719   ret->setCoords(mDesc1->getCoords());
3720   ret->setConnectivity(conn,connI,true);
3721   int nbCellsRet(ret->getNumberOfCells());
3722   //
3723   MCAuto<DataArrayDouble> vec2(DataArrayDouble::New()); vec2->alloc(1,3); std::copy(vec,vec+3,vec2->getPointer());
3724   MCAuto<MEDCouplingFieldDouble> ortho(ret->buildOrthogonalField());
3725   MCAuto<DataArrayDouble> ortho2(ortho->getArray()->selectByTupleIdSafeSlice(0,1,1));
3726   MCAuto<DataArrayDouble> dott(DataArrayDouble::Dot(ortho2,vec2));
3727   MCAuto<DataArrayDouble> ccm(ret->computeCellCenterOfMass());
3728   MCAuto<DataArrayDouble> occm;
3729   {
3730     MCAuto<DataArrayDouble> pt(DataArrayDouble::New()); pt->alloc(1,3); std::copy(origin,origin+3,pt->getPointer());
3731     occm=DataArrayDouble::Substract(ccm,pt);
3732   }
3733   vec2=DataArrayDouble::New(); vec2->alloc(nbCellsRet,3);
3734   vec2->setPartOfValuesSimple1(vec[0],0,nbCellsRet,1,0,1,1); vec2->setPartOfValuesSimple1(vec[1],0,nbCellsRet,1,1,2,1); vec2->setPartOfValuesSimple1(vec[2],0,nbCellsRet,1,2,3,1);
3735   MCAuto<DataArrayDouble> dott2(DataArrayDouble::Dot(occm,vec2));
3736   //
3737   const int *cPtr(ret->getNodalConnectivity()->begin()),*ciPtr(ret->getNodalConnectivityIndex()->begin());
3738   MCAuto<MEDCouplingUMesh> ret2(MEDCouplingUMesh::New("Clip3D",3));
3739   ret2->setCoords(mDesc1->getCoords());
3740   MCAuto<DataArrayInt> conn2(DataArrayInt::New()),conn2I(DataArrayInt::New());
3741   conn2I->pushBackSilent(0); conn2->alloc(0,1);
3742   std::vector<int> cell0(1,(int)INTERP_KERNEL::NORM_POLYHED);
3743   std::vector<int> cell1(1,(int)INTERP_KERNEL::NORM_POLYHED);
3744   if(dott->getIJ(0,0)>0)
3745     {
3746       cell0.insert(cell0.end(),cPtr+1,cPtr+ciPtr[1]);
3747       std::reverse_copy(cPtr+1,cPtr+ciPtr[1],std::inserter(cell1,cell1.end()));
3748     }
3749   else
3750     {
3751       cell1.insert(cell1.end(),cPtr+1,cPtr+ciPtr[1]);
3752       std::reverse_copy(cPtr+1,cPtr+ciPtr[1],std::inserter(cell0,cell0.end()));
3753     }
3754   for(int i=1;i<nbCellsRet;i++)
3755     {
3756       if(dott2->getIJ(i,0)<0)
3757         {
3758           if(ciPtr[i+1]-ciPtr[i]>=4)
3759             {
3760               cell0.push_back(-1);
3761               cell0.insert(cell0.end(),cPtr+ciPtr[i]+1,cPtr+ciPtr[i+1]);
3762             }
3763         }
3764       else
3765         {
3766           if(ciPtr[i+1]-ciPtr[i]>=4)
3767             {
3768               cell1.push_back(-1);
3769               cell1.insert(cell1.end(),cPtr+ciPtr[i]+1,cPtr+ciPtr[i+1]);
3770             }
3771         }
3772     }
3773   conn2->insertAtTheEnd(cell0.begin(),cell0.end());
3774   conn2I->pushBackSilent(conn2->getNumberOfTuples());
3775   conn2->insertAtTheEnd(cell1.begin(),cell1.end());
3776   conn2I->pushBackSilent(conn2->getNumberOfTuples());
3777   ret2->setConnectivity(conn2,conn2I,true);
3778   ret2->checkConsistencyLight();
3779   ret2->orientCorrectlyPolyhedrons();
3780   return ret2;
3781 }
3782
3783 /*!
3784  * Finds cells whose bounding boxes intersect a given plane.
3785  *  \param [in] origin - 3 components of a point defining location of the plane.
3786  *  \param [in] vec - 3 components of a vector normal to the plane. Vector magnitude
3787  *         must be greater than 1e-6.
3788  *  \param [in] eps - half-thickness of the plane.
3789  *  \return DataArrayInt * - a new instance of DataArrayInt holding ids of the found
3790  *         cells. The caller is to delete this array using decrRef() as it is no more
3791  *         needed.
3792  *  \throw If the coordinates array is not set.
3793  *  \throw If the nodal connectivity of cells is not defined.
3794  *  \throw If \a this->getSpaceDimension() != 3.
3795  *  \throw If magnitude of \a vec is less than 1e-6.
3796  *  \sa buildSlice3D()
3797  */
3798 DataArrayInt *MEDCouplingUMesh::getCellIdsCrossingPlane(const double *origin, const double *vec, double eps) const
3799 {
3800   checkFullyDefined();
3801   if(getSpaceDimension()!=3)
3802     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D works on umeshes with spaceDim equal to 3 !");
3803   double normm=sqrt(vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2]);
3804   if(normm<1e-6)
3805     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getCellIdsCrossingPlane : parameter 'vec' should have a norm2 greater than 1e-6 !");
3806   double vec2[3];
3807   vec2[0]=vec[1]; vec2[1]=-vec[0]; vec2[2]=0.;//vec2 is the result of cross product of vec with (0,0,1)
3808   double angle=acos(vec[2]/normm);
3809   MCAuto<DataArrayInt> cellIds;
3810   double bbox[6];
3811   if(angle>eps)
3812     {
3813       MCAuto<DataArrayDouble> coo=_coords->deepCopy();
3814       double normm2(sqrt(vec2[0]*vec2[0]+vec2[1]*vec2[1]+vec2[2]*vec2[2]));
3815       if(normm2/normm>1e-6)
3816         DataArrayDouble::Rotate3DAlg(origin,vec2,angle,coo->getNumberOfTuples(),coo->getPointer(),coo->getPointer());
3817       MCAuto<MEDCouplingUMesh> mw=clone(false);//false -> shallow copy
3818       mw->setCoords(coo);
3819       mw->getBoundingBox(bbox);
3820       bbox[4]=origin[2]-eps; bbox[5]=origin[2]+eps;
3821       cellIds=mw->getCellsInBoundingBox(bbox,eps);
3822     }
3823   else
3824     {
3825       getBoundingBox(bbox);
3826       bbox[4]=origin[2]-eps; bbox[5]=origin[2]+eps;
3827       cellIds=getCellsInBoundingBox(bbox,eps);
3828     }
3829   return cellIds.retn();
3830 }
3831
3832 /*!
3833  * This method checks that \a this is a contiguous mesh. The user is expected to call this method on a mesh with meshdim==1.
3834  * If not an exception will thrown. If this is an empty mesh with no cell an exception will be thrown too.
3835  * No consideration of coordinate is done by this method.
3836  * A 1D mesh is said contiguous if : a cell i with nodal connectivity (k,p) the cell i+1 the nodal connectivity should be (p,m)
3837  * If not false is returned. In case that false is returned a call to MEDCoupling::MEDCouplingUMesh::mergeNodes could be useful.
3838  */
3839 bool MEDCouplingUMesh::isContiguous1D() const
3840 {
3841   if(getMeshDimension()!=1)
3842     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::isContiguous1D : this method has a sense only for 1D mesh !");
3843   int nbCells=getNumberOfCells();
3844   if(nbCells<1)
3845     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::isContiguous1D : this method has a sense for non empty mesh !");
3846   const int *connI(_nodal_connec_index->begin()),*conn(_nodal_connec->begin());
3847   int ref=conn[connI[0]+2];
3848   for(int i=1;i<nbCells;i++)
3849     {
3850       if(conn[connI[i]+1]!=ref)
3851         return false;
3852       ref=conn[connI[i]+2];
3853     }
3854   return true;
3855 }
3856
3857 /*!
3858  * This method is only callable on mesh with meshdim == 1 containing only SEG2 and spaceDim==3.
3859  * This method projects this on the 3D line defined by (pt,v). This methods first checks that all SEG2 are along v vector.
3860  * \param pt reference point of the line
3861  * \param v normalized director vector of the line
3862  * \param eps max precision before throwing an exception
3863  * \param res output of size this->getNumberOfCells
3864  */
3865 void MEDCouplingUMesh::project1D(const double *pt, const double *v, double eps, double *res) const
3866 {
3867   if(getMeshDimension()!=1)
3868     throw INTERP_KERNEL::Exception("Expected a umesh with meshDim == 1 for project1D !");
3869   if(_types.size()!=1 || *(_types.begin())!=INTERP_KERNEL::NORM_SEG2)
3870     throw INTERP_KERNEL::Exception("Expected a umesh with only NORM_SEG2 type of elements for project1D !");
3871   if(getSpaceDimension()!=3)
3872     throw INTERP_KERNEL::Exception("Expected a umesh with spaceDim==3 for project1D !");
3873   MCAuto<MEDCouplingFieldDouble> f=buildDirectionVectorField();
3874   const double *fPtr=f->getArray()->getConstPointer();
3875   double tmp[3];
3876   for(std::size_t i=0;i<getNumberOfCells();i++)
3877     {
3878       const double *tmp1=fPtr+3*i;
3879       tmp[0]=tmp1[1]*v[2]-tmp1[2]*v[1];
3880       tmp[1]=tmp1[2]*v[0]-tmp1[0]*v[2];
3881       tmp[2]=tmp1[0]*v[1]-tmp1[1]*v[0];
3882       double n1=INTERP_KERNEL::norm<3>(tmp);
3883       n1/=INTERP_KERNEL::norm<3>(tmp1);
3884       if(n1>eps)
3885         throw INTERP_KERNEL::Exception("UMesh::Projection 1D failed !");
3886     }
3887   const double *coo=getCoords()->getConstPointer();
3888   for(int i=0;i<getNumberOfNodes();i++)
3889     {
3890       std::transform(coo+i*3,coo+i*3+3,pt,tmp,std::minus<double>());
3891       std::transform(tmp,tmp+3,v,tmp,std::multiplies<double>());
3892       res[i]=std::accumulate(tmp,tmp+3,0.);
3893     }
3894 }
3895
3896 /*!
3897  * This method computes the distance from a point \a pt to \a this and the first \a cellId in \a this corresponding to the returned distance. 
3898  * \a this is expected to be a mesh so that its space dimension is equal to its
3899  * mesh dimension + 1. Furthermore only mesh dimension 1 and 2 are supported for the moment.
3900  * Distance from \a ptBg to \a ptEnd is expected to be equal to the space dimension. \a this is also expected to be fully defined (connectivity and coordinates).
3901  *
3902  * WARNING, if there is some orphan nodes in \a this (nodes not fetched by any cells in \a this ( see MEDCouplingUMesh::zipCoords ) ) these nodes will ** not ** been taken
3903  * into account in this method. Only cells and nodes lying on them are considered in the algorithm (even if one of these orphan nodes is closer than returned distance).
3904  * A user that needs to consider orphan nodes should invoke DataArrayDouble::minimalDistanceTo method on the coordinates array of \a this.
3905  *
3906  * So this method is more accurate (so, more costly) than simply searching for the closest point in \a this.
3907  * If only this information is enough for you simply call \c getCoords()->distanceToTuple on \a this.
3908  *
3909  * \param [in] ptBg the start pointer (included) of the coordinates of the point
3910  * \param [in] ptEnd the end pointer (not included) of the coordinates of the point
3911  * \param [out] cellId that corresponds to minimal distance. If the closer node is not linked to any cell in \a this -1 is returned.
3912  * \return the positive value of the distance.
3913  * \throw if distance from \a ptBg to \a ptEnd is not equal to the space dimension. An exception is also thrown if mesh dimension of \a this is not equal to space
3914  * dimension - 1.
3915  * \sa DataArrayDouble::distanceToTuple, MEDCouplingUMesh::distanceToPoints
3916  */
3917 double MEDCouplingUMesh::distanceToPoint(const double *ptBg, const double *ptEnd, int& cellId) const
3918 {
3919   int meshDim=getMeshDimension(),spaceDim=getSpaceDimension();
3920   if(meshDim!=spaceDim-1)
3921     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoint works only for spaceDim=meshDim+1 !");
3922   if(meshDim!=2 && meshDim!=1)
3923     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoint : only mesh dimension 2 and 1 are implemented !");
3924   checkFullyDefined();
3925   if((int)std::distance(ptBg,ptEnd)!=spaceDim)
3926     { std::ostringstream oss; oss << "MEDCouplingUMesh::distanceToPoint : input point has to have dimension equal to the space dimension of this (" << spaceDim << ") !"; throw INTERP_KERNEL::Exception(oss.str()); }
3927   DataArrayInt *ret1=0;
3928   MCAuto<DataArrayDouble> pts=DataArrayDouble::New(); pts->useArray(ptBg,false,C_DEALLOC,1,spaceDim);
3929   MCAuto<DataArrayDouble> ret0=distanceToPoints(pts,ret1);
3930   MCAuto<DataArrayInt> ret1Safe(ret1);
3931   cellId=*ret1Safe->begin();
3932   return *ret0->begin();
3933 }
3934
3935 /*!
3936  * This method computes the distance from each point of points serie \a pts (stored in a DataArrayDouble in which each tuple represents a point)
3937  *  to \a this  and the first \a cellId in \a this corresponding to the returned distance. 
3938  * WARNING, if there is some orphan nodes in \a this (nodes not fetched by any cells in \a this ( see MEDCouplingUMesh::zipCoords ) ) these nodes will ** not ** been taken
3939  * into account in this method. Only cells and nodes lying on them are considered in the algorithm (even if one of these orphan nodes is closer than returned distance).
3940  * A user that needs to consider orphan nodes should invoke DataArrayDouble::minimalDistanceTo method on the coordinates array of \a this.
3941  * 
3942  * \a this is expected to be a mesh so that its space dimension is equal to its
3943  * mesh dimension + 1. Furthermore only mesh dimension 1 and 2 are supported for the moment.
3944  * Number of components of \a pts is expected to be equal to the space dimension. \a this is also expected to be fully defined (connectivity and coordinates).
3945  *
3946  * So this method is more accurate (so, more costly) than simply searching for each point in \a pts the closest point in \a this.
3947  * If only this information is enough for you simply call \c getCoords()->distanceToTuple on \a this.
3948  *
3949  * \param [in] pts the list of points in which each tuple represents a point
3950  * \param [out] cellIds a newly allocated object that tells for each point in \a pts the first cell id in \a this that minimizes the distance.
3951  * \return a newly allocated object to be dealed by the caller that tells for each point in \a pts the distance to \a this.
3952  * \throw if number of components of \a pts is not equal to the space dimension.
3953  * \throw if mesh dimension of \a this is not equal to space dimension - 1.
3954  * \sa DataArrayDouble::distanceToTuple, MEDCouplingUMesh::distanceToPoint
3955  */
3956 DataArrayDouble *MEDCouplingUMesh::distanceToPoints(const DataArrayDouble *pts, DataArrayInt *& cellIds) const
3957 {
3958   if(!pts)
3959     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints : input points pointer is NULL !");
3960   pts->checkAllocated();
3961   int meshDim=getMeshDimension(),spaceDim=getSpaceDimension();
3962   if(meshDim!=spaceDim-1)
3963     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints works only for spaceDim=meshDim+1 !");
3964   if(meshDim!=2 && meshDim!=1)
3965     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints : only mesh dimension 2 and 1 are implemented !");
3966   if((int)pts->getNumberOfComponents()!=spaceDim)
3967     {
3968       std::ostringstream oss; oss << "MEDCouplingUMesh::distanceToPoints : input pts DataArrayDouble has " << pts->getNumberOfComponents() << " components whereas it should be equal to " << spaceDim << " (mesh spaceDimension) !";
3969       throw INTERP_KERNEL::Exception(oss.str());
3970     }
3971   checkFullyDefined();
3972   int nbCells=getNumberOfCells();
3973   if(nbCells==0)
3974     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints : no cells in this !");
3975   int nbOfPts=pts->getNumberOfTuples();
3976   MCAuto<DataArrayDouble> ret0=DataArrayDouble::New(); ret0->alloc(nbOfPts,1);
3977   MCAuto<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(nbOfPts,1);
3978   const int *nc=_nodal_connec->begin(),*ncI=_nodal_connec_index->begin(); const double *coords=_coords->begin();
3979   double *ret0Ptr=ret0->getPointer(); int *ret1Ptr=ret1->getPointer(); const double *ptsPtr=pts->begin();
3980   MCAuto<DataArrayDouble> bboxArr(getBoundingBoxForBBTree());
3981   const double *bbox(bboxArr->begin());
3982   switch(spaceDim)
3983   {
3984     case 3:
3985       {
3986         BBTreeDst<3> myTree(bbox,0,0,nbCells);
3987         for(int i=0;i<nbOfPts;i++,ret0Ptr++,ret1Ptr++,ptsPtr+=3)
3988           {
3989             double x=std::numeric_limits<double>::max();
3990             std::vector<int> elems;
3991             myTree.getMinDistanceOfMax(ptsPtr,x);
3992             myTree.getElemsWhoseMinDistanceToPtSmallerThan(ptsPtr,x,elems);
3993             DistanceToPoint3DSurfAlg(ptsPtr,&elems[0],&elems[0]+elems.size(),coords,nc,ncI,*ret0Ptr,*ret1Ptr);
3994           }
3995         break;
3996       }
3997     case 2:
3998       {
3999         BBTreeDst<2> myTree(bbox,0,0,nbCells);
4000         for(int i=0;i<nbOfPts;i++,ret0Ptr++,ret1Ptr++,ptsPtr+=2)
4001           {
4002             double x=std::numeric_limits<double>::max();
4003             std::vector<int> elems;
4004             myTree.getMinDistanceOfMax(ptsPtr,x);
4005             myTree.getElemsWhoseMinDistanceToPtSmallerThan(ptsPtr,x,elems);
4006             DistanceToPoint2DCurveAlg(ptsPtr,&elems[0],&elems[0]+elems.size(),coords,nc,ncI,*ret0Ptr,*ret1Ptr);
4007           }
4008         break;
4009       }
4010     default:
4011       throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints : only spacedim 2 and 3 supported !");
4012   }
4013   cellIds=ret1.retn();
4014   return ret0.retn();
4015 }
4016
4017 /// @cond INTERNAL
4018
4019 /// @endcond
4020
4021 /*!
4022  * Finds cells in contact with a ball (i.e. a point with precision). 
4023  * For speed reasons, the INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_TRI6 and INTERP_KERNEL::NORM_QUAD8 cells are considered as convex cells to detect if a point is IN or OUT.
4024  * If it is not the case, please change their types to INTERP_KERNEL::NORM_POLYGON or INTERP_KERNEL::NORM_QPOLYG before invoking this method.
4025  *
4026  * \warning This method is suitable if the caller intends to evaluate only one
4027  *          point, for more points getCellsContainingPoints() is recommended as it is
4028  *          faster. 
4029  *  \param [in] pos - array of coordinates of the ball central point.
4030  *  \param [in] eps - ball radius.
4031  *  \return int - a smallest id of cells being in contact with the ball, -1 in case
4032  *         if there are no such cells.
4033  *  \throw If the coordinates array is not set.
4034  *  \throw If \a this->getMeshDimension() != \a this->getSpaceDimension().
4035  */
4036 int MEDCouplingUMesh::getCellContainingPoint(const double *pos, double eps) const
4037 {
4038   std::vector<int> elts;
4039   getCellsContainingPoint(pos,eps,elts);
4040   if(elts.empty())
4041     return -1;
4042   return elts.front();
4043 }
4044
4045 /*!
4046  * Finds cells in contact with a ball (i.e. a point with precision).
4047  * For speed reasons, the INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_TRI6 and INTERP_KERNEL::NORM_QUAD8 cells are considered as convex cells to detect if a point is IN or OUT.
4048  * If it is not the case, please change their types to INTERP_KERNEL::NORM_POLYGON or INTERP_KERNEL::NORM_QPOLYG before invoking this method.
4049  * \warning This method is suitable if the caller intends to evaluate only one
4050  *          point, for more points getCellsContainingPoints() is recommended as it is
4051  *          faster. 
4052  *  \param [in] pos - array of coordinates of the ball central point.
4053  *  \param [in] eps - ball radius.
4054  *  \param [out] elts - vector returning ids of the found cells. It is cleared
4055  *         before inserting ids.
4056  *  \throw If the coordinates array is not set.
4057  *  \throw If \a this->getMeshDimension() != \a this->getSpaceDimension().
4058  *
4059  *  \if ENABLE_EXAMPLES
4060  *  \ref cpp_mcumesh_getCellsContainingPoint "Here is a C++ example".<br>
4061  *  \ref  py_mcumesh_getCellsContainingPoint "Here is a Python example".
4062  *  \endif
4063  */
4064 void MEDCouplingUMesh::getCellsContainingPoint(const double *pos, double eps, std::vector<int>& elts) const
4065 {
4066   MCAuto<DataArrayInt> eltsUg,eltsIndexUg;
4067   getCellsContainingPoints(pos,1,eps,eltsUg,eltsIndexUg);
4068   elts.clear(); elts.insert(elts.end(),eltsUg->begin(),eltsUg->end());
4069 }
4070
4071 void MEDCouplingUMesh::getCellsContainingPointsZeAlg(const double *pos, int nbOfPoints, double eps,
4072                                                      MCAuto<DataArrayInt>& elts, MCAuto<DataArrayInt>& eltsIndex,
4073                                                      std::function<bool(INTERP_KERNEL::NormalizedCellType,int)> sensibilityTo2DQuadraticLinearCellsFunc) const
4074 {
4075   int spaceDim(getSpaceDimension()),mDim(getMeshDimension());
4076   if(spaceDim==3)
4077     {
4078       if(mDim==3)
4079         {
4080           const double *coords=_coords->getConstPointer();
4081           getCellsContainingPointsAlg<3>(coords,pos,nbOfPoints,eps,elts,eltsIndex,sensibilityTo2DQuadraticLinearCellsFunc);
4082         }
4083       else
4084         throw INTERP_KERNEL::Exception("For spaceDim==3 only meshDim==3 implemented for getelementscontainingpoints !");
4085     }
4086   else if(spaceDim==2)
4087     {
4088       if(mDim==2)
4089         {
4090           const double *coords=_coords->getConstPointer();
4091           getCellsContainingPointsAlg<2>(coords,pos,nbOfPoints,eps,elts,eltsIndex,sensibilityTo2DQuadraticLinearCellsFunc);
4092         }
4093       else
4094         throw INTERP_KERNEL::Exception("For spaceDim==2 only meshDim==2 implemented for getelementscontainingpoints !");
4095     }
4096   else if(spaceDim==1)
4097     {
4098       if(mDim==1)
4099         {
4100           const double *coords=_coords->getConstPointer();
4101           getCellsContainingPointsAlg<1>(coords,pos,nbOfPoints,eps,elts,eltsIndex,sensibilityTo2DQuadraticLinearCellsFunc);
4102         }
4103       else
4104         throw INTERP_KERNEL::Exception("For spaceDim==1 only meshDim==1 implemented for getelementscontainingpoints !");
4105     }
4106   else
4107     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getCellsContainingPoints : not managed for mdim not in [1,2,3] !");
4108 }
4109
4110 /*!
4111  * Finds cells in contact with several balls (i.e. points with precision).
4112  * This method is an extension of getCellContainingPoint() and
4113  * getCellsContainingPoint() for the case of multiple points.
4114  * For speed reasons, the INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_TRI6 and INTERP_KERNEL::NORM_QUAD8 cells are considered as convex cells to detect if a point is IN or OUT.
4115  * If it is not the case, please change their types to INTERP_KERNEL::NORM_POLYGON or INTERP_KERNEL::NORM_QPOLYG before invoking this method.
4116  *  \param [in] pos - an array of coordinates of points in full interlace mode :
4117  *         X0,Y0,Z0,X1,Y1,Z1,... Size of the array must be \a
4118  *         this->getSpaceDimension() * \a nbOfPoints 
4119  *  \param [in] nbOfPoints - number of points to locate within \a this mesh.
4120  *  \param [in] eps - radius of balls (i.e. the precision).
4121  *  \param [out] elts - vector returning ids of found cells.
4122  *  \param [out] eltsIndex - an array, of length \a nbOfPoints + 1,
4123  *         dividing cell ids in \a elts into groups each referring to one
4124  *         point. Its every element (except the last one) is an index pointing to the
4125  *         first id of a group of cells. For example cells in contact with the *i*-th
4126  *         point are described by following range of indices:
4127  *         [ \a eltsIndex[ *i* ], \a eltsIndex[ *i*+1 ] ) and the cell ids are
4128  *         \a elts[ \a eltsIndex[ *i* ]], \a elts[ \a eltsIndex[ *i* ] + 1 ], ...
4129  *         Number of cells in contact with the *i*-th point is
4130  *         \a eltsIndex[ *i*+1 ] - \a eltsIndex[ *i* ].
4131  *  \throw If the coordinates array is not set.
4132  *  \throw If \a this->getMeshDimension() != \a this->getSpaceDimension().
4133  *
4134  *  \if ENABLE_EXAMPLES
4135  *  \ref cpp_mcumesh_getCellsContainingPoints "Here is a C++ example".<br>
4136  *  \ref  py_mcumesh_getCellsContainingPoints "Here is a Python example".
4137  *  \endif
4138  */
4139 void MEDCouplingUMesh::getCellsContainingPoints(const double *pos, int nbOfPoints, double eps,
4140                                                 MCAuto<DataArrayInt>& elts, MCAuto<DataArrayInt>& eltsIndex) const
4141 {
4142   auto yesImSensibleTo2DQuadraticLinearCellsFunc([](INTERP_KERNEL::NormalizedCellType ct, int mdim) { return INTERP_KERNEL::CellModel::GetCellModel(ct).isQuadratic() && mdim == 2; } );
4143   this->getCellsContainingPointsZeAlg(pos,nbOfPoints,eps,elts,eltsIndex,yesImSensibleTo2DQuadraticLinearCellsFunc);
4144 }
4145
4146 /*!
4147  * Behaves like MEDCouplingMesh::getCellsContainingPoints for cells in \a this that are linear.
4148  * For quadratic cells in \a this, this method behaves by just considering linear part of cells.
4149  * This method is here only for backward compatibility (interpolation GaussPoints to GaussPoints).
4150  * 
4151  * \sa MEDCouplingUMesh::getCellsContainingPoints, MEDCouplingRemapper::prepareNotInterpKernelOnlyGaussGauss
4152  */
4153 void MEDCouplingUMesh::getCellsContainingPointsLinearPartOnlyOnNonDynType(const double *pos, int nbOfPoints, double eps, MCAuto<DataArrayInt>& elts, MCAuto<DataArrayInt>& eltsIndex) const
4154 {
4155   auto noImNotSensibleTo2DQuadraticLinearCellsFunc([](INTERP_KERNEL::NormalizedCellType,int) { return false; } );
4156   this->getCellsContainingPointsZeAlg(pos,nbOfPoints,eps,elts,eltsIndex,noImNotSensibleTo2DQuadraticLinearCellsFunc);
4157 }
4158
4159 /*!
4160  * Finds butterfly cells in \a this mesh. A 2D cell is considered to be butterfly if at
4161  * least two its edges intersect each other anywhere except their extremities. An
4162  * INTERP_KERNEL::NORM_NORI3 cell can \b not be butterfly.
4163  *  \param [in,out] cells - a vector returning ids of the found cells. It is not
4164  *         cleared before filling in.
4165  *  \param [in] eps - precision.
4166  *  \throw If \a this->getMeshDimension() != 2.
4167  *  \throw If \a this->getSpaceDimension() != 2 && \a this->getSpaceDimension() != 3.
4168  */
4169 void MEDCouplingUMesh::checkButterflyCells(std::vector<int>& cells, double eps) const
4170 {
4171   const char msg[]="Butterfly detection work only for 2D cells with spaceDim==2 or 3!";
4172   if(getMeshDimension()!=2)
4173     throw INTERP_KERNEL::Exception(msg);
4174   int spaceDim=getSpaceDimension();
4175   if(spaceDim!=2 && spaceDim!=3)
4176     throw INTERP_KERNEL::Exception(msg);
4177   const int *conn=_nodal_connec->getConstPointer();
4178   const int *connI=_nodal_connec_index->getConstPointer();
4179   int nbOfCells=getNumberOfCells();
4180   std::vector<double> cell2DinS2;
4181   for(int i=0;i<nbOfCells;i++)
4182     {
4183       int offset=connI[i];
4184       int nbOfNodesForCell=connI[i+1]-offset-1;
4185       if(nbOfNodesForCell<=3)
4186         continue;
4187       bool isQuad=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[offset]).isQuadratic();
4188       project2DCellOnXY(conn+offset+1,conn+connI[i+1],cell2DinS2);
4189       if(isButterfly2DCell(cell2DinS2,isQuad,eps))
4190         cells.push_back(i);
4191       cell2DinS2.clear();
4192     }
4193 }
4194
4195 /*!
4196  * This method is typically requested to unbutterfly 2D linear cells in \b this.
4197  *
4198  * This method expects that space dimension is equal to 2 and mesh dimension is equal to 2 too. If it is not the case an INTERP_KERNEL::Exception will be thrown.
4199  * This method works only for linear 2D cells. If there is any of non linear cells (INTERP_KERNEL::NORM_QUAD8 for example) an INTERP_KERNEL::Exception will be thrown too.
4200  * 
4201  * For each 2D linear cell in \b this, this method builds the convex envelop (or the convex hull) of the current cell.
4202  * This convex envelop is computed using Jarvis march algorithm.
4203  * The coordinates and the number of cells of \b this remain unchanged on invocation of this method.
4204  * Only connectivity of some cells could be modified if those cells were not representing a convex envelop. If a cell already equals its convex envelop (regardless orientation)
4205  * its connectivity will remain unchanged. If the computation leads to a modification of nodal connectivity of a cell its geometric type will be modified to INTERP_KERNEL::NORM_POLYGON.
4206  *
4207  * \return a newly allocated array containing cellIds that have been modified if any. If no cells have been impacted by this method NULL is returned.
4208  * \sa MEDCouplingUMesh::colinearize2D
4209  */
4210 DataArrayInt *MEDCouplingUMesh::convexEnvelop2D()
4211 {
4212   if(getMeshDimension()!=2 || getSpaceDimension()!=2)
4213     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convexEnvelop2D  works only for meshDim=2 and spaceDim=2 !");
4214   checkFullyDefined();
4215   const double *coords=getCoords()->getConstPointer();
4216   int nbOfCells=getNumberOfCells();
4217   MCAuto<DataArrayInt> nodalConnecIndexOut=DataArrayInt::New();
4218   nodalConnecIndexOut->alloc(nbOfCells+1,1);
4219   MCAuto<DataArrayInt> nodalConnecOut(DataArrayInt::New());
4220   int *workIndexOut=nodalConnecIndexOut->getPointer();
4221   *workIndexOut=0;
4222   const int *nodalConnecIn=_nodal_connec->getConstPointer();
4223   const int *nodalConnecIndexIn=_nodal_connec_index->getConstPointer();
4224   std::set<INTERP_KERNEL::NormalizedCellType> types;
4225   MCAuto<DataArrayInt> isChanged(DataArrayInt::New());
4226   isChanged->alloc(0,1);
4227   for(int i=0;i<nbOfCells;i++,workIndexOut++)
4228     {
4229       int pos=nodalConnecOut->getNumberOfTuples();
4230       if(BuildConvexEnvelopOf2DCellJarvis(coords,nodalConnecIn+nodalConnecIndexIn[i],nodalConnecIn+nodalConnecIndexIn[i+1],nodalConnecOut))
4231         isChanged->pushBackSilent(i);
4232       types.insert((INTERP_KERNEL::NormalizedCellType)nodalConnecOut->getIJ(pos,0));
4233       workIndexOut[1]=nodalConnecOut->getNumberOfTuples();
4234     }
4235   if(isChanged->empty())
4236     return 0;
4237   setConnectivity(nodalConnecOut,nodalConnecIndexOut,false);
4238   _types=types;
4239   return isChanged.retn();
4240 }
4241
4242 /*!
4243  * This method is \b NOT const because it can modify \a this.
4244  * \a this is expected to be an unstructured mesh with meshDim==2 and spaceDim==3. If not an exception will be thrown.
4245  * \param mesh1D is an unstructured mesh with MeshDim==1 and spaceDim==3. If not an exception will be thrown.
4246  * \param policy specifies the type of extrusion chosen:
4247  *   - \b 0 for translation only (most simple): the cells of the 1D mesh represent the vectors along which the 2D mesh
4248  *   will be repeated to build each level
4249  *   - \b 1 for translation and rotation: the translation is done as above. For each level, an arc of circle is fitted on
4250  *   the 3 preceding points of the 1D mesh. The center of the arc is the center of rotation for each level, the rotation is done
4251  *   along an axis normal to the plane containing the arc, and finally the angle of rotation is defined by the first two points on the
4252  *   arc.
4253  * \return an unstructured mesh with meshDim==3 and spaceDim==3. The returned mesh has the same coords than \a this.  
4254  */
4255 MEDCouplingUMesh *MEDCouplingUMesh::buildExtrudedMesh(const MEDCouplingUMesh *mesh1D, int policy)
4256 {
4257   checkFullyDefined();
4258   mesh1D->checkFullyDefined();
4259   if(!mesh1D->isContiguous1D())
4260     throw INTERP_KERNEL::Exception("buildExtrudedMesh : 1D mesh passed in parameter is not contiguous !");
4261   if(getSpaceDimension()!=mesh1D->getSpaceDimension())
4262     throw INTERP_KERNEL::Exception("Invalid call to buildExtrudedMesh this and mesh1D must have same space dimension !");
4263   if((getMeshDimension()!=2 || getSpaceDimension()!=3) && (getMeshDimension()!=1 || getSpaceDimension()!=2))
4264     throw INTERP_KERNEL::Exception("Invalid 'this' for buildExtrudedMesh method : must be (meshDim==2 and spaceDim==3) or (meshDim==1 and spaceDim==2) !");
4265   if(mesh1D->getMeshDimension()!=1)
4266     throw INTERP_KERNEL::Exception("Invalid 'mesh1D' for buildExtrudedMesh method : must be meshDim==1 !");
4267   bool isQuad=false;
4268   if(isPresenceOfQuadratic())
4269     {
4270       if(mesh1D->isFullyQuadratic())
4271         isQuad=true;
4272       else
4273         throw INTERP_KERNEL::Exception("Invalid 2D mesh and 1D mesh because 2D mesh has quadratic cells and 1D is not fully quadratic !");
4274     }
4275   int oldNbOfNodes(getNumberOfNodes());
4276   MCAuto<DataArrayDouble> newCoords;
4277   switch(policy)
4278   {
4279     case 0:
4280       {
4281         newCoords=fillExtCoordsUsingTranslation(mesh1D,isQuad);
4282         break;
4283       }
4284     case 1:
4285       {
4286         newCoords=fillExtCoordsUsingTranslAndAutoRotation(mesh1D,isQuad);
4287         break;
4288       }
4289     default:
4290       throw INTERP_KERNEL::Exception("Not implemented extrusion policy : must be in (0) !");
4291   }
4292   setCoords(newCoords);
4293   MCAuto<MEDCouplingUMesh> ret(buildExtrudedMeshFromThisLowLev(oldNbOfNodes,isQuad));
4294   updateTime();
4295   return ret.retn();
4296 }
4297
4298
4299 /*!
4300  * Checks if \a this mesh is constituted by only quadratic cells.
4301  *  \return bool - \c true if there are only quadratic cells in \a this mesh.
4302  *  \throw If the coordinates array is not set.
4303  *  \throw If the nodal connectivity of cells is not defined.
4304  */
4305 bool MEDCouplingUMesh::isFullyQuadratic() const
4306 {
4307   checkFullyDefined();
4308   bool ret=true;
4309   int nbOfCells=getNumberOfCells();
4310   for(int i=0;i<nbOfCells && ret;i++)
4311     {
4312       INTERP_KERNEL::NormalizedCellType type=getTypeOfCell(i);
4313       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
4314       ret=cm.isQuadratic();
4315     }
4316   return ret;
4317 }
4318
4319 /*!
4320  * Checks if \a this mesh includes any quadratic cell.
4321  *  \return bool - \c true if there is at least one quadratic cells in \a this mesh.
4322  *  \throw If the coordinates array is not set.
4323  *  \throw If the nodal connectivity of cells is not defined.
4324  */
4325 bool MEDCouplingUMesh::isPresenceOfQuadratic() const
4326 {
4327   checkFullyDefined();
4328   bool ret=false;
4329   int nbOfCells=getNumberOfCells();
4330   for(int i=0;i<nbOfCells && !ret;i++)
4331     {
4332       INTERP_KERNEL::NormalizedCellType type=getTypeOfCell(i);
4333       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
4334       ret=cm.isQuadratic();
4335     }
4336   return ret;
4337 }
4338
4339 /*!
4340  * Converts all quadratic cells to linear ones. If there are no quadratic cells in \a
4341  * this mesh, it remains unchanged.
4342  *  \throw If the coordinates array is not set.
4343  *  \throw If the nodal connectivity of cells is not defined.
4344  */
4345 void MEDCouplingUMesh::convertQuadraticCellsToLinear()
4346 {
4347   checkFullyDefined();
4348   int nbOfCells(getNumberOfCells());
4349   int delta=0;
4350   const int *iciptr=_nodal_connec_index->begin();
4351   for(int i=0;i<nbOfCells;i++)
4352     {
4353       INTERP_KERNEL::NormalizedCellType type=getTypeOfCell(i);
4354       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
4355       if(cm.isQuadratic())
4356         {
4357           INTERP_KERNEL::NormalizedCellType typel=cm.getLinearType();
4358           const INTERP_KERNEL::CellModel& cml=INTERP_KERNEL::CellModel::GetCellModel(typel);
4359           if(!cml.isDynamic())
4360             delta+=cm.getNumberOfNodes()-cml.getNumberOfNodes();
4361           else
4362             delta+=(iciptr[i+1]-iciptr[i]-1)/2;
4363         }
4364     }
4365   if(delta==0)
4366     return ;
4367   MCAuto<DataArrayInt> newConn(DataArrayInt::New()),newConnI(DataArrayInt::New());
4368   const int *icptr(_nodal_connec->begin());
4369   newConn->alloc(getNodalConnectivityArrayLen()-delta,1);
4370   newConnI->alloc(nbOfCells+1,1);
4371   int *ocptr(newConn->getPointer()),*ociptr(newConnI->getPointer());
4372   *ociptr=0;
4373   _types.clear();
4374   for(int i=0;i<nbOfCells;i++,ociptr++)
4375     {
4376       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)icptr[iciptr[i]];
4377       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
4378       if(!cm.isQuadratic())
4379         {
4380           _types.insert(type);
4381           ocptr=std::copy(icptr+iciptr[i],icptr+iciptr[i+1],ocptr);
4382           ociptr[1]=ociptr[0]+iciptr[i+1]-iciptr[i];
4383         }
4384       else
4385         {
4386           INTERP_KERNEL::NormalizedCellType typel=cm.getLinearType();
4387           _types.insert(typel);
4388           const INTERP_KERNEL::CellModel& cml=INTERP_KERNEL::CellModel::GetCellModel(typel);
4389           int newNbOfNodes=cml.getNumberOfNodes();
4390           if(cml.isDynamic())
4391             newNbOfNodes=(iciptr[i+1]-iciptr[i]-1)/2;
4392           *ocptr++=(int)typel;
4393           ocptr=std::copy(icptr+iciptr[i]+1,icptr+iciptr[i]+newNbOfNodes+1,ocptr);
4394           ociptr[1]=ociptr[0]+newNbOfNodes+1;
4395         }
4396     }
4397   setConnectivity(newConn,newConnI,false);
4398 }
4399
4400 /*!
4401  * This method converts all linear cell in \a this to quadratic one.
4402  * Contrary to MEDCouplingUMesh::convertQuadraticCellsToLinear method, here it is needed to specify the target
4403  * type of cells expected. For example INTERP_KERNEL::NORM_TRI3 can be converted to INTERP_KERNEL::NORM_TRI6 if \a conversionType is equal to 0 (the default)
4404  * or to INTERP_KERNEL::NORM_TRI7 if \a conversionType is equal to 1. All non linear cells and polyhedron in \a this are let untouched.
4405  * Contrary to MEDCouplingUMesh::convertQuadraticCellsToLinear method, the coordinates in \a this can be become bigger. All created nodes will be put at the
4406  * end of the existing coordinates.
4407  * 
4408  * \param [in] conversionType specifies the type of conversion expected. Only 0 (default) and 1 are supported presently. 0 those that creates the 'most' simple
4409  *             corresponding quadratic cells. 1 is those creating the 'most' complex.
4410  * \return a newly created DataArrayInt instance that the caller should deal with containing cell ids of converted cells.
4411  * 
4412  * \throw if \a this is not fully defined. It throws too if \a conversionType is not in [0,1].
4413  *
4414  * \sa MEDCouplingUMesh::convertQuadraticCellsToLinear
4415  */
4416 DataArrayInt *MEDCouplingUMesh::convertLinearCellsToQuadratic(int conversionType)
4417 {
4418   DataArrayInt *conn=0,*connI=0;
4419   DataArrayDouble *coords=0;
4420   std::set<INTERP_KERNEL::NormalizedCellType> types;
4421   checkFullyDefined();
4422   MCAuto<DataArrayInt> ret,connSafe,connISafe;
4423   MCAuto<DataArrayDouble> coordsSafe;
4424   int meshDim=getMeshDimension();
4425   switch(conversionType)
4426   {
4427     case 0:
4428       switch(meshDim)
4429       {
4430         case 1:
4431           ret=convertLinearCellsToQuadratic1D0(conn,connI,coords,types);
4432           connSafe=conn; connISafe=connI; coordsSafe=coords;
4433           break;
4434         case 2:
4435           ret=convertLinearCellsToQuadratic2D0(conn,connI,coords,types);
4436           connSafe=conn; connISafe=connI; coordsSafe=coords;
4437           break;
4438         case 3:
4439           ret=convertLinearCellsToQuadratic3D0(conn,connI,coords,types);
4440           connSafe=conn; connISafe=connI; coordsSafe=coords;
4441           break;
4442         default:
4443           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertLinearCellsToQuadratic : conversion of type 0 mesh dimensions available are [1,2,3] !");
4444       }
4445       break;
4446         case 1:
4447           {
4448             switch(meshDim)
4449             {
4450               case 1:
4451                 ret=convertLinearCellsToQuadratic1D0(conn,connI,coords,types);//it is not a bug. In 1D policy 0 and 1 are equals
4452                 connSafe=conn; connISafe=connI; coordsSafe=coords;
4453                 break;
4454               case 2:
4455                 ret=convertLinearCellsToQuadratic2D1(conn,connI,coords,types);
4456                 connSafe=conn; connISafe=connI; coordsSafe=coords;
4457                 break;
4458               case 3:
4459                 ret=convertLinearCellsToQuadratic3D1(conn,connI,coords,types);
4460                 connSafe=conn; connISafe=connI; coordsSafe=coords;
4461                 break;
4462               default:
4463                 throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertLinearCellsToQuadratic : conversion of type 1 mesh dimensions available are [1,2,3] !");
4464             }
4465             break;
4466           }
4467         default:
4468           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertLinearCellsToQuadratic : conversion type available are 0 (default, the simplest) and 1 (the most complex) !");
4469   }
4470   setConnectivity(connSafe,connISafe,false);
4471   _types=types;
4472   setCoords(coordsSafe);
4473   return ret.retn();
4474 }
4475
4476 /*!
4477  * Tessellates \a this 2D mesh by dividing not straight edges of quadratic faces,
4478  * so that the number of cells remains the same. Quadratic faces are converted to
4479  * polygons. This method works only for 2D meshes in
4480  * 2D space. If no cells are quadratic (INTERP_KERNEL::NORM_QUAD8,
4481  * INTERP_KERNEL::NORM_TRI6, INTERP_KERNEL::NORM_QPOLYG ), \a this mesh remains unchanged.
4482  * \warning This method can lead to a huge amount of nodes if \a eps is very low.
4483  *  \param [in] eps - specifies the maximal angle (in radians) between 2 sub-edges of
4484  *         a polylinized edge constituting the input polygon.
4485  *  \throw If the coordinates array is not set.
4486  *  \throw If the nodal connectivity of cells is not defined.
4487  *  \throw If \a this->getMeshDimension() != 2.
4488  *  \throw If \a this->getSpaceDimension() != 2.
4489  */
4490 void MEDCouplingUMesh::tessellate2D(double eps)
4491 {
4492   int meshDim(getMeshDimension()),spaceDim(getSpaceDimension());
4493   if(spaceDim!=2)
4494     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::tessellate2D : works only with space dimension equal to 2 !");
4495   switch(meshDim)
4496     {
4497     case 1:
4498       return tessellate2DCurveInternal(eps);
4499     case 2:
4500       return tessellate2DInternal(eps);
4501     default:
4502       throw INTERP_KERNEL::Exception("MEDCouplingUMesh::tessellate2D : mesh dimension must be in [1,2] !");
4503     }
4504 }
4505 /*!
4506  * Tessellates \a this 1D mesh in 2D space by dividing not straight quadratic edges.
4507  * \warning This method can lead to a huge amount of nodes if \a eps is very low.
4508  *  \param [in] eps - specifies the maximal angle (in radian) between 2 sub-edges of
4509  *         a sub-divided edge.
4510  *  \throw If the coordinates array is not set.
4511  *  \throw If the nodal connectivity of cells is not defined.
4512  *  \throw If \a this->getMeshDimension() != 1.
4513  *  \throw If \a this->getSpaceDimension() != 2.
4514  */
4515
4516 #if 0
4517 /*!
4518  * This method only works if \a this has spaceDimension equal to 2 and meshDimension also equal to 2.
4519  * This method allows to modify connectivity of cells in \a this that shares some edges in \a edgeIdsToBeSplit.
4520  * The nodes to be added in those 2D cells are defined by the pair of \a  nodeIdsToAdd and \a nodeIdsIndexToAdd.
4521  * Length of \a nodeIdsIndexToAdd is expected to equal to length of \a edgeIdsToBeSplit + 1.
4522  * The node ids in \a nodeIdsToAdd should be valid. Those nodes have to be sorted exactly following exactly the direction of the edge.
4523  * This method can be seen as the opposite method of colinearize2D.
4524  * This method can be lead to create some new nodes if quadratic polygon cells have to be split. In this case the added nodes will be put at the end
4525  * to avoid to modify the numbering of existing nodes.
4526  *
4527  * \param [in] nodeIdsToAdd - the list of node ids to be added (\a nodeIdsIndexToAdd array allows to walk on this array)
4528  * \param [in] nodeIdsIndexToAdd - the entry point of \a nodeIdsToAdd to point to the corresponding nodes to be added.
4529  * \param [in] mesh1Desc - 1st output of buildDescendingConnectivity2 on \a this.
4530  * \param [in] desc - 2nd output of buildDescendingConnectivity2 on \a this.
4531  * \param [in] descI - 3rd output of buildDescendingConnectivity2 on \a this.
4532  * \param [in] revDesc - 4th output of buildDescendingConnectivity2 on \a this.
4533  * \param [in] revDescI - 5th output of buildDescendingConnectivity2 on \a this.
4534  *
4535  * \sa buildDescendingConnectivity2
4536  */
4537 void MEDCouplingUMesh::splitSomeEdgesOf2DMesh(const DataArrayInt *nodeIdsToAdd, const DataArrayInt *nodeIdsIndexToAdd, const DataArrayInt *edgeIdsToBeSplit,
4538                                               const MEDCouplingUMesh *mesh1Desc, const DataArrayInt *desc, const DataArrayInt *descI, const DataArrayInt *revDesc, const DataArrayInt *revDescI)
4539 {
4540   if(!nodeIdsToAdd || !nodeIdsIndexToAdd || !edgeIdsToBeSplit || !mesh1Desc || !desc || !descI || !revDesc || !revDescI)
4541     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitSomeEdgesOf2DMesh : input pointers must be not NULL !");
4542   nodeIdsToAdd->checkAllocated(); nodeIdsIndexToAdd->checkAllocated(); edgeIdsToBeSplit->checkAllocated(); desc->checkAllocated(); descI->checkAllocated(); revDesc->checkAllocated(); revDescI->checkAllocated();
4543   if(getSpaceDimension()!=2 || getMeshDimension()!=2)
4544     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitSomeEdgesOf2DMesh : this must have spacedim=meshdim=2 !");
4545   if(mesh1Desc->getSpaceDimension()!=2 || mesh1Desc->getMeshDimension()!=1)
4546     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitSomeEdgesOf2DMesh : mesh1Desc must be the explosion of this with spaceDim=2 and meshDim = 1 !");
4547   //DataArrayInt *out0(0),*outi0(0);
4548   //MEDCouplingUMesh::ExtractFromIndexedArrays(idsInDesc2DToBeRefined->begin(),idsInDesc2DToBeRefined->end(),dd3,dd4,out0,outi0);
4549   //MCAuto<DataArrayInt> out0s(out0),outi0s(outi0);
4550   //out0s=out0s->buildUnique(); out0s->sort(true);
4551 }
4552 #endif
4553
4554
4555 /*!
4556  * Divides every cell of \a this mesh into simplices (triangles in 2D and tetrahedra in 3D).
4557  * In addition, returns an array mapping new cells to old ones. <br>
4558  * This method typically increases the number of cells in \a this mesh
4559  * but the number of nodes remains \b unchanged.
4560  * That's why the 3D splitting policies
4561  * INTERP_KERNEL::GENERAL_24 and INTERP_KERNEL::GENERAL_48 are not available here.
4562  *  \param [in] policy - specifies a pattern used for splitting.
4563  * The semantic of \a policy is:
4564  * - 0 - to split QUAD4 by cutting it along 0-2 diagonal (for 2D mesh only).
4565  * - 1 - to split QUAD4 by cutting it along 1-3 diagonal (for 2D mesh only).
4566  * - INTERP_KERNEL::PLANAR_FACE_5 - to split HEXA8  into 5 TETRA4 (for 3D mesh only - see INTERP_KERNEL::SplittingPolicy for an image).
4567  * - INTERP_KERNEL::PLANAR_FACE_6 - to split HEXA8  into 6 TETRA4 (for 3D mesh only - see INTERP_KERNEL::SplittingPolicy for an image).
4568  *
4569  *
4570  *  \return DataArrayInt * - a new instance of DataArrayInt holding, for each new cell,
4571  *          an id of old cell producing it. The caller is to delete this array using
4572  *         decrRef() as it is no more needed.
4573  *
4574  *  \throw If \a policy is 0 or 1 and \a this->getMeshDimension() != 2.
4575  *  \throw If \a policy is INTERP_KERNEL::PLANAR_FACE_5 or INTERP_KERNEL::PLANAR_FACE_6
4576  *          and \a this->getMeshDimension() != 3. 
4577  *  \throw If \a policy is not one of the four discussed above.
4578  *  \throw If the nodal connectivity of cells is not defined.
4579  * \sa MEDCouplingUMesh::tetrahedrize, MEDCoupling1SGTUMesh::sortHexa8EachOther
4580  */
4581 DataArrayInt *MEDCouplingUMesh::simplexize(int policy)
4582 {
4583   switch(policy)
4584   {
4585     case 0:
4586       return simplexizePol0();
4587     case 1:
4588       return simplexizePol1();
4589     case (int) INTERP_KERNEL::PLANAR_FACE_5:
4590         return simplexizePlanarFace5();
4591     case (int) INTERP_KERNEL::PLANAR_FACE_6:
4592         return simplexizePlanarFace6();
4593     default:
4594       throw INTERP_KERNEL::Exception("MEDCouplingUMesh::simplexize : unrecognized policy ! Must be :\n  - 0 or 1 (only available for meshdim=2) \n  - PLANAR_FACE_5, PLANAR_FACE_6  (only for meshdim=3)");
4595   }
4596 }
4597
4598 /*!
4599  * Checks if \a this mesh is constituted by simplex cells only. Simplex cells are:
4600  * - 1D: INTERP_KERNEL::NORM_SEG2
4601  * - 2D: INTERP_KERNEL::NORM_TRI3
4602  * - 3D: INTERP_KERNEL::NORM_TETRA4.
4603  *
4604  * This method is useful for users that need to use P1 field services as
4605  * MEDCouplingFieldDouble::getValueOn(), MEDCouplingField::buildMeasureField() etc.
4606  * All these methods need mesh support containing only simplex cells.
4607  *  \return bool - \c true if there are only simplex cells in \a this mesh.
4608  *  \throw If the coordinates array is not set.
4609  *  \throw If the nodal connectivity of cells is not defined.
4610  *  \throw If \a this->getMeshDimension() < 1.
4611  */
4612 bool MEDCouplingUMesh::areOnlySimplexCells() const
4613 {
4614   checkFullyDefined();
4615   int mdim=getMeshDimension();
4616   if(mdim<1 || mdim>3)
4617     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::areOnlySimplexCells : only available with meshes having a meshdim 1, 2 or 3 !");
4618   int nbCells=getNumberOfCells();
4619   const int *conn=_nodal_connec->begin();
4620   const int *connI=_nodal_connec_index->begin();
4621   for(int i=0;i<nbCells;i++)
4622     {
4623       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
4624       if(!cm.isSimplex())
4625         return false;
4626     }
4627   return true;
4628 }
4629
4630
4631
4632 /*!
4633  * Converts degenerated 2D or 3D linear cells of \a this mesh into cells of simpler
4634  * type. For example an INTERP_KERNEL::NORM_QUAD4 cell having only three unique nodes in
4635  * its connectivity is transformed into an INTERP_KERNEL::NORM_TRI3 cell.
4636  * Quadratic cells in 2D are also handled. In those cells edges where start=end=midpoint are removed.
4637  * This method does \b not perform geometrical checks and checks only nodal connectivity of cells,
4638  * so it can be useful to call mergeNodes() before calling this method.
4639  *  \throw If \a this->getMeshDimension() <= 1.
4640  *  \throw If the coordinates array is not set.
4641  *  \throw If the nodal connectivity of cells is not defined.
4642  */
4643 void MEDCouplingUMesh::convertDegeneratedCells()
4644 {
4645   checkFullyDefined();
4646   if(getMeshDimension()<=1)
4647     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertDegeneratedCells works on umeshes with meshdim equals to 2 or 3 !");
4648   int nbOfCells=getNumberOfCells();
4649   if(nbOfCells<1)
4650     return ;
4651   int initMeshLgth=getNodalConnectivityArrayLen();
4652   int *conn=_nodal_connec->getPointer();
4653   int *index=_nodal_connec_index->getPointer();
4654   int posOfCurCell=0;
4655   int newPos=0;
4656   int lgthOfCurCell;
4657   for(int i=0;i<nbOfCells;i++)
4658     {
4659       lgthOfCurCell=index[i+1]-posOfCurCell;
4660       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
4661       int newLgth;
4662       INTERP_KERNEL::NormalizedCellType newType=INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,
4663                                                                                                      conn+newPos+1,newLgth);
4664       conn[newPos]=newType;
4665       newPos+=newLgth+1;
4666       posOfCurCell=index[i+1];
4667       index[i+1]=newPos;
4668     }
4669   if(newPos!=initMeshLgth)
4670     _nodal_connec->reAlloc(newPos);
4671   computeTypes();
4672 }
4673
4674 /*!
4675  * Same as MEDCouplingUMesh::convertDegeneratedCells() plus deletion of the flat cells.
4676  * A cell is flat in the following cases:
4677  *   - for a linear cell, all points in the connectivity are equal
4678  *   - for a quadratic cell, either the above, or a quadratic polygon with two (linear) points and two
4679  *   identical quadratic points
4680  * \return a new instance of DataArrayInt holding ids of removed cells. The caller is to delete
4681  *      this array using decrRef() as it is no more needed.
4682  */
4683 DataArrayInt *MEDCouplingUMesh::convertDegeneratedCellsAndRemoveFlatOnes()
4684 {
4685   checkFullyDefined();
4686   if(getMeshDimension()<=1)
4687     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertDegeneratedCells works on umeshes with meshdim equals to 2 or 3 !");
4688   int nbOfCells=getNumberOfCells();
4689   MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4690   if(nbOfCells<1)
4691     return ret.retn();
4692   int initMeshLgth=getNodalConnectivityArrayLen();
4693   int *conn=_nodal_connec->getPointer();
4694   int *index=_nodal_connec_index->getPointer();
4695   int posOfCurCell=0;
4696   int newPos=0;
4697   int lgthOfCurCell, nbDelCells(0);
4698   for(int i=0;i<nbOfCells;i++)
4699     {
4700       lgthOfCurCell=index[i+1]-posOfCurCell;
4701       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
4702       int newLgth;
4703       INTERP_KERNEL::NormalizedCellType newType=INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,
4704                                                                                                      conn+newPos+1,newLgth);
4705       // Shall we delete the cell if it is completely degenerated:
4706       bool delCell=INTERP_KERNEL::CellSimplify::isFlatCell(conn, newPos, newLgth, newType);
4707       if (delCell)
4708         {
4709           nbDelCells++;
4710           ret->pushBackSilent(i);
4711         }
4712       else   //if the cell is to be deleted, simply stay at the same place
4713         {
4714           conn[newPos]=newType;
4715           newPos+=newLgth+1;
4716         }
4717       posOfCurCell=index[i+1];
4718       index[i+1-nbDelCells]=newPos;
4719     }
4720   if(newPos!=initMeshLgth)
4721     _nodal_connec->reAlloc(newPos);
4722   const int nCellDel=ret->getNumberOfTuples();
4723   if (nCellDel)
4724     _nodal_connec_index->reAlloc(nbOfCells-nCellDel+1);
4725   computeTypes();
4726   return ret.retn();
4727 }
4728
4729
4730 /*!
4731  * Finds incorrectly oriented cells of this 2D mesh in 3D space.
4732  * A cell is considered to be oriented correctly if an angle between its
4733  * normal vector and a given vector is less than \c PI / \c 2.
4734  *  \param [in] vec - 3 components of the vector specifying the correct orientation of
4735  *         cells. 
4736  *  \param [in] polyOnly - if \c true, only polygons are checked, else, all cells are
4737  *         checked.
4738  *  \param [in,out] cells - a vector returning ids of incorrectly oriented cells. It
4739  *         is not cleared before filling in.
4740  *  \throw If \a this->getMeshDimension() != 2.
4741  *  \throw If \a this->getSpaceDimension() != 3.
4742  *
4743  *  \if ENABLE_EXAMPLES
4744  *  \ref cpp_mcumesh_are2DCellsNotCorrectlyOriented "Here is a C++ example".<br>
4745  *  \ref  py_mcumesh_are2DCellsNotCorrectlyOriented "Here is a Python example".
4746  *  \endif
4747  */
4748 void MEDCouplingUMesh::are2DCellsNotCorrectlyOriented(const double *vec, bool polyOnly, std::vector<int>& cells) const
4749 {
4750   if(getMeshDimension()!=2 || getSpaceDimension()!=3)
4751     throw INTERP_KERNEL::Exception("Invalid mesh to apply are2DCellsNotCorrectlyOriented on it : must be meshDim==2 and spaceDim==3 !");
4752   int nbOfCells=getNumberOfCells();
4753   const int *conn=_nodal_connec->begin();
4754   const int *connI=_nodal_connec_index->begin();
4755   const double *coordsPtr=_coords->begin();
4756   for(int i=0;i<nbOfCells;i++)
4757     {
4758       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
4759       if(!polyOnly || (type==INTERP_KERNEL::NORM_POLYGON || type==INTERP_KERNEL::NORM_QPOLYG))
4760         {
4761           bool isQuadratic=INTERP_KERNEL::CellModel::GetCellModel(type).isQuadratic();
4762           if(!IsPolygonWellOriented(isQuadratic,vec,conn+connI[i]+1,conn+connI[i+1],coordsPtr))
4763             cells.push_back(i);
4764         }
4765     }
4766 }
4767
4768 /*!
4769  * Reverse connectivity of 2D cells whose orientation is not correct. A cell is
4770  * considered to be oriented correctly if an angle between its normal vector and a
4771  * given vector is less than \c PI / \c 2. 
4772  *  \param [in] vec - 3 components of the vector specifying the correct orientation of
4773  *         cells. 
4774  *  \param [in] polyOnly - if \c true, only polygons are checked, else, all cells are
4775  *         checked.
4776  *  \throw If \a this->getMeshDimension() != 2.
4777  *  \throw If \a this->getSpaceDimension() != 3.
4778  *
4779  *  \if ENABLE_EXAMPLES
4780  *  \ref cpp_mcumesh_are2DCellsNotCorrectlyOriented "Here is a C++ example".<br>
4781  *  \ref  py_mcumesh_are2DCellsNotCorrectlyOriented "Here is a Python example".
4782  *  \endif
4783  *
4784  *  \sa changeOrientationOfCells
4785  */
4786 void MEDCouplingUMesh::orientCorrectly2DCells(const double *vec, bool polyOnly)
4787 {
4788   if(getMeshDimension()!=2 || getSpaceDimension()!=3)
4789     throw INTERP_KERNEL::Exception("Invalid mesh to apply orientCorrectly2DCells on it : must be meshDim==2 and spaceDim==3 !");
4790   int nbOfCells(getNumberOfCells()),*conn(_nodal_connec->getPointer());
4791   const int *connI(_nodal_connec_index->begin());
4792   const double *coordsPtr(_coords->begin());
4793   bool isModified(false);
4794   for(int i=0;i<nbOfCells;i++)
4795     {
4796       INTERP_KERNEL::NormalizedCellType type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
4797       if(!polyOnly || (type==INTERP_KERNEL::NORM_POLYGON || type==INTERP_KERNEL::NORM_QPOLYG))
4798         {
4799           const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
4800           bool isQuadratic(cm.isQuadratic());
4801           if(!IsPolygonWellOriented(isQuadratic,vec,conn+connI[i]+1,conn+connI[i+1],coordsPtr))
4802             {
4803               isModified=true;
4804               cm.changeOrientationOf2D(conn+connI[i]+1,(unsigned int)(connI[i+1]-connI[i]-1));
4805             }
4806         }
4807     }
4808   if(isModified)
4809     _nodal_connec->declareAsNew();
4810   updateTime();
4811 }
4812
4813 /*!
4814  * This method change the orientation of cells in \a this without any consideration of coordinates. Only connectivity is impacted.
4815  *
4816  * \sa orientCorrectly2DCells
4817  */
4818 void MEDCouplingUMesh::changeOrientationOfCells()
4819 {
4820   int mdim(getMeshDimension());
4821   if(mdim!=2 && mdim!=1)
4822     throw INTERP_KERNEL::Exception("Invalid mesh to apply changeOrientationOfCells on it : must be meshDim==2 or meshDim==1 !");
4823   int nbOfCells(getNumberOfCells()),*conn(_nodal_connec->getPointer());
4824   const int *connI(_nodal_connec_index->begin());
4825   if(mdim==2)
4826     {//2D
4827       for(int i=0;i<nbOfCells;i++)
4828         {
4829           INTERP_KERNEL::NormalizedCellType type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
4830           const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
4831           cm.changeOrientationOf2D(conn+connI[i]+1,(unsigned int)(connI[i+1]-connI[i]-1));
4832         }
4833     }
4834   else
4835     {//1D
4836       for(int i=0;i<nbOfCells;i++)
4837         {
4838           INTERP_KERNEL::NormalizedCellType type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
4839           const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
4840           cm.changeOrientationOf1D(conn+connI[i]+1,(unsigned int)(connI[i+1]-connI[i]-1));
4841         }
4842     }
4843 }
4844
4845 /*!
4846  * Finds incorrectly oriented polyhedral cells, i.e. polyhedrons having correctly
4847  * oriented facets. The normal vector of the facet should point out of the cell.
4848  *  \param [in,out] cells - a vector returning ids of incorrectly oriented cells. It
4849  *         is not cleared before filling in.
4850  *  \throw If \a this->getMeshDimension() != 3.
4851  *  \throw If \a this->getSpaceDimension() != 3.
4852  *  \throw If the coordinates array is not set.
4853  *  \throw If the nodal connectivity of cells is not defined.
4854  *
4855  *  \if ENABLE_EXAMPLES
4856  *  \ref cpp_mcumesh_arePolyhedronsNotCorrectlyOriented "Here is a C++ example".<br>
4857  *  \ref  py_mcumesh_arePolyhedronsNotCorrectlyOriented "Here is a Python example".
4858  *  \endif
4859  */
4860 void MEDCouplingUMesh::arePolyhedronsNotCorrectlyOriented(std::vector<int>& cells) const
4861 {
4862   if(getMeshDimension()!=3 || getSpaceDimension()!=3)
4863     throw INTERP_KERNEL::Exception("Invalid mesh to apply arePolyhedronsNotCorrectlyOriented on it : must be meshDim==3 and spaceDim==3 !");
4864   int nbOfCells=getNumberOfCells();
4865   const int *conn=_nodal_connec->begin();
4866   const int *connI=_nodal_connec_index->begin();
4867   const double *coordsPtr=_coords->begin();
4868   for(int i=0;i<nbOfCells;i++)
4869     {
4870       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
4871       if(type==INTERP_KERNEL::NORM_POLYHED)
4872         {
4873           if(!IsPolyhedronWellOriented(conn+connI[i]+1,conn+connI[i+1],coordsPtr))
4874             cells.push_back(i);
4875         }
4876     }
4877 }
4878
4879 /*!
4880  * Tries to fix connectivity of polyhedra, so that normal vector of all facets to point
4881  * out of the cell. 
4882  *  \throw If \a this->getMeshDimension() != 3.
4883  *  \throw If \a this->getSpaceDimension() != 3.
4884  *  \throw If the coordinates array is not set.
4885  *  \throw If the nodal connectivity of cells is not defined.
4886  *  \throw If the reparation fails.
4887  *
4888  *  \if ENABLE_EXAMPLES
4889  *  \ref cpp_mcumesh_arePolyhedronsNotCorrectlyOriented "Here is a C++ example".<br>
4890  *  \ref  py_mcumesh_arePolyhedronsNotCorrectlyOriented "Here is a Python example".
4891  *  \endif
4892  * \sa MEDCouplingUMesh::findAndCorrectBadOriented3DCells
4893  */
4894 void MEDCouplingUMesh::orientCorrectlyPolyhedrons()
4895 {
4896   if(getMeshDimension()!=3 || getSpaceDimension()!=3)
4897     throw INTERP_KERNEL::Exception("Invalid mesh to apply orientCorrectlyPolyhedrons on it : must be meshDim==3 and spaceDim==3 !");
4898   int nbOfCells=getNumberOfCells();
4899   int *conn=_nodal_connec->getPointer();
4900   const int *connI=_nodal_connec_index->begin();
4901   const double *coordsPtr=_coords->begin();
4902   for(int i=0;i<nbOfCells;i++)
4903     {
4904       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
4905       if(type==INTERP_KERNEL::NORM_POLYHED)
4906         {
4907           try
4908           {
4909               if(!IsPolyhedronWellOriented(conn+connI[i]+1,conn+connI[i+1],coordsPtr))
4910                 TryToCorrectPolyhedronOrientation(conn+connI[i]+1,conn+connI[i+1],coordsPtr);
4911           }
4912           catch(INTERP_KERNEL::Exception& e)
4913           {
4914               std::ostringstream oss; oss << "Something wrong in polyhedron #" << i << " : " << e.what();
4915               throw INTERP_KERNEL::Exception(oss.str());
4916           }
4917         }
4918     }
4919   updateTime();
4920 }
4921
4922 /*!
4923  * This method invert orientation of all cells in \a this. 
4924  * After calling this method the absolute value of measure of cells in \a this are the same than before calling.
4925  * This method only operates on the connectivity so coordinates are not touched at all.
4926  */
4927 void MEDCouplingUMesh::invertOrientationOfAllCells()
4928 {
4929   checkConnectivityFullyDefined();
4930   std::set<INTERP_KERNEL::NormalizedCellType> gts(getAllGeoTypes());
4931   int *conn(_nodal_connec->getPointer());
4932   const int *conni(_nodal_connec_index->begin());
4933   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator gt=gts.begin();gt!=gts.end();gt++)
4934     {
4935       INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::OrientationInverter> oi(INTERP_KERNEL::OrientationInverter::BuildInstanceFrom(*gt));
4936       MCAuto<DataArrayInt> cwt(giveCellsWithType(*gt));
4937       for(const int *it=cwt->begin();it!=cwt->end();it++)
4938         oi->operate(conn+conni[*it]+1,conn+conni[*it+1]);
4939     }
4940   updateTime();
4941 }
4942
4943 /*!
4944  * Finds and fixes incorrectly oriented linear extruded volumes (INTERP_KERNEL::NORM_HEXA8,
4945  * INTERP_KERNEL::NORM_PENTA6, INTERP_KERNEL::NORM_HEXGP12 etc) to respect the MED convention
4946  * according to which the first facet of the cell should be oriented to have the normal vector
4947  * pointing out of cell.
4948  *  \return DataArrayInt * - a new instance of DataArrayInt holding ids of fixed
4949  *         cells. The caller is to delete this array using decrRef() as it is no more
4950  *         needed. 
4951  *  \throw If \a this->getMeshDimension() != 3.
4952  *  \throw If \a this->getSpaceDimension() != 3.
4953  *  \throw If the coordinates array is not set.
4954  *  \throw If the nodal connectivity of cells is not defined.
4955  *
4956  *  \if ENABLE_EXAMPLES
4957  *  \ref cpp_mcumesh_findAndCorrectBadOriented3DExtrudedCells "Here is a C++ example".<br>
4958  *  \ref  py_mcumesh_findAndCorrectBadOriented3DExtrudedCells "Here is a Python example".
4959  *  \endif
4960  * \sa MEDCouplingUMesh::findAndCorrectBadOriented3DCells
4961  */
4962 DataArrayInt *MEDCouplingUMesh::findAndCorrectBadOriented3DExtrudedCells()
4963 {
4964   const char msg[]="check3DCellsWellOriented detection works only for 3D cells !";
4965   if(getMeshDimension()!=3)
4966     throw INTERP_KERNEL::Exception(msg);
4967   int spaceDim=getSpaceDimension();
4968   if(spaceDim!=3)
4969     throw INTERP_KERNEL::Exception(msg);
4970   //
4971   int nbOfCells=getNumberOfCells();
4972   int *conn=_nodal_connec->getPointer();
4973   const int *connI=_nodal_connec_index->begin();
4974   const double *coo=getCoords()->begin();
4975   MCAuto<DataArrayInt> cells(DataArrayInt::New()); cells->alloc(0,1);
4976   for(int i=0;i<nbOfCells;i++)
4977     {
4978       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
4979       if(cm.isExtruded() && !cm.isDynamic() && !cm.isQuadratic())
4980         {
4981           if(!Is3DExtrudedStaticCellWellOriented(conn+connI[i]+1,conn+connI[i+1],coo))
4982             {
4983               CorrectExtrudedStaticCell(conn+connI[i]+1,conn+connI[i+1]);
4984               cells->pushBackSilent(i);
4985             }
4986         }
4987     }
4988   return cells.retn();
4989 }
4990
4991 /*!
4992  * This method is a faster method to correct orientation of all 3D cells in \a this.
4993  * This method works only if \a this is a 3D mesh, that is to say a mesh with mesh dimension 3 and a space dimension 3.
4994  * This method makes the hypothesis that \a this a coherent that is to say MEDCouplingUMesh::checkConsistency should throw no exception.
4995  * 
4996  * \return a newly allocated int array with one components containing cell ids renumbered to fit the convention of MED (MED file and MEDCoupling)
4997  * \sa MEDCouplingUMesh::orientCorrectlyPolyhedrons, 
4998  */
4999 DataArrayInt *MEDCouplingUMesh::findAndCorrectBadOriented3DCells()
5000 {
5001   if(getMeshDimension()!=3 || getSpaceDimension()!=3)
5002     throw INTERP_KERNEL::Exception("Invalid mesh to apply findAndCorrectBadOriented3DCells on it : must be meshDim==3 and spaceDim==3 !");
5003   int nbOfCells=getNumberOfCells();
5004   int *conn=_nodal_connec->getPointer();
5005   const int *connI=_nodal_connec_index->begin();
5006   const double *coordsPtr=_coords->begin();
5007   MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(0,1);
5008   for(int i=0;i<nbOfCells;i++)
5009     {
5010       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
5011       switch(type)
5012       {
5013         case INTERP_KERNEL::NORM_TETRA4:
5014           {
5015             if(!IsTetra4WellOriented(conn+connI[i]+1,conn+connI[i+1],coordsPtr))
5016               {
5017                 std::swap(*(conn+connI[i]+2),*(conn+connI[i]+3));
5018                 ret->pushBackSilent(i);
5019               }
5020             break;
5021           }
5022         case INTERP_KERNEL::NORM_PYRA5:
5023           {
5024             if(!IsPyra5WellOriented(conn+connI[i]+1,conn+connI[i+1],coordsPtr))
5025               {
5026                 std::swap(*(conn+connI[i]+2),*(conn+connI[i]+4));
5027                 ret->pushBackSilent(i);
5028               }
5029             break;
5030           }
5031         case INTERP_KERNEL::NORM_PENTA6:
5032         case INTERP_KERNEL::NORM_HEXA8:
5033         case INTERP_KERNEL::NORM_HEXGP12:
5034           {
5035             if(!Is3DExtrudedStaticCellWellOriented(conn+connI[i]+1,conn+connI[i+1],coordsPtr))
5036               {
5037                 CorrectExtrudedStaticCell(conn+connI[i]+1,conn+connI[i+1]);
5038                 ret->pushBackSilent(i);
5039               }
5040             break;
5041           }
5042         case INTERP_KERNEL::NORM_POLYHED:
5043           {
5044             if(!IsPolyhedronWellOriented(conn+connI[i]+1,conn+connI[i+1],coordsPtr))
5045               {
5046                 TryToCorrectPolyhedronOrientation(conn+connI[i]+1,conn+connI[i+1],coordsPtr);
5047                 ret->pushBackSilent(i);
5048               }
5049             break;
5050           }
5051         default:
5052           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::orientCorrectly3DCells : Your mesh contains type of cell not supported yet ! send mail to anthony.geay@cea.fr to add it !");
5053       }
5054     }
5055   updateTime();
5056   return ret.retn();
5057 }
5058
5059 /*!
5060  * This method has a sense for meshes with spaceDim==3 and meshDim==2.
5061  * If it is not the case an exception will be thrown.
5062  * This method is fast because the first cell of \a this is used to compute the plane.
5063  * \param vec output of size at least 3 used to store the normal vector (with norm equal to Area ) of searched plane.
5064  * \param pos output of size at least 3 used to store a point owned of searched plane.
5065  */
5066 void MEDCouplingUMesh::getFastAveragePlaneOfThis(double *vec, double *pos) const
5067 {
5068   if(getMeshDimension()!=2 || getSpaceDimension()!=3)
5069     throw INTERP_KERNEL::Exception("Invalid mesh to apply getFastAveragePlaneOfThis on it : must be meshDim==2 and spaceDim==3 !");
5070   const int *conn=_nodal_connec->begin();
5071   const int *connI=_nodal_connec_index->begin();
5072   const double *coordsPtr=_coords->begin();
5073   INTERP_KERNEL::areaVectorOfPolygon<int,INTERP_KERNEL::ALL_C_MODE>(conn+1,connI[1]-connI[0]-1,coordsPtr,vec);
5074   std::copy(coordsPtr+3*conn[1],coordsPtr+3*conn[1]+3,pos);
5075 }
5076
5077 /*!
5078  * Creates a new MEDCouplingFieldDouble holding Edge Ratio values of all
5079  * cells. Currently cells of the following types are treated:
5080  * INTERP_KERNEL::NORM_TRI3, INTERP_KERNEL::NORM_QUAD4 and INTERP_KERNEL::NORM_TETRA4.
5081  * For a cell of other type an exception is thrown.
5082  * Space dimension of a 2D mesh can be either 2 or 3.
5083  * The Edge Ratio of a cell \f$t\f$ is: 
5084  *  \f$\frac{|t|_\infty}{|t|_0}\f$,
5085  *  where \f$|t|_\infty\f$ and \f$|t|_0\f$ respectively denote the greatest and
5086  *  the smallest edge lengths of \f$t\f$.
5087  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
5088  *          cells and one time, lying on \a this mesh. The caller is to delete this
5089  *          field using decrRef() as it is no more needed. 
5090  *  \throw If the coordinates array is not set.
5091  *  \throw If \a this mesh contains elements of dimension different from the mesh dimension.
5092  *  \throw If the connectivity data array has more than one component.
5093  *  \throw If the connectivity data array has a named component.
5094  *  \throw If the connectivity index data array has more than one component.
5095  *  \throw If the connectivity index data array has a named component.
5096  *  \throw If \a this->getMeshDimension() is neither 2 nor 3.
5097  *  \throw If \a this->getSpaceDimension() is neither 2 nor 3.
5098  *  \throw If \a this mesh includes cells of type different from the ones enumerated above.
5099  */
5100 MEDCouplingFieldDouble *MEDCouplingUMesh::getEdgeRatioField() const
5101 {
5102   checkConsistencyLight();
5103   int spaceDim=getSpaceDimension();
5104   int meshDim=getMeshDimension();
5105   if(spaceDim!=2 && spaceDim!=3)
5106     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getEdgeRatioField : SpaceDimension must be equal to 2 or 3 !");
5107   if(meshDim!=2 && meshDim!=3)
5108     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getEdgeRatioField : MeshDimension must be equal to 2 or 3 !");
5109   MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
5110   ret->setMesh(this);
5111   int nbOfCells=getNumberOfCells();
5112   MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
5113   arr->alloc(nbOfCells,1);
5114   double *pt=arr->getPointer();
5115   ret->setArray(arr);//In case of throw to avoid mem leaks arr will be used after decrRef.
5116   const int *conn=_nodal_connec->begin();
5117   const int *connI=_nodal_connec_index->begin();
5118   const double *coo=_coords->begin();
5119   double tmp[12];
5120   for(int i=0;i<nbOfCells;i++,pt++)
5121     {
5122       INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
5123       switch(t)
5124       {
5125         case INTERP_KERNEL::NORM_TRI3:
5126           {
5127             FillInCompact3DMode(spaceDim,3,conn+1,coo,tmp);
5128             *pt=INTERP_KERNEL::triEdgeRatio(tmp);
5129             break;
5130           }
5131         case INTERP_KERNEL::NORM_QUAD4:
5132           {
5133             FillInCompact3DMode(spaceDim,4,conn+1,coo,tmp);
5134             *pt=INTERP_KERNEL::quadEdgeRatio(tmp);
5135             break;
5136           }
5137         case INTERP_KERNEL::NORM_TETRA4:
5138           {
5139             FillInCompact3DMode(spaceDim,4,conn+1,coo,tmp);
5140             *pt=INTERP_KERNEL::tetraEdgeRatio(tmp);
5141             break;
5142           }
5143         default:
5144           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getEdgeRatioField : A cell with not manged type (NORM_TRI3, NORM_QUAD4 and NORM_TETRA4) has been detected !");
5145       }
5146       conn+=connI[i+1]-connI[i];
5147     }
5148   ret->setName("EdgeRatio");
5149   ret->synchronizeTimeWithSupport();
5150   return ret.retn();
5151 }
5152
5153 /*!
5154  * Creates a new MEDCouplingFieldDouble holding Aspect Ratio values of all
5155  * cells. Currently cells of the following types are treated:
5156  * INTERP_KERNEL::NORM_TRI3, INTERP_KERNEL::NORM_QUAD4 and INTERP_KERNEL::NORM_TETRA4.
5157  * For a cell of other type an exception is thrown.
5158  * Space dimension of a 2D mesh can be either 2 or 3.
5159  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
5160  *          cells and one time, lying on \a this mesh. The caller is to delete this
5161  *          field using decrRef() as it is no more needed. 
5162  *  \throw If the coordinates array is not set.
5163  *  \throw If \a this mesh contains elements of dimension different from the mesh dimension.
5164  *  \throw If the connectivity data array has more than one component.
5165  *  \throw If the connectivity data array has a named component.
5166  *  \throw If the connectivity index data array has more than one component.
5167  *  \throw If the connectivity index data array has a named component.
5168  *  \throw If \a this->getMeshDimension() is neither 2 nor 3.
5169  *  \throw If \a this->getSpaceDimension() is neither 2 nor 3.
5170  *  \throw If \a this mesh includes cells of type different from the ones enumerated above.
5171  */
5172 MEDCouplingFieldDouble *MEDCouplingUMesh::getAspectRatioField() const
5173 {
5174   checkConsistencyLight();
5175   int spaceDim=getSpaceDimension();
5176   int meshDim=getMeshDimension();
5177   if(spaceDim!=2 && spaceDim!=3)
5178     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getAspectRatioField : SpaceDimension must be equal to 2 or 3 !");
5179   if(meshDim!=2 && meshDim!=3)
5180     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getAspectRatioField : MeshDimension must be equal to 2 or 3 !");
5181   MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
5182   ret->setMesh(this);
5183   int nbOfCells=getNumberOfCells();
5184   MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
5185   arr->alloc(nbOfCells,1);
5186   double *pt=arr->getPointer();
5187   ret->setArray(arr);//In case of throw to avoid mem leaks arr will be used after decrRef.
5188   const int *conn=_nodal_connec->begin();
5189   const int *connI=_nodal_connec_index->begin();
5190   const double *coo=_coords->begin();
5191   double tmp[12];
5192   for(int i=0;i<nbOfCells;i++,pt++)
5193     {
5194       INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
5195       switch(t)
5196       {
5197         case INTERP_KERNEL::NORM_TRI3:
5198           {
5199             FillInCompact3DMode(spaceDim,3,conn+1,coo,tmp);
5200             *pt=INTERP_KERNEL::triAspectRatio(tmp);
5201             break;
5202           }
5203         case INTERP_KERNEL::NORM_QUAD4:
5204           {
5205             FillInCompact3DMode(spaceDim,4,conn+1,coo,tmp);
5206             *pt=INTERP_KERNEL::quadAspectRatio(tmp);
5207             break;
5208           }
5209         case INTERP_KERNEL::NORM_TETRA4:
5210           {
5211             FillInCompact3DMode(spaceDim,4,conn+1,coo,tmp);
5212             *pt=INTERP_KERNEL::tetraAspectRatio(tmp);
5213             break;
5214           }
5215         default:
5216           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getAspectRatioField : A cell with not manged type (NORM_TRI3, NORM_QUAD4 and NORM_TETRA4) has been detected !");
5217       }
5218       conn+=connI[i+1]-connI[i];
5219     }
5220   ret->setName("AspectRatio");
5221   ret->synchronizeTimeWithSupport();
5222   return ret.retn();
5223 }
5224
5225 /*!
5226  * Creates a new MEDCouplingFieldDouble holding Warping factor values of all
5227  * cells of \a this 2D mesh in 3D space. It is a measure of the "planarity" of 2D cell
5228  * in 3D space. Currently only cells of the following types are
5229  * treated: INTERP_KERNEL::NORM_QUAD4.
5230  * For a cell of other type an exception is thrown.
5231  * The warp field is computed as follows: let (a,b,c,d) be the points of the quad.
5232  * Defining
5233  * \f$t=\vec{da}\times\vec{ab}\f$,
5234  * \f$u=\vec{ab}\times\vec{bc}\f$
5235  * \f$v=\vec{bc}\times\vec{cd}\f$
5236  * \f$w=\vec{cd}\times\vec{da}\f$, the warp is defined as \f$W^3\f$ with
5237  *  \f[
5238  *     W=min(\frac{t}{|t|}\cdot\frac{v}{|v|}, \frac{u}{|u|}\cdot\frac{w}{|w|})
5239  *  \f]
5240  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
5241  *          cells and one time, lying on \a this mesh. The caller is to delete this
5242  *          field using decrRef() as it is no more needed. 
5243  *  \throw If the coordinates array is not set.
5244  *  \throw If \a this mesh contains elements of dimension different from the mesh dimension.
5245  *  \throw If the connectivity data array has more than one component.
5246  *  \throw If the connectivity data array has a named component.
5247  *  \throw If the connectivity index data array has more than one component.
5248  *  \throw If the connectivity index data array has a named component.
5249  *  \throw If \a this->getMeshDimension() != 2.
5250  *  \throw If \a this->getSpaceDimension() != 3.
5251  *  \throw If \a this mesh includes cells of type different from the ones enumerated above.
5252  */
5253 MEDCouplingFieldDouble *MEDCouplingUMesh::getWarpField() const
5254 {
5255   checkConsistencyLight();
5256   int spaceDim=getSpaceDimension();
5257   int meshDim=getMeshDimension();
5258   if(spaceDim!=3)
5259     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getWarpField : SpaceDimension must be equal to 3 !");
5260   if(meshDim!=2)
5261     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getWarpField : MeshDimension must be equal to 2 !");
5262   MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
5263   ret->setMesh(this);
5264   int nbOfCells=getNumberOfCells();
5265   MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
5266   arr->alloc(nbOfCells,1);
5267   double *pt=arr->getPointer();
5268   ret->setArray(arr);//In case of throw to avoid mem leaks arr will be used after decrRef.
5269   const int *conn=_nodal_connec->begin();
5270   const int *connI=_nodal_connec_index->begin();
5271   const double *coo=_coords->begin();
5272   double tmp[12];
5273   for(int i=0;i<nbOfCells;i++,pt++)
5274     {
5275       INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
5276       switch(t)
5277       {
5278         case INTERP_KERNEL::NORM_QUAD4:
5279           {
5280             FillInCompact3DMode(3,4,conn+1,coo,tmp);
5281             *pt=INTERP_KERNEL::quadWarp(tmp);
5282             break;
5283           }
5284         default:
5285           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getWarpField : A cell with not manged type (NORM_QUAD4) has been detected !");
5286       }
5287       conn+=connI[i+1]-connI[i];
5288     }
5289   ret->setName("Warp");
5290   ret->synchronizeTimeWithSupport();
5291   return ret.retn();
5292 }
5293
5294
5295 /*!
5296  * Creates a new MEDCouplingFieldDouble holding Skew factor values of all
5297  * cells of \a this 2D mesh in 3D space. Currently cells of the following types are
5298  * treated: INTERP_KERNEL::NORM_QUAD4.
5299  * The skew is computed as follow for a quad with points (a,b,c,d): let
5300  * \f$u=\vec{ab}+\vec{dc}\f$ and \f$v=\vec{ac}+\vec{bd}\f$
5301  * then the skew is computed as:
5302  *  \f[
5303  *    s=\frac{u}{|u|}\cdot\frac{v}{|v|}
5304  *  \f]
5305  *
5306  * For a cell of other type an exception is thrown.
5307  *  \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
5308  *          cells and one time, lying on \a this mesh. The caller is to delete this
5309  *          field using decrRef() as it is no more needed. 
5310  *  \throw If the coordinates array is not set.
5311  *  \throw If \a this mesh contains elements of dimension different from the mesh dimension.
5312  *  \throw If the connectivity data array has more than one component.
5313  *  \throw If the connectivity data array has a named component.
5314  *  \throw If the connectivity index data array has more than one component.
5315  *  \throw If the connectivity index data array has a named component.
5316  *  \throw If \a this->getMeshDimension() != 2.
5317  *  \throw If \a this->getSpaceDimension() != 3.
5318  *  \throw If \a this mesh includes cells of type different from the ones enumerated above.
5319  */
5320 MEDCouplingFieldDouble *MEDCouplingUMesh::getSkewField() const
5321 {
5322   checkConsistencyLight();
5323   int spaceDim=getSpaceDimension();
5324   int meshDim=getMeshDimension();
5325   if(spaceDim!=3)
5326     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getSkewField : SpaceDimension must be equal to 3 !");
5327   if(meshDim!=2)
5328     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getSkewField : MeshDimension must be equal to 2 !");
5329   MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
5330   ret->setMesh(this);
5331   int nbOfCells=getNumberOfCells();
5332   MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
5333   arr->alloc(nbOfCells,1);
5334   double *pt=arr->getPointer();
5335   ret->setArray(arr);//In case of throw to avoid mem leaks arr will be used after decrRef.
5336   const int *conn=_nodal_connec->begin();
5337   const int *connI=_nodal_connec_index->begin();
5338   const double *coo=_coords->begin();
5339   double tmp[12];
5340   for(int i=0;i<nbOfCells;i++,pt++)
5341     {
5342       INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
5343       switch(t)
5344       {
5345         case INTERP_KERNEL::NORM_QUAD4:
5346           {
5347             FillInCompact3DMode(3,4,conn+1,coo,tmp);
5348             *pt=INTERP_KERNEL::quadSkew(tmp);
5349             break;
5350           }
5351         default:
5352           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getSkewField : A cell with not manged type (NORM_QUAD4) has been detected !");
5353       }
5354       conn+=connI[i+1]-connI[i];
5355     }
5356   ret->setName("Skew");
5357   ret->synchronizeTimeWithSupport();
5358   return ret.retn();
5359 }
5360
5361 /*!
5362  * Returns the cell field giving for each cell in \a this its diameter. Diameter means the max length of all possible SEG2 in the cell.
5363  *
5364  * \return a new instance of field containing the result. The returned instance has to be deallocated by the caller.
5365  *
5366  * \sa getSkewField, getWarpField, getAspectRatioField, getEdgeRatioField
5367  */
5368 MEDCouplingFieldDouble *MEDCouplingUMesh::computeDiameterField() const
5369 {
5370   checkConsistencyLight();
5371   MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME));
5372   ret->setMesh(this);
5373   std::set<INTERP_KERNEL::NormalizedCellType> types;
5374   ComputeAllTypesInternal(types,_nodal_connec,_nodal_connec_index);
5375   int spaceDim(getSpaceDimension()),nbCells(getNumberOfCells());
5376   MCAuto<DataArrayDouble> arr(DataArrayDouble::New());
5377   arr->alloc(nbCells,1);
5378   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=types.begin();it!=types.end();it++)
5379     {
5380       INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::DiameterCalculator> dc(INTERP_KERNEL::CellModel::GetCellModel(*it).buildInstanceOfDiameterCalulator(spaceDim));
5381       MCAuto<DataArrayInt> cellIds(giveCellsWithType(*it));
5382       dc->computeForListOfCellIdsUMeshFrmt(cellIds->begin(),cellIds->end(),_nodal_connec_index->begin(),_nodal_connec->begin(),getCoords()->begin(),arr->getPointer());
5383     }
5384   ret->setArray(arr);
5385   ret->setName("Diameter");
5386   return ret.retn();
5387 }
5388
5389 /*!
5390  * This method aggregate the bbox of each cell and put it into bbox parameter (xmin,xmax,ymin,ymax,zmin,zmax).
5391  * 
5392  * \param [in] arcDetEps - a parameter specifying in case of 2D quadratic polygon cell the detection limit between linear and arc circle. (By default 1e-12)
5393  *                         For all other cases this input parameter is ignored.
5394  * \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components.
5395  * 
5396  * \throw If \a this is not fully set (coordinates and connectivity).
5397  * \throw If a cell in \a this has no valid nodeId.
5398  * \sa MEDCouplingUMesh::getBoundingBoxForBBTreeFast, MEDCouplingUMesh::getBoundingBoxForBBTree2DQuadratic
5399  */
5400 DataArrayDouble *MEDCouplingUMesh::getBoundingBoxForBBTree(double arcDetEps) const
5401 {
5402   int mDim(getMeshDimension()),sDim(getSpaceDimension());
5403   if((mDim==3 && sDim==3) || (mDim==2 && sDim==3) || (mDim==1 && sDim==1) || ( mDim==1 && sDim==3))  // Compute refined boundary box for quadratic elements only in 2D.
5404     return getBoundingBoxForBBTreeFast();
5405   if((mDim==2 && sDim==2) || (mDim==1 && sDim==2))
5406     {
5407       bool presenceOfQuadratic(false);
5408       for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=_types.begin();it!=_types.end();it++)
5409         {
5410           const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(*it));
5411           if(cm.isQuadratic())
5412             presenceOfQuadratic=true;
5413         }
5414       if(!presenceOfQuadratic)
5415         return getBoundingBoxForBBTreeFast();
5416       if(mDim==2 && sDim==2)
5417         return getBoundingBoxForBBTree2DQuadratic(arcDetEps);
5418       else
5419         return getBoundingBoxForBBTree1DQuadratic(arcDetEps);
5420     }
5421   throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getBoundingBoxForBBTree : Managed dimensions are (mDim=1,sDim=1), (mDim=1,sDim=2), (mDim=1,sDim=3), (mDim=2,sDim=2), (mDim=2,sDim=3) and (mDim=3,sDim=3) !");
5422 }
5423
5424 /*!
5425  * This method aggregate the bbox of each cell only considering the nodes constituting each cell and put it into bbox parameter.
5426  * So meshes having quadratic cells the computed bounding boxes can be invalid !
5427  * 
5428  * \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components.
5429  * 
5430  * \throw If \a this is not fully set (coordinates and connectivity).
5431  * \throw If a cell in \a this has no valid nodeId.
5432  */
5433 DataArrayDouble *MEDCouplingUMesh::getBoundingBoxForBBTreeFast() const
5434 {
5435   checkFullyDefined();
5436   int spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes());
5437   MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
5438   double *bbox(ret->getPointer());
5439   for(int i=0;i<nbOfCells*spaceDim;i++)
5440     {
5441       bbox[2*i]=std::numeric_limits<double>::max();
5442       bbox[2*i+1]=-std::numeric_limits<double>::max();
5443     }
5444   const double *coordsPtr(_coords->begin());
5445   const int *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
5446   for(int i=0;i<nbOfCells;i++)
5447     {
5448       int offset=connI[i]+1;
5449       int nbOfNodesForCell(connI[i+1]-offset),kk(0);
5450       for(int j=0;j<nbOfNodesForCell;j++)
5451         {
5452           int nodeId=conn[offset+j];
5453           if(nodeId>=0 && nodeId<nbOfNodes)
5454             {
5455               for(int k=0;k<spaceDim;k++)
5456                 {
5457                   bbox[2*spaceDim*i+2*k]=std::min(bbox[2*spaceDim*i+2*k],coordsPtr[spaceDim*nodeId+k]);
5458                   bbox[2*spaceDim*i+2*k+1]=std::max(bbox[2*spaceDim*i+2*k+1],coordsPtr[spaceDim*nodeId+k]);
5459                 }
5460               kk++;
5461             }
5462         }
5463       if(kk==0)
5464         {
5465           std::ostringstream oss; oss << "MEDCouplingUMesh::getBoundingBoxForBBTree : cell #" << i << " contains no valid nodeId !";
5466           throw INTERP_KERNEL::Exception(oss.str());
5467         }
5468     }
5469   return ret.retn();
5470 }
5471
5472 /*!
5473  * This method aggregates the bbox of each 2D cell in \a this considering the whole shape. This method is particularly
5474  * useful for 2D meshes having quadratic cells
5475  * because for this type of cells getBoundingBoxForBBTreeFast method may return invalid bounding boxes (since it just considers
5476  * the two extremities of the arc of circle).
5477  * 
5478  * \param [in] arcDetEps - a parameter specifying in case of 2D quadratic polygon cell the detection limit between linear and arc circle. (By default 1e-12)
5479  * \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components.
5480  * \throw If \a this is not fully defined.
5481  * \throw If \a this is not a mesh with meshDimension equal to 2.
5482  * \throw If \a this is not a mesh with spaceDimension equal to 2.
5483  * \sa MEDCouplingUMesh::getBoundingBoxForBBTree1DQuadratic
5484  */
5485 DataArrayDouble *MEDCouplingUMesh::getBoundingBoxForBBTree2DQuadratic(double arcDetEps) const
5486 {
5487   checkFullyDefined();
5488   INTERP_KERNEL::QuadraticPlanarPrecision arcPrec(arcDetEps);
5489
5490   int spaceDim(getSpaceDimension()),mDim(getMeshDimension()),nbOfCells(getNumberOfCells());
5491   if(spaceDim!=2 || mDim!=2)
5492     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getBoundingBoxForBBTree2DQuadratic : This method should be applied on mesh with mesh dimension equal to 2 and space dimension also equal to 2!");
5493   MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
5494   double *bbox(ret->getPointer());
5495   const double *coords(_coords->begin());
5496   const int *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
5497   for(int i=0;i<nbOfCells;i++,bbox+=4,connI++)
5498     {
5499       const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[*connI]));
5500       int sz(connI[1]-connI[0]-1);
5501       std::vector<INTERP_KERNEL::Node *> nodes(sz);
5502       INTERP_KERNEL::QuadraticPolygon *pol(0);
5503       for(int j=0;j<sz;j++)
5504         {
5505           int nodeId(conn[*connI+1+j]);
5506           nodes[j]=new INTERP_KERNEL::Node(coords[nodeId*2],coords[nodeId*2+1]);
5507         }
5508       if(!cm.isQuadratic())
5509         pol=INTERP_KERNEL::QuadraticPolygon::BuildLinearPolygon(nodes);
5510       else
5511         pol=INTERP_KERNEL::QuadraticPolygon::BuildArcCirclePolygon(nodes);
5512       INTERP_KERNEL::Bounds b; b.prepareForAggregation(); pol->fillBounds(b); delete pol;
5513       bbox[0]=b.getXMin(); bbox[1]=b.getXMax(); bbox[2]=b.getYMin(); bbox[3]=b.getYMax(); 
5514     }
5515   return ret.retn();
5516 }
5517
5518 /*!
5519  * This method aggregates the bbox of each 1D cell in \a this considering the whole shape. This method is particularly
5520  * useful for 2D meshes having quadratic cells
5521  * because for this type of cells getBoundingBoxForBBTreeFast method may return invalid bounding boxes (since it just considers
5522  * the two extremities of the arc of circle).
5523  * 
5524  * \param [in] arcDetEps - a parameter specifying in case of 2D quadratic polygon cell the detection limit between linear and arc circle. (By default 1e-12)
5525  * \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components.
5526  * \throw If \a this is not fully defined.
5527  * \throw If \a this is not a mesh with meshDimension equal to 1.
5528  * \throw If \a this is not a mesh with spaceDimension equal to 2.
5529  * \sa MEDCouplingUMesh::getBoundingBoxForBBTree2DQuadratic
5530  */
5531 DataArrayDouble *MEDCouplingUMesh::getBoundingBoxForBBTree1DQuadratic(double arcDetEps) const
5532 {
5533   checkFullyDefined();
5534   int spaceDim(getSpaceDimension()),mDim(getMeshDimension()),nbOfCells(getNumberOfCells());
5535   if(spaceDim!=2 || mDim!=1)
5536     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getBoundingBoxForBBTree1DQuadratic : This method should be applied on mesh with mesh dimension equal to 1 and space dimension also equal to 2!");
5537   INTERP_KERNEL::QuadraticPlanarPrecision arcPrec(arcDetEps);
5538   MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
5539   double *bbox(ret->getPointer());
5540   const double *coords(_coords->begin());
5541   const int *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
5542   for(int i=0;i<nbOfCells;i++,bbox+=4,connI++)
5543     {
5544       const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[*connI]));
5545       int sz(connI[1]-connI[0]-1);
5546       std::vector<INTERP_KERNEL::Node *> nodes(sz);
5547       INTERP_KERNEL::Edge *edge(0);
5548       for(int j=0;j<sz;j++)
5549         {
5550           int nodeId(conn[*connI+1+j]);
5551           nodes[j]=new INTERP_KERNEL::Node(coords[nodeId*2],coords[nodeId*2+1]);
5552         }
5553       if(!cm.isQuadratic())
5554         edge=INTERP_KERNEL::QuadraticPolygon::BuildLinearEdge(nodes);
5555       else
5556         edge=INTERP_KERNEL::QuadraticPolygon::BuildArcCircleEdge(nodes);
5557       const INTERP_KERNEL::Bounds& b(edge->getBounds());
5558       bbox[0]=b.getXMin(); bbox[1]=b.getXMax(); bbox[2]=b.getYMin(); bbox[3]=b.getYMax(); edge->decrRef();
5559     }
5560   return ret.retn();
5561 }
5562
5563 /// @cond INTERNAL
5564
5565 namespace MEDCouplingImpl
5566 {
5567   class ConnReader
5568   {
5569   public:
5570     ConnReader(const int *c, int val):_conn(c),_val(val) { }
5571     bool operator() (const int& pos) { return _conn[pos]!=_val; }
5572   private:
5573     const int *_conn;
5574     int _val;
5575   };
5576
5577   class ConnReader2
5578   {
5579   public:
5580     ConnReader2(const int *c, int val):_conn(c),_val(val) { }
5581     bool operator() (const int& pos) { return _conn[pos]==_val; }
5582   private:
5583     const int *_conn;
5584     int _val;
5585   };
5586 }
5587
5588 /// @endcond
5589
5590 /*!
5591  * This method expects that \a this is sorted by types. If not an exception will be thrown.
5592  * This method returns in the same format as code (see MEDCouplingUMesh::checkTypeConsistencyAndContig or MEDCouplingUMesh::splitProfilePerType) how
5593  * \a this is composed in cell types.
5594  * The returned array is of size 3*n where n is the number of different types present in \a this. 
5595  * For every k in [0,n] ret[3*k+2]==-1 because it has no sense here. 
5596  * This parameter is kept only for compatibility with other method listed above.
5597  */
5598 std::vector<int> MEDCouplingUMesh::getDistributionOfTypes() const
5599 {
5600   checkConnectivityFullyDefined();
5601   const int *conn=_nodal_connec->begin();
5602   const int *connI=_nodal_connec_index->begin();
5603   const int *work=connI;
5604   int nbOfCells=getNumberOfCells();
5605   std::size_t n=getAllGeoTypes().size();
5606   std::vector<int> ret(3*n,-1); //ret[3*k+2]==-1 because it has no sense here
5607   std::set<INTERP_KERNEL::NormalizedCellType> types;
5608   for(std::size_t i=0;work!=connI+nbOfCells;i++)
5609     {
5610       INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)conn[*work];
5611       if(types.find(typ)!=types.end())
5612         {
5613           std::ostringstream oss; oss << "MEDCouplingUMesh::getDistributionOfTypes : Type " << INTERP_KERNEL::CellModel::GetCellModel(typ).getRepr();
5614           oss << " is not contiguous !";
5615           throw INTERP_KERNEL::Exception(oss.str());
5616         }
5617       types.insert(typ);
5618       ret[3*i]=typ;
5619       const int *work2=std::find_if(work+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,typ));
5620       ret[3*i+1]=(int)std::distance(work,work2);
5621       work=work2;
5622     }
5623   return ret;
5624 }
5625
5626 /*!
5627  * This method is used to check that this has contiguous cell type in same order than described in \a code.
5628  * only for types cell, type node is not managed.
5629  * Format of \a code is the following. \a code should be of size 3*n and non empty. If not an exception is thrown.
5630  * foreach k in [0,n) on 3*k pos represent the geometric type and 3*k+1 number of elements of type 3*k.
5631  * 3*k+2 refers if different from -1 the pos in 'idsPerType' to get the corresponding array.
5632  * If 2 or more same geometric type is in \a code and exception is thrown too.
5633  *
5634  * This method firstly checks
5635  * If it exists k so that 3*k geometric type is not in geometric types of this an exception will be thrown.
5636  * If it exists k so that 3*k geometric type exists but the number of consecutive cell types does not match,
5637  * an exception is thrown too.
5638  * 
5639  * If all geometric types in \a code are exactly those in \a this null pointer is returned.
5640  * If it exists a geometric type in \a this \b not in \a code \b no exception is thrown 
5641  * and a DataArrayInt instance is returned that the user has the responsibility to deallocate.
5642  */
5643 DataArrayInt *MEDCouplingUMesh::checkTypeConsistencyAndContig(const std::vector<int>& code, const std::vector<const DataArrayInt *>& idsPerType) const
5644 {
5645   if(code.empty())
5646     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : code is empty, should not !");
5647   std::size_t sz=code.size();
5648   std::size_t n=sz/3;
5649   if(sz%3!=0)
5650     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : code size is NOT %3 !");
5651   std::vector<INTERP_KERNEL::NormalizedCellType> types;
5652   int nb=0;
5653   bool isNoPflUsed=true;
5654   for(std::size_t i=0;i<n;i++)
5655     if(std::find(types.begin(),types.end(),(INTERP_KERNEL::NormalizedCellType)code[3*i])==types.end())
5656       {
5657         types.push_back((INTERP_KERNEL::NormalizedCellType)code[3*i]);
5658         nb+=code[3*i+1];
5659         if(_types.find((INTERP_KERNEL::NormalizedCellType)code[3*i])==_types.end())
5660           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : expected geo types not in this !");
5661         isNoPflUsed=isNoPflUsed && (code[3*i+2]==-1);
5662       }
5663   if(types.size()!=n)
5664     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : code contains duplication of types in unstructured mesh !");
5665   if(isNoPflUsed)
5666     {
5667       if(!checkConsecutiveCellTypesAndOrder(&types[0],&types[0]+types.size()))
5668         throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : non contiguous type !");
5669       if(types.size()==_types.size())
5670         return 0;
5671     }
5672   MCAuto<DataArrayInt> ret=DataArrayInt::New();
5673   ret->alloc(nb,1);
5674   int *retPtr=ret->getPointer();
5675   const int *connI=_nodal_connec_index->begin();
5676   const int *conn=_nodal_connec->begin();
5677   int nbOfCells=getNumberOfCells();
5678   const int *i=connI;
5679   int kk=0;
5680   for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator it=types.begin();it!=types.end();it++,kk++)
5681     {
5682       i=std::find_if(i,connI+nbOfCells,MEDCouplingImpl::ConnReader2(conn,(int)(*it)));
5683       int offset=(int)std::distance(connI,i);
5684       const int *j=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)(*it)));
5685       int nbOfCellsOfCurType=(int)std::distance(i,j);
5686       if(code[3*kk+2]==-1)
5687         for(int k=0;k<nbOfCellsOfCurType;k++)
5688           *retPtr++=k+offset;
5689       else
5690         {
5691           int idInIdsPerType=code[3*kk+2];
5692           if(idInIdsPerType>=0 && idInIdsPerType<(int)idsPerType.size())
5693             {
5694               const DataArrayInt *zePfl=idsPerType[idInIdsPerType];
5695               if(zePfl)
5696                 {
5697                   zePfl->checkAllocated();
5698                   if(zePfl->getNumberOfComponents()==1)
5699                     {
5700                       for(const int *k=zePfl->begin();k!=zePfl->end();k++,retPtr++)
5701                         {
5702                           if(*k>=0 && *k<nbOfCellsOfCurType)
5703                             *retPtr=(*k)+offset;
5704                           else
5705                             {
5706                               std::ostringstream oss; oss << "MEDCouplingUMesh::checkTypeConsistencyAndContig : the section " << kk << " points to the profile #" << idInIdsPerType;
5707                               oss << ", and this profile contains a value " << *k << " should be in [0," << nbOfCellsOfCurType << ") !";
5708                               throw INTERP_KERNEL::Exception(oss.str());
5709                             }
5710                         }
5711                     }
5712                   else
5713                     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : presence of a profile with nb of compo != 1 !");
5714                 }
5715               else
5716                 throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : presence of null profile !");
5717             }
5718           else
5719             {
5720               std::ostringstream oss; oss << "MEDCouplingUMesh::checkTypeConsistencyAndContig : at section " << kk << " of code it points to the array #" << idInIdsPerType;
5721               oss << " should be in [0," << idsPerType.size() << ") !";
5722               throw INTERP_KERNEL::Exception(oss.str());
5723             }
5724         }
5725       i=j;
5726     }
5727   return ret.retn();
5728 }
5729
5730 /*!
5731  * This method makes the hypothesis that \a this is sorted by type. If not an exception will be thrown.
5732  * This method is the opposite of MEDCouplingUMesh::checkTypeConsistencyAndContig method. Given a list of cells in \a profile it returns a list of sub-profiles sorted by geo type.
5733  * The result is put in the array \a idsPerType. In the returned parameter \a code, foreach i \a code[3*i+2] refers (if different from -1) to a location into the \a idsPerType.
5734  * This method has 1 input \a profile and 3 outputs \a code \a idsInPflPerType and \a idsPerType.
5735  * 
5736  * \param [in] profile
5737  * \param [out] code is a vector of size 3*n where n is the number of different geometric type in \a this \b reduced to the profile \a profile. \a code has exactly the same semantic than in MEDCouplingUMesh::checkTypeConsistencyAndContig method.
5738  * \param [out] idsInPflPerType is a vector of size of different geometric type in the subpart defined by \a profile of \a this ( equal to \a code.size()/3). For each i,
5739  *              \a idsInPflPerType[i] stores the tuple ids in \a profile that correspond to the geometric type code[3*i+0]
5740  * \param [out] idsPerType is a vector of size of different sub profiles needed to be defined to represent the profile \a profile for a given geometric type.
5741  *              This vector can be empty in case of all geometric type cells are fully covered in ascending in the given input \a profile.
5742  * \throw if \a profile has not exactly one component. It throws too, if \a profile contains some values not in [0,getNumberOfCells()) or if \a this is not fully defined
5743  */
5744 void MEDCouplingUMesh::splitProfilePerType(const DataArrayInt *profile, std::vector<int>& code, std::vector<DataArrayInt *>& idsInPflPerType, std::vector<DataArrayInt *>& idsPerType, bool smartPflKiller) const
5745 {
5746   if(!profile)
5747     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitProfilePerType : input profile is NULL !");
5748   if(profile->getNumberOfComponents()!=1)
5749     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitProfilePerType : input profile should have exactly one component !");
5750   checkConnectivityFullyDefined();
5751   const int *conn=_nodal_connec->begin();
5752   const int *connI=_nodal_connec_index->begin();
5753   int nbOfCells=getNumberOfCells();
5754   std::vector<INTERP_KERNEL::NormalizedCellType> types;
5755   std::vector<int> typeRangeVals(1);
5756   for(const int *i=connI;i!=connI+nbOfCells;)
5757     {
5758       INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
5759       if(std::find(types.begin(),types.end(),curType)!=types.end())
5760         {
5761           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitProfilePerType : current mesh is not sorted by type !");
5762         }
5763       types.push_back(curType);
5764       i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
5765       typeRangeVals.push_back((int)std::distance(connI,i));
5766     }
5767   //
5768   DataArrayInt *castArr=0,*rankInsideCast=0,*castsPresent=0;
5769   profile->splitByValueRange(&typeRangeVals[0],&typeRangeVals[0]+typeRangeVals.size(),castArr,rankInsideCast,castsPresent);
5770   MCAuto<DataArrayInt> tmp0=castArr;
5771   MCAuto<DataArrayInt> tmp1=rankInsideCast;
5772   MCAuto<DataArrayInt> tmp2=castsPresent;
5773   //
5774   int nbOfCastsFinal=castsPresent->getNumberOfTuples();
5775   code.resize(3*nbOfCastsFinal);
5776   std::vector< MCAuto<DataArrayInt> > idsInPflPerType2;
5777   std::vector< MCAuto<DataArrayInt> > idsPerType2;
5778   for(int i=0;i<nbOfCastsFinal;i++)
5779     {
5780       int castId=castsPresent->getIJ(i,0);
5781       MCAuto<DataArrayInt> tmp3=castArr->findIdsEqual(castId);
5782       idsInPflPerType2.push_back(tmp3);
5783       code[3*i]=(int)types[castId];
5784       code[3*i+1]=tmp3->getNumberOfTuples();
5785       MCAuto<DataArrayInt> tmp4=rankInsideCast->selectByTupleId(tmp3->begin(),tmp3->begin()+tmp3->getNumberOfTuples());
5786       if(!smartPflKiller || !tmp4->isIota(typeRangeVals[castId+1]-typeRangeVals[castId]))
5787         {
5788           tmp4->copyStringInfoFrom(*profile);
5789           idsPerType2.push_back(tmp4);
5790           code[3*i+2]=(int)idsPerType2.size()-1;
5791         }
5792       else
5793         {
5794           code[3*i+2]=-1;
5795         }
5796     }
5797   std::size_t sz2=idsInPflPerType2.size();
5798   idsInPflPerType.resize(sz2);
5799   for(std::size_t i=0;i<sz2;i++)
5800     {
5801       DataArrayInt *locDa=idsInPflPerType2[i];
5802       locDa->incrRef();
5803       idsInPflPerType[i]=locDa;
5804     }
5805   std::size_t sz=idsPerType2.size();
5806   idsPerType.resize(sz);
5807   for(std::size_t i=0;i<sz;i++)
5808     {
5809       DataArrayInt *locDa=idsPerType2[i];
5810       locDa->incrRef();
5811       idsPerType[i]=locDa;
5812     }
5813 }
5814
5815 /*!
5816  * This method is here too emulate the MEDMEM behaviour on BDC (buildDescendingConnectivity). Hoping this method becomes deprecated very soon.
5817  * This method make the assumption that \a this and 'nM1LevMesh' mesh lyies on same coords (same pointer) as MED and MEDMEM does.
5818  * The following equality should be verified 'nM1LevMesh->getMeshDimension()==this->getMeshDimension()-1'
5819  * This method returns 5+2 elements. 'desc', 'descIndx', 'revDesc', 'revDescIndx' and 'meshnM1' behaves exactly as MEDCoupling::MEDCouplingUMesh::buildDescendingConnectivity except the content as described after. The returned array specifies the n-1 mesh reordered by type as MEDMEM does. 'nM1LevMeshIds' contains the ids in returned 'meshnM1'. Finally 'meshnM1Old2New' contains numbering old2new that is to say the cell #k in coarse 'nM1LevMesh' will have the number ret[k] in returned mesh 'nM1LevMesh' MEDMEM reordered.
5820  */
5821 MEDCouplingUMesh *MEDCouplingUMesh::emulateMEDMEMBDC(const MEDCouplingUMesh *nM1LevMesh, DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *&revDesc, DataArrayInt *&revDescIndx, DataArrayInt *& nM1LevMeshIds, DataArrayInt *&meshnM1Old2New) const
5822 {
5823   checkFullyDefined();
5824   nM1LevMesh->checkFullyDefined();
5825   if(getMeshDimension()-1!=nM1LevMesh->getMeshDimension())
5826     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::emulateMEDMEMBDC : The mesh passed as first argument should have a meshDim equal to this->getMeshDimension()-1 !" );
5827   if(_coords!=nM1LevMesh->getCoords())
5828     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::emulateMEDMEMBDC : 'this' and mesh in first argument should share the same coords : Use tryToShareSameCoords method !");
5829   MCAuto<DataArrayInt> tmp0=DataArrayInt::New();
5830   MCAuto<DataArrayInt> tmp1=DataArrayInt::New();
5831   MCAuto<MEDCouplingUMesh> ret1=buildDescendingConnectivity(desc,descIndx,tmp0,tmp1);
5832   MCAuto<DataArrayInt> ret0=ret1->sortCellsInMEDFileFrmt();
5833   desc->transformWithIndArr(ret0->begin(),ret0->begin()+ret0->getNbOfElems());
5834   MCAuto<MEDCouplingUMesh> tmp=MEDCouplingUMesh::New();
5835   tmp->setConnectivity(tmp0,tmp1);
5836   tmp->renumberCells(ret0->begin(),false);
5837   revDesc=tmp->getNodalConnectivity();
5838   revDescIndx=tmp->getNodalConnectivityIndex();
5839   DataArrayInt *ret=0;
5840   if(!ret1->areCellsIncludedIn(nM1LevMesh,2,ret))
5841     {
5842       int tmp2;
5843       ret->getMaxValue(tmp2);
5844       ret->decrRef();
5845       std::ostringstream oss; oss << "MEDCouplingUMesh::emulateMEDMEMBDC : input N-1 mesh present a cell not in descending mesh ... Id of cell is " << tmp2 << " !";
5846       throw INTERP_KERNEL::Exception(oss.str());
5847     }
5848   nM1LevMeshIds=ret;
5849   //
5850   revDesc->incrRef();
5851   revDescIndx->incrRef();
5852   ret1->incrRef();
5853   ret0->incrRef();
5854   meshnM1Old2New=ret0;
5855   return ret1;
5856 }
5857
5858 /*!
5859  * Permutes the nodal connectivity arrays so that the cells are sorted by type, which is
5860  * necessary for writing the mesh to MED file. Additionally returns a permutation array
5861  * in "Old to New" mode.
5862  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete
5863  *          this array using decrRef() as it is no more needed.
5864  *  \throw If the nodal connectivity of cells is not defined.
5865  */
5866 DataArrayInt *MEDCouplingUMesh::sortCellsInMEDFileFrmt()
5867 {
5868   checkConnectivityFullyDefined();
5869   MCAuto<DataArrayInt> ret=getRenumArrForMEDFileFrmt();
5870   renumberCells(ret->begin(),false);
5871   return ret.retn();
5872 }
5873
5874 /*!
5875  * This methods checks that cells are sorted by their types.
5876  * This method makes asumption (no check) that connectivity is correctly set before calling.
5877  */
5878 bool MEDCouplingUMesh::checkConsecutiveCellTypes() const
5879 {
5880   checkFullyDefined();
5881   const int *conn=_nodal_connec->begin();
5882   const int *connI=_nodal_connec_index->begin();
5883   int nbOfCells=getNumberOfCells();
5884   std::set<INTERP_KERNEL::NormalizedCellType> types;
5885   for(const int *i=connI;i!=connI+nbOfCells;)
5886     {
5887       INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
5888       if(types.find(curType)!=types.end())
5889         return false;
5890       types.insert(curType);
5891       i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
5892     }
5893   return true;
5894 }
5895
5896 /*!
5897  * This method is a specialization of MEDCouplingUMesh::checkConsecutiveCellTypesAndOrder method that is called here.
5898  * The geometric type order is specified by MED file.
5899  * 
5900  * \sa  MEDCouplingUMesh::checkConsecutiveCellTypesAndOrder
5901  */
5902 bool MEDCouplingUMesh::checkConsecutiveCellTypesForMEDFileFrmt() const
5903 {
5904   return checkConsecutiveCellTypesAndOrder(MEDMEM_ORDER,MEDMEM_ORDER+N_MEDMEM_ORDER);
5905 }
5906
5907 /*!
5908  * This method performs the same job as checkConsecutiveCellTypes except that the order of types sequence is analyzed to check
5909  * that the order is specified in array defined by [ \a orderBg , \a orderEnd ).
5910  * If there is some geo types in \a this \b NOT in [ \a orderBg, \a orderEnd ) it is OK (return true) if contiguous.
5911  * If there is some geo types in [ \a orderBg, \a orderEnd ) \b NOT in \a this it is OK too (return true) if contiguous.
5912  */
5913 bool MEDCouplingUMesh::checkConsecutiveCellTypesAndOrder(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd) const
5914 {
5915   checkFullyDefined();
5916   const int *conn=_nodal_connec->begin();
5917   const int *connI=_nodal_connec_index->begin();
5918   int nbOfCells=getNumberOfCells();
5919   if(nbOfCells==0)
5920     return true;
5921   int lastPos=-1;
5922   std::set<INTERP_KERNEL::NormalizedCellType> sg;
5923   for(const int *i=connI;i!=connI+nbOfCells;)
5924     {
5925       INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
5926       const INTERP_KERNEL::NormalizedCellType *isTypeExists=std::find(orderBg,orderEnd,curType);
5927       if(isTypeExists!=orderEnd)
5928         {
5929           int pos=(int)std::distance(orderBg,isTypeExists);
5930           if(pos<=lastPos)
5931             return false;
5932           lastPos=pos;
5933           i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
5934         }
5935       else
5936         {
5937           if(sg.find(curType)==sg.end())
5938             {
5939               i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
5940               sg.insert(curType);
5941             }
5942           else
5943             return false;
5944         }
5945     }
5946   return true;
5947 }
5948
5949 /*!
5950  * This method returns 2 newly allocated DataArrayInt instances. The first is an array of size 'this->getNumberOfCells()' with one component,
5951  * that tells for each cell the pos of its type in the array on type given in input parameter. The 2nd output parameter is an array with the same
5952  * number of tuples than input type array and with one component. This 2nd output array gives type by type the number of occurrence of type in 'this'.
5953  */
5954 DataArrayInt *MEDCouplingUMesh::getLevArrPerCellTypes(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd, DataArrayInt *&nbPerType) const
5955 {
5956   checkConnectivityFullyDefined();
5957   int nbOfCells=getNumberOfCells();
5958   const int *conn=_nodal_connec->begin();
5959   const int *connI=_nodal_connec_index->begin();
5960   MCAuto<DataArrayInt> tmpa=DataArrayInt::New();
5961   MCAuto<DataArrayInt> tmpb=DataArrayInt::New();
5962   tmpa->alloc(nbOfCells,1);
5963   tmpb->alloc((int)std::distance(orderBg,orderEnd),1);
5964   tmpb->fillWithZero();
5965   int *tmp=tmpa->getPointer();
5966   int *tmp2=tmpb->getPointer();
5967   for(const int *i=connI;i!=connI+nbOfCells;i++)
5968     {
5969       const INTERP_KERNEL::NormalizedCellType *where=std::find(orderBg,orderEnd,(INTERP_KERNEL::NormalizedCellType)conn[*i]);
5970       if(where!=orderEnd)
5971         {
5972           int pos=(int)std::distance(orderBg,where);
5973           tmp2[pos]++;
5974           tmp[std::distance(connI,i)]=pos;
5975         }
5976       else
5977         {
5978           const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[*i]);
5979           std::ostringstream oss; oss << "MEDCouplingUMesh::getLevArrPerCellTypes : Cell #" << std::distance(connI,i);
5980           oss << " has a type " << cm.getRepr() << " not in input array of type !";
5981           throw INTERP_KERNEL::Exception(oss.str());
5982         }
5983     }
5984   nbPerType=tmpb.retn();
5985   return tmpa.retn();
5986 }
5987
5988 /*!
5989  * This method behaves exactly as MEDCouplingUMesh::getRenumArrForConsecutiveCellTypesSpec but the order is those defined in MED file spec.
5990  *
5991  * \return a new object containing the old to new correspondence.
5992  *
5993  * \sa MEDCouplingUMesh::getRenumArrForConsecutiveCellTypesSpec, MEDCouplingUMesh::sortCellsInMEDFileFrmt.
5994  */
5995 DataArrayInt *MEDCouplingUMesh::getRenumArrForMEDFileFrmt() const
5996 {
5997   return getRenumArrForConsecutiveCellTypesSpec(MEDMEM_ORDER,MEDMEM_ORDER+N_MEDMEM_ORDER);
5998 }
5999
6000 /*!
6001  * This method is similar to method MEDCouplingUMesh::rearrange2ConsecutiveCellTypes except that the type order is specified by [ \a orderBg , \a orderEnd ) (as MEDCouplingUMesh::checkConsecutiveCellTypesAndOrder method) and that this method is \b const and performs \b NO permutation in \a this.
6002  * This method returns an array of size getNumberOfCells() that gives a renumber array old2New that can be used as input of MEDCouplingMesh::renumberCells.
6003  * The mesh after this call to MEDCouplingMesh::renumberCells will pass the test of MEDCouplingUMesh::checkConsecutiveCellTypesAndOrder with the same inputs.
6004  * The returned array minimizes the permutations that is to say the order of cells inside same geometric type remains the same.
6005  */
6006 DataArrayInt *MEDCouplingUMesh::getRenumArrForConsecutiveCellTypesSpec(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd) const
6007 {
6008   DataArrayInt *nbPerType=0;
6009   MCAuto<DataArrayInt> tmpa=getLevArrPerCellTypes(orderBg,orderEnd,nbPerType);
6010   nbPerType->decrRef();
6011   return tmpa->buildPermArrPerLevel();
6012 }
6013
6014 /*!
6015  * This method reorganize the cells of \a this so that the cells with same geometric types are put together.
6016  * The number of cells remains unchanged after the call of this method.
6017  * This method tries to minimizes the number of needed permutations. So, this method behaves not exactly as
6018  * MEDCouplingUMesh::sortCellsInMEDFileFrmt.
6019  *
6020  * \return the array giving the correspondence old to new.
6021  */
6022 DataArrayInt *MEDCouplingUMesh::rearrange2ConsecutiveCellTypes()
6023 {
6024   checkFullyDefined();
6025   computeTypes();
6026   const int *conn=_nodal_connec->begin();
6027   const int *connI=_nodal_connec_index->begin();
6028   int nbOfCells=getNumberOfCells();
6029   std::vector<INTERP_KERNEL::NormalizedCellType> types;
6030   for(const int *i=connI;i!=connI+nbOfCells && (types.size()!=_types.size());)
6031     if(std::find(types.begin(),types.end(),(INTERP_KERNEL::NormalizedCellType)conn[*i])==types.end())
6032       {
6033         INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
6034         types.push_back(curType);
6035         for(i++;i!=connI+nbOfCells && (INTERP_KERNEL::NormalizedCellType)conn[*i]==curType;i++);
6036       }
6037   DataArrayInt *ret=DataArrayInt::New();
6038   ret->alloc(nbOfCells,1);
6039   int *retPtr=ret->getPointer();
6040   std::fill(retPtr,retPtr+nbOfCells,-1);
6041   int newCellId=0;
6042   for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=types.begin();iter!=types.end();iter++)
6043     {
6044       for(const int *i=connI;i!=connI+nbOfCells;i++)
6045         if((INTERP_KERNEL::NormalizedCellType)conn[*i]==(*iter))
6046           retPtr[std::distance(connI,i)]=newCellId++;
6047     }
6048   renumberCells(retPtr,false);
6049   return ret;
6050 }
6051
6052 /*!
6053  * This method splits \a this into as mush as untructured meshes that consecutive set of same type cells.
6054  * So this method has typically a sense if MEDCouplingUMesh::checkConsecutiveCellTypes has a sense.
6055  * This method makes asumption that connectivity is correctly set before calling.
6056  */
6057 std::vector<MEDCouplingUMesh *> MEDCouplingUMesh::splitByType() const
6058 {
6059   checkConnectivityFullyDefined();
6060   const int *conn=_nodal_connec->begin();
6061   const int *connI=_nodal_connec_index->begin();
6062   int nbOfCells=getNumberOfCells();
6063   std::vector<MEDCouplingUMesh *> ret;
6064   for(const int *i=connI;i!=connI+nbOfCells;)
6065     {
6066       INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
6067       int beginCellId=(int)std::distance(connI,i);
6068       i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
6069       int endCellId=(int)std::distance(connI,i);
6070       int sz=endCellId-beginCellId;
6071       int *cells=new int[sz];
6072       for(int j=0;j<sz;j++)
6073         cells[j]=beginCellId+j;
6074       MEDCouplingUMesh *m=(MEDCouplingUMesh *)buildPartOfMySelf(cells,cells+sz,true);
6075       delete [] cells;
6076       ret.push_back(m);
6077     }
6078   return ret;
6079 }
6080
6081 /*!
6082  * This method performs the opposite operation than those in MEDCoupling1SGTUMesh::buildUnstructured.
6083  * If \a this is a single geometric type unstructured mesh, it will be converted into a more compact data structure,
6084  * MEDCoupling1GTUMesh instance. The returned instance will aggregate the same DataArrayDouble instance of coordinates than \a this.
6085  *
6086  * \return a newly allocated instance, that the caller must manage.
6087  * \throw If \a this contains more than one geometric type.
6088  * \throw If the nodal connectivity of \a this is not fully defined.
6089  * \throw If the internal data is not coherent.
6090  */
6091 MEDCoupling1GTUMesh *MEDCouplingUMesh::convertIntoSingleGeoTypeMesh() const
6092 {
6093   checkConnectivityFullyDefined();
6094   if(_types.size()!=1)
6095     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertIntoSingleGeoTypeMesh : current mesh does not contain exactly one geometric type !");
6096   INTERP_KERNEL::NormalizedCellType typ=*_types.begin();
6097   MCAuto<MEDCoupling1GTUMesh> ret=MEDCoupling1GTUMesh::New(getName(),typ);
6098   ret->setCoords(getCoords());
6099   MEDCoupling1SGTUMesh *retC=dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh*)ret);
6100   if(retC)
6101     {
6102       MCAuto<DataArrayInt> c=convertNodalConnectivityToStaticGeoTypeMesh();
6103       retC->setNodalConnectivity(c);
6104     }
6105   else
6106     {
6107       MEDCoupling1DGTUMesh *retD=dynamic_cast<MEDCoupling1DGTUMesh *>((MEDCoupling1GTUMesh*)ret);
6108       if(!retD)
6109         throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertIntoSingleGeoTypeMesh : Internal error !");
6110       DataArrayInt *c=0,*ci=0;
6111       convertNodalConnectivityToDynamicGeoTypeMesh(c,ci);
6112       MCAuto<DataArrayInt> cs(c),cis(ci);
6113       retD->setNodalConnectivity(cs,cis);
6114     }
6115   return ret.retn();
6116 }
6117
6118 DataArrayInt *MEDCouplingUMesh::convertNodalConnectivityToStaticGeoTypeMesh() const
6119 {
6120   checkConnectivityFullyDefined();
6121   if(_types.size()!=1)
6122     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertNodalConnectivityToStaticGeoTypeMesh : current mesh does not contain exactly one geometric type !");
6123   INTERP_KERNEL::NormalizedCellType typ=*_types.begin();
6124   const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
6125   if(cm.isDynamic())
6126     {
6127       std::ostringstream oss; oss << "MEDCouplingUMesh::convertNodalConnectivityToStaticGeoTypeMesh : this contains a single geo type (" << cm.getRepr() << ") but ";
6128       oss << "this type is dynamic ! Only static geometric type is possible for that type ! call convertNodalConnectivityToDynamicGeoTypeMesh instead !";
6129       throw INTERP_KERNEL::Exception(oss.str());
6130     }
6131   int nbCells=getNumberOfCells();
6132   int typi=(int)typ;
6133   int nbNodesPerCell=(int)cm.getNumberOfNodes();
6134   MCAuto<DataArrayInt> connOut=DataArrayInt::New(); connOut->alloc(nbCells*nbNodesPerCell,1);
6135   int *outPtr=connOut->getPointer();
6136   const int *conn=_nodal_connec->begin();
6137   const int *connI=_nodal_connec_index->begin();
6138   nbNodesPerCell++;
6139   for(int i=0;i<nbCells;i++,connI++)
6140     {
6141       if(conn[connI[0]]==typi && connI[1]-connI[0]==nbNodesPerCell)
6142         outPtr=std::copy(conn+connI[0]+1,conn+connI[1],outPtr);
6143       else
6144         {
6145           std::ostringstream oss; oss << "MEDCouplingUMesh::convertNodalConnectivityToStaticGeoTypeMesh : there something wrong in cell #" << i << " ! The type of cell is not those expected, or the length of nodal connectivity is not those expected (" << nbNodesPerCell-1 << ") !";
6146           throw INTERP_KERNEL::Exception(oss.str());
6147         }
6148     }
6149   return connOut.retn();
6150 }
6151
6152 /*!
6153  * Convert the nodal connectivity of the mesh so that all the cells are of dynamic types (polygon or quadratic
6154  * polygon). This returns the corresponding new nodal connectivity in \ref numbering-indirect format.
6155  * \param nodalConn
6156  * \param nodalConnI
6157  */
6158 void MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh(DataArrayInt *&nodalConn, DataArrayInt *&nodalConnIndex) const
6159 {
6160   static const char msg0[]="MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh : nodal connectivity in this are invalid ! Call checkConsistency !";
6161   checkConnectivityFullyDefined();
6162   if(_types.size()!=1)
6163     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh : current mesh does not contain exactly one geometric type !");
6164   int nbCells=getNumberOfCells(),lgth=_nodal_connec->getNumberOfTuples();
6165   if(lgth<nbCells)
6166     throw INTERP_KERNEL::Exception(msg0);
6167   MCAuto<DataArrayInt> c(DataArrayInt::New()),ci(DataArrayInt::New());
6168   c->alloc(lgth-nbCells,1); ci->alloc(nbCells+1,1);
6169   int *cp(c->getPointer()),*cip(ci->getPointer());
6170   const int *incp(_nodal_connec->begin()),*incip(_nodal_connec_index->begin());
6171   cip[0]=0;
6172   for(int i=0;i<nbCells;i++,cip++,incip++)
6173     {
6174       int strt(incip[0]+1),stop(incip[1]);//+1 to skip geo type
6175       int delta(stop-strt);
6176       if(delta>=1)
6177         {
6178           if((strt>=0 && strt<lgth) && (stop>=0 && stop<=lgth))
6179             cp=std::copy(incp+strt,incp+stop,cp);
6180           else
6181             throw INTERP_KERNEL::Exception(msg0);
6182         }
6183       else
6184         throw INTERP_KERNEL::Exception(msg0);
6185       cip[1]=cip[0]+delta;
6186     }
6187   nodalConn=c.retn(); nodalConnIndex=ci.retn();
6188 }
6189
6190 /*!
6191  * This method takes in input a vector of MEDCouplingUMesh instances lying on the same coordinates with same mesh dimensions.
6192  * Each mesh in \b ms must be sorted by type with the same order (typically using MEDCouplingUMesh::sortCellsInMEDFileFrmt).
6193  * This method is particularly useful for MED file interaction. It allows to aggregate several meshes and keeping the type sorting
6194  * and the track of the permutation by chunk of same geotype cells to retrieve it. The traditional formats old2new and new2old
6195  * are not used here to avoid the build of big permutation array.
6196  *
6197  * \param [in] ms meshes with same mesh dimension lying on the same coords and sorted by type following de the same geometric type order than
6198  *                those specified in MEDCouplingUMesh::sortCellsInMEDFileFrmt method.
6199  * \param [out] szOfCellGrpOfSameType is a newly allocated DataArrayInt instance whose number of tuples is equal to the number of chunks of same geotype
6200  *              in all meshes in \b ms. The accumulation of all values of this array is equal to the number of cells of returned mesh.
6201  * \param [out] idInMsOfCellGrpOfSameType is a newly allocated DataArrayInt instance having the same size than \b szOfCellGrpOfSameType. This
6202  *              output array gives for each chunck of same type the corresponding mesh id in \b ms.
6203  * \return A newly allocated unstructured mesh that is the result of the aggregation on same coords of all meshes in \b ms. This returned mesh
6204  *         is sorted by type following the geo cell types order of MEDCouplingUMesh::sortCellsInMEDFileFrmt method.
6205  */
6206 MEDCouplingUMesh *MEDCouplingUMesh::AggregateSortedByTypeMeshesOnSameCoords(const std::vector<const MEDCouplingUMesh *>& ms,
6207                                                                             DataArrayInt *&szOfCellGrpOfSameType,
6208                                                                             DataArrayInt *&idInMsOfCellGrpOfSameType)
6209 {
6210   std::vector<const MEDCouplingUMesh *> ms2;
6211   for(std::vector<const MEDCouplingUMesh *>::const_iterator it=ms.begin();it!=ms.end();it++)
6212     if(*it)
6213       {
6214         (*it)->checkConnectivityFullyDefined();
6215         ms2.push_back(*it);
6216       }
6217   if(ms2.empty())
6218     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::AggregateSortedByTypeMeshesOnSameCoords : input vector is empty !");
6219   const DataArrayDouble *refCoo=ms2[0]->getCoords();
6220   int meshDim=ms2[0]->getMeshDimension();
6221   std::vector<const MEDCouplingUMesh *> m1ssm;
6222   std::vector< MCAuto<MEDCouplingUMesh> > m1ssmAuto;
6223   //
6224   std::vector<const MEDCouplingUMesh *> m1ssmSingle;
6225   std::vector< MCAuto<MEDCouplingUMesh> > m1ssmSingleAuto;
6226   int fake=0,rk=0;
6227   MCAuto<DataArrayInt> ret1(DataArrayInt::New()),ret2(DataArrayInt::New());
6228   ret1->alloc(0,1); ret2->alloc(0,1);
6229   for(std::vector<const MEDCouplingUMesh *>::const_iterator it=ms2.begin();it!=ms2.end();it++,rk++)
6230     {
6231       if(meshDim!=(*it)->getMeshDimension())
6232         throw INTERP_KERNEL::Exception("MEDCouplingUMesh::AggregateSortedByTypeMeshesOnSameCoords : meshdims mismatch !");
6233       if(refCoo!=(*it)->getCoords())
6234         throw INTERP_KERNEL::Exception("MEDCouplingUMesh::AggregateSortedByTypeMeshesOnSameCoords : meshes are not shared by a single coordinates coords !");
6235       std::vector<MEDCouplingUMesh *> sp=(*it)->splitByType();
6236       std::copy(sp.begin(),sp.end(),std::back_insert_iterator< std::vector<const MEDCouplingUMesh *> >(m1ssm));
6237       std::copy(sp.begin(),sp.end(),std::back_insert_iterator< std::vector<MCAuto<MEDCouplingUMesh> > >(m1ssmAuto));
6238       for(std::vector<MEDCouplingUMesh *>::const_iterator it2=sp.begin();it2!=sp.end();it2++)
6239         {
6240           MEDCouplingUMesh *singleCell=static_cast<MEDCouplingUMesh *>((*it2)->buildPartOfMySelf(&fake,&fake+1,true));
6241           m1ssmSingleAuto.push_back(singleCell);
6242           m1ssmSingle.push_back(singleCell);
6243           ret1->pushBackSilent((*it2)->getNumberOfCells()); ret2->pushBackSilent(rk);
6244         }
6245     }
6246   MCAuto<MEDCouplingUMesh> m1ssmSingle2=MEDCouplingUMesh::MergeUMeshesOnSameCoords(m1ssmSingle);
6247   MCAuto<DataArrayInt> renum=m1ssmSingle2->sortCellsInMEDFileFrmt();
6248   std::vector<const MEDCouplingUMesh *> m1ssmfinal(m1ssm.size());
6249   for(std::size_t i=0;i<m1ssm.size();i++)
6250     m1ssmfinal[renum->getIJ(i,0)]=m1ssm[i];
6251   MCAuto<MEDCouplingUMesh> ret0=MEDCouplingUMesh::MergeUMeshesOnSameCoords(m1ssmfinal);
6252   szOfCellGrpOfSameType=ret1->renumber(renum->begin());
6253   idInMsOfCellGrpOfSameType=ret2->renumber(renum->begin());
6254   return ret0.retn();
6255 }
6256
6257 /*!
6258  * This method returns a newly created DataArrayInt instance.
6259  * This method retrieves cell ids in [ \a begin, \a end ) that have the type \a type.
6260  */
6261 DataArrayInt *MEDCouplingUMesh::keepCellIdsByType(INTERP_KERNEL::NormalizedCellType type, const int *begin, const int *end) const
6262 {
6263   checkFullyDefined();
6264   const int *conn=_nodal_connec->begin();
6265   const int *connIndex=_nodal_connec_index->begin();
6266   MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
6267   for(const int *w=begin;w!=end;w++)
6268     if((INTERP_KERNEL::NormalizedCellType)conn[connIndex[*w]]==type)
6269       ret->pushBackSilent(*w);
6270   return ret.retn();
6271 }
6272
6273 /*!
6274  * This method makes the assumption that da->getNumberOfTuples()<this->getNumberOfCells(). This method makes the assumption that ids contained in 'da'
6275  * are in [0:getNumberOfCells())
6276  */
6277 DataArrayInt *MEDCouplingUMesh::convertCellArrayPerGeoType(const DataArrayInt *da) const
6278 {
6279   checkFullyDefined();
6280   const int *conn=_nodal_connec->begin();
6281   const int *connI=_nodal_connec_index->begin();
6282   int nbOfCells=getNumberOfCells();
6283   std::set<INTERP_KERNEL::NormalizedCellType> types(getAllGeoTypes());
6284   int *tmp=new int[nbOfCells];
6285   for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=types.begin();iter!=types.end();iter++)
6286     {
6287       int j=0;
6288       for(const int *i=connI;i!=connI+nbOfCells;i++)
6289         if((INTERP_KERNEL::NormalizedCellType)conn[*i]==(*iter))
6290           tmp[std::distance(connI,i)]=j++;
6291     }
6292   DataArrayInt *ret=DataArrayInt::New();
6293   ret->alloc(da->getNumberOfTuples(),da->getNumberOfComponents());
6294   ret->copyStringInfoFrom(*da);
6295   int *retPtr=ret->getPointer();
6296   const int *daPtr=da->begin();
6297   int nbOfElems=da->getNbOfElems();
6298   for(int k=0;k<nbOfElems;k++)
6299     retPtr[k]=tmp[daPtr[k]];
6300   delete [] tmp;
6301   return ret;
6302 }
6303
6304 /*!
6305  * This method reduced number of cells of this by keeping cells whose type is different from 'type' and if type=='type'
6306  * This method \b works \b for mesh sorted by type.
6307  * cells whose ids is in 'idsPerGeoType' array.
6308  * This method conserves coords and name of mesh.
6309  */
6310 MEDCouplingUMesh *MEDCouplingUMesh::keepSpecifiedCells(INTERP_KERNEL::NormalizedCellType type, const int *idsPerGeoTypeBg, const int *idsPerGeoTypeEnd) const
6311 {
6312   std::vector<int> code=getDistributionOfTypes();
6313   std::size_t nOfTypesInThis=code.size()/3;
6314   int sz=0,szOfType=0;
6315   for(std::size_t i=0;i<nOfTypesInThis;i++)
6316     {
6317       if(code[3*i]!=type)
6318         sz+=code[3*i+1];
6319       else
6320         szOfType=code[3*i+1];
6321     }
6322   for(const int *work=idsPerGeoTypeBg;work!=idsPerGeoTypeEnd;work++)
6323     if(*work<0 || *work>=szOfType)
6324       {
6325         std::ostringstream oss; oss << "MEDCouplingUMesh::keepSpecifiedCells : Request on type " << type << " at place #" << std::distance(idsPerGeoTypeBg,work) << " value " << *work;
6326         oss << ". It should be in [0," << szOfType << ") !";
6327         throw INTERP_KERNEL::Exception(oss.str());
6328       }
6329   MCAuto<DataArrayInt> idsTokeep=DataArrayInt::New(); idsTokeep->alloc(sz+(int)std::distance(idsPerGeoTypeBg,idsPerGeoTypeEnd),1);
6330   int *idsPtr=idsTokeep->getPointer();
6331   int offset=0;
6332   for(std::size_t i=0;i<nOfTypesInThis;i++)
6333     {
6334       if(code[3*i]!=type)
6335         for(int j=0;j<code[3*i+1];j++)
6336           *idsPtr++=offset+j;
6337       else
6338         idsPtr=std::transform(idsPerGeoTypeBg,idsPerGeoTypeEnd,idsPtr,std::bind2nd(std::plus<int>(),offset));
6339       offset+=code[3*i+1];
6340     }
6341   MCAuto<MEDCouplingUMesh> ret=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(idsTokeep->begin(),idsTokeep->end(),true));
6342   ret->copyTinyInfoFrom(this);
6343   return ret.retn();
6344 }
6345
6346 /*!
6347  * This method returns a vector of size 'this->getNumberOfCells()'.
6348  * This method retrieves for each cell in \a this if it is linear (false) or quadratic(true).
6349  */
6350 std::vector<bool> MEDCouplingUMesh::getQuadraticStatus() const
6351 {
6352   int ncell=getNumberOfCells();
6353   std::vector<bool> ret(ncell);
6354   const int *cI=getNodalConnectivityIndex()->begin();
6355   const int *c=getNodalConnectivity()->begin();
6356   for(int i=0;i<ncell;i++)
6357     {
6358       INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)c[cI[i]];
6359       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
6360       ret[i]=cm.isQuadratic();
6361     }
6362   return ret;
6363 }
6364
6365 /*!
6366  * Returns a newly created mesh (with ref count ==1) that contains merge of \a this and \a other.
6367  */
6368 MEDCouplingMesh *MEDCouplingUMesh::mergeMyselfWith(const MEDCouplingMesh *other) const
6369 {
6370   if(other->getType()!=UNSTRUCTURED)
6371     throw INTERP_KERNEL::Exception("Merge of umesh only available with umesh each other !");
6372   const MEDCouplingUMesh *otherC=static_cast<const MEDCouplingUMesh *>(other);
6373   return MergeUMeshes(this,otherC);
6374 }
6375
6376 /*!
6377  * Returns a new DataArrayDouble holding barycenters of all cells. The barycenter is
6378  * computed by averaging coordinates of cell nodes, so this method is not a right
6379  * choice for degenerated meshes (not well oriented, cells with measure close to zero).
6380  *  \return DataArrayDouble * - a new instance of DataArrayDouble, of size \a
6381  *          this->getNumberOfCells() tuples per \a this->getSpaceDimension()
6382  *          components. The caller is to delete this array using decrRef() as it is
6383  *          no more needed.
6384  *  \throw If the coordinates array is not set.
6385  *  \throw If the nodal connectivity of cells is not defined.
6386  *  \sa MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell
6387  */
6388 DataArrayDouble *MEDCouplingUMesh::computeCellCenterOfMass() const
6389 {
6390   MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
6391   int spaceDim=getSpaceDimension();
6392   int nbOfCells=getNumberOfCells();
6393   ret->alloc(nbOfCells,spaceDim);
6394   ret->copyStringInfoFrom(*getCoords());
6395   double *ptToFill=ret->getPointer();
6396   const int *nodal=_nodal_connec->begin();
6397   const int *nodalI=_nodal_connec_index->begin();
6398   const double *coor=_coords->begin();
6399   for(int i=0;i<nbOfCells;i++)
6400     {
6401       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[i]];
6402       INTERP_KERNEL::computeBarycenter2<int,INTERP_KERNEL::ALL_C_MODE>(type,nodal+nodalI[i]+1,nodalI[i+1]-nodalI[i]-1,coor,spaceDim,ptToFill);
6403       ptToFill+=spaceDim;
6404     }
6405   return ret.retn();
6406 }
6407
6408 /*!
6409  * This method computes for each cell in \a this, the location of the iso barycenter of nodes constituting
6410  * the cell. Contrary to badly named MEDCouplingUMesh::computeCellCenterOfMass method that returns the center of inertia of the 
6411  * 
6412  * \return a newly allocated DataArrayDouble instance that the caller has to deal with. The returned 
6413  *          DataArrayDouble instance will have \c this->getNumberOfCells() tuples and \c this->getSpaceDimension() components.
6414  * 
6415  * \sa MEDCouplingUMesh::computeCellCenterOfMass
6416  * \throw If \a this is not fully defined (coordinates and connectivity)
6417  * \throw If there is presence in nodal connectivity in \a this of node ids not in [0, \c this->getNumberOfNodes() )
6418  */
6419 DataArrayDouble *MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell() const
6420 {
6421   checkFullyDefined();
6422   MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
6423   int spaceDim=getSpaceDimension();
6424   int nbOfCells=getNumberOfCells();
6425   int nbOfNodes=getNumberOfNodes();
6426   ret->alloc(nbOfCells,spaceDim);
6427   double *ptToFill=ret->getPointer();
6428   const int *nodal=_nodal_connec->begin();
6429   const int *nodalI=_nodal_connec_index->begin();
6430   const double *coor=_coords->begin();
6431   for(int i=0;i<nbOfCells;i++,ptToFill+=spaceDim)
6432     {
6433       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[i]];
6434       std::fill(ptToFill,ptToFill+spaceDim,0.);
6435       if(type!=INTERP_KERNEL::NORM_POLYHED)
6436         {
6437           for(const int *conn=nodal+nodalI[i]+1;conn!=nodal+nodalI[i+1];conn++)
6438             {
6439               if(*conn>=0 && *conn<nbOfNodes)
6440                 std::transform(coor+spaceDim*conn[0],coor+spaceDim*(conn[0]+1),ptToFill,ptToFill,std::plus<double>());
6441               else
6442                 {
6443                   std::ostringstream oss; oss << "MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell : on cell #" << i << " presence of nodeId #" << *conn << " should be in [0," <<   nbOfNodes << ") !";
6444                   throw INTERP_KERNEL::Exception(oss.str());
6445                 }
6446             }
6447           int nbOfNodesInCell=nodalI[i+1]-nodalI[i]-1;
6448           if(nbOfNodesInCell>0)
6449             std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind2nd(std::multiplies<double>(),1./(double)nbOfNodesInCell));
6450           else
6451             {
6452               std::ostringstream oss; oss << "MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell : on cell #" << i << " presence of cell with no nodes !";
6453               throw INTERP_KERNEL::Exception(oss.str());
6454             }
6455         }
6456       else
6457         {
6458           std::set<int> s(nodal+nodalI[i]+1,nodal+nodalI[i+1]);
6459           s.erase(-1);
6460           for(std::set<int>::const_iterator it=s.begin();it!=s.end();it++)
6461             {
6462               if(*it>=0 && *it<nbOfNodes)
6463                 std::transform(coor+spaceDim*(*it),coor+spaceDim*((*it)+1),ptToFill,ptToFill,std::plus<double>());
6464               else
6465                 {
6466                   std::ostringstream oss; oss << "MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell : on cell polyhedron cell #" << i << " presence of nodeId #" << *it << " should be in [0," <<   nbOfNodes << ") !";
6467                   throw INTERP_KERNEL::Exception(oss.str());
6468                 }
6469             }
6470           if(!s.empty())
6471             std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind2nd(std::multiplies<double>(),1./(double)s.size()));
6472           else
6473             {
6474               std::ostringstream oss; oss << "MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell : on polyhedron cell #" << i << " there are no nodes !";
6475               throw INTERP_KERNEL::Exception(oss.str());
6476             }
6477         }
6478     }
6479   return ret.retn();
6480 }
6481
6482 /*!
6483  * Returns a new DataArrayDouble holding barycenters of specified cells. The
6484  * barycenter is computed by averaging coordinates of cell nodes. The cells to treat
6485  * are specified via an array of cell ids. 
6486  *  \warning Validity of the specified cell ids is not checked! 
6487  *           Valid range is [ 0, \a this->getNumberOfCells() ).
6488  *  \param [in] begin - an array of cell ids of interest.
6489  *  \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element.
6490  *  \return DataArrayDouble * - a new instance of DataArrayDouble, of size ( \a
6491  *          end - \a begin ) tuples per \a this->getSpaceDimension() components. The
6492  *          caller is to delete this array using decrRef() as it is no more needed. 
6493  *  \throw If the coordinates array is not set.
6494  *  \throw If the nodal connectivity of cells is not defined.
6495  *
6496  *  \if ENABLE_EXAMPLES
6497  *  \ref cpp_mcumesh_getPartBarycenterAndOwner "Here is a C++ example".<br>
6498  *  \ref  py_mcumesh_getPartBarycenterAndOwner "Here is a Python example".
6499  *  \endif
6500  */
6501 DataArrayDouble *MEDCouplingUMesh::getPartBarycenterAndOwner(const int *begin, const int *end) const
6502 {
6503   DataArrayDouble *ret=DataArrayDouble::New();
6504   int spaceDim=getSpaceDimension();
6505   int nbOfTuple=(int)std::distance(begin,end);
6506   ret->alloc(nbOfTuple,spaceDim);
6507   double *ptToFill=ret->getPointer();
6508   double *tmp=new double[spaceDim];
6509   const int *nodal=_nodal_connec->begin();
6510   const int *nodalI=_nodal_connec_index->begin();
6511   const double *coor=_coords->begin();
6512   for(const int *w=begin;w!=end;w++)
6513     {
6514       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[*w]];
6515       INTERP_KERNEL::computeBarycenter2<int,INTERP_KERNEL::ALL_C_MODE>(type,nodal+nodalI[*w]+1,nodalI[*w+1]-nodalI[*w]-1,coor,spaceDim,ptToFill);
6516       ptToFill+=spaceDim;
6517     }
6518   delete [] tmp;
6519   return ret;
6520 }
6521
6522 /*!
6523  * Returns a DataArrayDouble instance giving for each cell in \a this the equation of plane given by "a*X+b*Y+c*Z+d=0".
6524  * So the returned instance will have 4 components and \c this->getNumberOfCells() tuples.
6525  * So this method expects that \a this has a spaceDimension equal to 3 and meshDimension equal to 2.
6526  * The computation of the plane equation is done using each time the 3 first nodes of 2D cells.
6527  * This method is useful to detect 2D cells in 3D space that are not coplanar.
6528  * 
6529  * \return DataArrayDouble * - a new instance of DataArrayDouble having 4 components and a number of tuples equal to number of cells in \a this.
6530  * \throw If spaceDim!=3 or meshDim!=2.
6531  * \throw If connectivity of \a this is invalid.
6532  * \throw If connectivity of a cell in \a this points to an invalid node.
6533  */
6534 DataArrayDouble *MEDCouplingUMesh::computePlaneEquationOf3DFaces() const
6535 {
6536   MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
6537   int nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes());
6538   if(getSpaceDimension()!=3 || getMeshDimension()!=2)
6539     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computePlaneEquationOf3DFaces : This method must be applied on a mesh having meshDimension equal 2 and a spaceDimension equal to 3 !");
6540   ret->alloc(nbOfCells,4);
6541   double *retPtr(ret->getPointer());
6542   const int *nodal(_nodal_connec->begin()),*nodalI(_nodal_connec_index->begin());
6543   const double *coor(_coords->begin());
6544   for(int i=0;i<nbOfCells;i++,nodalI++,retPtr+=4)
6545     {
6546       double matrix[16]={0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,0},matrix2[16];
6547       if(nodalI[1]-nodalI[0]>=4)
6548         {
6549           double aa[3]={coor[nodal[nodalI[0]+1+1]*3+0]-coor[nodal[nodalI[0]+1+0]*3+0],
6550                         coor[nodal[nodalI[0]+1+1]*3+1]-coor[nodal[nodalI[0]+1+0]*3+1],
6551                         coor[nodal[nodalI[0]+1+1]*3+2]-coor[nodal[nodalI[0]+1+0]*3+2]}
6552           ,bb[3]={coor[nodal[nodalI[0]+1+2]*3+0]-coor[nodal[nodalI[0]+1+0]*3+0],
6553                         coor[nodal[nodalI[0]+1+2]*3+1]-coor[nodal[nodalI[0]+1+0]*3+1],
6554                         coor[nodal[nodalI[0]+1+2]*3+2]-coor[nodal[nodalI[0]+1+0]*3+2]};
6555           double cc[3]={aa[1]*bb[2]-aa[2]*bb[1],aa[2]*bb[0]-aa[0]*bb[2],aa[0]*bb[1]-aa[1]*bb[0]};
6556           for(int j=0;j<3;j++)
6557             {
6558               int nodeId(nodal[nodalI[0]+1+j]);
6559               if(nodeId>=0 && nodeId<nbOfNodes)
6560                 std::copy(coor+nodeId*3,coor+(nodeId+1)*3,matrix+4*j);
6561               else
6562                 {
6563                   std::ostringstream oss; oss << "MEDCouplingUMesh::computePlaneEquationOf3DFaces : invalid 2D cell #" << i << " ! This cell points to an invalid nodeId : " << nodeId << " !";
6564                   throw INTERP_KERNEL::Exception(oss.str());
6565                 }
6566             }
6567           if(sqrt(cc[0]*cc[0]+cc[1]*cc[1]+cc[2]*cc[2])>1e-7)
6568             {
6569               INTERP_KERNEL::inverseMatrix(matrix,4,matrix2);
6570               retPtr[0]=matrix2[3]; retPtr[1]=matrix2[7]; retPtr[2]=matrix2[11]; retPtr[3]=matrix2[15];
6571             }
6572           else
6573             {
6574               if(nodalI[1]-nodalI[0]==4)
6575                 {
6576                   std::ostringstream oss; oss << "MEDCouplingUMesh::computePlaneEquationOf3DFaces : cell" << i << " : Presence of The 3 colinear points !";
6577                   throw INTERP_KERNEL::Exception(oss.str());
6578                 }
6579               //
6580               double dd[3]={0.,0.,0.};
6581               for(int offset=nodalI[0]+1;offset<nodalI[1];offset++)
6582                 std::transform(coor+3*nodal[offset],coor+3*(nodal[offset]+1),dd,dd,std::plus<double>());
6583               int nbOfNodesInCell(nodalI[1]-nodalI[0]-1);
6584               std::transform(dd,dd+3,dd,std::bind2nd(std::multiplies<double>(),1./(double)nbOfNodesInCell));
6585               std::copy(dd,dd+3,matrix+4*2);
6586               INTERP_KERNEL::inverseMatrix(matrix,4,matrix2);
6587               retPtr[0]=matrix2[3]; retPtr[1]=matrix2[7]; retPtr[2]=matrix2[11]; retPtr[3]=matrix2[15];
6588             }
6589         }
6590       else
6591         {
6592           std::ostringstream oss; oss << "MEDCouplingUMesh::computePlaneEquationOf3DFaces : invalid 2D cell #" << i << " ! Must be constitued by more than 3 nodes !";
6593           throw INTERP_KERNEL::Exception(oss.str());
6594         }
6595     }
6596   return ret.retn();
6597 }
6598
6599 /*!
6600  * This method expects as input a DataArrayDouble non nul instance 'da' that should be allocated. If not an exception is thrown.
6601  * 
6602  */
6603 MEDCouplingUMesh *MEDCouplingUMesh::Build0DMeshFromCoords(DataArrayDouble *da)
6604 {
6605   if(!da)
6606     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::Build0DMeshFromCoords : instance of DataArrayDouble must be not null !");
6607   da->checkAllocated();
6608   std::string name(da->getName());
6609   MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::New(name,0));
6610   if(name.empty())
6611     ret->setName("Mesh");
6612   ret->setCoords(da);
6613   int nbOfTuples(da->getNumberOfTuples());
6614   MCAuto<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New());
6615   c->alloc(2*nbOfTuples,1);
6616   cI->alloc(nbOfTuples+1,1);
6617   int *cp(c->getPointer()),*cip(cI->getPointer());
6618   *cip++=0;
6619   for(int i=0;i<nbOfTuples;i++)
6620     {
6621       *cp++=INTERP_KERNEL::NORM_POINT1;
6622       *cp++=i;
6623       *cip++=2*(i+1);
6624     }
6625   ret->setConnectivity(c,cI,true);
6626   return ret.retn();
6627 }
6628
6629 MCAuto<MEDCouplingUMesh> MEDCouplingUMesh::Build1DMeshFromCoords(DataArrayDouble *da)
6630 {
6631   if(!da)
6632     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::Build01MeshFromCoords : instance of DataArrayDouble must be not null !");
6633   da->checkAllocated();
6634   std::string name(da->getName());
6635   MCAuto<MEDCouplingUMesh> ret;
6636   {
6637     MCAuto<MEDCouplingCMesh> tmp(MEDCouplingCMesh::New());
6638     MCAuto<DataArrayDouble> arr(DataArrayDouble::New());
6639     arr->alloc(da->getNumberOfTuples());
6640     tmp->setCoordsAt(0,arr);
6641     ret=tmp->buildUnstructured();
6642   }
6643   ret->setCoords(da);
6644   if(name.empty())
6645     ret->setName("Mesh");
6646   else
6647     ret->setName(name);
6648   return ret;
6649 }
6650
6651 /*!
6652  * Creates a new MEDCouplingUMesh by concatenating two given meshes of the same dimension.
6653  * Cells and nodes of
6654  * the first mesh precede cells and nodes of the second mesh within the result mesh.
6655  *  \param [in] mesh1 - the first mesh.
6656  *  \param [in] mesh2 - the second mesh.
6657  *  \return MEDCouplingUMesh * - the result mesh. It is a new instance of
6658  *          MEDCouplingUMesh. The caller is to delete this mesh using decrRef() as it
6659  *          is no more needed.
6660  *  \throw If \a mesh1 == NULL or \a mesh2 == NULL.
6661  *  \throw If the coordinates array is not set in none of the meshes.
6662  *  \throw If \a mesh1->getMeshDimension() < 0 or \a mesh2->getMeshDimension() < 0.
6663  *  \throw If \a mesh1->getMeshDimension() != \a mesh2->getMeshDimension().
6664  */
6665 MEDCouplingUMesh *MEDCouplingUMesh::MergeUMeshes(const MEDCouplingUMesh *mesh1, const MEDCouplingUMesh *mesh2)
6666 {
6667   std::vector<const MEDCouplingUMesh *> tmp(2);
6668   tmp[0]=const_cast<MEDCouplingUMesh *>(mesh1); tmp[1]=const_cast<MEDCouplingUMesh *>(mesh2);
6669   return MergeUMeshes(tmp);
6670 }
6671
6672 /*!
6673  * Creates a new MEDCouplingUMesh by concatenating all given meshes of the same dimension.
6674  * Cells and nodes of
6675  * the *i*-th mesh precede cells and nodes of the (*i*+1)-th mesh within the result mesh.
6676  *  \param [in] a - a vector of meshes (MEDCouplingUMesh) to concatenate.
6677  *  \return MEDCouplingUMesh * - the result mesh. It is a new instance of
6678  *          MEDCouplingUMesh. The caller is to delete this mesh using decrRef() as it
6679  *          is no more needed.
6680  *  \throw If \a a.size() == 0.
6681  *  \throw If \a a[ *i* ] == NULL.
6682  *  \throw If the coordinates array is not set in none of the meshes.
6683  *  \throw If \a a[ *i* ]->getMeshDimension() < 0.
6684  *  \throw If the meshes in \a a are of different dimension (getMeshDimension()).
6685  */
6686 MEDCouplingUMesh *MEDCouplingUMesh::MergeUMeshes(const std::vector<const MEDCouplingUMesh *>& a)
6687 {
6688   std::size_t sz=a.size();
6689   if(sz==0)
6690     return MergeUMeshesLL(a);
6691   for(std::size_t ii=0;ii<sz;ii++)
6692     if(!a[ii])
6693       {
6694         std::ostringstream oss; oss << "MEDCouplingUMesh::MergeUMeshes : item #" << ii << " in input array of size "<< sz << " is empty !";
6695         throw INTERP_KERNEL::Exception(oss.str());
6696       }
6697   std::vector< MCAuto<MEDCouplingUMesh> > bb(sz);
6698   std::vector< const MEDCouplingUMesh * > aa(sz);
6699   int spaceDim=-3;
6700   for(std::size_t i=0;i<sz && spaceDim==-3;i++)
6701     {
6702       const MEDCouplingUMesh *cur=a[i];
6703       const DataArrayDouble *coo=cur->getCoords();
6704       if(coo)
6705         spaceDim=coo->getNumberOfComponents();
6706     }
6707   if(spaceDim==-3)
6708     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::MergeUMeshes : no spaceDim specified ! unable to perform merge !");
6709   for(std::size_t i=0;i<sz;i++)
6710     {
6711       bb[i]=a[i]->buildSetInstanceFromThis(spaceDim);
6712       aa[i]=bb[i];
6713     }
6714   return MergeUMeshesLL(aa);
6715 }
6716
6717 /*!
6718  * Creates a new MEDCouplingUMesh by concatenating cells of two given meshes of same
6719  * dimension and sharing the node coordinates array.
6720  * All cells of the first mesh precede all cells of the second mesh
6721  * within the result mesh.
6722  *  \param [in] mesh1 - the first mesh.
6723  *  \param [in] mesh2 - the second mesh.
6724  *  \return MEDCouplingUMesh * - the result mesh. It is a new instance of
6725  *          MEDCouplingUMesh. The caller is to delete this mesh using decrRef() as it
6726  *          is no more needed.
6727  *  \throw If \a mesh1 == NULL or \a mesh2 == NULL.
6728  *  \throw If the meshes do not share the node coordinates array.
6729  *  \throw If \a mesh1->getMeshDimension() < 0 or \a mesh2->getMeshDimension() < 0.
6730  *  \throw If \a mesh1->getMeshDimension() != \a mesh2->getMeshDimension().
6731  */
6732 MEDCouplingUMesh *MEDCouplingUMesh::MergeUMeshesOnSameCoords(const MEDCouplingUMesh *mesh1, const MEDCouplingUMesh *mesh2)
6733 {
6734   std::vector<const MEDCouplingUMesh *> tmp(2);
6735   tmp[0]=mesh1; tmp[1]=mesh2;
6736   return MergeUMeshesOnSameCoords(tmp);
6737 }
6738
6739 /*!
6740  * Creates a new MEDCouplingUMesh by concatenating cells of all given meshes of same
6741  * dimension and sharing the node coordinates array.
6742  * All cells of the *i*-th mesh precede all cells of the
6743  * (*i*+1)-th mesh within the result mesh.
6744  *  \param [in] meshes - a vector of meshes (MEDCouplingUMesh) to concatenate.
6745  *  \return MEDCouplingUMesh * - the result mesh. It is a new instance of
6746  *          MEDCouplingUMesh. The caller is to delete this mesh using decrRef() as it
6747  *          is no more needed.
6748  *  \throw If \a a.size() == 0.
6749  *  \throw If \a a[ *i* ] == NULL.
6750  *  \throw If the meshes do not share the node coordinates array.
6751  *  \throw If \a a[ *i* ]->getMeshDimension() < 0.
6752  *  \throw If the meshes in \a a are of different dimension (getMeshDimension()).
6753  */
6754 MEDCouplingUMesh *MEDCouplingUMesh::MergeUMeshesOnSameCoords(const std::vector<const MEDCouplingUMesh *>& meshes)
6755 {
6756   if(meshes.empty())
6757     throw INTERP_KERNEL::Exception("meshes input parameter is expected to be non empty.");
6758   for(std::size_t ii=0;ii<meshes.size();ii++)
6759     if(!meshes[ii])
6760       {
6761         std::ostringstream oss; oss << "MEDCouplingUMesh::MergeUMeshesOnSameCoords : item #" << ii << " in input array of size "<< meshes.size() << " is empty !";
6762         throw INTERP_KERNEL::Exception(oss.str());
6763       }
6764   const DataArrayDouble *coords=meshes.front()->getCoords();
6765   int meshDim=meshes.front()->getMeshDimension();
6766   std::vector<const MEDCouplingUMesh *>::const_iterator iter=meshes.begin();
6767   int meshLgth=0;
6768   int meshIndexLgth=0;
6769   for(;iter!=meshes.end();iter++)
6770     {
6771       if(coords!=(*iter)->getCoords())
6772         throw INTERP_KERNEL::Exception("meshes does not share the same coords ! Try using tryToShareSameCoords method !");
6773       if(meshDim!=(*iter)->getMeshDimension())
6774         throw INTERP_KERNEL::Exception("Mesh dimensions mismatches, FuseUMeshesOnSameCoords impossible !");
6775       meshLgth+=(*iter)->getNodalConnectivityArrayLen();
6776       meshIndexLgth+=(*iter)->getNumberOfCells();
6777     }
6778   MCAuto<DataArrayInt> nodal=DataArrayInt::New();
6779   nodal->alloc(meshLgth,1);
6780   int *nodalPtr=nodal->getPointer();
6781   MCAuto<DataArrayInt> nodalIndex=DataArrayInt::New();
6782   nodalIndex->alloc(meshIndexLgth+1,1);
6783   int *nodalIndexPtr=nodalIndex->getPointer();
6784   int offset=0;
6785   for(iter=meshes.begin();iter!=meshes.end();iter++)
6786     {
6787       const int *nod=(*iter)->getNodalConnectivity()->begin();
6788       const int *index=(*iter)->getNodalConnectivityIndex()->begin();
6789       int nbOfCells=(*iter)->getNumberOfCells();
6790       int meshLgth2=(*iter)->getNodalConnectivityArrayLen();
6791       nodalPtr=std::copy(nod,nod+meshLgth2,nodalPtr);
6792       if(iter!=meshes.begin())
6793         nodalIndexPtr=std::transform(index+1,index+nbOfCells+1,nodalIndexPtr,std::bind2nd(std::plus<int>(),offset));
6794       else
6795         nodalIndexPtr=std::copy(index,index+nbOfCells+1,nodalIndexPtr);
6796       offset+=meshLgth2;
6797     }
6798   MEDCouplingUMesh *ret=MEDCouplingUMesh::New();
6799   ret->setName("merge");
6800   ret->setMeshDimension(meshDim);
6801   ret->setConnectivity(nodal,nodalIndex,true);
6802   ret->setCoords(coords);
6803   return ret;
6804 }
6805
6806 /*!
6807  * Creates a new MEDCouplingUMesh by concatenating cells of all given meshes of same
6808  * dimension and sharing the node coordinates array. Cells of the *i*-th mesh precede
6809  * cells of the (*i*+1)-th mesh within the result mesh. Duplicates of cells are
6810  * removed from \a this mesh and arrays mapping between new and old cell ids in "Old to
6811  * New" mode are returned for each input mesh.
6812  *  \param [in] meshes - a vector of meshes (MEDCouplingUMesh) to concatenate.
6813  *  \param [in] compType - specifies a cell comparison technique. For meaning of its
6814  *          valid values [0,1,2], see zipConnectivityTraducer().
6815  *  \param [in,out] corr - an array of DataArrayInt, of the same size as \a
6816  *          meshes. The *i*-th array describes cell ids mapping for \a meshes[ *i* ]
6817  *          mesh. The caller is to delete each of the arrays using decrRef() as it is
6818  *          no more needed.
6819  *  \return MEDCouplingUMesh * - the result mesh. It is a new instance of
6820  *          MEDCouplingUMesh. The caller is to delete this mesh using decrRef() as it
6821  *          is no more needed.
6822  *  \throw If \a meshes.size() == 0.
6823  *  \throw If \a meshes[ *i* ] == NULL.
6824  *  \throw If the meshes do not share the node coordinates array.
6825  *  \throw If \a meshes[ *i* ]->getMeshDimension() < 0.
6826  *  \throw If the \a meshes are of different dimension (getMeshDimension()).
6827  *  \throw If the nodal connectivity of cells of any of \a meshes is not defined.
6828  *  \throw If the nodal connectivity any of \a meshes includes an invalid id.
6829  */
6830 MEDCouplingUMesh *MEDCouplingUMesh::FuseUMeshesOnSameCoords(const std::vector<const MEDCouplingUMesh *>& meshes, int compType, std::vector<DataArrayInt *>& corr)
6831 {
6832   //All checks are delegated to MergeUMeshesOnSameCoords
6833   MCAuto<MEDCouplingUMesh> ret=MergeUMeshesOnSameCoords(meshes);
6834   MCAuto<DataArrayInt> o2n=ret->zipConnectivityTraducer(compType);
6835   corr.resize(meshes.size());
6836   std::size_t nbOfMeshes=meshes.size();
6837   int offset=0;
6838   const int *o2nPtr=o2n->begin();
6839   for(std::size_t i=0;i<nbOfMeshes;i++)
6840     {
6841       DataArrayInt *tmp=DataArrayInt::New();
6842       int curNbOfCells=meshes[i]->getNumberOfCells();
6843       tmp->alloc(curNbOfCells,1);
6844       std::copy(o2nPtr+offset,o2nPtr+offset+curNbOfCells,tmp->getPointer());
6845       offset+=curNbOfCells;
6846       tmp->setName(meshes[i]->getName());
6847       corr[i]=tmp;
6848     }
6849   return ret.retn();
6850 }
6851
6852 /*!
6853  * Makes all given meshes share the nodal connectivity array. The common connectivity
6854  * array is created by concatenating the connectivity arrays of all given meshes. All
6855  * the given meshes must be of the same space dimension but dimension of cells **can
6856  * differ**. This method is particularly useful in MEDLoader context to build a \ref
6857  * MEDCoupling::MEDFileUMesh "MEDFileUMesh" instance that expects that underlying
6858  * MEDCouplingUMesh'es of different dimension share the same nodal connectivity array.
6859  *  \param [in,out] meshes - a vector of meshes to update.
6860  *  \throw If any of \a meshes is NULL.
6861  *  \throw If the coordinates array is not set in any of \a meshes.
6862  *  \throw If the nodal connectivity of cells is not defined in any of \a meshes.
6863  *  \throw If \a meshes are of different space dimension.
6864  */
6865 void MEDCouplingUMesh::PutUMeshesOnSameAggregatedCoords(const std::vector<MEDCouplingUMesh *>& meshes)
6866 {
6867   std::size_t sz=meshes.size();
6868   if(sz==0 || sz==1)
6869     return;
6870   std::vector< const DataArrayDouble * > coords(meshes.size());
6871   std::vector< const DataArrayDouble * >::iterator it2=coords.begin();
6872   for(std::vector<MEDCouplingUMesh *>::const_iterator it=meshes.begin();it!=meshes.end();it++,it2++)
6873     {
6874       if((*it))
6875         {
6876           (*it)->checkConnectivityFullyDefined();
6877           const DataArrayDouble *coo=(*it)->getCoords();
6878           if(coo)
6879             *it2=coo;
6880           else
6881             {
6882               std::ostringstream oss; oss << " MEDCouplingUMesh::PutUMeshesOnSameAggregatedCoords : Item #" << std::distance(meshes.begin(),it) << " inside the vector of length " << meshes.size();
6883               oss << " has no coordinate array defined !";
6884               throw INTERP_KERNEL::Exception(oss.str());
6885             }
6886         }
6887       else
6888         {
6889           std::ostringstream oss; oss << " MEDCouplingUMesh::PutUMeshesOnSameAggregatedCoords : Item #" << std::distance(meshes.begin(),it) << " inside the vector of length " << meshes.size();
6890           oss << " is null !";
6891           throw INTERP_KERNEL::Exception(oss.str());
6892         }
6893     }
6894   MCAuto<DataArrayDouble> res=DataArrayDouble::Aggregate(coords);
6895   std::vector<MEDCouplingUMesh *>::const_iterator it=meshes.begin();
6896   int offset=(*it)->getNumberOfNodes();
6897   (*it++)->setCoords(res);
6898   for(;it!=meshes.end();it++)
6899     {
6900       int oldNumberOfNodes=(*it)->getNumberOfNodes();
6901       (*it)->setCoords(res);
6902       (*it)->shiftNodeNumbersInConn(offset);
6903       offset+=oldNumberOfNodes;
6904     }
6905 }
6906
6907 /*!
6908  * Merges nodes coincident with a given precision within all given meshes that share
6909  * the nodal connectivity array. The given meshes **can be of different** mesh
6910  * dimension. This method is particularly useful in MEDLoader context to build a \ref
6911  * MEDCoupling::MEDFileUMesh "MEDFileUMesh" instance that expects that underlying
6912  * MEDCouplingUMesh'es of different dimension share the same nodal connectivity array. 
6913  *  \param [in,out] meshes - a vector of meshes to update.
6914  *  \param [in] eps - the precision used to detect coincident nodes (infinite norm).
6915  *  \throw If any of \a meshes is NULL.
6916  *  \throw If the \a meshes do not share the same node coordinates array.
6917  *  \throw If the nodal connectivity of cells is not defined in any of \a meshes.
6918  */
6919 void MEDCouplingUMesh::MergeNodesOnUMeshesSharingSameCoords(const std::vector<MEDCouplingUMesh *>& meshes, double eps)
6920 {
6921   if(meshes.empty())
6922     return ;
6923   std::set<const DataArrayDouble *> s;
6924   for(std::vector<MEDCouplingUMesh *>::const_iterator it=meshes.begin();it!=meshes.end();it++)
6925     {
6926       if(*it)
6927         s.insert((*it)->getCoords());
6928       else
6929         {
6930           std::ostringstream oss; oss << "MEDCouplingUMesh::MergeNodesOnUMeshesSharingSameCoords : In input vector of unstructured meshes of size " << meshes.size() << " the element #" << std::distance(meshes.begin(),it) << " is null !";
6931           throw INTERP_KERNEL::Exception(oss.str());
6932         }
6933     }
6934   if(s.size()!=1)
6935     {
6936       std::ostringstream oss; oss << "MEDCouplingUMesh::MergeNodesOnUMeshesSharingSameCoords : In input vector of unstructured meshes of size " << meshes.size() << ", it appears that they do not share the same instance of DataArrayDouble for coordiantes ! tryToShareSameCoordsPermute method can help to reach that !";
6937       throw INTERP_KERNEL::Exception(oss.str());
6938     }
6939   const DataArrayDouble *coo=*(s.begin());
6940   if(!coo)
6941     return;
6942   //
6943   DataArrayInt *comm,*commI;
6944   coo->findCommonTuples(eps,-1,comm,commI);
6945   MCAuto<DataArrayInt> tmp1(comm),tmp2(commI);
6946   int oldNbOfNodes=coo->getNumberOfTuples();
6947   int newNbOfNodes;
6948   MCAuto<DataArrayInt> o2n=DataArrayInt::ConvertIndexArrayToO2N(oldNbOfNodes,comm->begin(),commI->begin(),commI->end(),newNbOfNodes);
6949   if(oldNbOfNodes==newNbOfNodes)
6950     return ;
6951   MCAuto<DataArrayDouble> newCoords=coo->renumberAndReduce(o2n->begin(),newNbOfNodes);
6952   for(std::vector<MEDCouplingUMesh *>::const_iterator it=meshes.begin();it!=meshes.end();it++)
6953     {
6954       (*it)->renumberNodesInConn(o2n->begin());
6955       (*it)->setCoords(newCoords);
6956     } 
6957 }
6958
6959
6960 /*!
6961  * This static operates only for coords in 3D. The polygon is specified by its connectivity nodes in [ \a begin , \a end ).
6962  */
6963 bool MEDCouplingUMesh::IsPolygonWellOriented(bool isQuadratic, const double *vec, const int *begin, const int *end, const double *coords)
6964 {
6965   std::size_t i, ip1;
6966   double v[3]={0.,0.,0.};
6967   std::size_t sz=std::distance(begin,end);
6968   if(isQuadratic)
6969     sz/=2;
6970   for(i=0;i<sz;i++)
6971     {
6972       v[0]+=coords[3*begin[i]+1]*coords[3*begin[(i+1)%sz]+2]-coords[3*begin[i]+2]*coords[3*begin[(i+1)%sz]+1];
6973       v[1]+=coords[3*begin[i]+2]*coords[3*begin[(i+1)%sz]]-coords[3*begin[i]]*coords[3*begin[(i+1)%sz]+2];
6974       v[2]+=coords[3*begin[i]]*coords[3*begin[(i+1)%sz]+1]-coords[3*begin[i]+1]*coords[3*begin[(i+1)%sz]];
6975     }
6976   double ret = vec[0]*v[0]+vec[1]*v[1]+vec[2]*v[2];
6977
6978   // Try using quadratic points if standard points are degenerated (for example a QPOLYG with two
6979   // SEG3 forming a circle):
6980   if (fabs(ret) < INTERP_KERNEL::DEFAULT_ABS_TOL && isQuadratic)
6981     {
6982       v[0] = 0.0; v[1] = 0.0; v[2] = 0.0;
6983       for(std::size_t j=0;j<sz;j++)
6984         {
6985           if (j%2)  // current point i is quadratic, next point i+1 is standard
6986             {
6987               i = sz+j;
6988               ip1 = (j+1)%sz; // ip1 = "i+1"
6989             }
6990           else      // current point i is standard, next point i+1 is quadratic
6991             {
6992               i = j;
6993               ip1 = j+sz;
6994             }
6995           v[0]+=coords[3*begin[i]+1]*coords[3*begin[ip1]+2]-coords[3*begin[i]+2]*coords[3*begin[ip1]+1];
6996           v[1]+=coords[3*begin[i]+2]*coords[3*begin[ip1]]-coords[3*begin[i]]*coords[3*begin[ip1]+2];
6997           v[2]+=coords[3*begin[i]]*coords[3*begin[ip1]+1]-coords[3*begin[i]+1]*coords[3*begin[ip1]];
6998         }
6999       ret = vec[0]*v[0]+vec[1]*v[1]+vec[2]*v[2];
7000     }
7001   return (ret>0.);
7002 }
7003
7004 /*!
7005  * The polyhedron is specified by its connectivity nodes in [ \a begin , \a end ).
7006  */
7007 bool MEDCouplingUMesh::IsPolyhedronWellOriented(const int *begin, const int *end, const double *coords)
7008 {
7009   std::vector<std::pair<int,int> > edges;
7010   std::size_t nbOfFaces=std::count(begin,end,-1)+1;
7011   const int *bgFace=begin;
7012   for(std::size_t i=0;i<nbOfFaces;i++)
7013     {
7014       const int *endFace=std::find(bgFace+1,end,-1);
7015       std::size_t nbOfEdgesInFace=std::distance(bgFace,endFace);
7016       for(std::size_t j=0;j<nbOfEdgesInFace;j++)
7017         {
7018           std::pair<int,int> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
7019           if(std::find(edges.begin(),edges.end(),p1)!=edges.end())
7020             return false;
7021           edges.push_back(p1);
7022         }
7023       bgFace=endFace+1;
7024     }
7025   return INTERP_KERNEL::calculateVolumeForPolyh2<int,INTERP_KERNEL::ALL_C_MODE>(begin,(int)std::distance(begin,end),coords)>-EPS_FOR_POLYH_ORIENTATION;
7026 }
7027
7028 /*!
7029  * The 3D extruded static cell (PENTA6,HEXA8,HEXAGP12...) its connectivity nodes in [ \a begin , \a end ).
7030  */
7031 bool MEDCouplingUMesh::Is3DExtrudedStaticCellWellOriented(const int *begin, const int *end, const double *coords)
7032 {
7033   double vec0[3],vec1[3];
7034   std::size_t sz=std::distance(begin,end);
7035   if(sz%2!=0)
7036     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::Is3DExtrudedStaticCellWellOriented : the length of nodal connectivity of extruded cell is not even !");
7037   int nbOfNodes=(int)sz/2;
7038   INTERP_KERNEL::areaVectorOfPolygon<int,INTERP_KERNEL::ALL_C_MODE>(begin,nbOfNodes,coords,vec0);
7039   const double *pt0=coords+3*begin[0];
7040   const double *pt1=coords+3*begin[nbOfNodes];
7041   vec1[0]=pt1[0]-pt0[0]; vec1[1]=pt1[1]-pt0[1]; vec1[2]=pt1[2]-pt0[2];
7042   return (vec0[0]*vec1[0]+vec0[1]*vec1[1]+vec0[2]*vec1[2])<0.;
7043 }
7044
7045 void MEDCouplingUMesh::CorrectExtrudedStaticCell(int *begin, int *end)
7046 {
7047   std::size_t sz=std::distance(begin,end);
7048   INTERP_KERNEL::AutoPtr<int> tmp=new int[sz];
7049   std::size_t nbOfNodes(sz/2);
7050   std::copy(begin,end,(int *)tmp);
7051   for(std::size_t j=1;j<nbOfNodes;j++)
7052     {
7053       begin[j]=tmp[nbOfNodes-j];
7054       begin[j+nbOfNodes]=tmp[nbOfNodes+nbOfNodes-j];
7055     }
7056 }
7057
7058 bool MEDCouplingUMesh::IsTetra4WellOriented(const int *begin, const int *end, const double *coords)
7059 {
7060   std::size_t sz=std::distance(begin,end);
7061   if(sz!=4)
7062     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::IsTetra4WellOriented : Tetra4 cell with not 4 nodes ! Call checkConsistency !");
7063   double vec0[3],vec1[3];
7064   const double *pt0=coords+3*begin[0],*pt1=coords+3*begin[1],*pt2=coords+3*begin[2],*pt3=coords+3*begin[3];
7065   vec0[0]=pt1[0]-pt0[0]; vec0[1]=pt1[1]-pt0[1]; vec0[2]=pt1[2]-pt0[2]; vec1[0]=pt2[0]-pt0[0]; vec1[1]=pt2[1]-pt0[1]; vec1[2]=pt2[2]-pt0[2]; 
7066   return ((vec0[1]*vec1[2]-vec0[2]*vec1[1])*(pt3[0]-pt0[0])+(vec0[2]*vec1[0]-vec0[0]*vec1[2])*(pt3[1]-pt0[1])+(vec0[0]*vec1[1]-vec0[1]*vec1[0])*(pt3[2]-pt0[2]))<0;
7067 }
7068
7069 bool MEDCouplingUMesh::IsPyra5WellOriented(const int *begin, const int *end, const double *coords)
7070 {
7071   std::size_t sz=std::distance(begin,end);
7072   if(sz!=5)
7073     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::IsPyra5WellOriented : Pyra5 cell with not 5 nodes ! Call checkConsistency !");
7074   double vec0[3];
7075   INTERP_KERNEL::areaVectorOfPolygon<int,INTERP_KERNEL::ALL_C_MODE>(begin,4,coords,vec0);
7076   const double *pt0=coords+3*begin[0],*pt1=coords+3*begin[4];
7077   return (vec0[0]*(pt1[0]-pt0[0])+vec0[1]*(pt1[1]-pt0[1])+vec0[2]*(pt1[2]-pt0[2]))<0.;
7078 }
7079
7080 /*!
7081  * This method performs a simplyfication of a single polyedron cell. To do that each face of cell whose connectivity is defined by [ \b begin , \b end ) 
7082  * is compared with the others in order to find faces in the same plane (with approx of eps). If any, the cells are grouped together and projected to
7083  * a 2D space.
7084  *
7085  * \param [in] eps is a relative precision that allows to establish if some 3D plane are coplanar or not.
7086  * \param [in] coords the coordinates with nb of components exactly equal to 3
7087  * \param [in] begin begin of the nodal connectivity (geometric type included) of a single polyhedron cell
7088  * \param [in] end end of nodal connectivity of a single polyhedron cell (excluded)
7089  * \param [out] res the result is put at the end of the vector without any alteration of the data.
7090  */
7091 void MEDCouplingUMesh::SimplifyPolyhedronCell(double eps, const DataArrayDouble *coords, int index, DataArrayInt *res, MEDCouplingUMesh *faces,
7092                                               DataArrayInt *E_Fi, DataArrayInt *E_F, DataArrayInt *F_Ei, DataArrayInt *F_E)
7093 {
7094   int nbFaces = E_Fi->getIJ(index + 1, 0) - E_Fi->getIJ(index, 0);
7095   MCAuto<DataArrayDouble> v=DataArrayDouble::New(); v->alloc(nbFaces,3);
7096   double *vPtr=v->getPointer();
7097   MCAuto<DataArrayDouble> p=DataArrayDouble::New(); p->alloc(nbFaces,2);
7098   double *pPtr=p->getPointer();
7099   int *e_fi = E_Fi->getPointer(), *e_f = E_F->getPointer(), *f_ei = F_Ei->getPointer(), *f_e = F_E->getPointer();
7100   const int *f_idx = faces->getNodalConnectivityIndex()->getPointer(), *f_cnn = faces->getNodalConnectivity()->getPointer();
7101   for(int i=0;i<nbFaces;i++,vPtr+=3,pPtr++)
7102     {
7103       int face = e_f[e_fi[index] + i];
7104       ComputeVecAndPtOfFace(eps, coords->begin(), f_cnn + f_idx[face] + 1, f_cnn + f_idx[face + 1], vPtr, pPtr);
7105       // to differentiate faces going to different cells:
7106       pPtr++, *pPtr = 0;
7107       for (int j = f_ei[face]; j < f_ei[face + 1]; j++)
7108         *pPtr += f_e[j];
7109     }
7110   pPtr=p->getPointer(); vPtr=v->getPointer();
7111   DataArrayInt *comm1=0,*commI1=0;
7112   v->findCommonTuples(eps,-1,comm1,commI1);
7113   for (int i = 0; i < nbFaces; i++)
7114     if (comm1->findIdFirstEqual(i) < 0)
7115       {
7116         comm1->pushBackSilent(i);
7117         commI1->pushBackSilent(comm1->getNumberOfTuples());
7118       }
7119   MCAuto<DataArrayInt> comm1Auto(comm1),commI1Auto(commI1);
7120   const int *comm1Ptr=comm1->begin();
7121   const int *commI1Ptr=commI1->begin();
7122   int nbOfGrps1=commI1Auto->getNumberOfTuples()-1;
7123   res->pushBackSilent((int)INTERP_KERNEL::NORM_POLYHED);
7124   //
7125   for(int i=0;i<nbOfGrps1;i++)
7126     {
7127       int vecId=comm1Ptr[commI1Ptr[i]];
7128       MCAuto<DataArrayDouble> tmpgrp2=p->selectByTupleId(comm1Ptr+commI1Ptr[i],comm1Ptr+commI1Ptr[i+1]);
7129       DataArrayInt *comm2=0,*commI2=0;
7130       tmpgrp2->findCommonTuples(eps,-1,comm2,commI2);
7131       for (int j = 0; j < commI1Ptr[i+1] - commI1Ptr[i]; j++)
7132         if (comm2->findIdFirstEqual(j) < 0)
7133           {
7134             comm2->pushBackSilent(j);
7135             commI2->pushBackSilent(comm2->getNumberOfTuples());
7136           }
7137       MCAuto<DataArrayInt> comm2Auto(comm2),commI2Auto(commI2);
7138       const int *comm2Ptr=comm2->begin();
7139       const int *commI2Ptr=commI2->begin();
7140       int nbOfGrps2=commI2Auto->getNumberOfTuples()-1;
7141       for(int j=0;j<nbOfGrps2;j++)
7142         {
7143           if(commI2Ptr[j+1] == commI2Ptr[j] + 1)
7144             {
7145               int face = e_f[e_fi[index] + comm1Ptr[commI1Ptr[i] + comm2Ptr[commI2Ptr[j]]]]; //hmmm
7146               res->insertAtTheEnd(f_cnn + f_idx[face] + 1, f_cnn + f_idx[face + 1]);
7147               res->pushBackSilent(-1);
7148             }
7149           else
7150             {
7151               int pointId=comm1Ptr[commI1Ptr[i]+comm2Ptr[commI2Ptr[j]]];
7152               MCAuto<DataArrayInt> ids2=comm2->selectByTupleIdSafeSlice(commI2Ptr[j],commI2Ptr[j+1],1);
7153               ids2->transformWithIndArr(comm1Ptr+commI1Ptr[i],comm1Ptr+commI1Ptr[i+1]);
7154               ids2->transformWithIndArr(e_f + e_fi[index], e_f + e_fi[index + 1]);
7155               MCAuto<MEDCouplingUMesh> mm3=static_cast<MEDCouplingUMesh *>(faces->buildPartOfMySelf(ids2->begin(),ids2->end(),true));
7156               MCAuto<DataArrayInt> idsNodeTmp=mm3->zipCoordsTraducer();
7157               MCAuto<DataArrayInt> idsNode=idsNodeTmp->invertArrayO2N2N2O(mm3->getNumberOfNodes());
7158               const int *idsNodePtr=idsNode->begin();
7159               double center[3]; center[0]=pPtr[2*pointId]*vPtr[3*vecId]; center[1]=pPtr[2*pointId]*vPtr[3*vecId+1]; center[2]=pPtr[2*pointId]*vPtr[3*vecId+2];
7160               double vec[3]; vec[0]=vPtr[3*vecId+1]; vec[1]=-vPtr[3*vecId]; vec[2]=0.;
7161               double norm=vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2];
7162               if(std::abs(norm)>eps)
7163                 {
7164                   double angle=INTERP_KERNEL::EdgeArcCircle::SafeAsin(norm);
7165                   mm3->rotate(center,vec,angle);
7166                 }
7167               mm3->changeSpaceDimension(2);
7168               MCAuto<MEDCouplingUMesh> mm4=mm3->buildSpreadZonesWithPoly();
7169               const int *conn4=mm4->getNodalConnectivity()->begin();
7170               const int *connI4=mm4->getNodalConnectivityIndex()->begin();
7171               int nbOfCells=mm4->getNumberOfCells();
7172               for(int k=0;k<nbOfCells;k++)
7173                 {
7174                   int l=0;
7175                   for(const int *work=conn4+connI4[k]+1;work!=conn4+connI4[k+1];work++,l++)
7176                     res->pushBackSilent(idsNodePtr[*work]);
7177                   res->pushBackSilent(-1);
7178                 }
7179             }
7180         }
7181     }
7182   res->popBackSilent();
7183 }
7184
7185 /*!
7186  * This method computes the normalized vector of the plane and the pos of the point belonging to the plane and the line defined by the vector going
7187  * through origin. The plane is defined by its nodal connectivity [ \b begin, \b end ).
7188  * 
7189  * \param [in] eps below that value the dot product of 2 vectors is considered as colinears
7190  * \param [in] coords coordinates expected to have 3 components.
7191  * \param [in] begin start of the nodal connectivity of the face.
7192  * \param [in] end end of the nodal connectivity (excluded) of the face.
7193  * \param [out] v the normalized vector of size 3
7194  * \param [out] p the pos of plane
7195  */
7196 void MEDCouplingUMesh::ComputeVecAndPtOfFace(double eps, const double *coords, const int *begin, const int *end, double *v, double *p)
7197 {
7198   std::size_t nbPoints=std::distance(begin,end);
7199   if(nbPoints<3)
7200     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeVecAndPtOfFace : < of 3 points in face ! not able to find a plane on that face !");
7201   double vec[3]={0.,0.,0.};
7202   std::size_t j=0;
7203   bool refFound=false;
7204   for(;j<nbPoints-1 && !refFound;j++)
7205     {
7206       vec[0]=coords[3*begin[j+1]]-coords[3*begin[j]];
7207       vec[1]=coords[3*begin[j+1]+1]-coords[3*begin[j]+1];
7208       vec[2]=coords[3*begin[j+1]+2]-coords[3*begin[j]+2];
7209       double norm=sqrt(vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2]);
7210       if(norm>eps)
7211         {
7212           refFound=true;
7213           vec[0]/=norm; vec[1]/=norm; vec[2]/=norm;
7214         }
7215     }
7216   for(std::size_t i=j;i<nbPoints-1;i++)
7217     {
7218       double curVec[3];
7219       curVec[0]=coords[3*begin[i+1]]-coords[3*begin[i]];
7220       curVec[1]=coords[3*begin[i+1]+1]-coords[3*begin[i]+1];
7221       curVec[2]=coords[3*begin[i+1]+2]-coords[3*begin[i]+2];
7222       double norm=sqrt(curVec[0]*curVec[0]+curVec[1]*curVec[1]+curVec[2]*curVec[2]);
7223       if(norm<eps)
7224         continue;
7225       curVec[0]/=norm; curVec[1]/=norm; curVec[2]/=norm;
7226       v[0]=vec[1]*curVec[2]-vec[2]*curVec[1]; v[1]=vec[2]*curVec[0]-vec[0]*curVec[2]; v[2]=vec[0]*curVec[1]-vec[1]*curVec[0];
7227       norm=sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
7228       if(norm>eps)
7229         {
7230           v[0]/=norm; v[1]/=norm; v[2]/=norm;
7231           *p=v[0]*coords[3*begin[i]]+v[1]*coords[3*begin[i]+1]+v[2]*coords[3*begin[i]+2];
7232           return ;
7233         }
7234     }
7235   throw INTERP_KERNEL::Exception("Not able to find a normal vector of that 3D face !");
7236 }
7237
7238 /*!
7239  * This method tries to obtain a well oriented polyhedron.
7240  * If the algorithm fails, an exception will be thrown.
7241  */
7242 void MEDCouplingUMesh::TryToCorrectPolyhedronOrientation(int *begin, int *end, const double *coords)
7243 {
7244   std::list< std::pair<int,int> > edgesOK,edgesFinished;
7245   std::size_t nbOfFaces=std::count(begin,end,-1)+1;
7246   std::vector<bool> isPerm(nbOfFaces,false);//field on faces False: I don't know, True : oriented
7247   isPerm[0]=true;
7248   int *bgFace=begin,*endFace=std::find(begin+1,end,-1);
7249   std::size_t nbOfEdgesInFace=std::distance(bgFace,endFace);
7250   for(std::size_t l=0;l<nbOfEdgesInFace;l++) { std::pair<int,int> p1(bgFace[l],bgFace[(l+1)%nbOfEdgesInFace]); edgesOK.push_back(p1); }
7251   //
7252   while(std::find(isPerm.begin(),isPerm.end(),false)!=isPerm.end())
7253     {
7254       bgFace=begin;
7255       std::size_t smthChanged=0;
7256       for(std::size_t i=0;i<nbOfFaces;i++)
7257         {
7258           endFace=std::find(bgFace+1,end,-1);
7259           nbOfEdgesInFace=std::distance(bgFace,endFace);
7260           if(!isPerm[i])
7261             {
7262               bool b;
7263               for(std::size_t j=0;j<nbOfEdgesInFace;j++)
7264                 {
7265                   std::pair<int,int> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
7266                   std::pair<int,int> p2(p1.second,p1.first);
7267                   bool b1=std::find(edgesOK.begin(),edgesOK.end(),p1)!=edgesOK.end();
7268                   bool b2=std::find(edgesOK.begin(),edgesOK.end(),p2)!=edgesOK.end();
7269                   if(b1 || b2) { b=b2; isPerm[i]=true; smthChanged++; break; }
7270                 }
7271               if(isPerm[i])
7272                 { 
7273                   if(!b)
7274                     std::reverse(bgFace+1,endFace);
7275                   for(std::size_t j=0;j<nbOfEdgesInFace;j++)
7276                     {
7277                       std::pair<int,int> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
7278                       std::pair<int,int> p2(p1.second,p1.first);
7279                       if(std::find(edgesOK.begin(),edgesOK.end(),p1)!=edgesOK.end())
7280                         { std::ostringstream oss; oss << "Face #" << j << " of polyhedron looks bad !"; throw INTERP_KERNEL::Exception(oss.str()); }
7281                       if(std::find(edgesFinished.begin(),edgesFinished.end(),p1)!=edgesFinished.end() || std::find(edgesFinished.begin(),edgesFinished.end(),p2)!=edgesFinished.end())
7282                         { std::ostringstream oss; oss << "Face #" << j << " of polyhedron looks bad !"; throw INTERP_KERNEL::Exception(oss.str()); }
7283                       std::list< std::pair<int,int> >::iterator it=std::find(edgesOK.begin(),edgesOK.end(),p2);
7284                       if(it!=edgesOK.end())
7285                         {
7286                           edgesOK.erase(it);
7287                           edgesFinished.push_back(p1);
7288                         }
7289                       else
7290                         edgesOK.push_back(p1);
7291                     }
7292                 }
7293             }
7294           bgFace=endFace+1;
7295         }
7296       if(smthChanged==0)
7297         { throw INTERP_KERNEL::Exception("The polyhedron looks too bad to be repaired !"); }
7298     }
7299   if(!edgesOK.empty())
7300     { throw INTERP_KERNEL::Exception("The polyhedron looks too bad to be repaired : Some edges are shared only once !"); }
7301   if(INTERP_KERNEL::calculateVolumeForPolyh2<int,INTERP_KERNEL::ALL_C_MODE>(begin,(int)std::distance(begin,end),coords)<-EPS_FOR_POLYH_ORIENTATION)
7302     {//not lucky ! The first face was not correctly oriented : reorient all faces...
7303       bgFace=begin;
7304       for(std::size_t i=0;i<nbOfFaces;i++)
7305         {
7306           endFace=std::find(bgFace+1,end,-1);
7307           std::reverse(bgFace+1,endFace);
7308           bgFace=endFace+1;
7309         }
7310     }
7311 }
7312
7313
7314 /*!
7315  * This method makes the assumption spacedimension == meshdimension == 2.
7316  * This method works only for linear cells.
7317  * 
7318  * \return a newly allocated array containing the connectivity of a polygon type enum included (NORM_POLYGON in pos#0)
7319  */
7320 DataArrayInt *MEDCouplingUMesh::buildUnionOf2DMesh() const
7321 {
7322   if(getMeshDimension()!=2 || getSpaceDimension()!=2)
7323     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildUnionOf2DMesh : meshdimension, spacedimension must be equal to 2 !");
7324   MCAuto<MEDCouplingUMesh> skin(computeSkin());
7325   int oldNbOfNodes(skin->getNumberOfNodes());
7326   MCAuto<DataArrayInt> o2n(skin->zipCoordsTraducer());
7327   int nbOfNodesExpected(skin->getNumberOfNodes());
7328   MCAuto<DataArrayInt> n2o(o2n->invertArrayO2N2N2O(oldNbOfNodes));
7329   int nbCells(skin->getNumberOfCells());
7330   if(nbCells==nbOfNodesExpected)
7331     return buildUnionOf2DMeshLinear(skin,n2o);
7332   else if(2*nbCells==nbOfNodesExpected)
7333     return buildUnionOf2DMeshQuadratic(skin,n2o);
7334   else
7335     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildUnionOf2DMesh : the mesh 2D in input appears to be not in a single part of a 2D mesh !");
7336 }
7337
7338 /*!
7339  * This method makes the assumption spacedimension == meshdimension == 3.
7340  * This method works only for linear cells.
7341  * 
7342  * \return a newly allocated array containing the connectivity of a polygon type enum included (NORM_POLYHED in pos#0)
7343  */
7344 DataArrayInt *MEDCouplingUMesh::buildUnionOf3DMesh() const
7345 {
7346   if(getMeshDimension()!=3 || getSpaceDimension()!=3)
7347     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildUnionOf3DMesh : meshdimension, spacedimension must be equal to 2 !");
7348   MCAuto<MEDCouplingUMesh> m=computeSkin();
7349   const int *conn=m->getNodalConnectivity()->begin();
7350   const int *connI=m->getNodalConnectivityIndex()->begin();
7351   int nbOfCells=m->getNumberOfCells();
7352   MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(m->getNodalConnectivity()->getNumberOfTuples(),1);
7353   int *work=ret->getPointer();  *work++=INTERP_KERNEL::NORM_POLYHED;
7354   if(nbOfCells<1)
7355     return ret.retn();
7356   work=std::copy(conn+connI[0]+1,conn+connI[1],work);
7357   for(int i=1;i<nbOfCells;i++)
7358     {
7359       *work++=-1;
7360       work=std::copy(conn+connI[i]+1,conn+connI[i+1],work);
7361     }
7362   return ret.retn();
7363 }
7364
7365 /*!
7366  * \brief Creates a graph of cell neighbors
7367  *  \return MEDCouplingSkyLineArray * - an sky line array the user should delete.
7368  *  In the sky line array, graph arcs are stored in terms of (index,value) notation.
7369  *  For example
7370  *  - index:  0 3 5 6 6
7371  *  - value:  1 2 3 2 3 3
7372  *  means 6 arcs (0,1), (0,2), (0,3), (1,2), (1,3), (2,3)
7373  *  Arcs are not doubled but reflexive (1,1) arcs are present for each cell
7374  */
7375 MEDCouplingSkyLineArray* MEDCouplingUMesh::generateGraph() const
7376 {
7377   checkConnectivityFullyDefined();
7378
7379   int meshDim = this->getMeshDimension();
7380   MEDCoupling::DataArrayInt* indexr=MEDCoupling::DataArrayInt::New();
7381   MEDCoupling::DataArrayInt* revConn=MEDCoupling::DataArrayInt::New();
7382   this->getReverseNodalConnectivity(revConn,indexr);
7383   const int* indexr_ptr=indexr->begin();
7384   const int* revConn_ptr=revConn->begin();
7385
7386   const MEDCoupling::DataArrayInt* index;
7387   const MEDCoupling::DataArrayInt* conn;
7388   conn=this->getNodalConnectivity(); // it includes a type as the 1st element!!!
7389   index=this->getNodalConnectivityIndex();
7390   int nbCells=this->getNumberOfCells();
7391   const int* index_ptr=index->begin();
7392   const int* conn_ptr=conn->begin();
7393
7394   //creating graph arcs (cell to cell relations)
7395   //arcs are stored in terms of (index,value) notation
7396   // 0 3 5 6 6
7397   // 1 2 3 2 3 3
7398   // means 6 arcs (0,1), (0,2), (0,3), (1,2), (1,3), (2,3)
7399   // in present version arcs are not doubled but reflexive (1,1) arcs are present for each cell
7400
7401   //warning here one node have less than or equal effective number of cell with it
7402   //but cell could have more than effective nodes
7403   //because other equals nodes in other domain (with other global inode)
7404   std::vector <int> cell2cell_index(nbCells+1,0);
7405   std::vector <int> cell2cell;
7406   cell2cell.reserve(3*nbCells);
7407
7408   for (int icell=0; icell<nbCells;icell++)
7409     {
7410       std::map<int,int > counter;
7411       for (int iconn=index_ptr[icell]+1; iconn<index_ptr[icell+1];iconn++)
7412         {
7413           int inode=conn_ptr[iconn];
7414           for (int iconnr=indexr_ptr[inode]; iconnr<indexr_ptr[inode+1];iconnr++)
7415             {
7416               int icell2=revConn_ptr[iconnr];
7417               std::map<int,int>::iterator iter=counter.find(icell2);
7418               if (iter!=counter.end()) (iter->second)++;
7419               else counter.insert(std::make_pair(icell2,1));
7420             }
7421         }
7422       for (std::map<int,int>::const_iterator iter=counter.begin();
7423            iter!=counter.end(); iter++)
7424         if (iter->second >= meshDim)
7425           {
7426             cell2cell_index[icell+1]++;
7427             cell2cell.push_back(iter->first);
7428           }
7429     }
7430   indexr->decrRef();
7431   revConn->decrRef();
7432   cell2cell_index[0]=0;
7433   for (int icell=0; icell<nbCells;icell++)
7434     cell2cell_index[icell+1]=cell2cell_index[icell]+cell2cell_index[icell+1];
7435
7436   //filling up index and value to create skylinearray structure
7437   MEDCouplingSkyLineArray * array(MEDCouplingSkyLineArray::New(cell2cell_index,cell2cell));
7438   return array;
7439 }
7440
7441
7442 void MEDCouplingUMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const
7443 {
7444   int nbOfCells=getNumberOfCells();
7445   if(nbOfCells<=0)
7446     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::writeVTK : the unstructured mesh has no cells !");
7447   ofs << "  <" << getVTKDataSetType() << ">\n";
7448   ofs << "    <Piece NumberOfPoints=\"" << getNumberOfNodes() << "\" NumberOfCells=\"" << nbOfCells << "\">\n";
7449   ofs << "      <PointData>\n" << pointData << std::endl;
7450   ofs << "      </PointData>\n";
7451   ofs << "      <CellData>\n" << cellData << std::endl;
7452   ofs << "      </CellData>\n";
7453   ofs << "      <Points>\n";
7454   if(getSpaceDimension()==3)
7455     _coords->writeVTK(ofs,8,"Points",byteData);
7456   else
7457     {
7458       MCAuto<DataArrayDouble> coo=_coords->changeNbOfComponents(3,0.);
7459       coo->writeVTK(ofs,8,"Points",byteData);
7460     }
7461   ofs << "      </Points>\n";
7462   ofs << "      <Cells>\n";
7463   const int *cPtr=_nodal_connec->begin();
7464   const int *cIPtr=_nodal_connec_index->begin();
7465   MCAuto<DataArrayInt> faceoffsets=DataArrayInt::New(); faceoffsets->alloc(nbOfCells,1);
7466   MCAuto<DataArrayInt> types=DataArrayInt::New(); types->alloc(nbOfCells,1);
7467   MCAuto<DataArrayInt> offsets=DataArrayInt::New(); offsets->alloc(nbOfCells,1);
7468   MCAuto<DataArrayInt> connectivity=DataArrayInt::New(); connectivity->alloc(_nodal_connec->getNumberOfTuples()-nbOfCells,1);
7469   int *w1=faceoffsets->getPointer(),*w2=types->getPointer(),*w3=offsets->getPointer(),*w4=connectivity->getPointer();
7470   int szFaceOffsets=0,szConn=0;
7471   for(int i=0;i<nbOfCells;i++,w1++,w2++,w3++)
7472     {
7473       *w2=cPtr[cIPtr[i]];
7474       if((INTERP_KERNEL::NormalizedCellType)cPtr[cIPtr[i]]!=INTERP_KERNEL::NORM_POLYHED)
7475         {
7476           *w1=-1;
7477           *w3=szConn+cIPtr[i+1]-cIPtr[i]-1; szConn+=cIPtr[i+1]-cIPtr[i]-1;
7478           w4=std::copy(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1],w4);
7479         }
7480       else
7481         {
7482           int deltaFaceOffset=cIPtr[i+1]-cIPtr[i]+1;
7483           *w1=szFaceOffsets+deltaFaceOffset; szFaceOffsets+=deltaFaceOffset;
7484           std::set<int> c(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1]); c.erase(-1);
7485           *w3=szConn+(int)c.size(); szConn+=(int)c.size();
7486           w4=std::copy(c.begin(),c.end(),w4);
7487         }
7488     }
7489   types->transformWithIndArr(MEDCOUPLING2VTKTYPETRADUCER,MEDCOUPLING2VTKTYPETRADUCER+INTERP_KERNEL::NORM_MAXTYPE+1);
7490   types->writeVTK(ofs,8,"UInt8","types",byteData);
7491   offsets->writeVTK(ofs,8,"Int32","offsets",byteData);
7492   if(szFaceOffsets!=0)
7493     {//presence of Polyhedra
7494       connectivity->reAlloc(szConn);
7495       faceoffsets->writeVTK(ofs,8,"Int32","faceoffsets",byteData);
7496       MCAuto<DataArrayInt> faces=DataArrayInt::New(); faces->alloc(szFaceOffsets,1);
7497       w1=faces->getPointer();
7498       for(int i=0;i<nbOfCells;i++)
7499         if((INTERP_KERNEL::NormalizedCellType)cPtr[cIPtr[i]]==INTERP_KERNEL::NORM_POLYHED)
7500           {
7501             int nbFaces=std::count(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1],-1)+1;
7502             *w1++=nbFaces;
7503             const int *w6=cPtr+cIPtr[i]+1,*w5=0;
7504             for(int j=0;j<nbFaces;j++)
7505               {
7506                 w5=std::find(w6,cPtr+cIPtr[i+1],-1);
7507                 *w1++=(int)std::distance(w6,w5);
7508                 w1=std::copy(w6,w5,w1);
7509                 w6=w5+1;
7510               }
7511           }
7512       faces->writeVTK(ofs,8,"Int32","faces",byteData);
7513     }
7514   connectivity->writeVTK(ofs,8,"Int32","connectivity",byteData);
7515   ofs << "      </Cells>\n";
7516   ofs << "    </Piece>\n";
7517   ofs << "  </" << getVTKDataSetType() << ">\n";
7518 }
7519
7520 void MEDCouplingUMesh::reprQuickOverview(std::ostream& stream) const
7521 {
7522   stream << "MEDCouplingUMesh C++ instance at " << this << ". Name : \"" << getName() << "\".";
7523   if(_mesh_dim==-2)
7524     { stream << " Not set !"; return ; }
7525   stream << " Mesh dimension : " << _mesh_dim << ".";
7526   if(_mesh_dim==-1)
7527     return ;
7528   if(!_coords)
7529     { stream << " No coordinates set !"; return ; }
7530   if(!_coords->isAllocated())
7531     { stream << " Coordinates set but not allocated !"; return ; }
7532   stream << " Space dimension : " << _coords->getNumberOfComponents() << "." << std::endl;
7533   stream << "Number of nodes : " << _coords->getNumberOfTuples() << ".";
7534   if(!_nodal_connec_index)
7535     { stream << std::endl << "Nodal connectivity NOT set !"; return ; }
7536   if(!_nodal_connec_index->isAllocated())
7537     { stream << std::endl << "Nodal connectivity set but not allocated !"; return ; }
7538   int lgth=_nodal_connec_index->getNumberOfTuples();
7539   int cpt=_nodal_connec_index->getNumberOfComponents();
7540   if(cpt!=1 || lgth<1)
7541     return ;
7542   stream << std::endl << "Number of cells : " << lgth-1 << ".";
7543 }
7544
7545 std::string MEDCouplingUMesh::getVTKDataSetType() const
7546 {
7547   return std::string("UnstructuredGrid");
7548 }
7549
7550 std::string MEDCouplingUMesh::getVTKFileExtension() const
7551 {
7552   return std::string("vtu");
7553 }
7554
7555
7556
7557 /**
7558  * Provides a renumbering of the cells of this (which has to be a piecewise connected 1D line), so that
7559  * the segments of the line are indexed in consecutive order (i.e. cells \a i and \a i+1 are neighbors).
7560  * This doesn't modify the mesh. This method only works using nodal connectivity consideration. Coordinates of nodes are ignored here.
7561  * The caller is to deal with the resulting DataArrayInt.
7562  *  \throw If the coordinate array is not set.
7563  *  \throw If the nodal connectivity of the cells is not defined.
7564  *  \throw If m1 is not a mesh of dimension 2, or m1 is not a mesh of dimension 1
7565  *  \throw If m2 is not a (piecewise) line (i.e. if a point has more than 2 adjacent segments)
7566  *
7567  * \sa DataArrayInt::sortEachPairToMakeALinkedList
7568  */
7569 DataArrayInt *MEDCouplingUMesh::orderConsecutiveCells1D() const
7570 {
7571   checkFullyDefined();
7572   if(getMeshDimension()!=1)
7573     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::orderConsecutiveCells1D works on unstructured mesh with meshdim = 1 !");
7574
7575   // Check that this is a line (and not a more complex 1D mesh) - each point is used at most by 2 segments:
7576   MCAuto<DataArrayInt> _d(DataArrayInt::New()),_dI(DataArrayInt::New());
7577   MCAuto<DataArrayInt> _rD(DataArrayInt::New()),_rDI(DataArrayInt::New());
7578   MCAuto<MEDCouplingUMesh> m_points(buildDescendingConnectivity(_d, _dI, _rD, _rDI));
7579   const int *d(_d->begin()), *dI(_dI->begin());
7580   const int *rD(_rD->begin()), *rDI(_rDI->begin());
7581   MCAuto<DataArrayInt> _dsi(_rDI->deltaShiftIndex());
7582   const int * dsi(_dsi->begin());
7583   MCAuto<DataArrayInt> dsii = _dsi->findIdsNotInRange(0,3);
7584   m_points=0;
7585   if (dsii->getNumberOfTuples())
7586     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::orderConsecutiveCells1D only work with a mesh being a (piecewise) connected line!");
7587
7588   int nc(getNumberOfCells());
7589   MCAuto<DataArrayInt> result(DataArrayInt::New());
7590   result->alloc(nc,1);
7591
7592   // set of edges not used so far
7593   std::set<int> edgeSet;
7594   for (int i=0; i<nc; edgeSet.insert(i), i++);
7595
7596   int startSeg=0;
7597   int newIdx=0;
7598   // while we have points with only one neighbor segments
7599   do
7600     {
7601       std::list<int> linePiece;
7602       // fills a list of consecutive segment linked to startSeg. This can go forward or backward.
7603       for (int direction=0;direction<2;direction++) // direction=0 --> forward, direction=1 --> backward
7604         {
7605           // Fill the list forward (resp. backward) from the start segment:
7606           int activeSeg = startSeg;
7607           int prevPointId = -20;
7608           int ptId;
7609           while (!edgeSet.empty())
7610             {
7611               if (!(direction == 1 && prevPointId==-20)) // prevent adding twice startSeg
7612                 {
7613                   if (direction==0)
7614                     linePiece.push_back(activeSeg);
7615                   else
7616                     linePiece.push_front(activeSeg);
7617                   edgeSet.erase(activeSeg);
7618                 }
7619
7620               int ptId1 = d[dI[activeSeg]], ptId2 = d[dI[activeSeg]+1];
7621               ptId = direction ? (ptId1 == prevPointId ? ptId2 : ptId1) : (ptId2 == prevPointId ? ptId1 : ptId2);
7622               if (dsi[ptId] == 1) // hitting the end of the line
7623                 break;
7624               prevPointId = ptId;
7625               int seg1 = rD[rDI[ptId]], seg2 = rD[rDI[ptId]+1];
7626               activeSeg = (seg1 == activeSeg) ? seg2 : seg1;
7627             }
7628         }
7629       // Done, save final piece into DA:
7630       std::copy(linePiece.begin(), linePiece.end(), result->getPointer()+newIdx);
7631       newIdx += linePiece.size();
7632
7633       // identify next valid start segment (one which is not consumed)
7634       if(!edgeSet.empty())
7635         startSeg = *(edgeSet.begin());
7636     }
7637   while (!edgeSet.empty());
7638   return result.retn();
7639 }
7640
7641 /**
7642  * This method split some of edges of 2D cells in \a this. The edges to be split are specified in \a subNodesInSeg
7643  * and in \a subNodesInSegI using \ref numbering-indirect storage mode.
7644  * To do the work this method can optionally needs information about middle of subedges for quadratic cases if
7645  * a minimal creation of new nodes is wanted.
7646  * So this method try to reduce at most the number of new nodes. The only case that can lead this method to add
7647  * nodes if a SEG3 is split without information of middle.
7648  * \b WARNING : is returned value is different from 0 a call to MEDCouplingUMesh::mergeNodes is necessary to
7649  * avoid to have a non conform mesh.
7650  *
7651  * \return int - the number of new nodes created (in most of cases 0).
7652  * 
7653  * \throw If \a this is not coherent.
7654  * \throw If \a this has not spaceDim equal to 2.
7655  * \throw If \a this has not meshDim equal to 2.
7656  * \throw If some subcells needed to be split are orphan.
7657  * \sa MEDCouplingUMesh::conformize2D
7658  */
7659 int MEDCouplingUMesh::split2DCells(const DataArrayInt *desc, const DataArrayInt *descI, const DataArrayInt *subNodesInSeg, const DataArrayInt *subNodesInSegI, const DataArrayInt *midOpt, const DataArrayInt *midOptI)
7660 {
7661   if(!desc || !descI || !subNodesInSeg || !subNodesInSegI)
7662     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::split2DCells : the 4 first arrays must be not null !");
7663   desc->checkAllocated(); descI->checkAllocated(); subNodesInSeg->checkAllocated(); subNodesInSegI->checkAllocated();
7664   if(getSpaceDimension()!=2 || getMeshDimension()!=2)
7665     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::split2DCells : This method only works for meshes with spaceDim=2 and meshDim=2 !");
7666   if(midOpt==0 && midOptI==0)
7667     {
7668       split2DCellsLinear(desc,descI,subNodesInSeg,subNodesInSegI);
7669       return 0;
7670     }
7671   else if(midOpt!=0 && midOptI!=0)
7672     return split2DCellsQuadratic(desc,descI,subNodesInSeg,subNodesInSegI,midOpt,midOptI);
7673   else
7674     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::split2DCells : middle parameters must be set to null for all or not null for all.");
7675 }
7676
7677 /*!
7678  * This method compute the convex hull of a single 2D cell. This method tries to conserve at maximum the given input connectivity. In particular, if the orientation of cell is not clockwise
7679  * as in MED format norm. If definitely the result of Jarvis algorithm is not matchable with the input connectivity, the result will be copied into \b nodalConnecOut parameter and
7680  * the geometric cell type set to INTERP_KERNEL::NORM_POLYGON.
7681  * This method excepts that \b coords parameter is expected to be in dimension 2. [ \b nodalConnBg , \b nodalConnEnd ) is the nodal connectivity of the input
7682  * cell (geometric cell type included at the position 0). If the meshdimension of the input cell is not equal to 2 an INTERP_KERNEL::Exception will be thrown.
7683  * 
7684  * \return false if the input connectivity represents already the convex hull, true if the input cell needs to be reordered.
7685  */
7686 bool MEDCouplingUMesh::BuildConvexEnvelopOf2DCellJarvis(const double *coords, const int *nodalConnBg, const int *nodalConnEnd, DataArrayInt *nodalConnecOut)
7687 {
7688   std::size_t sz=std::distance(nodalConnBg,nodalConnEnd);
7689   if(sz>=4)
7690     {
7691       const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)*nodalConnBg);
7692       if(cm.getDimension()==2)
7693         {
7694           const int *node=nodalConnBg+1;
7695           int startNode=*node++;
7696           double refX=coords[2*startNode];
7697           for(;node!=nodalConnEnd;node++)
7698             {
7699               if(coords[2*(*node)]<refX)
7700                 {
7701                   startNode=*node;
7702                   refX=coords[2*startNode];
7703                 }
7704             }
7705           std::vector<int> tmpOut; tmpOut.reserve(sz); tmpOut.push_back(startNode);
7706           refX=1e300;
7707           double tmp1;
7708           double tmp2[2];
7709           double angle0=-M_PI/2;
7710           //
7711           int nextNode=-1;
7712           int prevNode=-1;
7713           double resRef;
7714           double angleNext=0.;
7715           while(nextNode!=startNode)
7716             {
7717               nextNode=-1;
7718               resRef=1e300;
7719               for(node=nodalConnBg+1;node!=nodalConnEnd;node++)
7720                 {
7721                   if(*node!=tmpOut.back() && *node!=prevNode)
7722                     {
7723                       tmp2[0]=coords[2*(*node)]-coords[2*tmpOut.back()]; tmp2[1]=coords[2*(*node)+1]-coords[2*tmpOut.back()+1];
7724                       double angleM=INTERP_KERNEL::EdgeArcCircle::GetAbsoluteAngle(tmp2,tmp1);
7725                       double res;
7726                       if(angleM<=angle0)
7727                         res=angle0-angleM;
7728                       else
7729                         res=angle0-angleM+2.*M_PI;
7730                       if(res<resRef)
7731                         {
7732                           nextNode=*node;
7733                           resRef=res;
7734                           angleNext=angleM;
7735                         }
7736                     }
7737                 }
7738               if(nextNode!=startNode)
7739                 {
7740                   angle0=angleNext-M_PI;
7741                   if(angle0<-M_PI)
7742                     angle0+=2*M_PI;
7743                   prevNode=tmpOut.back();
7744                   tmpOut.push_back(nextNode);
7745                 }
7746             }
7747           std::vector<int> tmp3(2*(sz-1));
7748           std::vector<int>::iterator it=std::copy(nodalConnBg+1,nodalConnEnd,tmp3.begin());
7749           std::copy(nodalConnBg+1,nodalConnEnd,it);
7750           if(std::search(tmp3.begin(),tmp3.end(),tmpOut.begin(),tmpOut.end())!=tmp3.end())
7751             {
7752               nodalConnecOut->insertAtTheEnd(nodalConnBg,nodalConnEnd);
7753               return false;
7754             }
7755           if(std::search(tmp3.rbegin(),tmp3.rend(),tmpOut.begin(),tmpOut.end())!=tmp3.rend())
7756             {
7757               nodalConnecOut->insertAtTheEnd(nodalConnBg,nodalConnEnd);
7758               return false;
7759             }
7760           else
7761             {
7762               nodalConnecOut->pushBackSilent((int)INTERP_KERNEL::NORM_POLYGON);
7763               nodalConnecOut->insertAtTheEnd(tmpOut.begin(),tmpOut.end());
7764               return true;
7765             }
7766         }
7767       else
7768         throw INTERP_KERNEL::Exception("MEDCouplingUMesh::BuildConvexEnvelopOf2DCellJarvis : invalid 2D cell connectivity !");
7769     }
7770   else
7771     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::BuildConvexEnvelopOf2DCellJarvis : invalid 2D cell connectivity !");
7772 }
7773
7774 /*!
7775  * This method works on an input pair (\b arr, \b arrIndx) where \b arr indexes is in \b arrIndx.
7776  * This method will not impact the size of inout parameter \b arrIndx but the size of \b arr will be modified in case of suppression.
7777  * 
7778  * \param [in] idsToRemoveBg begin of set of ids to remove in \b arr (included)
7779  * \param [in] idsToRemoveEnd end of set of ids to remove in \b arr (excluded)
7780  * \param [in,out] arr array in which the remove operation will be done.
7781  * \param [in,out] arrIndx array in the remove operation will modify
7782  * \param [in] offsetForRemoval (by default 0) offset so that for each i in [0,arrIndx->getNumberOfTuples()-1) removal process will be performed in the following range [arr+arrIndx[i]+offsetForRemoval,arr+arr[i+1])
7783  * \return true if \b arr and \b arrIndx have been modified, false if not.
7784  */
7785 bool MEDCouplingUMesh::RemoveIdsFromIndexedArrays(const int *idsToRemoveBg, const int *idsToRemoveEnd, DataArrayInt *arr, DataArrayInt *arrIndx, int offsetForRemoval)
7786 {
7787   if(!arrIndx || !arr)
7788     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::RemoveIdsFromIndexedArrays : some input arrays are empty !");
7789   if(offsetForRemoval<0)
7790     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::RemoveIdsFromIndexedArrays : offsetForRemoval should be >=0 !");
7791   std::set<int> s(idsToRemoveBg,idsToRemoveEnd);
7792   int nbOfGrps=arrIndx->getNumberOfTuples()-1;
7793   int *arrIPtr=arrIndx->getPointer();
7794   *arrIPtr++=0;
7795   int previousArrI=0;
7796   const int *arrPtr=arr->begin();
7797   std::vector<int> arrOut;//no utility to switch to DataArrayInt because copy always needed
7798   for(int i=0;i<nbOfGrps;i++,arrIPtr++)
7799     {
7800       if(*arrIPtr-previousArrI>offsetForRemoval)
7801         {
7802           for(const int *work=arrPtr+previousArrI+offsetForRemoval;work!=arrPtr+*arrIPtr;work++)
7803             {
7804               if(s.find(*work)==s.end())
7805                 arrOut.push_back(*work);
7806             }
7807         }
7808       previousArrI=*arrIPtr;
7809       *arrIPtr=(int)arrOut.size();
7810     }
7811   if(arr->getNumberOfTuples()==arrOut.size())
7812     return false;
7813   arr->alloc((int)arrOut.size(),1);
7814   std::copy(arrOut.begin(),arrOut.end(),arr->getPointer());
7815   return true;
7816 }
7817
7818 /*!
7819  * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn
7820  * (\ref numbering-indirect).
7821  * This method returns the result of the extraction ( specified by a set of ids in [\b idsOfSelectBg , \b idsOfSelectEnd ) ).
7822  * The selection of extraction is done standardly in new2old format.
7823  * This method returns indexed arrays (\ref numbering-indirect) using 2 arrays (arrOut,arrIndexOut).
7824  *
7825  * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
7826  * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
7827  * \param [in] arrIn arr origin array from which the extraction will be done.
7828  * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
7829  * \param [out] arrOut the resulting array
7830  * \param [out] arrIndexOut the index array of the resulting array \b arrOut
7831  * \sa MEDCouplingUMesh::ExtractFromIndexedArraysSlice
7832  */
7833 void MEDCouplingUMesh::ExtractFromIndexedArrays(const int *idsOfSelectBg, const int *idsOfSelectEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
7834                                                 DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
7835 {
7836   if(!arrIn || !arrIndxIn)
7837     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArrays : input pointer is NULL !");
7838   arrIn->checkAllocated(); arrIndxIn->checkAllocated();
7839   if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
7840     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArrays : input arrays must have exactly one component !");
7841   std::size_t sz=std::distance(idsOfSelectBg,idsOfSelectEnd);
7842   const int *arrInPtr=arrIn->begin();
7843   const int *arrIndxPtr=arrIndxIn->begin();
7844   int nbOfGrps=arrIndxIn->getNumberOfTuples()-1;
7845   if(nbOfGrps<0)
7846     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArrays : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
7847   int maxSizeOfArr=arrIn->getNumberOfTuples();
7848   MCAuto<DataArrayInt> arro=DataArrayInt::New();
7849   MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
7850   arrIo->alloc((int)(sz+1),1);
7851   const int *idsIt=idsOfSelectBg;
7852   int *work=arrIo->getPointer();
7853   *work++=0;
7854   int lgth=0;
7855   for(std::size_t i=0;i<sz;i++,work++,idsIt++)
7856     {
7857       if(*idsIt>=0 && *idsIt<nbOfGrps)
7858         lgth+=arrIndxPtr[*idsIt+1]-arrIndxPtr[*idsIt];
7859       else
7860         {
7861           std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " ! Must be in [0," << nbOfGrps << ") !";
7862           throw INTERP_KERNEL::Exception(oss.str());
7863         }
7864       if(lgth>=work[-1])
7865         *work=lgth;
7866       else
7867         {
7868           std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " and at this pos arrIndxIn[" << *idsIt;
7869           oss << "+1]-arrIndxIn[" << *idsIt << "] < 0 ! The input index array is bugged !";
7870           throw INTERP_KERNEL::Exception(oss.str());
7871         }
7872     }
7873   arro->alloc(lgth,1);
7874   work=arro->getPointer();
7875   idsIt=idsOfSelectBg;
7876   for(std::size_t i=0;i<sz;i++,idsIt++)
7877     {
7878       if(arrIndxPtr[*idsIt]>=0 && arrIndxPtr[*idsIt+1]<=maxSizeOfArr)
7879         work=std::copy(arrInPtr+arrIndxPtr[*idsIt],arrInPtr+arrIndxPtr[*idsIt+1],work);
7880       else
7881         {
7882           std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " arrIndx[" << *idsIt << "] must be >= 0 and arrIndx[";
7883           oss << *idsIt << "+1] <= " << maxSizeOfArr << " (the size of arrIn)!";
7884           throw INTERP_KERNEL::Exception(oss.str());
7885         }
7886     }
7887   arrOut=arro.retn();
7888   arrIndexOut=arrIo.retn();
7889 }
7890
7891 /*!
7892  * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn
7893  * (\ref numbering-indirect).
7894  * This method returns the result of the extraction ( specified by a set of ids with a slice given by \a idsOfSelectStart, \a idsOfSelectStop and \a idsOfSelectStep ).
7895  * The selection of extraction is done standardly in new2old format.
7896  * This method returns indexed arrays (\ref numbering-indirect) using 2 arrays (arrOut,arrIndexOut).
7897  *
7898  * \param [in] idsOfSelectStart begin of set of ids of the input extraction (included)
7899  * \param [in] idsOfSelectStop end of set of ids of the input extraction (excluded)
7900  * \param [in] idsOfSelectStep
7901  * \param [in] arrIn arr origin array from which the extraction will be done.
7902  * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
7903  * \param [out] arrOut the resulting array
7904  * \param [out] arrIndexOut the index array of the resulting array \b arrOut
7905  * \sa MEDCouplingUMesh::ExtractFromIndexedArrays
7906  */
7907 void MEDCouplingUMesh::ExtractFromIndexedArraysSlice(int idsOfSelectStart, int idsOfSelectStop, int idsOfSelectStep, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
7908                                                  DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
7909 {
7910   if(!arrIn || !arrIndxIn)
7911     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArraysSlice : input pointer is NULL !");
7912   arrIn->checkAllocated(); arrIndxIn->checkAllocated();
7913   if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
7914     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArraysSlice : input arrays must have exactly one component !");
7915   int sz=DataArrayInt::GetNumberOfItemGivenBESRelative(idsOfSelectStart,idsOfSelectStop,idsOfSelectStep,"MEDCouplingUMesh::ExtractFromIndexedArraysSlice : Input slice ");
7916   const int *arrInPtr=arrIn->begin();
7917   const int *arrIndxPtr=arrIndxIn->begin();
7918   int nbOfGrps=arrIndxIn->getNumberOfTuples()-1;
7919   if(nbOfGrps<0)
7920     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArraysSlice : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
7921   int maxSizeOfArr=arrIn->getNumberOfTuples();
7922   MCAuto<DataArrayInt> arro=DataArrayInt::New();
7923   MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
7924   arrIo->alloc((int)(sz+1),1);
7925   int idsIt=idsOfSelectStart;
7926   int *work=arrIo->getPointer();
7927   *work++=0;
7928   int lgth=0;
7929   for(int i=0;i<sz;i++,work++,idsIt+=idsOfSelectStep)
7930     {
7931       if(idsIt>=0 && idsIt<nbOfGrps)
7932         lgth+=arrIndxPtr[idsIt+1]-arrIndxPtr[idsIt];
7933       else
7934         {
7935           std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " ! Must be in [0," << nbOfGrps << ") !";
7936           throw INTERP_KERNEL::Exception(oss.str());
7937         }
7938       if(lgth>=work[-1])
7939         *work=lgth;
7940       else
7941         {
7942           std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " and at this pos arrIndxIn[" << idsIt;
7943           oss << "+1]-arrIndxIn[" << idsIt << "] < 0 ! The input index array is bugged !";
7944           throw INTERP_KERNEL::Exception(oss.str());
7945         }
7946     }
7947   arro->alloc(lgth,1);
7948   work=arro->getPointer();
7949   idsIt=idsOfSelectStart;
7950   for(int i=0;i<sz;i++,idsIt+=idsOfSelectStep)
7951     {
7952       if(arrIndxPtr[idsIt]>=0 && arrIndxPtr[idsIt+1]<=maxSizeOfArr)
7953         work=std::copy(arrInPtr+arrIndxPtr[idsIt],arrInPtr+arrIndxPtr[idsIt+1],work);
7954       else
7955         {
7956           std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " arrIndx[" << idsIt << "] must be >= 0 and arrIndx[";
7957           oss << idsIt << "+1] <= " << maxSizeOfArr << " (the size of arrIn)!";
7958           throw INTERP_KERNEL::Exception(oss.str());
7959         }
7960     }
7961   arrOut=arro.retn();
7962   arrIndexOut=arrIo.retn();
7963 }
7964
7965 /*!
7966  * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
7967  * This method builds an output pair (\b arrOut,\b arrIndexOut) that is a copy from \b arrIn for all cell ids \b not \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) and for
7968  * cellIds \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) a copy coming from the corresponding values in input pair (\b srcArr, \b srcArrIndex).
7969  * This method is an generalization of MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx that performs the same thing but by without building explicitly a result output arrays.
7970  *
7971  * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
7972  * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
7973  * \param [in] arrIn arr origin array from which the extraction will be done.
7974  * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
7975  * \param [in] srcArr input array that will be used as source of copy for ids in [ \b idsOfSelectBg, \b idsOfSelectEnd )
7976  * \param [in] srcArrIndex index array of \b srcArr
7977  * \param [out] arrOut the resulting array
7978  * \param [out] arrIndexOut the index array of the resulting array \b arrOut
7979  * 
7980  * \sa MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx
7981  */
7982 void MEDCouplingUMesh::SetPartOfIndexedArrays(const int *idsOfSelectBg, const int *idsOfSelectEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
7983                                               const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex,
7984                                               DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
7985 {
7986   if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
7987     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArrays : presence of null pointer in input parameter !");
7988   MCAuto<DataArrayInt> arro=DataArrayInt::New();
7989   MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
7990   int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
7991   std::vector<bool> v(nbOfTuples,true);
7992   int offset=0;
7993   const int *arrIndxInPtr=arrIndxIn->begin();
7994   const int *srcArrIndexPtr=srcArrIndex->begin();
7995   for(const int *it=idsOfSelectBg;it!=idsOfSelectEnd;it++,srcArrIndexPtr++)
7996     {
7997       if(*it>=0 && *it<nbOfTuples)
7998         {
7999           v[*it]=false;
8000           offset+=(srcArrIndexPtr[1]-srcArrIndexPtr[0])-(arrIndxInPtr[*it+1]-arrIndxInPtr[*it]);
8001         }
8002       else
8003         {
8004           std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArrays : On pos #" << std::distance(idsOfSelectBg,it) << " value is " << *it << " not in [0," << nbOfTuples << ") !";
8005           throw INTERP_KERNEL::Exception(oss.str());
8006         }
8007     }
8008   srcArrIndexPtr=srcArrIndex->begin();
8009   arrIo->alloc(nbOfTuples+1,1);
8010   arro->alloc(arrIn->getNumberOfTuples()+offset,1);
8011   const int *arrInPtr=arrIn->begin();
8012   const int *srcArrPtr=srcArr->begin();
8013   int *arrIoPtr=arrIo->getPointer(); *arrIoPtr++=0;
8014   int *arroPtr=arro->getPointer();
8015   for(int ii=0;ii<nbOfTuples;ii++,arrIoPtr++)
8016     {
8017       if(v[ii])
8018         {
8019           arroPtr=std::copy(arrInPtr+arrIndxInPtr[ii],arrInPtr+arrIndxInPtr[ii+1],arroPtr);
8020           *arrIoPtr=arrIoPtr[-1]+(arrIndxInPtr[ii+1]-arrIndxInPtr[ii]);
8021         }
8022       else
8023         {
8024           std::size_t pos=std::distance(idsOfSelectBg,std::find(idsOfSelectBg,idsOfSelectEnd,ii));
8025           arroPtr=std::copy(srcArrPtr+srcArrIndexPtr[pos],srcArrPtr+srcArrIndexPtr[pos+1],arroPtr);
8026           *arrIoPtr=arrIoPtr[-1]+(srcArrIndexPtr[pos+1]-srcArrIndexPtr[pos]);
8027         }
8028     }
8029   arrOut=arro.retn();
8030   arrIndexOut=arrIo.retn();
8031 }
8032
8033 /*!
8034  * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
8035  * This method is an specialization of MEDCouplingUMesh::SetPartOfIndexedArrays in the case of assignment do not modify the index in \b arrIndxIn.
8036  *
8037  * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
8038  * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
8039  * \param [in,out] arrInOut arr origin array from which the extraction will be done.
8040  * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
8041  * \param [in] srcArr input array that will be used as source of copy for ids in [ \b idsOfSelectBg , \b idsOfSelectEnd )
8042  * \param [in] srcArrIndex index array of \b srcArr
8043  * 
8044  * \sa MEDCouplingUMesh::SetPartOfIndexedArrays
8045  */
8046 void MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx(const int *idsOfSelectBg, const int *idsOfSelectEnd, DataArrayInt *arrInOut, const DataArrayInt *arrIndxIn,
8047                                                      const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex)
8048 {
8049   if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
8050     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx : presence of null pointer in input parameter !");
8051   int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
8052   const int *arrIndxInPtr=arrIndxIn->begin();
8053   const int *srcArrIndexPtr=srcArrIndex->begin();
8054   int *arrInOutPtr=arrInOut->getPointer();
8055   const int *srcArrPtr=srcArr->begin();
8056   for(const int *it=idsOfSelectBg;it!=idsOfSelectEnd;it++,srcArrIndexPtr++)
8057     {
8058       if(*it>=0 && *it<nbOfTuples)
8059         {
8060           if(srcArrIndexPtr[1]-srcArrIndexPtr[0]==arrIndxInPtr[*it+1]-arrIndxInPtr[*it])
8061             std::copy(srcArrPtr+srcArrIndexPtr[0],srcArrPtr+srcArrIndexPtr[1],arrInOutPtr+arrIndxInPtr[*it]);
8062           else
8063             {
8064               std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx : On pos #" << std::distance(idsOfSelectBg,it) << " id (idsOfSelectBg[" << std::distance(idsOfSelectBg,it)<< "]) is " << *it << " arrIndxIn[id+1]-arrIndxIn[id]!=srcArrIndex[pos+1]-srcArrIndex[pos] !";
8065               throw INTERP_KERNEL::Exception(oss.str());
8066             }
8067         }
8068       else
8069         {
8070           std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx : On pos #" << std::distance(idsOfSelectBg,it) << " value is " << *it << " not in [0," << nbOfTuples << ") !";
8071           throw INTERP_KERNEL::Exception(oss.str());
8072         }
8073     }
8074 }
8075
8076 /*!
8077  * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arr indexes is in \b arrIndxIn.
8078  * This method expects that these two input arrays come from the output of MEDCouplingUMesh::computeNeighborsOfCells method.
8079  * This method start from id 0 that will be contained in output DataArrayInt. It searches then all neighbors of id0 looking at arrIn[arrIndxIn[0]:arrIndxIn[0+1]].
8080  * Then it is repeated recursively until either all ids are fetched or no more ids are reachable step by step.
8081  * A negative value in \b arrIn means that it is ignored.
8082  * This method is useful to see if a mesh is contiguous regarding its connectivity. If it is not the case the size of returned array is different from arrIndxIn->getNumberOfTuples()-1.
8083  * 
8084  * \param [in] arrIn arr origin array from which the extraction will be done.
8085  * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
8086  * \return a newly allocated DataArray that stores all ids fetched by the gradually spread process.
8087  * \sa MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed, MEDCouplingUMesh::partitionBySpreadZone
8088  */
8089 DataArrayInt *MEDCouplingUMesh::ComputeSpreadZoneGradually(const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn)
8090 {
8091   int seed=0,nbOfDepthPeelingPerformed=0;
8092   return ComputeSpreadZoneGraduallyFromSeed(&seed,&seed+1,arrIn,arrIndxIn,-1,nbOfDepthPeelingPerformed);
8093 }
8094
8095 /*!
8096  * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arr indexes is in \b arrIndxIn.
8097  * This method expects that these two input arrays come from the output of MEDCouplingUMesh::computeNeighborsOfCells method.
8098  * This method start from id 0 that will be contained in output DataArrayInt. It searches then all neighbors of id0 regarding arrIn[arrIndxIn[0]:arrIndxIn[0+1]].
8099  * Then it is repeated recursively until either all ids are fetched or no more ids are reachable step by step.
8100  * A negative value in \b arrIn means that it is ignored.
8101  * This method is useful to see if a mesh is contiguous regarding its connectivity. If it is not the case the size of returned array is different from arrIndxIn->getNumberOfTuples()-1.
8102  * \param [in] seedBg the begin pointer (included) of an array containing the seed of the search zone
8103  * \param [in] seedEnd the end pointer (not included) of an array containing the seed of the search zone
8104  * \param [in] arrIn arr origin array from which the extraction will be done.
8105  * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
8106  * \param [in] nbOfDepthPeeling the max number of peels requested in search. By default -1, that is to say, no limit.
8107  * \param [out] nbOfDepthPeelingPerformed the number of peels effectively performed. May be different from \a nbOfDepthPeeling
8108  * \return a newly allocated DataArray that stores all ids fetched by the gradually spread process.
8109  * \sa MEDCouplingUMesh::partitionBySpreadZone
8110  */
8111 DataArrayInt *MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(const int *seedBg, const int *seedEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn, int nbOfDepthPeeling, int& nbOfDepthPeelingPerformed)
8112 {
8113   nbOfDepthPeelingPerformed=0;
8114   if(!arrIndxIn)
8115     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed : arrIndxIn input pointer is NULL !");
8116   int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
8117   if(nbOfTuples<=0)
8118     {
8119       DataArrayInt *ret=DataArrayInt::New(); ret->alloc(0,1);
8120       return ret;
8121     }
8122   //
8123   std::vector<bool> fetched(nbOfTuples,false);
8124   return ComputeSpreadZoneGraduallyFromSeedAlg(fetched,seedBg,seedEnd,arrIn,arrIndxIn,nbOfDepthPeeling,nbOfDepthPeelingPerformed);
8125 }
8126
8127
8128 /*!
8129  * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
8130  * This method builds an output pair (\b arrOut,\b arrIndexOut) that is a copy from \b arrIn for all cell ids \b not \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) and for
8131  * cellIds \b in [\b idsOfSelectBg, \b idsOfSelectEnd) a copy coming from the corresponding values in input pair (\b srcArr, \b srcArrIndex).
8132  * This method is an generalization of MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx that performs the same thing but by without building explicitly a result output arrays.
8133  *
8134  * \param [in] start begin of set of ids of the input extraction (included)
8135  * \param [in] end end of set of ids of the input extraction (excluded)
8136  * \param [in] step step of the set of ids in range mode.
8137  * \param [in] arrIn arr origin array from which the extraction will be done.
8138  * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
8139  * \param [in] srcArr input array that will be used as source of copy for ids in [\b idsOfSelectBg, \b idsOfSelectEnd)
8140  * \param [in] srcArrIndex index array of \b srcArr
8141  * \param [out] arrOut the resulting array
8142  * \param [out] arrIndexOut the index array of the resulting array \b arrOut
8143  * 
8144  * \sa MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx MEDCouplingUMesh::SetPartOfIndexedArrays
8145  */
8146 void MEDCouplingUMesh::SetPartOfIndexedArraysSlice(int start, int end, int step, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
8147                                                const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex,
8148                                                DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
8149 {
8150   if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
8151     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArraysSlice : presence of null pointer in input parameter !");
8152   MCAuto<DataArrayInt> arro=DataArrayInt::New();
8153   MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
8154   int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
8155   int offset=0;
8156   const int *arrIndxInPtr=arrIndxIn->begin();
8157   const int *srcArrIndexPtr=srcArrIndex->begin();
8158   int nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::SetPartOfIndexedArraysSlice : ");
8159   int it=start;
8160   for(int i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
8161     {
8162       if(it>=0 && it<nbOfTuples)
8163         offset+=(srcArrIndexPtr[1]-srcArrIndexPtr[0])-(arrIndxInPtr[it+1]-arrIndxInPtr[it]);
8164       else
8165         {
8166           std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSlice : On pos #" << i << " value is " << it << " not in [0," << nbOfTuples << ") !";
8167           throw INTERP_KERNEL::Exception(oss.str());
8168         }
8169     }
8170   srcArrIndexPtr=srcArrIndex->begin();
8171   arrIo->alloc(nbOfTuples+1,1);
8172   arro->alloc(arrIn->getNumberOfTuples()+offset,1);
8173   const int *arrInPtr=arrIn->begin();
8174   const int *srcArrPtr=srcArr->begin();
8175   int *arrIoPtr=arrIo->getPointer(); *arrIoPtr++=0;
8176   int *arroPtr=arro->getPointer();
8177   for(int ii=0;ii<nbOfTuples;ii++,arrIoPtr++)
8178     {
8179       int pos=DataArray::GetPosOfItemGivenBESRelativeNoThrow(ii,start,end,step);
8180       if(pos<0)
8181         {
8182           arroPtr=std::copy(arrInPtr+arrIndxInPtr[ii],arrInPtr+arrIndxInPtr[ii+1],arroPtr);
8183           *arrIoPtr=arrIoPtr[-1]+(arrIndxInPtr[ii+1]-arrIndxInPtr[ii]);
8184         }
8185       else
8186         {
8187           arroPtr=std::copy(srcArrPtr+srcArrIndexPtr[pos],srcArrPtr+srcArrIndexPtr[pos+1],arroPtr);
8188           *arrIoPtr=arrIoPtr[-1]+(srcArrIndexPtr[pos+1]-srcArrIndexPtr[pos]);
8189         }
8190     }
8191   arrOut=arro.retn();
8192   arrIndexOut=arrIo.retn();
8193 }
8194
8195 /*!
8196  * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
8197  * This method is an specialization of MEDCouplingUMesh::SetPartOfIndexedArrays in the case of assignment do not modify the index in \b arrIndxIn.
8198  *
8199  * \param [in] start begin of set of ids of the input extraction (included)
8200  * \param [in] end end of set of ids of the input extraction (excluded)
8201  * \param [in] step step of the set of ids in range mode.
8202  * \param [in,out] arrInOut arr origin array from which the extraction will be done.
8203  * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
8204  * \param [in] srcArr input array that will be used as source of copy for ids in [\b idsOfSelectBg, \b idsOfSelectEnd)
8205  * \param [in] srcArrIndex index array of \b srcArr
8206  * 
8207  * \sa MEDCouplingUMesh::SetPartOfIndexedArraysSlice MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx
8208  */
8209 void MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice(int start, int end, int step, DataArrayInt *arrInOut, const DataArrayInt *arrIndxIn,
8210                                                       const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex)
8211 {
8212   if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
8213     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice : presence of null pointer in input parameter !");
8214   int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
8215   const int *arrIndxInPtr=arrIndxIn->begin();
8216   const int *srcArrIndexPtr=srcArrIndex->begin();
8217   int *arrInOutPtr=arrInOut->getPointer();
8218   const int *srcArrPtr=srcArr->begin();
8219   int nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice : ");
8220   int it=start;
8221   for(int i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
8222     {
8223       if(it>=0 && it<nbOfTuples)
8224         {
8225           if(srcArrIndexPtr[1]-srcArrIndexPtr[0]==arrIndxInPtr[it+1]-arrIndxInPtr[it])
8226             std::copy(srcArrPtr+srcArrIndexPtr[0],srcArrPtr+srcArrIndexPtr[1],arrInOutPtr+arrIndxInPtr[it]);
8227           else
8228             {
8229               std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice : On pos #" << i << " id (idsOfSelectBg[" << i << "]) is " << it << " arrIndxIn[id+1]-arrIndxIn[id]!=srcArrIndex[pos+1]-srcArrIndex[pos] !";
8230               throw INTERP_KERNEL::Exception(oss.str());
8231             }
8232         }
8233       else
8234         {
8235           std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice : On pos #" << i << " value is " << it << " not in [0," << nbOfTuples << ") !";
8236           throw INTERP_KERNEL::Exception(oss.str());
8237         }
8238     }
8239 }
8240
8241 /*!
8242  * \b this is expected to be a mesh fully defined whose spaceDim==meshDim.
8243  * It returns a new allocated mesh having the same mesh dimension and lying on same coordinates.
8244  * The returned mesh contains as poly cells as number of contiguous zone (regarding connectivity).
8245  * A spread contiguous zone is built using poly cells (polyhedra in 3D, polygons in 2D and polyline in 1D).
8246  * The sum of measure field of returned mesh is equal to the sum of measure field of this.
8247  * 
8248  * \return a newly allocated mesh lying on the same coords than \b this with same meshdimension than \b this.
8249  */
8250 MEDCouplingUMesh *MEDCouplingUMesh::buildSpreadZonesWithPoly() const
8251 {
8252   checkFullyDefined();
8253   int mdim=getMeshDimension();
8254   int spaceDim=getSpaceDimension();
8255   if(mdim!=spaceDim)
8256     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSpreadZonesWithPoly : meshdimension and spacedimension do not match !");
8257   std::vector<DataArrayInt *> partition=partitionBySpreadZone();
8258   std::vector< MCAuto<DataArrayInt> > partitionAuto; partitionAuto.reserve(partition.size());
8259   std::copy(partition.begin(),partition.end(),std::back_insert_iterator<std::vector< MCAuto<DataArrayInt> > >(partitionAuto));
8260   MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New(getName(),mdim);
8261   ret->setCoords(getCoords());
8262   ret->allocateCells((int)partition.size());
8263   //
8264   for(std::vector<DataArrayInt *>::const_iterator it=partition.begin();it!=partition.end();it++)
8265     {
8266       MCAuto<MEDCouplingUMesh> tmp=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf((*it)->begin(),(*it)->end(),true));
8267       MCAuto<DataArrayInt> cell;
8268       switch(mdim)
8269       {
8270         case 2:
8271           cell=tmp->buildUnionOf2DMesh();
8272           break;
8273         case 3:
8274           cell=tmp->buildUnionOf3DMesh();
8275           break;
8276         default:
8277           throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSpreadZonesWithPoly : meshdimension supported are [2,3] ! Not implemented yet for others !");
8278       }
8279
8280       ret->insertNextCell((INTERP_KERNEL::NormalizedCellType)cell->getIJSafe(0,0),cell->getNumberOfTuples()-1,cell->begin()+1);
8281     }
8282   //
8283   ret->finishInsertingCells();
8284   return ret.retn();
8285 }
8286
8287 /*!
8288  * This method partitions \b this into contiguous zone.
8289  * This method only needs a well defined connectivity. Coordinates are not considered here.
8290  * This method returns a vector of \b newly allocated arrays that the caller has to deal with.
8291  */
8292 std::vector<DataArrayInt *> MEDCouplingUMesh::partitionBySpreadZone() const
8293 {
8294   DataArrayInt *neigh=0,*neighI=0;
8295   computeNeighborsOfCells(neigh,neighI);
8296   MCAuto<DataArrayInt> neighAuto(neigh),neighIAuto(neighI);
8297   return PartitionBySpreadZone(neighAuto,neighIAuto);
8298 }
8299
8300 std::vector<DataArrayInt *> MEDCouplingUMesh::PartitionBySpreadZone(const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn)
8301 {
8302   if(!arrIn || !arrIndxIn)
8303     throw INTERP_KERNEL::Exception("PartitionBySpreadZone : null input pointers !");
8304   arrIn->checkAllocated(); arrIndxIn->checkAllocated();
8305   int nbOfTuples(arrIndxIn->getNumberOfTuples());
8306   if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1 || nbOfTuples<1)
8307     throw INTERP_KERNEL::Exception("PartitionBySpreadZone : invalid arrays in input !");
8308   int nbOfCellsCur(nbOfTuples-1);
8309   std::vector<DataArrayInt *> ret;
8310   if(nbOfCellsCur<=0)
8311     return ret;
8312   std::vector<bool> fetchedCells(nbOfCellsCur,false);
8313   std::vector< MCAuto<DataArrayInt> > ret2;
8314   int seed=0;
8315   while(seed<nbOfCellsCur)
8316     {
8317       int nbOfPeelPerformed=0;
8318       ret2.push_back(ComputeSpreadZoneGraduallyFromSeedAlg(fetchedCells,&seed,&seed+1,arrIn,arrIndxIn,-1,nbOfPeelPerformed));
8319       seed=(int)std::distance(fetchedCells.begin(),std::find(fetchedCells.begin()+seed,fetchedCells.end(),false));
8320     }
8321   for(std::vector< MCAuto<DataArrayInt> >::iterator it=ret2.begin();it!=ret2.end();it++)
8322     ret.push_back((*it).retn());
8323   return ret;
8324 }
8325
8326 /*!
8327  * This method returns given a distribution of cell type (returned for example by MEDCouplingUMesh::getDistributionOfTypes method and customized after) a
8328  * newly allocated DataArrayInt instance with 2 components ready to be interpreted as input of DataArrayInt::findRangeIdForEachTuple method.
8329  *
8330  * \param [in] code a code with the same format than those returned by MEDCouplingUMesh::getDistributionOfTypes except for the code[3*k+2] that should contain start id of chunck.
8331  * \return a newly allocated DataArrayInt to be managed by the caller.
8332  * \throw In case of \a code has not the right format (typically of size 3*n)
8333  */
8334 DataArrayInt *MEDCouplingUMesh::ComputeRangesFromTypeDistribution(const std::vector<int>& code)
8335 {
8336   MCAuto<DataArrayInt> ret=DataArrayInt::New();
8337   std::size_t nb=code.size()/3;
8338   if(code.size()%3!=0)
8339     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeRangesFromTypeDistribution : invalid input code !");
8340   ret->alloc((int)nb,2);
8341   int *retPtr=ret->getPointer();
8342   for(std::size_t i=0;i<nb;i++,retPtr+=2)
8343     {
8344       retPtr[0]=code[3*i+2];
8345       retPtr[1]=code[3*i+2]+code[3*i+1];
8346     }
8347   return ret.retn();
8348 }
8349
8350 /*!
8351  * This method expects that \a this a 3D mesh (spaceDim=3 and meshDim=3) with all coordinates and connectivities set.
8352  * All cells in \a this are expected to be linear 3D cells.
8353  * This method will split **all** 3D cells in \a this into INTERP_KERNEL::NORM_TETRA4 cells and put them in the returned mesh.
8354  * It leads to an increase to number of cells.
8355  * This method contrary to MEDCouplingUMesh::simplexize can append coordinates in \a this to perform its work.
8356  * The \a nbOfAdditionalPoints returned value informs about it. If > 0, the coordinates array in returned mesh will have \a nbOfAdditionalPoints 
8357  * more tuples (nodes) than in \a this. Anyway, all the nodes in \a this (with the same order) will be in the returned mesh.
8358  *
8359  * \param [in] policy - the policy of splitting that must be in (PLANAR_FACE_5, PLANAR_FACE_6, GENERAL_24, GENERAL_48). The policy will be used only for INTERP_KERNEL::NORM_HEXA8 cells.
8360  *                      For all other cells, the splitting policy will be ignored. See INTERP_KERNEL::SplittingPolicy for the images.
8361  * \param [out] nbOfAdditionalPoints - number of nodes added to \c this->_coords. If > 0 a new coordinates object will be constructed result of the aggregation of the old one and the new points added. 
8362  * \param [out] n2oCells - A new instance of DataArrayInt holding, for each new cell,
8363  *          an id of old cell producing it. The caller is to delete this array using
8364  *         decrRef() as it is no more needed.
8365  * \return MEDCoupling1SGTUMesh * - the mesh containing only INTERP_KERNEL::NORM_TETRA4 cells.
8366  *
8367  * \warning This method operates on each cells in this independently ! So it can leads to non conform mesh in returned value ! If you expect to have a conform mesh in output
8368  * the policy PLANAR_FACE_6 should be used on a mesh sorted with MEDCoupling1SGTUMesh::sortHexa8EachOther.
8369  * 
8370  * \throw If \a this is not a 3D mesh (spaceDim==3 and meshDim==3).
8371  * \throw If \a this is not fully constituted with linear 3D cells.
8372  * \sa MEDCouplingUMesh::simplexize, MEDCoupling1SGTUMesh::sortHexa8EachOther
8373  */
8374 MEDCoupling1SGTUMesh *MEDCouplingUMesh::tetrahedrize(int policy, DataArrayInt *& n2oCells, int& nbOfAdditionalPoints) const
8375 {
8376   INTERP_KERNEL::SplittingPolicy pol((INTERP_KERNEL::SplittingPolicy)policy);
8377   checkConnectivityFullyDefined();
8378   if(getMeshDimension()!=3 || getSpaceDimension()!=3)
8379     throw INTERP_KERNEL::Exception("MEDCouplingUMesh::tetrahedrize : only available for mesh with meshdim == 3 and spacedim == 3 !");
8380   int nbOfCells(getNumberOfCells()),nbNodes(getNumberOfNodes());
8381   MCAuto<MEDCoupling1SGTUMesh> ret0(MEDCoupling1SGTUMesh::New(getName(),INTERP_KERNEL::NORM_TETRA4));
8382   MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfCells,1);
8383   int *retPt(ret->getPointer());
8384   MCAuto<DataArrayInt> newConn(DataArrayInt::New()); newConn->alloc(0,1);
8385   MCAuto<DataArrayDouble> addPts(DataArrayDouble::New()); addPts->alloc(0,1);
8386   const int *oldc(_nodal_connec->begin());
8387   const int *oldci(_nodal_connec_index->begin());
8388   const double *coords(_coords->begin());
8389   for(int i=0;i<nbOfCells;i++,oldci++,retPt++)
8390     {
8391       std::vector<int> a; std::vector<double> b;
8392       INTERP_KERNEL::SplitIntoTetras(pol,(INTERP_KERNEL::NormalizedCellType)oldc[oldci[0]],oldc+oldci[0]+1,oldc+oldci[1],coords,a,b);
8393       std::size_t nbOfTet(a.size()/4); *retPt=(int)nbOfTet;
8394       const int *aa(&a[0]);
8395       if(!b.empty())
8396         {
8397           for(std::vector<int>::iterator it=a.begin();it!=a.end();it++)
8398             if(*it<0)
8399               *it=(-(*(it))-1+nbNodes);
8400           addPts->insertAtTheEnd(b.begin(),b.end());
8401           nbNodes+=(int)b.size()/3;
8402         }
8403       for(std::size_t j=0;j<nbOfTet;j++,aa+=4)
8404         newConn->insertAtTheEnd(aa,aa+4);
8405     }
8406   if(!addPts->empty())
8407     {
8408       addPts->rearrange(3);
8409       nbOfAdditionalPoints=addPts->getNumberOfTuples();
8410       addPts=DataArrayDouble::Aggregate(getCoords(),addPts);
8411       ret0->setCoords(addPts);
8412     }
8413   else
8414     {
8415       nbOfAdditionalPoints=0;
8416       ret0->setCoords(getCoords());
8417     }
8418   ret0->setNodalConnectivity(newConn);
8419   //
8420   ret->computeOffsetsFull();
8421   n2oCells=ret->buildExplicitArrOfSliceOnScaledArr(0,nbOfCells,1);
8422   return ret0.retn();
8423 }
8424
8425 MEDCouplingUMeshCellIterator::MEDCouplingUMeshCellIterator(MEDCouplingUMesh *mesh):_mesh(mesh),_cell(new MEDCouplingUMeshCell(mesh)),
8426     _own_cell(true),_cell_id(-1),_nb_cell(0)
8427 {
8428   if(mesh)
8429     {
8430       mesh->incrRef();
8431       _nb_cell=mesh->getNumberOfCells();
8432     }
8433 }
8434
8435 MEDCouplingUMeshCellIterator::~MEDCouplingUMeshCellIterator()
8436 {
8437   if(_mesh)
8438     _mesh->decrRef();
8439   if(_own_cell)
8440     delete _cell;
8441 }
8442
8443 MEDCouplingUMeshCellIterator::MEDCouplingUMeshCellIterator(MEDCouplingUMesh *mesh, MEDCouplingUMeshCell *itc, int bg, int end):_mesh(mesh),_cell(itc),
8444     _own_cell(false),_cell_id(bg-1),
8445     _nb_cell(end)
8446 {
8447   if(mesh)
8448     mesh->incrRef();
8449 }
8450
8451 MEDCouplingUMeshCell *MEDCouplingUMeshCellIterator::nextt()
8452 {
8453   _cell_id++;
8454   if(_cell_id<_nb_cell)
8455     {
8456       _cell->next();
8457       return _cell;
8458     }
8459   else
8460     return 0;
8461 }
8462
8463 MEDCouplingUMeshCellByTypeEntry::MEDCouplingUMeshCellByTypeEntry(MEDCouplingUMesh *mesh):_mesh(mesh)
8464 {
8465   if(_mesh)
8466     _mesh->incrRef();
8467 }
8468
8469 MEDCouplingUMeshCellByTypeIterator *MEDCouplingUMeshCellByTypeEntry::iterator()
8470 {
8471   return new MEDCouplingUMeshCellByTypeIterator(_mesh);
8472 }
8473
8474 MEDCouplingUMeshCellByTypeEntry::~MEDCouplingUMeshCellByTypeEntry()
8475 {
8476   if(_mesh)
8477     _mesh->decrRef();
8478 }
8479
8480 MEDCouplingUMeshCellEntry::MEDCouplingUMeshCellEntry(MEDCouplingUMesh *mesh,  INTERP_KERNEL::NormalizedCellType type, MEDCouplingUMeshCell *itc, int bg, int end):_mesh(mesh),_type(type),
8481     _itc(itc),
8482     _bg(bg),_end(end)
8483 {
8484   if(_mesh)
8485     _mesh->incrRef();
8486 }
8487
8488 MEDCouplingUMeshCellEntry::~MEDCouplingUMeshCellEntry()
8489 {
8490   if(_mesh)
8491     _mesh->decrRef();
8492 }
8493
8494 INTERP_KERNEL::NormalizedCellType MEDCouplingUMeshCellEntry::getType() const
8495 {
8496   return _type;
8497 }
8498
8499 int MEDCouplingUMeshCellEntry::getNumberOfElems() const
8500 {
8501   return _end-_bg;
8502 }
8503
8504 MEDCouplingUMeshCellIterator *MEDCouplingUMeshCellEntry::iterator()
8505 {
8506   return new MEDCouplingUMeshCellIterator(_mesh,_itc,_bg,_end);
8507 }
8508
8509 MEDCouplingUMeshCellByTypeIterator::MEDCouplingUMeshCellByTypeIterator(MEDCouplingUMesh *mesh):_mesh(mesh),_cell(new MEDCouplingUMeshCell(mesh)),_cell_id(0),_nb_cell(0)
8510 {
8511   if(mesh)
8512     {
8513       mesh->incrRef();
8514       _nb_cell=mesh->getNumberOfCells();
8515     }
8516 }
8517
8518 MEDCouplingUMeshCellByTypeIterator::~MEDCouplingUMeshCellByTypeIterator()
8519 {
8520   if(_mesh)
8521     _mesh->decrRef();
8522   delete _cell;
8523 }
8524
8525 MEDCouplingUMeshCellEntry *MEDCouplingUMeshCellByTypeIterator::nextt()
8526 {
8527   const int *c=_mesh->getNodalConnectivity()->begin();
8528   const int *ci=_mesh->getNodalConnectivityIndex()->begin();
8529   if(_cell_id<_nb_cell)
8530     {
8531       INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[_cell_id]];
8532       int nbOfElems=(int)std::distance(ci+_cell_id,std::find_if(ci+_cell_id,ci+_nb_cell,MEDCouplingImpl::ConnReader(c,type)));
8533       int startId=_cell_id;
8534       _cell_id+=nbOfElems;
8535       return new MEDCouplingUMeshCellEntry(_mesh,type,_cell,startId,_cell_id);
8536     }
8537   else
8538     return 0;
8539 }
8540
8541 MEDCouplingUMeshCell::MEDCouplingUMeshCell(MEDCouplingUMesh *mesh):_conn(0),_conn_indx(0),_conn_lgth(NOTICABLE_FIRST_VAL)
8542 {
8543   if(mesh)
8544     {
8545       _conn=mesh->getNodalConnectivity()->getPointer();
8546       _conn_indx=mesh->getNodalConnectivityIndex()->getPointer();
8547     }
8548 }
8549
8550 void MEDCouplingUMeshCell::next()
8551 {
8552   if(_conn_lgth!=NOTICABLE_FIRST_VAL)
8553     {
8554       _conn+=_conn_lgth;
8555       _conn_indx++;
8556     }
8557   _conn_lgth=_conn_indx[1]-_conn_indx[0];
8558 }
8559
8560 std::string MEDCouplingUMeshCell::repr() const
8561 {
8562   if(_conn_lgth!=NOTICABLE_FIRST_VAL)
8563     {
8564       std::ostringstream oss; oss << "Cell Type " << INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)_conn[0]).getRepr();
8565       oss << " : ";
8566       std::copy(_conn+1,_conn+_conn_lgth,std::ostream_iterator<int>(oss," "));
8567       return oss.str();
8568     }
8569   else
8570     return std::string("MEDCouplingUMeshCell::repr : Invalid pos");
8571 }
8572
8573 INTERP_KERNEL::NormalizedCellType MEDCouplingUMeshCell::getType() const
8574 {
8575   if(_conn_lgth!=NOTICABLE_FIRST_VAL)
8576     return (INTERP_KERNEL::NormalizedCellType)_conn[0];
8577   else
8578     return INTERP_KERNEL::NORM_ERROR;
8579 }
8580
8581 const int *MEDCouplingUMeshCell::getAllConn(int& lgth) const
8582 {
8583   lgth=_conn_lgth;
8584   if(_conn_lgth!=NOTICABLE_FIRST_VAL)
8585     return _conn;
8586   else
8587     return 0;
8588 }