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 }