]> SALOME platform Git repositories - tools/medcoupling.git/blob - src/MEDCoupling/MEDCouplingCurveLinearMesh.cxx
Salome HOME
Little refactoring of progeny mechanism to avoid if.
[tools/medcoupling.git] / src / MEDCoupling / MEDCouplingCurveLinearMesh.cxx
1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Anthony Geay (CEA/DEN)
20
21 #include "MEDCouplingCurveLinearMesh.hxx"
22 #include "MEDCouplingPointSet.hxx"
23 #include "MEDCouplingMemArray.hxx"
24 #include "MEDCouplingFieldDouble.hxx"
25
26 #include "VolSurfUser.txx"
27 #include "PointLocatorAlgos.txx"
28
29 #include <functional>
30 #include <algorithm>
31 #include <sstream>
32 #include <numeric>
33
34 using namespace ParaMEDMEM;
35
36 MEDCouplingCurveLinearMesh::MEDCouplingCurveLinearMesh():_coords(0),_structure(0)
37 {
38 }
39
40 MEDCouplingCurveLinearMesh::MEDCouplingCurveLinearMesh(const MEDCouplingCurveLinearMesh& other, bool deepCopy):MEDCouplingStructuredMesh(other,deepCopy),_structure(other._structure)
41 {
42   if(deepCopy)
43     {
44       if((const DataArrayDouble *)other._coords)
45         _coords=other._coords->deepCpy();
46     }
47   else
48     _coords=other._coords;
49 }
50
51 MEDCouplingCurveLinearMesh::~MEDCouplingCurveLinearMesh()
52 {
53 }
54
55 MEDCouplingCurveLinearMesh *MEDCouplingCurveLinearMesh::New()
56 {
57   return new MEDCouplingCurveLinearMesh;
58 }
59
60 MEDCouplingCurveLinearMesh *MEDCouplingCurveLinearMesh::New(const std::string& meshName)
61 {
62   MEDCouplingCurveLinearMesh *ret=new MEDCouplingCurveLinearMesh;
63   ret->setName(meshName);
64   return ret;
65 }
66
67 MEDCouplingMesh *MEDCouplingCurveLinearMesh::deepCpy() const
68 {
69   return clone(true);
70 }
71
72 MEDCouplingCurveLinearMesh *MEDCouplingCurveLinearMesh::clone(bool recDeepCpy) const
73 {
74   return new MEDCouplingCurveLinearMesh(*this,recDeepCpy);
75 }
76
77 void MEDCouplingCurveLinearMesh::updateTime() const
78 {
79   if((const DataArrayDouble *)_coords)
80     updateTimeWith(*_coords);
81 }
82
83 std::size_t MEDCouplingCurveLinearMesh::getHeapMemorySizeWithoutChildren() const
84 {
85   std::size_t ret(MEDCouplingStructuredMesh::getHeapMemorySizeWithoutChildren());
86   ret+=_structure.capacity()*sizeof(int);
87   return ret;
88 }
89
90 std::vector<const BigMemoryObject *> MEDCouplingCurveLinearMesh::getDirectChildrenWithNull() const
91 {
92   std::vector<const BigMemoryObject *> ret;
93   ret.push_back((const DataArrayDouble *)_coords);
94   return ret;
95 }
96
97 /*!
98  * This method copyies all tiny strings from other (name and components name).
99  * @throw if other and this have not same mesh type.
100  */
101 void MEDCouplingCurveLinearMesh::copyTinyStringsFrom(const MEDCouplingMesh *other)
102
103   const MEDCouplingCurveLinearMesh *otherC=dynamic_cast<const MEDCouplingCurveLinearMesh *>(other);
104   if(!otherC)
105     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::copyTinyStringsFrom : meshes have not same type !");
106   MEDCouplingStructuredMesh::copyTinyStringsFrom(other);
107   if((DataArrayDouble *)_coords && (const DataArrayDouble *)otherC->_coords)
108     _coords->copyStringInfoFrom(*otherC->_coords);
109 }
110
111 bool MEDCouplingCurveLinearMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const
112 {
113   if(!other)
114     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::isEqualIfNotWhy : input other pointer is null !");
115   const MEDCouplingCurveLinearMesh *otherC=dynamic_cast<const MEDCouplingCurveLinearMesh *>(other);
116   if(!otherC)
117     {
118       reason="mesh given in input is not castable in MEDCouplingCurveLinearMesh !";
119       return false;
120     }
121   if(!MEDCouplingStructuredMesh::isEqualIfNotWhy(other,prec,reason))
122     return false;
123   std::ostringstream oss; oss.precision(15);
124   if(((const DataArrayDouble *)_coords && ((const DataArrayDouble *)otherC->_coords)==0) || (((const DataArrayDouble *)_coords)==0 && (const DataArrayDouble *)otherC->_coords))
125     {
126       oss << "Only one CurveLinearMesh between the two this and other has its coordinates defined !";
127       reason=oss.str();
128       return false;
129     }
130   if((const DataArrayDouble *)_coords)
131     {
132       if(!_coords->isEqualIfNotWhy(*(otherC->_coords),prec,reason))
133         {
134           oss << "Coordinates DataArrayDouble of differ :";
135           reason.insert(0,oss.str());
136           return false;
137         }
138       if(_structure!=otherC->_structure)
139         { reason="CurveLinearMesh structures differ !"; return false; }
140     }
141   return true;
142 }
143
144 bool MEDCouplingCurveLinearMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
145 {
146   const MEDCouplingCurveLinearMesh *otherC=dynamic_cast<const MEDCouplingCurveLinearMesh *>(other);
147   if(!otherC)
148     return false;
149   if(((const DataArrayDouble *)_coords && ((const DataArrayDouble *)otherC->_coords)==0) || (((const DataArrayDouble *)_coords)==0 && (const DataArrayDouble *)otherC->_coords))
150     return false;
151   if((const DataArrayDouble *)_coords)
152     {
153       if(!_coords->isEqualWithoutConsideringStr(*(otherC->_coords),prec))
154         return false;
155       if(_structure!=otherC->_structure)
156         return false;
157     }
158   return true;
159 }
160
161 void MEDCouplingCurveLinearMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
162                                                       DataArrayInt *&cellCor, DataArrayInt *&nodeCor) const
163 {
164   if(!isEqualWithoutConsideringStr(other,prec))
165     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::checkDeepEquivalWith : Meshes are not the same !");
166 }
167
168 /*!
169  * Nothing is done here (except to check that the other is a ParaMEDMEM::MEDCouplingCurveLinearMesh instance too).
170  * The user intend that the nodes are the same, so by construction of ParaMEDMEM::MEDCouplingCurveLinearMesh, \a this and \a other are the same !
171  */
172 void MEDCouplingCurveLinearMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
173                                                                  DataArrayInt *&cellCor) const
174 {
175   if(!isEqualWithoutConsideringStr(other,prec))
176     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::checkDeepEquivalOnSameNodesWith : Meshes are not the same !");
177 }
178
179 void MEDCouplingCurveLinearMesh::checkCoherency() const
180 {
181   std::size_t sz=_structure.size(),i=0,nbOfNodes=1;
182   if(sz<1)
183     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::checkCoherency : structure should have a lgth of size 1 at least !");
184   for(std::vector<int>::const_iterator it=_structure.begin();it!=_structure.end();it++,i++)
185     {
186       if((*it)<1)
187         { std::ostringstream oss; oss << "MEDCouplingCurveLinearMesh::checkCoherency : At pos #" << i << " of structure value is " << *it << "should be >= 1 !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); }
188       nbOfNodes*=*it;
189     }
190   if(!((const DataArrayDouble *)_coords))
191     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::checkCoherency : the array is not set !");
192   if(!_coords->isAllocated())
193     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::checkCoherency : the array is not allocated !");
194   if(_coords->getNumberOfComponents()<1)
195     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::checkCoherency : the array should have >= 1 components !");
196   if(_coords->getNumberOfTuples()!=(int)nbOfNodes)
197     {
198       std::ostringstream oss; oss << "MEDCouplingCurveLinearMesh::checkCoherency : structure said that number of nodes should be equal to " << nbOfNodes << " but number of tuples in array is equal to " << _coords->getNumberOfTuples() << " !";
199       throw INTERP_KERNEL::Exception(oss.str().c_str());
200     }
201 }
202
203 void MEDCouplingCurveLinearMesh::checkCoherency1(double eps) const
204 {
205   checkCoherency();
206 }
207
208 void MEDCouplingCurveLinearMesh::checkCoherency2(double eps) const
209 {
210   checkCoherency1(eps);
211 }
212
213 int MEDCouplingCurveLinearMesh::getNumberOfCells() const
214 {
215   checkCoherency();
216   return MEDCouplingStructuredMesh::getNumberOfCells();
217 }
218
219 int MEDCouplingCurveLinearMesh::getNumberOfNodes() const
220 {
221   checkCoherency();
222   return MEDCouplingStructuredMesh::getNumberOfNodes();
223 }
224
225 void MEDCouplingCurveLinearMesh::getNodeGridStructure(int *res) const
226 {
227   std::copy(_structure.begin(),_structure.end(),res);
228 }
229
230 /*!
231  * MEDCouplingCurveLinearMesh has the property to define 2 space dimensions. One coming from its coordinates. The other coming from the node structure.
232  * Normally they should be equal ! This method returns the space dimension from coordinates. If the other one is requested call getSpaceDimensionOnNodeStruct.
233  *
234  * \sa MEDCouplingStructuredMesh::getSpaceDimensionOnNodeStruct
235  */
236 int MEDCouplingCurveLinearMesh::getSpaceDimension() const
237 {
238   if(!((const DataArrayDouble *)_coords))
239     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getSpaceDimension : no array set ! impossible to deduce a space dimension !");
240   return _coords->getNumberOfComponents();
241 }
242
243 void MEDCouplingCurveLinearMesh::getCoordinatesOfNode(int nodeId, std::vector<double>& coo) const
244 {
245   if(!((const DataArrayDouble *)_coords))
246     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getCoordinatesOfNode : Coordinates not set !");
247   int nbOfCompo=_coords->getNumberOfComponents();
248   if(nodeId>=0 && nodeId<_coords->getNumberOfTuples())
249     coo.insert(coo.end(),_coords->begin()+nodeId*nbOfCompo,_coords->begin()+(nodeId+1)*nbOfCompo);
250   else
251     { std::ostringstream oss; oss << "MEDCouplingCurveLinearMesh::getCoordinatesOfNode : nodeId has to be in [0," << _coords->getNumberOfTuples() << ") !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); }
252 }
253
254 std::string MEDCouplingCurveLinearMesh::simpleRepr() const
255 {
256   std::ostringstream ret;
257   ret << "Curve linear mesh with name : \"" << getName() << "\"\n";
258   ret << "Description of mesh : \"" << getDescription() << "\"\n";
259   int tmpp1,tmpp2;
260   double tt=getTime(tmpp1,tmpp2);
261   ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
262   ret << "Iteration : " << tmpp1  << " Order : " << tmpp2 << "\n";
263   ret << "The nodal stucture of curve linear mesh is : [";
264   std::copy(_structure.begin(),_structure.end(),std::ostream_iterator<int>(ret,",")); ret << "]\n";
265   ret << "The coords array is this : ";
266   if((const DataArrayDouble *)_coords)
267     _coords->reprZipWithoutNameStream(ret);
268   else
269     ret << "no array specified !";
270   return ret.str();
271 }
272
273 std::string MEDCouplingCurveLinearMesh::advancedRepr() const
274 {
275   return simpleRepr();
276 }
277
278 DataArrayDouble *MEDCouplingCurveLinearMesh::getCoords()
279 {
280   return _coords;
281 }
282
283 const DataArrayDouble *MEDCouplingCurveLinearMesh::getCoords() const
284 {
285   return _coords;
286 }
287
288 void MEDCouplingCurveLinearMesh::setCoords(const DataArrayDouble *coords)
289 {
290   if(coords!=(const DataArrayDouble *)_coords)
291     {
292       _coords=const_cast<DataArrayDouble *>(coords);
293       if(coords)
294         coords->incrRef();
295       declareAsNew();
296     }
297 }
298
299 void MEDCouplingCurveLinearMesh::setNodeGridStructure(const int *gridStructBg, const int *gridStructEnd)
300 {
301   std::size_t sz=std::distance(gridStructBg,gridStructEnd);
302   if(sz>=1 && sz<=3)
303     {
304       _structure.resize(0);
305       _structure.insert(_structure.end(),gridStructBg,gridStructEnd);
306     }
307   else
308     {
309       std::ostringstream oss; oss << "MEDCouplingCurveLinearMesh::setNodeGridStructure : size of input nodal grid structure (" << sz << ") should be in 1, 2 or 3 !";
310       throw INTERP_KERNEL::Exception(oss.str().c_str());
311     }
312 }
313
314 std::vector<int> MEDCouplingCurveLinearMesh::getNodeGridStructure() const
315 {
316   return _structure;
317 }
318
319 MEDCouplingStructuredMesh *MEDCouplingCurveLinearMesh::buildStructuredSubPart(const std::vector< std::pair<int,int> >& cellPart) const
320 {
321   checkCoherency();
322   int dim(getSpaceDimension());
323   std::vector<int> dims(getMeshDimension());
324   if(dim!=(int)cellPart.size())
325     {
326       std::ostringstream oss; oss << "MEDCouplingCurveLinearMesh::buildStructuredSubPart : the space dimension is " << dim << " and cell part size is " << cellPart.size() << " !";
327       throw INTERP_KERNEL::Exception(oss.str().c_str());
328     }
329   std::vector< std::pair<int,int> > nodePartFormat(cellPart);
330   for(std::vector< std::pair<int,int> >::iterator it=nodePartFormat.begin();it!=nodePartFormat.end();it++)
331     (*it).second++;
332   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp1(BuildExplicitIdsFrom(getNodeGridStructure(),nodePartFormat));
333   MEDCouplingAutoRefCountObjectPtr<MEDCouplingCurveLinearMesh> ret(dynamic_cast<MEDCouplingCurveLinearMesh *>(deepCpy()));
334   const DataArrayDouble *coo(ret->getCoords());
335   if(coo)
336     {
337       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coo2(coo->selectByTupleIdSafe(tmp1->begin(),tmp1->end()));
338       ret->setCoords(coo2);
339     }
340   for(int i=0;i<dim;i++)
341     {
342       dims[i]=cellPart[i].second-cellPart[i].first+1;
343       if(dims[i]<1)
344         throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::buildStructuredSubPart : invalid input cellPart !");
345     }
346   ret->setNodeGridStructure(&dims[0],&dims[0]+dims.size());
347   return ret.retn();
348 }
349
350 void MEDCouplingCurveLinearMesh::getBoundingBox(double *bbox) const
351 {
352   if(!((const DataArrayDouble *)_coords))
353     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getBoundingBox : Coordinates not set !");
354   _coords->getMinMaxPerComponent(bbox);
355 }
356
357 MEDCouplingFieldDouble *MEDCouplingCurveLinearMesh::getMeasureField(bool isAbs) const
358 {
359   checkCoherency();
360   int meshDim=getMeshDimension();
361   std::string name="MeasureOfMesh_"; name+=getName();
362   MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
363   field->setName(name); field->setMesh(const_cast<MEDCouplingCurveLinearMesh *>(this)); field->synchronizeTimeWithMesh();
364   switch(meshDim)
365   {
366     case 3:
367       { getMeasureFieldMeshDim3(isAbs,field); return field.retn(); }
368     case 2:
369       { getMeasureFieldMeshDim2(isAbs,field); return field.retn(); }
370     case 1:
371       { getMeasureFieldMeshDim1(isAbs,field); return field.retn(); }
372     default:
373       throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getMeasureField : mesh dimension must be in [1,2,3] !");
374   }
375 }
376
377 /*!
378  * \param [in,out] f field feeded with good values.
379  * \sa MEDCouplingCurveLinearMesh::getMeasureField
380  */
381 void MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim1(bool isAbs, MEDCouplingFieldDouble *field) const
382 {
383   int nbnodes=getNumberOfNodes();
384   int spaceDim=getSpaceDimension();
385   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::New(); field->setArray(arr);
386   if(nbnodes==0)
387     { arr->alloc(0,1); return; }
388   if(spaceDim==1)
389     {
390       arr->alloc(nbnodes-1,1);
391       std::transform(_coords->begin()+1,_coords->end(),_coords->begin(),arr->getPointer(),std::minus<double>());
392       if(isAbs)
393         arr->abs();
394     }
395   else
396     {
397       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> tmp=DataArrayDouble::New(); tmp->alloc(nbnodes-1,spaceDim);
398       std::transform(_coords->begin()+spaceDim,_coords->end(),_coords->begin(),tmp->getPointer(),std::minus<double>());
399       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> tmp2=tmp->magnitude(); field->setArray(tmp2);
400     }
401 }
402
403 /*!
404  * \param [in,out] f field feeded with good values.
405  * \sa MEDCouplingCurveLinearMesh::getMeasureField
406  */
407 void MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim2(bool isAbs, MEDCouplingFieldDouble *field) const
408 {
409   int nbcells=getNumberOfCells();
410   int spaceDim=getSpaceDimension();
411   if(spaceDim!=2 && spaceDim!=3)
412     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim2 : with meshDim 2 only space dimension 2 and 3 are possible !");
413   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::New(); field->setArray(arr);
414   arr->alloc(nbcells,1);
415   double *pt=arr->getPointer();
416   const double *coords=_coords->begin();
417   int nX=_structure[0]-1;
418   int conn[4];
419   for(int i=0;i<nbcells;i++,pt++)
420     {
421       int cy=i/nX,cx=i-cy*nX;
422       conn[0]=cy*(nX+1)+cx; conn[1]=(cy+1)*(nX+1)+cx; conn[2]=(cy+1)*(nX+1)+1+cx; conn[3]=cy*(nX+1)+cx+1;
423       *pt=INTERP_KERNEL::computeVolSurfOfCell2<int,INTERP_KERNEL::ALL_C_MODE>(INTERP_KERNEL::NORM_QUAD4,conn,4,coords,spaceDim);
424     }
425   if(isAbs)
426     arr->abs();
427 }
428
429 /*!
430  * \param [in,out] f field feeded with good values.
431  * \sa MEDCouplingCurveLinearMesh::getMeasureField
432  */
433 void MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim3(bool isAbs, MEDCouplingFieldDouble *field) const
434 {
435   int nbcells=getNumberOfCells();
436   int spaceDim=getSpaceDimension();
437   if(spaceDim!=3)
438     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getMeasureFieldMeshDim3 : with meshDim 3 only space dimension 3 is possible !");
439   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr=DataArrayDouble::New(); field->setArray(arr);
440   arr->alloc(nbcells,1);
441   double *pt=arr->getPointer();
442   const double *coords=_coords->begin();
443   int nX=_structure[0]-1,nY=(_structure[0]-1)*(_structure[1]-1);
444   int nY1=_structure[0]*_structure[1];
445   int conn[8];
446   for(int i=0;i<nbcells;i++,pt++)
447     {
448       int cz=i/nY;
449       int cy=(i-cz*nY)/nX;
450       int cx=(i-cz*nY)-nX*cy;
451       conn[0]=cz*nY1+cy*(nX+1)+cx; conn[1]=cz*nY1+(cy+1)*(nX+1)+cx; conn[2]=cz*nY1+(cy+1)*(nX+1)+1+cx; conn[3]=cz*nY1+cy*(nX+1)+cx+1;
452       conn[4]=(cz+1)*nY1+cy*(nX+1)+cx; conn[5]=(cz+1)*nY1+(cy+1)*(nX+1)+cx; conn[6]=(cz+1)*nY1+(cy+1)*(nX+1)+1+cx; conn[7]=(cz+1)*nY1+cy*(nX+1)+cx+1;
453       *pt=INTERP_KERNEL::computeVolSurfOfCell2<int,INTERP_KERNEL::ALL_C_MODE>(INTERP_KERNEL::NORM_HEXA8,conn,8,coords,3);
454     }
455   if(isAbs)
456     arr->abs();
457 }
458
459 /*!
460  * not implemented yet !
461  */
462 MEDCouplingFieldDouble *MEDCouplingCurveLinearMesh::getMeasureFieldOnNode(bool isAbs) const
463 {
464   throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getMeasureFieldOnNode : not implemented yet !");
465 }
466
467 MEDCouplingFieldDouble *MEDCouplingCurveLinearMesh::buildOrthogonalField() const
468 {
469   if(getMeshDimension()!=2)
470     throw INTERP_KERNEL::Exception("Expected a cmesh with meshDim == 2 !");
471   MEDCouplingFieldDouble *ret=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
472   DataArrayDouble *array=DataArrayDouble::New();
473   int nbOfCells=getNumberOfCells();
474   array->alloc(nbOfCells,3);
475   double *vals=array->getPointer();
476   for(int i=0;i<nbOfCells;i++)
477     { vals[3*i]=0.; vals[3*i+1]=0.; vals[3*i+2]=1.; }
478   ret->setArray(array);
479   array->decrRef();
480   ret->setMesh(this);
481   return ret;
482 }
483
484 /// @cond INTERNAL
485
486 namespace ParaMEDMEM
487 {
488   template<const int SPACEDIMM>
489   class DummyClsMCL
490   {
491   public:
492     static const int MY_SPACEDIM=SPACEDIMM;
493     static const int MY_MESHDIM=8;
494     typedef int MyConnType;
495     static const INTERP_KERNEL::NumberingPolicy My_numPol=INTERP_KERNEL::ALL_C_MODE;
496     // begin
497     // useless, but for windows compilation ...
498     const double* getCoordinatesPtr() const { return 0; }
499     const int* getConnectivityPtr() const { return 0; }
500     const int* getConnectivityIndexPtr() const { return 0; }
501     INTERP_KERNEL::NormalizedCellType getTypeOfElement(int) const { return (INTERP_KERNEL::NormalizedCellType)0; }
502     // end
503   };
504 }
505
506 /// @endcond
507
508 int MEDCouplingCurveLinearMesh::getCellContainingPoint(const double *pos, double eps) const
509 {
510   checkCoherency();
511   int spaceDim=getSpaceDimension();
512   const double *coords=_coords->getConstPointer();
513   int nodeId=-1;
514   _coords->distanceToTuple(pos,pos+spaceDim,nodeId);
515   if(nodeId<0)
516     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getCellContainingPoint : internal problem 1 !");
517   int conn[8];
518   int nbOfNodes=getNumberOfNodes();
519   if(nbOfNodes==1)
520     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getCellContainingPoint : No cells in this !");
521   switch(getMeshDimension())
522   {
523     case 1:
524       if(spaceDim==1)
525         {
526           if(nodeId>0)
527             {
528               conn[0]=nodeId-1; conn[1]=nodeId;
529               if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<1> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_SEG2,coords,conn,2,eps))
530                 return nodeId-1;
531             }
532           if(nodeId<nbOfNodes-1)
533             {
534               conn[0]=nodeId; conn[1]=nodeId+1;
535               if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<1> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_SEG2,coords,conn,2,eps))
536                 return nodeId;
537             }
538         }
539     case 2:
540       if(spaceDim==2)
541         {
542           int ny=nodeId/_structure[0],nx=nodeId-ny*_structure[0];
543           if(nx>0 && ny>0)
544             {
545               conn[0]=nx-1+_structure[0]*(ny-1); conn[1]=nx-1+_structure[0]*ny; conn[2]=nx+_structure[0]*ny; conn[3]=nx+_structure[0]*(ny-1);
546               if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<2> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_QUAD4,coords,conn,4,eps))
547                 return nx-1+(ny-1)*_structure[0];
548             }
549           if(nx<_structure[0]-1 && ny>0)
550             {
551               conn[0]=nx+_structure[0]*(ny-1); conn[1]=nx+_structure[0]*ny; conn[2]=nx+1+_structure[0]*ny; conn[3]=nx+1+_structure[0]*(ny-1);
552               if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<2> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_QUAD4,coords,conn,4,eps))
553                 return nx+(ny-1)*_structure[0];
554             }
555           if(nx>0 && ny<_structure[1]-1)
556             {
557               conn[0]=nx-1+_structure[0]*ny; conn[1]=nx-1+_structure[0]*(ny+1); conn[2]=nx+_structure[0]*(ny+1); conn[3]=nx+_structure[0]*ny;
558               if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<2> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_QUAD4,coords,conn,4,eps))
559                 return nx-1+ny*_structure[0];
560             }
561           if(nx<_structure[0]-1 && ny<_structure[1]-1)
562             {
563               conn[0]=nx+_structure[0]*ny; conn[1]=nx+_structure[0]*(ny+1); conn[2]=nx+1+_structure[0]*(ny+1); conn[3]=nx+1+_structure[0]*ny;
564               if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<2> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_QUAD4,coords,conn,4,eps))
565                 return nx+ny*_structure[0];
566             }
567         }
568     case 3:
569       {
570         if(spaceDim==3)
571           {
572             int nY=_structure[0]*_structure[1];
573             int nz=nodeId/_structure[1]; int ny=(nodeId-nz*nY)/_structure[0]; int nx=(nodeId-nz*nY)-_structure[0]*ny;
574             if(nx>0 && ny>0 && nz>0)
575               {
576                 conn[0]=nx-1+_structure[0]*(ny-1)+nY*(nz-1); conn[1]=nx-1+_structure[2]*ny+nY*(nz-1); conn[2]=nx+_structure[2]*ny+nY*(nz-1); conn[3]=nx+_structure[0]*(ny-1)+nY*(nz-1);
577                 conn[4]=nx-1+_structure[0]*(ny-1)+nY*nz; conn[5]=nx-1+_structure[0]*ny+nY*nz; conn[6]=nx+_structure[0]*ny+nY*nz; conn[7]=nx+_structure[0]*(ny-1)+nY*nz;
578                 if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<3> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_HEXA8,coords,conn,8,eps))
579                   return nx-1+(ny-1)*_structure[0]+(nz-1)*nY;
580               }
581             if(nx<_structure[0]-1 && ny>0 && nz>0)
582               {
583                 conn[0]=nx+_structure[0]*(ny-1)+nY*(nz-1); conn[1]=nx+_structure[0]*ny+nY*(nz-1); conn[2]=nx+1+_structure[0]*ny+nY*(nz-1); conn[3]=nx+1+_structure[0]*(ny-1)+nY*(nz-1);
584                 conn[4]=nx+_structure[0]*(ny-1)+nY*nz; conn[5]=nx+_structure[0]*ny+nY*nz; conn[6]=nx+1+_structure[0]*ny+nY*nz; conn[7]=nx+1+_structure[0]*(ny-1)+nY*nz;
585                 if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<3> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_HEXA8,coords,conn,8,eps))
586                   return nx+(ny-1)*_structure[0]+(nz-1)*nY;
587               }
588             if(nx>0 && ny<_structure[1]-1 && nz>0)
589               {
590                 conn[0]=nx-1+_structure[0]*ny+nY*(nz-1); conn[1]=nx-1+_structure[0]*(ny+1)+nY*(nz-1); conn[2]=nx+_structure[0]*(ny+1)+nY*(nz-1); conn[3]=nx+_structure[0]*ny+nY*(nz-1);
591                 conn[4]=nx-1+_structure[0]*ny+nY*nz; conn[5]=nx-1+_structure[0]*(ny+1)+nY*nz; conn[6]=nx+_structure[0]*(ny+1)+nY*nz; conn[7]=nx+_structure[0]*ny+nY*nz;
592                 if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<3> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_HEXA8,coords,conn,8,eps))
593                   return nx-1+ny*_structure[0]+(nz-1)*nY;
594               }
595             if(nx<_structure[0]-1 && ny<_structure[1]-1 && nz>0)
596               {
597                 conn[0]=nx+_structure[0]*ny+nY*(nz-1); conn[1]=nx+_structure[0]*(ny+1)+nY*(nz-1); conn[2]=nx+1+_structure[0]*(ny+1)+nY*(nz-1); conn[3]=nx+1+_structure[0]*ny+nY*(nz-1);
598                 conn[4]=nx+_structure[0]*ny+nY*nz; conn[5]=nx+_structure[0]*(ny+1)+nY*nz; conn[6]=nx+1+_structure[0]*(ny+1)+nY*nz; conn[7]=nx+1+_structure[0]*ny+nY*nz;
599                 if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<3> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_HEXA8,coords,conn,8,eps))
600                   return nx+ny*_structure[0]+(nz-1)*nY;
601               }
602             if(nx>0 && ny>0 && nz<_structure[2]-1)
603               {
604                 conn[0]=nx-1+_structure[0]*(ny-1)+nY*(nz-1); conn[1]=nx-1+_structure[2]*ny+nY*(nz-1); conn[2]=nx+_structure[2]*ny+nY*(nz-1); conn[3]=nx+_structure[0]*(ny-1)+nY*(nz-1);
605                 conn[4]=nx-1+_structure[0]*(ny-1)+nY*nz; conn[5]=nx-1+_structure[0]*ny+nY*nz; conn[6]=nx+_structure[0]*ny+nY*nz; conn[7]=nx+_structure[0]*(ny-1)+nY*nz;
606                 if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<3> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_HEXA8,coords,conn,8,eps))
607                   return nx-1+(ny-1)*_structure[0]+nz*nY;
608               }
609             if(nx<_structure[0]-1 && ny>0 && nz<_structure[2]-1)
610               {
611                 conn[0]=nx+_structure[0]*(ny-1)+nY*(nz-1); conn[1]=nx+_structure[0]*ny+nY*(nz-1); conn[2]=nx+1+_structure[0]*ny+nY*(nz-1); conn[3]=nx+1+_structure[0]*(ny-1)+nY*(nz-1);
612                 conn[4]=nx+_structure[0]*(ny-1)+nY*nz; conn[5]=nx+_structure[0]*ny+nY*nz; conn[6]=nx+1+_structure[0]*ny+nY*nz; conn[7]=nx+1+_structure[0]*(ny-1)+nY*nz;
613                 if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<3> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_HEXA8,coords,conn,8,eps))
614                   return nx+(ny-1)*_structure[0]+nz*nY;
615               }
616             if(nx>0 && ny<_structure[1]-1 && nz<_structure[2]-1)
617               {
618                 conn[0]=nx-1+_structure[0]*ny+nY*(nz-1); conn[1]=nx-1+_structure[0]*(ny+1)+nY*(nz-1); conn[2]=nx+_structure[0]*(ny+1)+nY*(nz-1); conn[3]=nx+_structure[0]*ny+nY*(nz-1);
619                 conn[4]=nx-1+_structure[0]*ny+nY*nz; conn[5]=nx-1+_structure[0]*(ny+1)+nY*nz; conn[6]=nx+_structure[0]*(ny+1)+nY*nz; conn[7]=nx+_structure[0]*ny+nY*nz;
620                 if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<3> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_HEXA8,coords,conn,8,eps))
621                   return nx-1+ny*_structure[0]+nz*nY;
622               }
623             if(nx<_structure[0]-1 && ny<_structure[1]-1 && nz<_structure[2]-1)
624               {
625                 conn[0]=nx+_structure[0]*ny+nY*(nz-1); conn[1]=nx+_structure[0]*(ny+1)+nY*(nz-1); conn[2]=nx+1+_structure[0]*(ny+1)+nY*(nz-1); conn[3]=nx+1+_structure[0]*ny+nY*(nz-1);
626                 conn[4]=nx+_structure[0]*ny+nY*nz; conn[5]=nx+_structure[0]*(ny+1)+nY*nz; conn[6]=nx+1+_structure[0]*(ny+1)+nY*nz; conn[7]=nx+1+_structure[0]*ny+nY*nz;
627                 if(INTERP_KERNEL::PointLocatorAlgos<DummyClsMCL<3> >::isElementContainsPoint(pos,INTERP_KERNEL::NORM_HEXA8,coords,conn,8,eps))
628                   return nx+ny*_structure[0]+nz*nY;
629               }
630           }
631       }
632     default:
633       throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getCellContainingPoint : mesh dimension managed are 1, 2 or 3 !");
634   }
635 }
636
637 void MEDCouplingCurveLinearMesh::rotate(const double *center, const double *vector, double angle)
638 {
639   if(!((DataArrayDouble *)_coords))
640     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::rotate : no coordinates set !");
641   int spaceDim=getSpaceDimension();
642   int nbNodes=_coords->getNumberOfTuples();
643   double *coords=_coords->getPointer();
644   if(spaceDim==3)
645     MEDCouplingPointSet::Rotate3DAlg(center,vector,angle,nbNodes,coords);
646   else if(spaceDim==2)
647     MEDCouplingPointSet::Rotate2DAlg(center,angle,nbNodes,coords);
648   else
649     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::rotate : invalid space dim for rotation must be 2 or 3");
650   _coords->declareAsNew();
651   updateTime();
652 }
653
654 void MEDCouplingCurveLinearMesh::translate(const double *vector)
655 {
656   if(!vector)
657     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::translate : NULL input point !");
658   if(!((DataArrayDouble *)_coords))
659     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::translate : no coordinates set !");
660   double *coords=_coords->getPointer();
661   int nbNodes=getNumberOfNodes();
662   int dim=getSpaceDimension();
663   for(int i=0; i<nbNodes; i++)
664     for(int idim=0; idim<dim;idim++)
665       coords[i*dim+idim]+=vector[idim];
666   _coords->declareAsNew();
667   updateTime();
668 }
669
670 void MEDCouplingCurveLinearMesh::scale(const double *point, double factor)
671 {
672   if(!point)
673     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::scale : NULL input point !");
674   if(!((DataArrayDouble *)_coords))
675     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::scale : no coordinates set !");
676   double *coords=_coords->getPointer();
677   int nbNodes=_coords->getNumberOfTuples();
678   int dim=_coords->getNumberOfComponents();
679   for(int i=0;i<nbNodes;i++)
680     {
681       std::transform(coords+i*dim,coords+(i+1)*dim,point,coords+i*dim,std::minus<double>());
682       std::transform(coords+i*dim,coords+(i+1)*dim,coords+i*dim,std::bind2nd(std::multiplies<double>(),factor));
683       std::transform(coords+i*dim,coords+(i+1)*dim,point,coords+i*dim,std::plus<double>());
684     }
685   _coords->declareAsNew();
686   updateTime();
687 }
688
689 MEDCouplingMesh *MEDCouplingCurveLinearMesh::mergeMyselfWith(const MEDCouplingMesh *other) const
690 {
691   throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::mergeMyselfWith : not available for CurveLinear Mesh !");
692 }
693
694 DataArrayDouble *MEDCouplingCurveLinearMesh::getCoordinatesAndOwner() const
695 {
696   DataArrayDouble *ret=const_cast<DataArrayDouble *>((const DataArrayDouble *)_coords);
697   if(ret)
698     ret->incrRef();
699   return ret;
700 }
701
702 DataArrayDouble *MEDCouplingCurveLinearMesh::getBarycenterAndOwner() const
703 {
704   checkCoherency();
705   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
706   int spaceDim=getSpaceDimension();
707   int meshDim=getMeshDimension();
708   int nbOfCells=getNumberOfCells();
709   ret->alloc(nbOfCells,spaceDim);
710   ret->copyStringInfoFrom(*getCoords());
711   switch(meshDim)
712   {
713     case 3:
714       { getBarycenterAndOwnerMeshDim3(ret); return ret.retn(); }
715     case 2:
716       { getBarycenterAndOwnerMeshDim2(ret); return ret.retn(); }
717     case 1:
718       { getBarycenterAndOwnerMeshDim1(ret); return ret.retn(); }
719     default:
720       throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getBarycenterAndOwner : mesh dimension must be in [1,2,3] !");
721   }
722 }
723
724 DataArrayDouble *MEDCouplingCurveLinearMesh::computeIsoBarycenterOfNodesPerCell() const
725 {
726   return MEDCouplingCurveLinearMesh::getBarycenterAndOwner();
727 }
728
729 /*!
730  * \param [in,out] bary Barycenter array feeded with good values.
731  * \sa MEDCouplingCurveLinearMesh::getBarycenterAndOwner
732  */
733 void MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim3(DataArrayDouble *bary) const
734 {
735   int nbOfCells=getNumberOfCells();
736   double *ptToFill=bary->getPointer();
737   const double *coor=_coords->getConstPointer();
738   if(getSpaceDimension()!=3)
739     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim3 : with meshDim 3 only space dimension 3 is possible !");
740   int nX=_structure[0]-1,nY=(_structure[0]-1)*(_structure[1]-1);
741   int nY1=_structure[0]*_structure[1];
742   int conn[8];
743   for(int i=0;i<nbOfCells;i++)
744     {
745       int cz=i/nY;
746       int cy=(i-cz*nY)/nX;
747       int cx=(i-cz*nY)-nX*cy;
748       conn[0]=cz*nY1+cy*(nX+1)+cx+1; conn[1]=cz*nY1+cy*(nX+1)+cx; conn[2]=cz*nY1+(cy+1)*(nX+1)+cx; conn[3]=cz*nY1+(cy+1)*(nX+1)+1+cx;
749       conn[4]=(cz+1)*nY1+cy*(nX+1)+cx+1; conn[5]=(cz+1)*nY1+cy*(nX+1)+cx; conn[6]=(cz+1)*nY1+(cy+1)*(nX+1)+cx; conn[7]=(cz+1)*nY1+(cy+1)*(nX+1)+1+cx;
750       INTERP_KERNEL::computeBarycenter2<int,INTERP_KERNEL::ALL_C_MODE>(INTERP_KERNEL::NORM_HEXA8,conn,8,coor,3,ptToFill);
751       ptToFill+=3;
752     }
753 }
754
755 /*!
756  * \param [in,out] bary Barycenter array feeded with good values.
757  * \sa MEDCouplingCurveLinearMesh::getBarycenterAndOwner
758  */
759 void MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim2(DataArrayDouble *bary) const
760 {
761   int nbcells=getNumberOfCells();
762   int spaceDim=getSpaceDimension();
763   double *ptToFill=bary->getPointer();
764   const double *coor=_coords->getConstPointer();
765   if(spaceDim!=2 && spaceDim!=3)
766     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim2 : with meshDim 2 only space dimension 2 and 3 are possible !");
767   int nX=_structure[0]-1;
768   int conn[4];
769   for(int i=0;i<nbcells;i++)
770     {
771       int cy=i/nX,cx=i-cy*nX;
772       conn[0]=cy*(nX+1)+cx; conn[1]=(cy+1)*(nX+1)+cx; conn[2]=(cy+1)*(nX+1)+1+cx; conn[3]=cy*(nX+1)+cx+1;
773       INTERP_KERNEL::computeBarycenter2<int,INTERP_KERNEL::ALL_C_MODE>(INTERP_KERNEL::NORM_QUAD4,conn,4,coor,spaceDim,ptToFill);
774       ptToFill+=spaceDim;
775     }
776 }
777
778 /*!
779  * \param [in,out] bary Barycenter array feeded with good values.
780  * \sa MEDCouplingCurveLinearMesh::getBarycenterAndOwner
781  */
782 void MEDCouplingCurveLinearMesh::getBarycenterAndOwnerMeshDim1(DataArrayDouble *bary) const
783 {
784   int spaceDim=getSpaceDimension();
785   std::transform(_coords->begin()+spaceDim,_coords->end(),_coords->begin(),bary->getPointer(),std::plus<double>());
786   std::transform(bary->begin(),bary->end(),bary->getPointer(),std::bind2nd(std::multiplies<double>(),0.5));
787 }
788
789 void MEDCouplingCurveLinearMesh::renumberCells(const int *old2NewBg, bool check)
790 {
791   throw INTERP_KERNEL::Exception("Functionnality of renumbering cell not available for CurveLinear Mesh !");
792 }
793
794 void MEDCouplingCurveLinearMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<int>& tinyInfo, std::vector<std::string>& littleStrings) const
795 {
796   int it,order;
797   double time=getTime(it,order);
798   tinyInfo.clear();
799   tinyInfoD.clear();
800   littleStrings.clear();
801   littleStrings.push_back(getName());
802   littleStrings.push_back(getDescription());
803   littleStrings.push_back(getTimeUnit());
804   //
805   std::vector<std::string> littleStrings2;
806   if((const DataArrayDouble *)_coords)
807     _coords->getTinySerializationStrInformation(littleStrings2);
808   littleStrings.insert(littleStrings.end(),littleStrings2.begin(),littleStrings2.end());
809   //
810   tinyInfo.push_back(it);
811   tinyInfo.push_back(order);
812   tinyInfo.push_back((int)_structure.size());
813   for(std::vector<int>::const_iterator itt=_structure.begin();itt!=_structure.end();itt++)
814     tinyInfo.push_back(*itt);
815   std::vector<int> tinyInfo2;
816   if((const DataArrayDouble *)_coords)
817     _coords->getTinySerializationIntInformation(tinyInfo2);
818   tinyInfo.insert(tinyInfo.end(),tinyInfo2.begin(),tinyInfo2.end());
819   //
820   tinyInfoD.push_back(time);
821 }
822
823 void MEDCouplingCurveLinearMesh::resizeForUnserialization(const std::vector<int>& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
824 {
825   a1->alloc(tinyInfo[2],1);
826   std::vector<int> tinyInfo2(tinyInfo.begin()+3+tinyInfo[2],tinyInfo.end());
827   a2->resizeForUnserialization(tinyInfo2);
828 }
829
830 void MEDCouplingCurveLinearMesh::serialize(DataArrayInt *&a1, DataArrayDouble *&a2) const
831 {
832   a1=DataArrayInt::New();
833   a1->alloc((int)_structure.size(),1);
834   int *ptr=a1->getPointer();
835   for(std::vector<int>::const_iterator it=_structure.begin();it!=_structure.end();it++,ptr++)
836     *ptr=(*it);
837   int sz=0;
838   if((const DataArrayDouble *)_coords)
839     if(_coords->isAllocated())
840       sz=_coords->getNbOfElems();
841   a2=DataArrayDouble::New();
842   a2->alloc(sz,1);
843   if(sz!=0 && (const DataArrayDouble *)_coords)
844     std::copy(_coords->begin(),_coords->end(),a2->getPointer());
845 }
846
847 void MEDCouplingCurveLinearMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<int>& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2,
848                                                  const std::vector<std::string>& littleStrings)
849 {
850   setName(littleStrings[0]);
851   setDescription(littleStrings[1]);
852   setTimeUnit(littleStrings[2]);
853   setTime(tinyInfoD[0],tinyInfo[0],tinyInfo[1]);
854   int sz=tinyInfo[2];
855   _structure.resize(sz);
856   for(int i=0;i<sz;i++)
857     _structure[i]=tinyInfo[3+i];
858   if((int)tinyInfo.size()>sz+3)
859     {
860       _coords=DataArrayDouble::New();
861       std::vector<int> tinyInfo2(tinyInfo.begin()+3+sz,tinyInfo.end());
862       _coords->resizeForUnserialization(tinyInfo2);
863       std::copy(a2->begin(),a2->end(),_coords->getPointer());
864       std::vector<std::string> littleStrings2(littleStrings.begin()+3,littleStrings.end());
865       _coords->finishUnserialization(tinyInfo2,littleStrings2);
866     }
867 }
868
869 void MEDCouplingCurveLinearMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const
870 {
871   std::ostringstream extent;
872   int meshDim=(int)_structure.size();
873   if(meshDim<=0 || meshDim>3)
874     throw INTERP_KERNEL::Exception("MEDCouplingCurveLinearMesh::writeVTKLL : meshDim invalid ! must be in [1,2,3] !");
875   for(int i=0;i<3;i++)
876     { int val=i<meshDim?_structure[i]-1:0; extent << "0 " <<  val << " "; }
877   ofs << "  <" << getVTKDataSetType() << " WholeExtent=\"" << extent.str() << "\">\n";
878   ofs << "    <Piece Extent=\"" << extent.str() << "\">\n";
879   ofs << "      <PointData>\n" << pointData << std::endl;
880   ofs << "      </PointData>\n";
881   ofs << "      <CellData>\n" << cellData << std::endl;
882   ofs << "      </CellData>\n";
883   ofs << "      <Points>\n";
884   if(getSpaceDimension()==3)
885     _coords->writeVTK(ofs,8,"Points",byteData);
886   else
887     {
888       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coo=_coords->changeNbOfComponents(3,0.);
889       coo->writeVTK(ofs,8,"Points",byteData);
890     }
891   ofs << "      </Points>\n";
892   ofs << "    </Piece>\n";
893   ofs << "  </" << getVTKDataSetType() << ">\n";
894 }
895
896 void MEDCouplingCurveLinearMesh::reprQuickOverview(std::ostream& stream) const
897 {
898   stream << "MEDCouplingCurveLinearMesh C++ instance at " << this << ". Name : \"" << getName() << "\".";
899   stream << " Nodal structure : [";
900   for(std::size_t i=0;i<_structure.size();i++)
901     {
902       char tmp='X'+i;
903       stream << " " << tmp << "=" << _structure[i];
904       if(i!=_structure.size()-1)
905         stream << ", ";
906     }
907   stream << " ].";
908   const DataArrayDouble *coo(_coords);
909   if(!coo)
910     { stream << std::endl << "No coordinates set !"; return ; }
911   if(!coo->isAllocated())
912     { stream << std::endl << "Coordinates set but not allocated !"; return ; }
913   int nbOfCompo=coo->getNumberOfComponents();
914   if(nbOfCompo!=(int)_structure.size())
915     { stream << std::endl << "Coordinates set and allocated but mismatch number of components !"; return ; }
916   stream << std::endl << "Coordinates ( number of tuples = " << coo->getNumberOfTuples() << " ) : ";
917   coo->reprQuickOverviewData(stream,200);
918 }
919
920 std::string MEDCouplingCurveLinearMesh::getVTKFileExtension() const
921 {
922   return std::string("vts");
923 }
924
925 std::string MEDCouplingCurveLinearMesh::getVTKDataSetType() const
926 {
927   return std::string("StructuredGrid");
928 }