src/MEDCoupling/MEDCouplingCMesh.cxx

   1 // Copyright (C) 2007-2013  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.
   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 "MEDCouplingCMesh.hxx"
  22 #include "MEDCouplingMemArray.hxx"
  23 #include "MEDCouplingFieldDouble.hxx"
  24
  25 #include <functional>
  26 #include <algorithm>
  27 #include <sstream>
  28 #include <numeric>
  29
  30 using namespace ParaMEDMEM;
  31
  32 MEDCouplingCMesh::MEDCouplingCMesh():_x_array(0),_y_array(0),_z_array(0)
  33 {
  34 }
  35
  36 MEDCouplingCMesh::MEDCouplingCMesh(const MEDCouplingCMesh& other, bool deepCopy):MEDCouplingStructuredMesh(other,deepCopy)
  37 {
  38   if(deepCopy)
  39     {
  40       if(other._x_array)
  41         _x_array=other._x_array->deepCpy();
  42       else
  43         _x_array=0;
  44       if(other._y_array)
  45         _y_array=other._y_array->deepCpy();
  46       else
  47         _y_array=0;
  48       if(other._z_array)
  49         _z_array=other._z_array->deepCpy();
  50       else
  51         _z_array=0;
  52     }
  53   else
  54     {
  55       _x_array=other._x_array;
  56       if(_x_array)
  57         _x_array->incrRef();
  58       _y_array=other._y_array;
  59       if(_y_array)
  60         _y_array->incrRef();
  61       _z_array=other._z_array;
  62       if(_z_array)
  63         _z_array->incrRef();
  64     }
  65 }
  66
  67 MEDCouplingCMesh::~MEDCouplingCMesh()
  68 {
  69   if(_x_array)
  70     _x_array->decrRef();
  71   if(_y_array)
  72     _y_array->decrRef();
  73   if(_z_array)
  74     _z_array->decrRef();
  75 }
  76
  77 MEDCouplingCMesh *MEDCouplingCMesh::New()
  78 {
  79   return new MEDCouplingCMesh;
  80 }
  81
  82 MEDCouplingCMesh *MEDCouplingCMesh::New(const char *meshName)
  83 {
  84   MEDCouplingCMesh *ret=new MEDCouplingCMesh;
  85   ret->setName(meshName);
  86   return ret;
  87 }
  88
  89 MEDCouplingMesh *MEDCouplingCMesh::deepCpy() const
  90 {
  91   return clone(true);
  92 }
  93
  94 MEDCouplingCMesh *MEDCouplingCMesh::clone(bool recDeepCpy) const
  95 {
  96   return new MEDCouplingCMesh(*this,recDeepCpy);
  97 }
  98
  99 void MEDCouplingCMesh::updateTime() const
 100 {
 101   if(_x_array)
 102     updateTimeWith(*_x_array);
 103   if(_y_array)
 104     updateTimeWith(*_y_array);
 105   if(_z_array)
 106     updateTimeWith(*_z_array);
 107 }
 108
 109 std::size_t MEDCouplingCMesh::getHeapMemorySize() const
 110 {
 111   std::size_t ret=0;
 112   std::set<DataArrayDouble *> s;
 113   s.insert(_x_array); s.insert(_y_array); s.insert(_z_array);
 114   s.erase(NULL);
 115   for(std::set<DataArrayDouble *>::const_iterator it=s.begin();it!=s.end();it++)
 116     if(*it)
 117       ret+=(*it)->getHeapMemorySize();
 118   return MEDCouplingStructuredMesh::getHeapMemorySize()+ret;
 119 }
 120
 121 /*!
 122  * This method copyies all tiny strings from other (name and components name).
 123  * @throw if other and this have not same mesh type.
 124  */
 125 void MEDCouplingCMesh::copyTinyStringsFrom(const MEDCouplingMesh *other) throw(INTERP_KERNEL::Exception)
 126 {
 127   const MEDCouplingCMesh *otherC=dynamic_cast<const MEDCouplingCMesh *>(other);
 128   if(!otherC)
 129     throw INTERP_KERNEL::Exception("MEDCouplingCMesh::copyTinyStringsFrom : meshes have not same type !");
 130   MEDCouplingStructuredMesh::copyTinyStringsFrom(other);
 131   if(_x_array && otherC->_x_array)
 132     _x_array->copyStringInfoFrom(*otherC->_x_array);
 133   if(_y_array && otherC->_y_array)
 134     _y_array->copyStringInfoFrom(*otherC->_y_array);
 135   if(_z_array && otherC->_z_array)
 136     _z_array->copyStringInfoFrom(*otherC->_z_array);
 137 }
 138
 139 bool MEDCouplingCMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const throw(INTERP_KERNEL::Exception)
 140 {
 141   if(!other)
 142     throw INTERP_KERNEL::Exception("MEDCouplingCMesh::isEqualIfNotWhy : input other pointer is null !");
 143   const MEDCouplingCMesh *otherC=dynamic_cast<const MEDCouplingCMesh *>(other);
 144   if(!otherC)
 145     {
 146       reason="mesh given in input is not castable in MEDCouplingCMesh !";
 147       return false;
 148     }
 149   if(!MEDCouplingMesh::isEqualIfNotWhy(other,prec,reason))
 150     return false;
 151   const DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
 152   const DataArrayDouble *otherArr[3]={otherC->_x_array,otherC->_y_array,otherC->_z_array};
 153   std::ostringstream oss; oss.precision(15);
 154   for(int i=0;i<3;i++)
 155     {
 156       if((thisArr[i]!=0 && otherArr[i]==0) || (thisArr[i]==0 && otherArr[i]!=0))
 157         {
 158           oss << "Only one CMesh between the two this and other has its coordinates of rank" << i << " defined !";
 159           reason=oss.str();
 160           return false;
 161         }
 162       if(thisArr[i])
 163         if(!thisArr[i]->isEqualIfNotWhy(*otherArr[i],prec,reason))
 164           {
 165             oss << "Coordinates DataArrayDouble of rank #" << i << " differ :";
 166             reason.insert(0,oss.str());
 167             return false;
 168           }
 169     }
 170   return true;
 171 }
 172
 173 bool MEDCouplingCMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
 174 {
 175   const MEDCouplingCMesh *otherC=dynamic_cast<const MEDCouplingCMesh *>(other);
 176   if(!otherC)
 177     return false;
 178   const DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
 179   const DataArrayDouble *otherArr[3]={otherC->_x_array,otherC->_y_array,otherC->_z_array};
 180   for(int i=0;i<3;i++)
 181     {
 182       if((thisArr[i]!=0 && otherArr[i]==0) || (thisArr[i]==0 && otherArr[i]!=0))
 183         return false;
 184       if(thisArr[i])
 185         if(!thisArr[i]->isEqualWithoutConsideringStr(*otherArr[i],prec))
 186           return false;
 187     }
 188   return true;
 189 }
 190
 191 void MEDCouplingCMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
 192                                             DataArrayInt *&cellCor, DataArrayInt *&nodeCor) const throw(INTERP_KERNEL::Exception)
 193 {
 194   if(!isEqualWithoutConsideringStr(other,prec))
 195     throw INTERP_KERNEL::Exception("MEDCouplingCMesh::checkDeepEquivalWith : Meshes are not the same !");
 196 }
 197
 198 /*!
 199  * Nothing is done here (except to check that the other is a ParaMEDMEM::MEDCouplingCMesh instance too).
 200  * The user intend that the nodes are the same, so by construction of ParaMEDMEM::MEDCouplingCMesh, 'this' and 'other' are the same !
 201  */
 202 void MEDCouplingCMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
 203                                                        DataArrayInt *&cellCor) const throw(INTERP_KERNEL::Exception)
 204 {
 205   const MEDCouplingCMesh *otherC=dynamic_cast<const MEDCouplingCMesh *>(other);
 206   if(!otherC)
 207     throw INTERP_KERNEL::Exception("MEDCouplingCMesh::checkDeepEquivalOnSameNodesWith : other is NOT a cartesian mesh ! Impossible to check equivalence !");
 208 }
 209
 210 void MEDCouplingCMesh::checkCoherency() const throw(INTERP_KERNEL::Exception)
 211 {
 212   const char msg0[]="Invalid ";
 213   const char msg1[]=" array ! Must contain more than 1 element.";
 214   const char msg2[]=" array ! Must be with only one component.";
 215   if(_x_array)
 216     {
 217       if(_x_array->getNbOfElems()<2)
 218         {
 219           std::ostringstream os; os << msg0 << 'X' << msg1;
 220           throw INTERP_KERNEL::Exception(os.str().c_str());
 221         }
 222       if(_x_array->getNumberOfComponents()!=1)
 223         {
 224           std::ostringstream os; os << msg0 << 'X' << msg2;
 225           throw INTERP_KERNEL::Exception(os.str().c_str());
 226         }
 227     }
 228   if(_y_array)
 229     {
 230       if(_y_array->getNbOfElems()<2)
 231         {
 232           std::ostringstream os; os << msg0 << 'Y' << msg1;
 233           throw INTERP_KERNEL::Exception(os.str().c_str());
 234         }
 235       if(_y_array->getNumberOfComponents()!=1)
 236         {
 237           std::ostringstream os; os << msg0 << 'Y' << msg2;
 238           throw INTERP_KERNEL::Exception(os.str().c_str());
 239         }
 240
 241     }
 242   if(_z_array)
 243     {
 244       if(_z_array->getNbOfElems()<2)
 245         {
 246           std::ostringstream os; os << msg0 << 'Z' << msg1;
 247           throw INTERP_KERNEL::Exception(os.str().c_str());
 248         }
 249       if(_z_array->getNumberOfComponents()!=1)
 250         {
 251           std::ostringstream os; os << msg0 << 'Z' << msg2;
 252           throw INTERP_KERNEL::Exception(os.str().c_str());
 253         }
 254     }
 255 }
 256
 257 void MEDCouplingCMesh::checkCoherency1(double eps) const throw(INTERP_KERNEL::Exception)
 258 {
 259   checkCoherency();
 260   if(_x_array)
 261     _x_array->checkMonotonic(true, eps);
 262   if(_y_array)
 263     _y_array->checkMonotonic(true, eps);
 264   if(_z_array)
 265     _z_array->checkMonotonic(true, eps);
 266 }
 267
 268 void MEDCouplingCMesh::checkCoherency2(double eps) const throw(INTERP_KERNEL::Exception)
 269 {
 270   checkCoherency1(eps);
 271 }
 272
 273 int MEDCouplingCMesh::getNumberOfCells() const
 274 {
 275   int ret=1;
 276   if(_x_array)
 277     ret*=_x_array->getNbOfElems()-1;
 278   if(_y_array)
 279     ret*=_y_array->getNbOfElems()-1;
 280   if(_z_array)
 281     ret*=_z_array->getNbOfElems()-1;
 282   return ret;
 283 }
 284
 285 int MEDCouplingCMesh::getNumberOfNodes() const
 286 {
 287   int ret=1;
 288   if(_x_array)
 289     ret*=_x_array->getNbOfElems();
 290   if(_y_array)
 291     ret*=_y_array->getNbOfElems();
 292   if(_z_array)
 293     ret*=_z_array->getNbOfElems();
 294   return ret;
 295 }
 296
 297 void MEDCouplingCMesh::getSplitCellValues(int *res) const
 298 {
 299   int spaceDim=getSpaceDimension();
 300   for(int l=0;l<spaceDim;l++)
 301     {
 302       int val=1;
 303       for(int p=0;p<spaceDim-l-1;p++)
 304         val*=getCoordsAt(p)->getNbOfElems()-1;
 305       res[spaceDim-l-1]=val;
 306     }
 307 }
 308
 309 void MEDCouplingCMesh::getSplitNodeValues(int *res) const
 310 {
 311   int spaceDim=getSpaceDimension();
 312   for(int l=0;l<spaceDim;l++)
 313     {
 314       int val=1;
 315       for(int p=0;p<spaceDim-l-1;p++)
 316         val*=getCoordsAt(p)->getNbOfElems();
 317       res[spaceDim-l-1]=val;
 318     }
 319 }
 320
 321 void MEDCouplingCMesh::getNodeGridStructure(int *res) const
 322 {
 323   int meshDim=getMeshDimension();
 324   for(int i=0;i<meshDim;i++)
 325     res[i]=getCoordsAt(i)->getNbOfElems();
 326 }
 327
 328 int MEDCouplingCMesh::getSpaceDimension() const
 329 {
 330   int ret=0;
 331   if(_x_array)
 332     ret++;
 333   if(_y_array)
 334     ret++;
 335   if(_z_array)
 336     ret++;
 337   return ret;
 338 }
 339
 340 int MEDCouplingCMesh::getMeshDimension() const
 341 {
 342   return getSpaceDimension();
 343 }
 344
 345 void MEDCouplingCMesh::getCoordinatesOfNode(int nodeId, std::vector<double>& coo) const throw(INTERP_KERNEL::Exception)
 346 {
 347   int tmp[3];
 348   int spaceDim=getSpaceDimension();
 349   getSplitNodeValues(tmp);
 350   const DataArrayDouble *tabs[3]={getCoordsAt(0),getCoordsAt(1),getCoordsAt(2)};
 351   int tmp2[3];
 352   GetPosFromId(nodeId,spaceDim,tmp,tmp2);
 353   for(int j=0;j<spaceDim;j++)
 354     if(tabs[j])
 355       coo.push_back(tabs[j]->getConstPointer()[tmp2[j]]);
 356 }
 357
 358 std::string MEDCouplingCMesh::simpleRepr() const
 359 {
 360   std::ostringstream ret;
 361   ret << "Cartesian mesh with name : \"" << getName() << "\"\n";
 362   ret << "Description of mesh : \"" << getDescription() << "\"\n";
 363   int tmpp1,tmpp2;
 364   double tt=getTime(tmpp1,tmpp2);
 365   ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
 366   ret << "Iteration : " << tmpp1  << " Order : " << tmpp2 << "\n";
 367   ret << "Mesh and SpaceDimension dimension : " << getSpaceDimension() << "\n\nArrays :\n________\n\n";
 368   if(_x_array)
 369     {
 370       ret << "X Array :\n";
 371       _x_array->reprZipWithoutNameStream(ret);
 372     }
 373   if(_y_array)
 374     {
 375       ret << "Y Array :\n";
 376       _y_array->reprZipWithoutNameStream(ret);
 377     }
 378   if(_z_array)
 379     {
 380       ret << "Z Array :\n";
 381       _z_array->reprZipWithoutNameStream(ret);
 382     }
 383   return ret.str();
 384 }
 385
 386 std::string MEDCouplingCMesh::advancedRepr() const
 387 {
 388   return simpleRepr();
 389 }
 390
 391 const DataArrayDouble *MEDCouplingCMesh::getCoordsAt(int i) const throw(INTERP_KERNEL::Exception)
 392 {
 393   switch(i)
 394     {
 395     case 0:
 396       return _x_array;
 397     case 1:
 398       return _y_array;
 399     case 2:
 400       return _z_array;
 401     default:
 402       throw INTERP_KERNEL::Exception("Invalid rank specified must be 0 or 1 or 2.");
 403     }
 404 }
 405
 406 DataArrayDouble *MEDCouplingCMesh::getCoordsAt(int i) throw(INTERP_KERNEL::Exception)
 407 {
 408   switch(i)
 409     {
 410     case 0:
 411       return _x_array;
 412     case 1:
 413       return _y_array;
 414     case 2:
 415       return _z_array;
 416     default:
 417       throw INTERP_KERNEL::Exception("Invalid rank specified must be 0 or 1 or 2.");
 418     }
 419 }
 420
 421 void MEDCouplingCMesh::setCoordsAt(int i, const DataArrayDouble *arr) throw(INTERP_KERNEL::Exception)
 422 {
 423   if(arr)
 424     arr->checkNbOfComps(1,"MEDCouplingCMesh::setCoordsAt");
 425   DataArrayDouble **thisArr[3]={&_x_array,&_y_array,&_z_array};
 426   if(i<0 || i>2)
 427     throw INTERP_KERNEL::Exception("Invalid rank specified must be 0 or 1 or 2.");
 428   if(arr!=*(thisArr[i]))
 429     {
 430       if(*(thisArr[i]))
 431         (*(thisArr[i]))->decrRef();
 432       (*(thisArr[i]))=const_cast<DataArrayDouble *>(arr);
 433       if(*(thisArr[i]))
 434         (*(thisArr[i]))->incrRef();
 435       declareAsNew();
 436     }
 437 }
 438
 439 void MEDCouplingCMesh::setCoords(const DataArrayDouble *coordsX, const DataArrayDouble *coordsY, const DataArrayDouble *coordsZ)
 440 {
 441   if(coordsX)
 442     coordsX->checkNbOfComps(1,"MEDCouplingCMesh::setCoords : coordsX");
 443   if(coordsY)
 444     coordsY->checkNbOfComps(1,"MEDCouplingCMesh::setCoords : coordsY");
 445   if(coordsZ)
 446     coordsZ->checkNbOfComps(1,"MEDCouplingCMesh::setCoords : coordsZ");
 447   if(_x_array)
 448     _x_array->decrRef();
 449   _x_array=const_cast<DataArrayDouble *>(coordsX);
 450   if(_x_array)
 451     _x_array->incrRef();
 452   if(_y_array)
 453     _y_array->decrRef();
 454   _y_array=const_cast<DataArrayDouble *>(coordsY);
 455   if(_y_array)
 456     _y_array->incrRef();
 457   if(_z_array)
 458     _z_array->decrRef();
 459   _z_array=const_cast<DataArrayDouble *>(coordsZ);
 460   if(_z_array)
 461     _z_array->incrRef();
 462   declareAsNew();
 463 }
 464
 465 void MEDCouplingCMesh::getBoundingBox(double *bbox) const
 466 {
 467   int dim=getSpaceDimension();
 468   int j=0;
 469   for (int idim=0; idim<dim; idim++)
 470     {
 471       const DataArrayDouble *c=getCoordsAt(idim);
 472       if(c)
 473         {
 474           const double *coords=c->getConstPointer();
 475           int nb=c->getNbOfElems();
 476           bbox[2*j]=coords[0];
 477           bbox[2*j+1]=coords[nb-1];
 478           j++;
 479         }
 480     }
 481 }
 482
 483 MEDCouplingFieldDouble *MEDCouplingCMesh::getMeasureField(bool isAbs) const
 484 {
 485   std::string name="MeasureOfMesh_";
 486   name+=getName();
 487   int nbelem=getNumberOfCells();
 488   MEDCouplingFieldDouble *field=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 489   field->setName(name.c_str());
 490   DataArrayDouble* array=DataArrayDouble::New();
 491   array->alloc(nbelem,1);
 492   double *area_vol=array->getPointer();
 493   field->setArray(array) ;
 494   array->decrRef();
 495   field->setMesh(const_cast<MEDCouplingCMesh *>(this));
 496   field->synchronizeTimeWithMesh();
 497   int tmp[3];
 498   getSplitCellValues(tmp);
 499   int dim=getSpaceDimension();
 500   const double **thisArr=new const double *[dim];
 501   const DataArrayDouble *thisArr2[3]={_x_array,_y_array,_z_array};
 502   for(int i=0;i<dim;i++)
 503     thisArr[i]=thisArr2[i]->getConstPointer();
 504   for(int icell=0;icell<nbelem;icell++)
 505     {
 506       int tmp2[3];
 507       GetPosFromId(icell,dim,tmp,tmp2);
 508       area_vol[icell]=1.;
 509       for(int i=0;i<dim;i++)
 510         area_vol[icell]*=thisArr[i][tmp2[i]+1]-thisArr[i][tmp2[i]];
 511     }
 512   delete [] thisArr;
 513   return field;
 514 }
 515
 516 /*!
 517  * not implemented yet !
 518  */
 519 MEDCouplingFieldDouble *MEDCouplingCMesh::getMeasureFieldOnNode(bool isAbs) const
 520 {
 521   throw INTERP_KERNEL::Exception("MEDCouplingCMesh::getMeasureFieldOnNode : not implemented yet !");
 522   //return 0;
 523 }
 524
 525 int MEDCouplingCMesh::getCellContainingPoint(const double *pos, double eps) const
 526 {
 527   int dim=getSpaceDimension();
 528   int ret=0;
 529   int coeff=1;
 530   for(int i=0;i<dim;i++)
 531     {
 532       const double *d=getCoordsAt(i)->getConstPointer();
 533       int nbOfNodes=getCoordsAt(i)->getNbOfElems();
 534       double ref=pos[i];
 535       const double *w=std::find_if(d,d+nbOfNodes,std::bind2nd(std::greater_equal<double>(),ref));
 536       int w2=(int)std::distance(d,w);
 537       if(w2<nbOfNodes)
 538         {
 539           if(w2==0)
 540             {
 541               if(ref>d[0]-eps)
 542                 w2=1;
 543               else
 544                 return -1;
 545             }
 546           ret+=coeff*(w2-1);
 547           coeff*=nbOfNodes-1;
 548         }
 549       else
 550         return -1;
 551     }
 552   return ret;
 553 }
 554
 555 void MEDCouplingCMesh::rotate(const double *center, const double *vector, double angle)
 556 {
 557   throw INTERP_KERNEL::Exception("No rotation available on CMesh : Traduce it to StructuredMesh to apply it !");
 558 }
 559
 560 void MEDCouplingCMesh::translate(const double *vector)
 561 {
 562   if(_x_array)
 563     std::transform(_x_array->getConstPointer(),_x_array->getConstPointer()+_x_array->getNbOfElems(),
 564                    _x_array->getPointer(),std::bind2nd(std::plus<double>(),vector[0]));
 565   if(_y_array)
 566     std::transform(_y_array->getConstPointer(),_y_array->getConstPointer()+_y_array->getNbOfElems(),
 567                    _y_array->getPointer(),std::bind2nd(std::plus<double>(),vector[1]));
 568   if(_z_array)
 569     std::transform(_z_array->getConstPointer(),_z_array->getConstPointer()+_z_array->getNbOfElems(),
 570                    _z_array->getPointer(),std::bind2nd(std::plus<double>(),vector[2]));
 571 }
 572
 573 void MEDCouplingCMesh::scale(const double *point, double factor)
 574 {
 575   for(int i=0;i<3;i++)
 576     {
 577       DataArrayDouble *c=getCoordsAt(i);
 578       if(c)
 579         {
 580           double *coords=c->getPointer();
 581           int lgth=c->getNbOfElems();
 582           std::transform(coords,coords+lgth,coords,std::bind2nd(std::minus<double>(),point[i]));
 583           std::transform(coords,coords+lgth,coords,std::bind2nd(std::multiplies<double>(),factor));
 584           std::transform(coords,coords+lgth,coords,std::bind2nd(std::plus<double>(),point[i]));
 585           c->declareAsNew();
 586         }
 587     }
 588   updateTime();
 589 }
 590
 591 MEDCouplingMesh *MEDCouplingCMesh::mergeMyselfWith(const MEDCouplingMesh *other) const
 592 {
 593   //not implemented yet !
 594   return 0;
 595 }
 596
 597 DataArrayDouble *MEDCouplingCMesh::getCoordinatesAndOwner() const
 598 {
 599   DataArrayDouble *ret=DataArrayDouble::New();
 600   int spaceDim=getSpaceDimension();
 601   int nbNodes=getNumberOfNodes();
 602   ret->alloc(nbNodes,spaceDim);
 603   double *pt=ret->getPointer();
 604   int tmp[3];
 605   getSplitNodeValues(tmp);
 606   const DataArrayDouble *tabs[3]={getCoordsAt(0),getCoordsAt(1),getCoordsAt(2)};
 607   const double *tabsPtr[3];
 608   for(int j=0;j<spaceDim;j++)
 609     {
 610       tabsPtr[j]=tabs[j]->getConstPointer();
 611       ret->setInfoOnComponent(j,tabs[j]->getInfoOnComponent(0).c_str());
 612     }
 613   int tmp2[3];
 614   for(int i=0;i<nbNodes;i++)
 615     {
 616       GetPosFromId(i,spaceDim,tmp,tmp2);
 617       for(int j=0;j<spaceDim;j++)
 618         pt[i*spaceDim+j]=tabsPtr[j][tmp2[j]];
 619     }
 620   return ret;
 621 }
 622
 623 DataArrayDouble *MEDCouplingCMesh::getBarycenterAndOwner() const
 624 {
 625   DataArrayDouble *ret=DataArrayDouble::New();
 626   int spaceDim=getSpaceDimension();
 627   int nbCells=getNumberOfCells();
 628   ret->alloc(nbCells,spaceDim);
 629   double *pt=ret->getPointer();
 630   int tmp[3];
 631   getSplitCellValues(tmp);
 632   const DataArrayDouble *tabs[3]={getCoordsAt(0),getCoordsAt(1),getCoordsAt(2)};
 633   std::vector<double> tabsPtr[3];
 634   for(int j=0;j<spaceDim;j++)
 635     {
 636       int sz=tabs[j]->getNbOfElems()-1;
 637       ret->setInfoOnComponent(j,tabs[j]->getInfoOnComponent(0).c_str());
 638       const double *srcPtr=tabs[j]->getConstPointer();
 639       tabsPtr[j].insert(tabsPtr[j].end(),srcPtr,srcPtr+sz);
 640       std::transform(tabsPtr[j].begin(),tabsPtr[j].end(),srcPtr+1,tabsPtr[j].begin(),std::plus<double>());
 641       std::transform(tabsPtr[j].begin(),tabsPtr[j].end(),tabsPtr[j].begin(),std::bind2nd(std::multiplies<double>(),0.5));
 642     }
 643   int tmp2[3];
 644   for(int i=0;i<nbCells;i++)
 645     {
 646       GetPosFromId(i,spaceDim,tmp,tmp2);
 647       for(int j=0;j<spaceDim;j++)
 648         pt[i*spaceDim+j]=tabsPtr[j][tmp2[j]];
 649     }
 650   return ret;
 651 }
 652
 653 DataArrayDouble *MEDCouplingCMesh::computeIsoBarycenterOfNodesPerCell() const throw(INTERP_KERNEL::Exception)
 654 {
 655   return MEDCouplingCMesh::getBarycenterAndOwner();
 656 }
 657
 658 void MEDCouplingCMesh::renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception)
 659 {
 660   throw INTERP_KERNEL::Exception("Functionnality of renumbering cell not available for CMesh !");
 661 }
 662
 663 void MEDCouplingCMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<int>& tinyInfo, std::vector<std::string>& littleStrings) const
 664 {
 665   int it,order;
 666   double time=getTime(it,order);
 667   tinyInfo.clear();
 668   tinyInfoD.clear();
 669   littleStrings.clear();
 670   littleStrings.push_back(getName());
 671   littleStrings.push_back(getDescription());
 672   littleStrings.push_back(getTimeUnit());
 673   const DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
 674   for(int i=0;i<3;i++)
 675     {
 676       int val=-1;
 677       std::string st;
 678       if(thisArr[i])
 679         {
 680           val=thisArr[i]->getNumberOfTuples();
 681           st=thisArr[i]->getInfoOnComponent(0);
 682         }
 683       tinyInfo.push_back(val);
 684       littleStrings.push_back(st);
 685     }
 686   tinyInfo.push_back(it);
 687   tinyInfo.push_back(order);
 688   tinyInfoD.push_back(time);
 689 }
 690
 691 void MEDCouplingCMesh::resizeForUnserialization(const std::vector<int>& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
 692 {
 693   a1->alloc(0,1);
 694   int sum=0;
 695   for(int i=0;i<3;i++)
 696     if(tinyInfo[i]!=-1)
 697       sum+=tinyInfo[i];
 698   a2->alloc(sum,1);
 699 }
 700
 701 void MEDCouplingCMesh::serialize(DataArrayInt *&a1, DataArrayDouble *&a2) const
 702 {
 703   a1=DataArrayInt::New();
 704   a1->alloc(0,1);
 705   const DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
 706   int sz=0;
 707   for(int i=0;i<3;i++)
 708     {
 709       if(thisArr[i])
 710         sz+=thisArr[i]->getNumberOfTuples();
 711     }
 712   a2=DataArrayDouble::New();
 713   a2->alloc(sz,1);
 714   double *a2Ptr=a2->getPointer();
 715   for(int i=0;i<3;i++)
 716     if(thisArr[i])
 717       a2Ptr=std::copy(thisArr[i]->getConstPointer(),thisArr[i]->getConstPointer()+thisArr[i]->getNumberOfTuples(),a2Ptr);
 718 }
 719
 720 void MEDCouplingCMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<int>& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2,
 721                                        const std::vector<std::string>& littleStrings)
 722 {
 723   setName(littleStrings[0].c_str());
 724   setDescription(littleStrings[1].c_str());
 725   setTimeUnit(littleStrings[2].c_str());
 726   DataArrayDouble **thisArr[3]={&_x_array,&_y_array,&_z_array};
 727   const double *data=a2->getConstPointer();
 728   for(int i=0;i<3;i++)
 729     {
 730       if(tinyInfo[i]!=-1)
 731         {
 732           (*(thisArr[i]))=DataArrayDouble::New();
 733           (*(thisArr[i]))->alloc(tinyInfo[i],1);
 734           (*(thisArr[i]))->setInfoOnComponent(0,littleStrings[i+3].c_str());
 735           std::copy(data,data+tinyInfo[i],(*(thisArr[i]))->getPointer());
 736           data+=tinyInfo[i];
 737         }
 738     }
 739   setTime(tinyInfoD[0],tinyInfo[3],tinyInfo[4]);
 740 }
 741
 742 void MEDCouplingCMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData) const throw(INTERP_KERNEL::Exception)
 743 {
 744   std::ostringstream extent;
 745   DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
 746   for(int i=0;i<3;i++)
 747     {
 748       if(thisArr[i])
 749         { extent << "0 " <<  thisArr[i]->getNumberOfTuples()-1 << " "; }
 750       else
 751         { extent << "0 0 "; }
 752     }
 753   ofs << "  <" << getVTKDataSetType() << " WholeExtent=\"" << extent.str() << "\">\n";
 754   ofs << "    <Piece Extent=\"" << extent.str() << "\">\n";
 755   ofs << "      <PointData>\n" << pointData << std::endl;
 756   ofs << "      </PointData>\n";
 757   ofs << "      <CellData>\n" << cellData << std::endl;
 758   ofs << "      </CellData>\n";
 759   ofs << "      <Coordinates>\n";
 760   for(int i=0;i<3;i++)
 761     {
 762       if(thisArr[i])
 763         thisArr[i]->writeVTK(ofs,8,"Array");
 764       else
 765         {
 766           MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coo=DataArrayDouble::New(); coo->alloc(1,1);
 767           coo->setIJ(0,0,0.);
 768           coo->writeVTK(ofs,8,"Array");
 769         }
 770     }
 771   ofs << "      </Coordinates>\n";
 772   ofs << "    </Piece>\n";
 773   ofs << "  </" << getVTKDataSetType() << ">\n";
 774 }
 775
 776 void MEDCouplingCMesh::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
 777 {
 778   stream << "MEDCouplingCMesh C++ instance at " << this << ".";
 779 }
 780
 781 std::string MEDCouplingCMesh::getVTKDataSetType() const throw(INTERP_KERNEL::Exception)
 782 {
 783   return std::string("RectilinearGrid");
 784 }