1 // Copyright (C) 2007-2023 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (CEA/DEN)
21 #include "MEDCouplingMappedExtrudedMesh.hxx"
22 #include "MEDCouplingUMesh.hxx"
23 #include "MEDCouplingCMesh.hxx"
24 #include "MEDCouplingMemArray.hxx"
25 #include "MEDCouplingFieldDouble.hxx"
27 #include "CellModel.hxx"
29 #include "InterpolationUtils.hxx"
40 using namespace MEDCoupling;
43 * Build an extruded mesh instance from 3D and 2D unstructured mesh lying on the \b same \b coords.
44 * @param mesh3D 3D unstructured mesh.
45 * @param mesh2D 2D unstructured mesh lying on the same coordinates than mesh3D. \b Warning mesh2D is \b not \b const
46 * because the mesh is aggregated and potentially modified by rotate or translate method.
47 * @param cell2DId Id of cell in mesh2D mesh where the computation of 1D mesh will be done.
49 MEDCouplingMappedExtrudedMesh *MEDCouplingMappedExtrudedMesh::New(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, mcIdType cell2DId)
51 return new MEDCouplingMappedExtrudedMesh(mesh3D,mesh2D,cell2DId);
54 MEDCouplingMappedExtrudedMesh *MEDCouplingMappedExtrudedMesh::New(const MEDCouplingCMesh *mesh3D)
56 return new MEDCouplingMappedExtrudedMesh(mesh3D);
60 * This constructor is here only for unserialisation process.
61 * This constructor is normally completely useless for end user.
63 MEDCouplingMappedExtrudedMesh *MEDCouplingMappedExtrudedMesh::New()
65 return new MEDCouplingMappedExtrudedMesh;
68 MEDCouplingMeshType MEDCouplingMappedExtrudedMesh::getType() const
73 std::size_t MEDCouplingMappedExtrudedMesh::getHeapMemorySizeWithoutChildren() const
75 return MEDCouplingMesh::getHeapMemorySizeWithoutChildren();
78 std::vector<const BigMemoryObject *> MEDCouplingMappedExtrudedMesh::getDirectChildrenWithNull() const
80 std::vector<const BigMemoryObject *> ret;
81 ret.push_back(_mesh2D);
82 ret.push_back(_mesh1D);
83 ret.push_back(_mesh3D_ids);
88 * This method copyies all tiny strings from other (name and components name).
89 * @throw if other and this have not same mesh type.
91 void MEDCouplingMappedExtrudedMesh::copyTinyStringsFrom(const MEDCouplingMesh *other)
93 const MEDCouplingMappedExtrudedMesh *otherC=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(other);
95 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::copyTinyStringsFrom : meshes have not same type !");
96 MEDCouplingMesh::copyTinyStringsFrom(other);
97 _mesh2D->copyTinyStringsFrom(otherC->_mesh2D);
98 _mesh1D->copyTinyStringsFrom(otherC->_mesh1D);
101 MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, mcIdType cell2DId)
102 try:_mesh2D(const_cast<MEDCouplingUMesh *>(mesh2D)),_mesh1D(MEDCouplingUMesh::New()),_mesh3D_ids(0),_cell_2D_id(cell2DId)
104 if(_mesh2D.isNotNull())
106 computeExtrusion(mesh3D);
107 setName(mesh3D->getName()); setDescription(mesh3D->getDescription());
109 catch(INTERP_KERNEL::Exception& e)
114 MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingCMesh *mesh3D):_mesh1D(MEDCouplingUMesh::New()),_mesh3D_ids(0),_cell_2D_id(0)
117 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh contrct : null input pointer !");
118 if(mesh3D->getMeshDimension()!=3)
119 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh contrct : input cart mesh must have dimension equal to 3 !");
120 MCAuto<MEDCouplingUMesh> umesh3D(mesh3D->buildUnstructured());
121 MCAuto<MEDCouplingCMesh> cmesh2D(MEDCouplingCMesh::New()); cmesh2D->setName(mesh3D->getName());
122 cmesh2D->setCoords(mesh3D->getCoordsAt(0),mesh3D->getCoordsAt(1));
123 _mesh2D=cmesh2D->buildUnstructured();
124 _mesh2D->setCoords(umesh3D->getCoords());
125 computeExtrusion(umesh3D);
126 setName(mesh3D->getName()); setDescription(mesh3D->getDescription());
129 MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh():_mesh2D(0),_mesh1D(0),_mesh3D_ids(0),_cell_2D_id(-1)
133 MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingMappedExtrudedMesh& other, bool deepCpy):MEDCouplingMesh(other),_cell_2D_id(other._cell_2D_id)
137 _mesh2D=other._mesh2D->clone(true);
138 _mesh1D=other._mesh1D->clone(true);
139 _mesh3D_ids=other._mesh3D_ids->deepCopy();
143 _mesh2D=other._mesh2D;
144 _mesh1D=other._mesh1D;
145 _mesh3D_ids=other._mesh3D_ids;
149 mcIdType MEDCouplingMappedExtrudedMesh::getNumberOfCells() const
151 return _mesh2D->getNumberOfCells()*_mesh1D->getNumberOfCells();
154 mcIdType MEDCouplingMappedExtrudedMesh::getNumberOfNodes() const
156 return _mesh2D->getNumberOfNodes();
159 int MEDCouplingMappedExtrudedMesh::getSpaceDimension() const
164 int MEDCouplingMappedExtrudedMesh::getMeshDimension() const
169 MEDCouplingMappedExtrudedMesh *MEDCouplingMappedExtrudedMesh::deepCopy() const
174 MEDCouplingMappedExtrudedMesh *MEDCouplingMappedExtrudedMesh::clone(bool recDeepCpy) const
176 return new MEDCouplingMappedExtrudedMesh(*this,recDeepCpy);
179 const DataArrayDouble *MEDCouplingMappedExtrudedMesh::getDirectAccessOfCoordsArrIfInStructure() const
181 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::getDirectAccessOfCoordsArrIfInStructure : no direct access of DataArrayDouble holding nodes !");
184 bool MEDCouplingMappedExtrudedMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const
187 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::isEqualIfNotWhy : input other pointer is null !");
188 const MEDCouplingMappedExtrudedMesh *otherC=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(other);
189 std::ostringstream oss;
192 reason="mesh given in input is not castable in MEDCouplingMappedExtrudedMesh !";
195 if(!MEDCouplingMesh::isEqualIfNotWhy(other,prec,reason))
197 if(!_mesh2D->isEqualIfNotWhy(otherC->_mesh2D,prec,reason))
199 reason.insert(0,"Mesh2D unstructured meshes differ : ");
202 if(!_mesh1D->isEqualIfNotWhy(otherC->_mesh1D,prec,reason))
204 reason.insert(0,"Mesh1D unstructured meshes differ : ");
207 if(!_mesh3D_ids->isEqualIfNotWhy(*otherC->_mesh3D_ids,reason))
209 reason.insert(0,"Mesh3D ids DataArrayInt instances differ : ");
212 if(_cell_2D_id!=otherC->_cell_2D_id)
214 oss << "Cell 2D id of the two extruded mesh differ : this = " << _cell_2D_id << " other = " << otherC->_cell_2D_id;
221 bool MEDCouplingMappedExtrudedMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
223 const MEDCouplingMappedExtrudedMesh *otherC=dynamic_cast<const MEDCouplingMappedExtrudedMesh *>(other);
226 if(!_mesh2D->isEqualWithoutConsideringStr(otherC->_mesh2D,prec))
228 if(!_mesh1D->isEqualWithoutConsideringStr(otherC->_mesh1D,prec))
230 if(!_mesh3D_ids->isEqualWithoutConsideringStr(*otherC->_mesh3D_ids))
232 if(_cell_2D_id!=otherC->_cell_2D_id)
237 void MEDCouplingMappedExtrudedMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
238 DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const
240 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::checkDeepEquivalWith : not implemented yet !");
243 void MEDCouplingMappedExtrudedMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
244 DataArrayIdType *&cellCor) const
246 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::checkDeepEquivalOnSameNodesWith : not implemented yet !");
249 INTERP_KERNEL::NormalizedCellType MEDCouplingMappedExtrudedMesh::getTypeOfCell(mcIdType cellId) const
251 const mcIdType *ids(_mesh3D_ids->begin());
252 std::size_t nbOf3DCells(_mesh3D_ids->getNumberOfTuples());
253 const mcIdType *where(std::find(ids,ids+nbOf3DCells,cellId));
254 if(where==ids+nbOf3DCells)
255 throw INTERP_KERNEL::Exception("Invalid cellId specified >= getNumberOfCells() !");
256 std::size_t nbOfCells2D(_mesh2D->getNumberOfCells());
257 std::size_t locId((std::distance(ids,where))%nbOfCells2D);
258 INTERP_KERNEL::NormalizedCellType tmp(_mesh2D->getTypeOfCell(ToIdType(locId)));
259 return INTERP_KERNEL::CellModel::GetCellModel(tmp).getExtrudedType();
262 std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingMappedExtrudedMesh::getAllGeoTypes() const
264 std::set<INTERP_KERNEL::NormalizedCellType> ret2D(_mesh2D->getAllGeoTypes());
265 std::set<INTERP_KERNEL::NormalizedCellType> ret;
266 for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=ret2D.begin();it!=ret2D.end();it++)
267 ret.insert(INTERP_KERNEL::CellModel::GetCellModel(*it).getExtrudedType());
271 DataArrayIdType *MEDCouplingMappedExtrudedMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
273 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
274 INTERP_KERNEL::NormalizedCellType revExtTyp(cm.getReverseExtrudedType());
275 MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
276 if(revExtTyp==INTERP_KERNEL::NORM_ERROR)
281 MCAuto<DataArrayIdType> tmp(_mesh2D->giveCellsWithType(revExtTyp));
282 mcIdType nbOfLevs=_mesh1D->getNumberOfCells();
283 mcIdType nbOfCells2D=_mesh2D->getNumberOfCells();
284 mcIdType nbOfTuples(tmp->getNumberOfTuples());
285 ret->alloc(nbOfLevs*nbOfTuples,1);
286 mcIdType *pt(ret->getPointer());
287 for(int i=0;i<nbOfLevs;i++,pt+=nbOfTuples)
288 std::transform(tmp->begin(),tmp->end(),pt,std::bind(std::plus<mcIdType>(),std::placeholders::_1,i*nbOfCells2D));
289 MCAuto<DataArrayIdType> ret2(ret->renumberR(_mesh3D_ids->begin()));
294 DataArrayIdType *MEDCouplingMappedExtrudedMesh::computeNbOfNodesPerCell() const
296 MCAuto<DataArrayIdType> ret2D(_mesh2D->computeNbOfNodesPerCell());
297 mcIdType nbOfLevs=_mesh1D->getNumberOfCells();
298 mcIdType nbOfCells2D=_mesh2D->getNumberOfCells();
299 MCAuto<DataArrayIdType> ret3D(DataArrayIdType::New()); ret3D->alloc(nbOfLevs*nbOfCells2D,1);
300 mcIdType *pt(ret3D->getPointer());
301 for(int i=0;i<nbOfLevs;i++,pt+=nbOfCells2D)
302 std::copy(ret2D->begin(),ret2D->end(),pt);
303 ret3D->applyLin(2,0,0);
304 return ret3D->renumberR(_mesh3D_ids->begin());
307 DataArrayIdType *MEDCouplingMappedExtrudedMesh::computeNbOfFacesPerCell() const
309 MCAuto<DataArrayIdType> ret2D(_mesh2D->computeNbOfNodesPerCell());
310 mcIdType nbOfLevs=_mesh1D->getNumberOfCells();
311 mcIdType nbOfCells2D=_mesh2D->getNumberOfCells();
312 MCAuto<DataArrayIdType> ret3D(DataArrayIdType::New()); ret3D->alloc(nbOfLevs*nbOfCells2D,1);
313 mcIdType *pt(ret3D->getPointer());
314 for(int i=0;i<nbOfLevs;i++,pt+=nbOfCells2D)
315 std::copy(ret2D->begin(),ret2D->end(),pt);
316 ret3D->applyLin(2,2,0);
317 return ret3D->renumberR(_mesh3D_ids->begin());
320 DataArrayIdType *MEDCouplingMappedExtrudedMesh::computeEffectiveNbOfNodesPerCell() const
322 return computeNbOfNodesPerCell();
325 mcIdType MEDCouplingMappedExtrudedMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
328 mcIdType nbOfCells2D(_mesh2D->getNumberOfCells());
329 for(mcIdType i=0;i<nbOfCells2D;i++)
331 INTERP_KERNEL::NormalizedCellType t(_mesh2D->getTypeOfCell(i));
332 if(INTERP_KERNEL::CellModel::GetCellModel(t).getExtrudedType()==type)
335 return ret*_mesh1D->getNumberOfCells();
338 void MEDCouplingMappedExtrudedMesh::getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const
340 mcIdType nbOfCells2D(_mesh2D->getNumberOfCells());
341 mcIdType nbOfNodes2D(_mesh2D->getNumberOfNodes());
342 mcIdType locId(cellId%nbOfCells2D);
343 mcIdType lev(cellId/nbOfCells2D);
344 std::vector<mcIdType> tmp,tmp2;
345 _mesh2D->getNodeIdsOfCell(locId,tmp);
347 std::transform(tmp.begin(),tmp.end(),tmp.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,nbOfNodes2D*lev));
348 std::transform(tmp2.begin(),tmp2.end(),tmp2.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,nbOfNodes2D*(lev+1)));
349 conn.insert(conn.end(),tmp.begin(),tmp.end());
350 conn.insert(conn.end(),tmp2.begin(),tmp2.end());
353 void MEDCouplingMappedExtrudedMesh::getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const
355 mcIdType nbOfNodes2D(_mesh2D->getNumberOfNodes());
356 mcIdType locId(nodeId%nbOfNodes2D);
357 mcIdType lev(nodeId/nbOfNodes2D);
358 std::vector<double> tmp,tmp2;
359 _mesh2D->getCoordinatesOfNode(locId,tmp);
361 int spaceDim(_mesh1D->getSpaceDimension());
362 const double *z(_mesh1D->getCoords()->begin());
363 std::transform(tmp.begin(),tmp.end(),z+lev*spaceDim,tmp.begin(),std::plus<double>());
364 std::transform(tmp2.begin(),tmp2.end(),z+(lev+1)*spaceDim,tmp2.begin(),std::plus<double>());
365 coo.insert(coo.end(),tmp.begin(),tmp.end());
366 coo.insert(coo.end(),tmp2.begin(),tmp2.end());
369 std::string MEDCouplingMappedExtrudedMesh::simpleRepr() const
371 std::ostringstream ret;
372 ret << "3D Extruded mesh from a 2D Surf Mesh with name : \"" << getName() << "\"\n";
373 ret << "Description of mesh : \"" << getDescription() << "\"\n";
375 double tt=getTime(tmpp1,tmpp2);
376 ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
377 ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
378 ret << "Cell id where 1D mesh has been deduced : " << _cell_2D_id << "\n";
379 ret << "Number of cells : " << getNumberOfCells() << "(" << _mesh2D->getNumberOfCells() << "x" << _mesh1D->getNumberOfCells() << ")\n";
380 ret << "1D Mesh info : _____________________\n\n\n";
381 ret << _mesh1D->simpleRepr();
382 ret << "\n\n\n2D Mesh info : _____________________\n\n\n" << _mesh2D->simpleRepr() << "\n\n\n";
386 std::string MEDCouplingMappedExtrudedMesh::advancedRepr() const
388 std::ostringstream ret;
389 ret << "3D Extruded mesh from a 2D Surf Mesh with name : \"" << getName() << "\"\n";
390 ret << "Description of mesh : \"" << getDescription() << "\"\n";
392 double tt=getTime(tmpp1,tmpp2);
393 ret << "Time attached to the mesh (unit) : " << tt << " (" << getTimeUnit() << ")\n";
394 ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
395 ret << "Cell id where 1D mesh has been deduced : " << _cell_2D_id << "\n";
396 ret << "Number of cells : " << getNumberOfCells() << "(" << _mesh2D->getNumberOfCells() << "x" << _mesh1D->getNumberOfCells() << ")\n";
397 ret << "1D Mesh info : _____________________\n\n\n";
398 ret << _mesh1D->advancedRepr();
399 ret << "\n\n\n2D Mesh info : _____________________\n\n\n" << _mesh2D->advancedRepr() << "\n\n\n";
400 ret << "3D cell ids per level :\n";
404 void MEDCouplingMappedExtrudedMesh::checkConsistencyLight() const
408 void MEDCouplingMappedExtrudedMesh::checkConsistency(double eps) const
410 checkConsistencyLight();
413 void MEDCouplingMappedExtrudedMesh::getBoundingBox(double *bbox) const
416 _mesh2D->getBoundingBox(bbox2D);
417 const double *nodes1D(_mesh1D->getCoords()->begin());
418 mcIdType nbOfNodes1D(_mesh1D->getNumberOfNodes());
419 double bbox1DMin[3],bbox1DMax[3],tmp[3];
420 std::fill(bbox1DMin,bbox1DMin+3,std::numeric_limits<double>::max());
421 std::fill(bbox1DMax,bbox1DMax+3,-(std::numeric_limits<double>::max()));
422 for(mcIdType i=0;i<nbOfNodes1D;i++)
424 std::transform(nodes1D+3*i,nodes1D+3*(i+1),bbox1DMin,bbox1DMin,static_cast<const double& (*)(const double&, const double&)>(std::min<double>));
425 std::transform(nodes1D+3*i,nodes1D+3*(i+1),bbox1DMax,bbox1DMax,static_cast<const double& (*)(const double&, const double&)>(std::max<double>));
427 std::transform(bbox1DMax,bbox1DMax+3,bbox1DMin,tmp,std::minus<double>());
428 mcIdType id=ToIdType(std::distance(tmp,std::max_element(tmp,tmp+3)));
429 bbox[0]=bbox1DMin[0]; bbox[1]=bbox1DMax[0];
430 bbox[2]=bbox1DMin[1]; bbox[3]=bbox1DMax[1];
431 bbox[4]=bbox1DMin[2]; bbox[5]=bbox1DMax[2];
432 bbox[2*id+1]+=tmp[id];
435 void MEDCouplingMappedExtrudedMesh::updateTime() const
437 if(_mesh2D.isNotNull())
438 updateTimeWith(*_mesh2D);
439 if(_mesh1D.isNotNull())
440 updateTimeWith(*_mesh1D);
443 void MEDCouplingMappedExtrudedMesh::renumberCells(const mcIdType *old2NewBg, bool check)
445 throw INTERP_KERNEL::Exception("Functionality of renumbering cells unavailable for ExtrudedMesh");
449 * \b WARNING in case of modif think to update MEDFileUMesh::New implementation !
450 * \sa MEDFileUMesh::New
452 MEDCouplingUMesh *MEDCouplingMappedExtrudedMesh::build3DUnstructuredMesh() const
454 MCAuto<MEDCouplingUMesh> mesh2DZC(_mesh2D->deepCopyConnectivityOnly());
455 mesh2DZC->zipCoords();
456 MCAuto<MEDCouplingUMesh> ret(mesh2DZC->buildExtrudedMesh(_mesh1D,0));
457 const mcIdType *renum(_mesh3D_ids->begin());
458 ret->renumberCells(renum,false);
459 ret->setName(getName());
464 * \b WARNING in case of modif think to update MEDFileUMesh::New implementation !
465 * \sa MEDFileUMesh::New
467 MEDCouplingUMesh *MEDCouplingMappedExtrudedMesh::buildUnstructured() const
469 return build3DUnstructuredMesh();
472 MEDCouplingFieldDouble *MEDCouplingMappedExtrudedMesh::getMeasureField(bool) const
474 std::string name="MeasureOfMesh_";
476 MCAuto<MEDCouplingFieldDouble> ret2D(_mesh2D->getMeasureField(true)),ret1D(_mesh1D->getMeasureField(true));
477 const double *ret2DPtr(ret2D->getArray()->begin());
478 const double *ret1DPtr(ret1D->getArray()->begin());
479 mcIdType nbOf2DCells=_mesh2D->getNumberOfCells(),
480 nbOf1DCells=_mesh1D->getNumberOfCells(),nbOf3DCells(nbOf2DCells*nbOf1DCells);
481 const mcIdType *renum(_mesh3D_ids->begin());
482 MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME));
484 ret->synchronizeTimeWithMesh();
485 MCAuto<DataArrayDouble> da(DataArrayDouble::New());
486 da->alloc(nbOf3DCells,1);
487 double *retPtr(da->getPointer());
488 for(mcIdType i=0;i<nbOf1DCells;i++)
489 for(mcIdType j=0;j<nbOf2DCells;j++)
490 retPtr[renum[i*nbOf2DCells+j]]=ret2DPtr[j]*ret1DPtr[i];
496 MEDCouplingFieldDouble *MEDCouplingMappedExtrudedMesh::getMeasureFieldOnNode(bool isAbs) const
498 //not implemented yet
502 MEDCouplingFieldDouble *MEDCouplingMappedExtrudedMesh::buildOrthogonalField() const
504 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::buildOrthogonalField : This method has no sense for MEDCouplingMappedExtrudedMesh that is 3D !");
507 mcIdType MEDCouplingMappedExtrudedMesh::getCellContainingPoint(const double *pos, double eps) const
509 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::getCellContainingPoint : not implemented yet !");
512 void MEDCouplingMappedExtrudedMesh::getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const
514 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::getCellsContainingPoint : not implemented yet !");
517 MEDCouplingMappedExtrudedMesh::~MEDCouplingMappedExtrudedMesh()
521 void MEDCouplingMappedExtrudedMesh::computeExtrusion(const MEDCouplingUMesh *mesh3D)
523 const char errMsg1[]="2D mesh is empty unable to compute extrusion !";
524 const char errMsg2[]="Coords between 2D and 3D meshes are not the same ! Try MEDCouplingPointSet::tryToShareSameCoords method";
525 const char errMsg3[]="No chance to find extrusion pattern in mesh3D,mesh2D couple because nbCells3D%nbCells2D!=0 !";
526 if(_mesh2D.isNull() || mesh3D==0)
527 throw INTERP_KERNEL::Exception(errMsg1);
528 if(_mesh2D->getCoords()!=mesh3D->getCoords())
529 throw INTERP_KERNEL::Exception(errMsg2);
530 if(mesh3D->getNumberOfCells()%_mesh2D->getNumberOfCells()!=0)
531 throw INTERP_KERNEL::Exception(errMsg3);
532 if(_mesh3D_ids.isNull())
533 _mesh3D_ids=DataArrayIdType::New();
535 _mesh1D=MEDCouplingUMesh::New();
536 computeExtrusionAlg(mesh3D);
539 void MEDCouplingMappedExtrudedMesh::build1DExtrusion(mcIdType idIn3DDesc, mcIdType newId, mcIdType nbOf1DLev, MEDCouplingUMesh *subMesh,
540 const mcIdType *desc3D, const mcIdType *descIndx3D,
541 const mcIdType *revDesc3D, const mcIdType *revDescIndx3D,
544 mcIdType nbOf2DCells=_mesh2D->getNumberOfCells();
545 mcIdType start(revDescIndx3D[idIn3DDesc]);
546 mcIdType end(revDescIndx3D[idIn3DDesc+1]);
549 std::ostringstream ost; ost << "Invalid bases 2D mesh specified : 2D cell # " << idIn3DDesc;
550 ost << " shared by more than 1 3D cell !!!";
551 throw INTERP_KERNEL::Exception(ost.str().c_str());
553 mcIdType current3DCell(revDesc3D[start]);
554 mcIdType current2DCell(idIn3DDesc);
555 mcIdType *mesh3DIDs(_mesh3D_ids->getPointer());
556 mesh3DIDs[newId]=current3DCell;
557 const mcIdType *conn2D(subMesh->getNodalConnectivity()->begin());
558 const mcIdType *conn2DIndx(subMesh->getNodalConnectivityIndex()->begin());
559 for(mcIdType i=1;i<nbOf1DLev;i++)
561 std::vector<mcIdType> conn(conn2D+conn2DIndx[current2DCell]+1,conn2D+conn2DIndx[current2DCell+1]);
562 std::sort(conn.begin(),conn.end());
564 computeBaryCenterOfFace(conn,i-1);
565 current2DCell=findOppositeFaceOf(current2DCell,current3DCell,conn,
566 desc3D,descIndx3D,conn2D,conn2DIndx);
567 start=revDescIndx3D[current2DCell];
568 end=revDescIndx3D[current2DCell+1];
571 std::ostringstream ost; ost << "Expecting to have 2 3D cells attached to 2D cell " << current2DCell << "!";
572 ost << " : Impossible or call tryToShareSameCoords method !";
573 throw INTERP_KERNEL::Exception(ost.str().c_str());
575 if(revDesc3D[start]!=current3DCell)
576 current3DCell=revDesc3D[start];
578 current3DCell=revDesc3D[start+1];
579 mesh3DIDs[i*nbOf2DCells+newId]=current3DCell;
583 std::vector<mcIdType> conn(conn2D+conn2DIndx[current2DCell]+1,conn2D+conn2DIndx[current2DCell+1]);
584 std::sort(conn.begin(),conn.end());
585 computeBaryCenterOfFace(conn,nbOf1DLev-1);
586 current2DCell=findOppositeFaceOf(current2DCell,current3DCell,conn,
587 desc3D,descIndx3D,conn2D,conn2DIndx);
589 conn.insert(conn.end(),conn2D+conn2DIndx[current2DCell]+1,conn2D+conn2DIndx[current2DCell+1]);
590 std::sort(conn.begin(),conn.end());
591 computeBaryCenterOfFace(conn,nbOf1DLev);
595 mcIdType MEDCouplingMappedExtrudedMesh::findOppositeFaceOf(mcIdType current2DCell, mcIdType current3DCell, const std::vector<mcIdType>& connSorted,
596 const mcIdType *desc3D, const mcIdType *descIndx3D,
597 const mcIdType *conn2D, const mcIdType *conn2DIndx)
599 mcIdType start(descIndx3D[current3DCell]);
600 mcIdType end(descIndx3D[current3DCell+1]);
602 for(const mcIdType *candidate2D=desc3D+start;candidate2D!=desc3D+end && !found;candidate2D++)
604 if(*candidate2D!=current2DCell)
606 std::vector<mcIdType> conn2(conn2D+conn2DIndx[*candidate2D]+1,conn2D+conn2DIndx[*candidate2D+1]);
607 std::sort(conn2.begin(),conn2.end());
608 std::list<mcIdType> intersect;
609 std::set_intersection(connSorted.begin(),connSorted.end(),conn2.begin(),conn2.end(),
610 std::insert_iterator< std::list<mcIdType> >(intersect,intersect.begin()));
611 if(intersect.empty())
615 std::ostringstream ost; ost << "Impossible to find an opposite 2D face of face # " << current2DCell;
616 ost << " in 3D cell # " << current3DCell << " : Impossible or call tryToShareSameCoords method !";
617 throw INTERP_KERNEL::Exception(ost.str().c_str());
620 void MEDCouplingMappedExtrudedMesh::computeBaryCenterOfFace(const std::vector<mcIdType>& nodalConnec, mcIdType lev1DId)
622 double *zoneToUpdate(_mesh1D->getCoords()->getPointer()+lev1DId*3);
623 std::fill(zoneToUpdate,zoneToUpdate+3,0.);
624 const double *coords(_mesh2D->getCoords()->begin());
625 for(std::vector<mcIdType>::const_iterator iter=nodalConnec.begin();iter!=nodalConnec.end();iter++)
626 std::transform(zoneToUpdate,zoneToUpdate+3,coords+3*(*iter),zoneToUpdate,std::plus<double>());
627 std::transform(zoneToUpdate,zoneToUpdate+3,zoneToUpdate,std::bind(std::multiplies<double>(),std::placeholders::_1,(1./(double)nodalConnec.size())));
630 mcIdType MEDCouplingMappedExtrudedMesh::FindCorrespCellByNodalConn(const std::vector<mcIdType>& nodalConnec, const mcIdType *revNodalPtr, const mcIdType *revNodalIndxPtr)
632 std::vector<mcIdType>::const_iterator iter=nodalConnec.begin();
633 std::set<mcIdType> s1(revNodalPtr+revNodalIndxPtr[*iter],revNodalPtr+revNodalIndxPtr[*iter+1]);
635 for(;iter!=nodalConnec.end();iter++)
637 std::set<mcIdType> s2(revNodalPtr+revNodalIndxPtr[*iter],revNodalPtr+revNodalIndxPtr[*iter+1]);
638 std::set<mcIdType> s3;
639 std::set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),std::insert_iterator< std::set<mcIdType> >(s3,s3.end()));
643 return *(s1.begin());
644 std::ostringstream ostr;
645 ostr << "Cell with nodal connec : ";
646 std::copy(nodalConnec.begin(),nodalConnec.end(),std::ostream_iterator<mcIdType>(ostr," "));
647 ostr << " is not part of mesh";
648 throw INTERP_KERNEL::Exception(ostr.str().c_str());
652 * This method is callable on 1Dmeshes (meshDim==1 && spaceDim==3) returned by MEDCouplingMappedExtrudedMesh::getMesh1D typically.
653 * These 1Dmeshes (meshDim==1 && spaceDim==3) have a special semantic because these meshes do not specify a static location but a translation along a path.
654 * This method checks that 'm1' and 'm2' are compatible, if not an exception is thrown. In case these meshes ('m1' and 'm2') are compatible 2 corresponding meshes
655 * are created ('m1r' and 'm2r') that can be used for interpolation.
656 * @param m1 input mesh with meshDim==1 and spaceDim==3
657 * @param m2 input mesh with meshDim==1 and spaceDim==3
658 * @param eps tolerance acceptable to determine compatibility
659 * @param m1r output mesh with ref count equal to 1 with meshDim==1 and spaceDim==1
660 * @param m2r output mesh with ref count equal to 1 with meshDim==1 and spaceDim==1
661 * @param v is the output normalized vector of the common direction of 'm1' and 'm2'
662 * @throw in case that m1 and m2 are not compatible each other.
664 void MEDCouplingMappedExtrudedMesh::Project1DMeshes(const MEDCouplingUMesh *m1, const MEDCouplingUMesh *m2, double eps,
665 MEDCouplingUMesh *&m1r, MEDCouplingUMesh *&m2r, double *v)
667 if(m1->getSpaceDimension()!=3 || m1->getSpaceDimension()!=3)
668 throw INTERP_KERNEL::Exception("Input meshes are expected to have a spaceDim==3 for Projec1D !");
671 m1r->changeSpaceDimension(1);
672 m2r->changeSpaceDimension(1);
673 std::vector<mcIdType> c;
674 std::vector<double> ref,ref2;
675 m1->getNodeIdsOfCell(0,c);
676 m1->getCoordinatesOfNode(c[0],ref);
677 m1->getCoordinatesOfNode(c[1],ref2);
678 std::transform(ref2.begin(),ref2.end(),ref.begin(),v,std::minus<double>());
679 double n=INTERP_KERNEL::norm<3>(v);
680 std::transform(v,v+3,v,std::bind(std::multiplies<double>(),std::placeholders::_1,1/n));
681 m1->project1D(&ref[0],v,eps,m1r->getCoords()->getPointer());
682 m2->project1D(&ref[0],v,eps,m2r->getCoords()->getPointer());
685 void MEDCouplingMappedExtrudedMesh::rotate(const double *center, const double *vector, double angle)
687 _mesh2D->rotate(center,vector,angle);
688 _mesh1D->rotate(center,vector,angle);
691 void MEDCouplingMappedExtrudedMesh::translate(const double *vector)
693 _mesh2D->translate(vector);
694 _mesh1D->translate(vector);
697 void MEDCouplingMappedExtrudedMesh::scale(const double *point, double factor)
699 _mesh2D->scale(point,factor);
700 _mesh1D->scale(point,factor);
703 std::vector<mcIdType> MEDCouplingMappedExtrudedMesh::getDistributionOfTypes() const
705 throw INTERP_KERNEL::Exception("Not implemented yet !");
708 DataArrayIdType *MEDCouplingMappedExtrudedMesh::checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const
710 throw INTERP_KERNEL::Exception("Not implemented yet !");
713 void MEDCouplingMappedExtrudedMesh::splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller) const
715 throw INTERP_KERNEL::Exception("Not implemented yet !");
718 MEDCouplingMesh *MEDCouplingMappedExtrudedMesh::buildPart(const mcIdType *start, const mcIdType *end) const
720 // not implemented yet !
724 MEDCouplingMesh *MEDCouplingMappedExtrudedMesh::buildPartAndReduceNodes(const mcIdType *start, const mcIdType *end, DataArrayIdType*& arr) const
726 // not implemented yet !
730 DataArrayIdType *MEDCouplingMappedExtrudedMesh::simplexize(int policy)
732 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::simplexize : unavailable for such a type of mesh : Extruded !");
735 MEDCouplingMesh *MEDCouplingMappedExtrudedMesh::mergeMyselfWith(const MEDCouplingMesh *other) const
737 // not implemented yet !
741 DataArrayDouble *MEDCouplingMappedExtrudedMesh::getCoordinatesAndOwner() const
743 const DataArrayDouble *arr2D(_mesh2D->getCoords());
744 const DataArrayDouble *arr1D(_mesh1D->getCoords());
745 MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
746 ret->alloc(getNumberOfNodes(),3);
747 mcIdType nbOf1DLev(_mesh1D->getNumberOfNodes());
748 mcIdType nbOf2DNodes(_mesh2D->getNumberOfNodes());
749 const double *ptSrc(arr2D->begin());
750 double *pt(ret->getPointer());
751 std::copy(ptSrc,ptSrc+3*nbOf2DNodes,pt);
752 for(mcIdType i=1;i<nbOf1DLev;i++)
754 std::copy(ptSrc,ptSrc+3*nbOf2DNodes,pt+3*i*nbOf2DNodes);
756 std::copy(arr1D->begin()+3*i,arr1D->begin()+3*(i+1),vec);
757 std::transform(arr1D->begin()+3*(i-1),arr1D->begin()+3*i,vec,vec,std::minus<double>());
758 for(mcIdType j=0;j<nbOf2DNodes;j++)
759 std::transform(vec,vec+3,pt+3*(i*nbOf2DNodes+j),pt+3*(i*nbOf2DNodes+j),std::plus<double>());
764 DataArrayDouble *MEDCouplingMappedExtrudedMesh::computeCellCenterOfMass() const
766 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::computeCellCenterOfMass : not yet implemented !");
769 DataArrayDouble *MEDCouplingMappedExtrudedMesh::computeIsoBarycenterOfNodesPerCell() const
771 throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::computeIsoBarycenterOfNodesPerCell: not yet implemented !");
774 void MEDCouplingMappedExtrudedMesh::getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const
776 MCAuto<MEDCouplingUMesh> m(buildUnstructured());
777 m->getReverseNodalConnectivity(revNodal,revNodalIndx);
780 void MEDCouplingMappedExtrudedMesh::computeExtrusionAlg(const MEDCouplingUMesh *mesh3D)
782 _mesh3D_ids->alloc(mesh3D->getNumberOfCells(),1);
783 mcIdType nbOf1DLev=mesh3D->getNumberOfCells()/_mesh2D->getNumberOfCells();
784 _mesh1D->setMeshDimension(1);
785 _mesh1D->allocateCells(nbOf1DLev);
787 for(mcIdType i=0;i<nbOf1DLev;i++)
791 _mesh1D->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,tmpConn);
793 _mesh1D->finishInsertingCells();
794 DataArrayDouble *myCoords=DataArrayDouble::New();
795 myCoords->alloc(nbOf1DLev+1,3);
796 _mesh1D->setCoords(myCoords);
798 MCAuto<DataArrayIdType> desc(DataArrayIdType::New()),descIndx(DataArrayIdType::New()),revDesc(DataArrayIdType::New()),revDescIndx(DataArrayIdType::New());
799 MCAuto<MEDCouplingUMesh> subMesh(mesh3D->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx));
800 MCAuto<DataArrayIdType> revNodal2D(DataArrayIdType::New()),revNodalIndx2D(DataArrayIdType::New());
801 subMesh->getReverseNodalConnectivity(revNodal2D,revNodalIndx2D);
802 const mcIdType *nodal2D(_mesh2D->getNodalConnectivity()->begin());
803 const mcIdType *nodal2DIndx(_mesh2D->getNodalConnectivityIndex()->begin());
804 const mcIdType *revNodal2DPtr(revNodal2D->begin());
805 const mcIdType *revNodalIndx2DPtr(revNodalIndx2D->begin());
806 const mcIdType *descP(desc->begin()),*descIndxP(descIndx->begin()),*revDescP(revDesc->begin()),*revDescIndxP(revDescIndx->begin());
808 mcIdType nbOf2DCells=_mesh2D->getNumberOfCells();
809 for(mcIdType i=0;i<nbOf2DCells;i++)
811 mcIdType idInSubMesh;
812 std::vector<mcIdType> nodalConnec(nodal2D+nodal2DIndx[i]+1,nodal2D+nodal2DIndx[i+1]);
815 idInSubMesh=FindCorrespCellByNodalConn(nodalConnec,revNodal2DPtr,revNodalIndx2DPtr);
817 catch(INTERP_KERNEL::Exception& e)
819 std::ostringstream ostr; ostr << "mesh2D cell # " << i << " is not part of any cell of 3D mesh !\n";
821 throw INTERP_KERNEL::Exception(ostr.str().c_str());
823 build1DExtrusion(idInSubMesh,i,nbOf1DLev,subMesh,descP,descIndxP,revDescP,revDescIndxP,i==_cell_2D_id);
827 void MEDCouplingMappedExtrudedMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
829 std::vector<mcIdType> tinyInfo1;
830 std::vector<std::string> ls1;
831 std::vector<double> ls3;
832 _mesh2D->getTinySerializationInformation(ls3,tinyInfo1,ls1);
833 std::vector<mcIdType> tinyInfo2;
834 std::vector<std::string> ls2;
835 std::vector<double> ls4;
836 _mesh1D->getTinySerializationInformation(ls4,tinyInfo2,ls2);
837 tinyInfo.clear(); littleStrings.clear();
838 tinyInfo.insert(tinyInfo.end(),tinyInfo1.begin(),tinyInfo1.end());
839 littleStrings.insert(littleStrings.end(),ls1.begin(),ls1.end());
840 tinyInfo.insert(tinyInfo.end(),tinyInfo2.begin(),tinyInfo2.end());
841 littleStrings.insert(littleStrings.end(),ls2.begin(),ls2.end());
842 tinyInfo.push_back(_cell_2D_id);
843 tinyInfo.push_back(ToIdType(tinyInfo1.size()));
844 tinyInfo.push_back(_mesh3D_ids->getNbOfElems());
845 littleStrings.push_back(getName());
846 littleStrings.push_back(getDescription());
849 void MEDCouplingMappedExtrudedMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
851 std::size_t sz=tinyInfo.size();
852 mcIdType sz1=tinyInfo[sz-2];
853 std::vector<mcIdType> ti1(tinyInfo.begin(),tinyInfo.begin()+sz1);
854 std::vector<mcIdType> ti2(tinyInfo.begin()+sz1,tinyInfo.end()-3);
855 MEDCouplingUMesh *um=MEDCouplingUMesh::New();
856 DataArrayIdType *a1tmp=DataArrayIdType::New();
857 DataArrayDouble *a2tmp=DataArrayDouble::New();
858 mcIdType la1=0,la2=0;
859 std::vector<std::string> ls1,ls2;
860 um->resizeForUnserialization(ti1,a1tmp,a2tmp,ls1);
861 la1+=a1tmp->getNbOfElems(); la2+=a2tmp->getNbOfElems();
862 a1tmp->decrRef(); a2tmp->decrRef();
863 a1tmp=DataArrayIdType::New(); a2tmp=DataArrayDouble::New();
864 um->resizeForUnserialization(ti2,a1tmp,a2tmp,ls2);
865 la1+=a1tmp->getNbOfElems(); la2+=a2tmp->getNbOfElems();
866 a1tmp->decrRef(); a2tmp->decrRef();
869 a1->alloc(la1+tinyInfo[sz-1],1);
871 littleStrings.resize(ls1.size()+ls2.size()+2);
874 void MEDCouplingMappedExtrudedMesh::serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const
876 a1=DataArrayIdType::New(); a2=DataArrayDouble::New();
877 DataArrayIdType *a1_1=0,*a1_2=0;
878 DataArrayDouble *a2_1=0,*a2_2=0;
879 _mesh2D->serialize(a1_1,a2_1);
880 _mesh1D->serialize(a1_2,a2_2);
881 a1->alloc(a1_1->getNbOfElems()+a1_2->getNbOfElems()+_mesh3D_ids->getNbOfElems(),1);
882 mcIdType *ptri=a1->getPointer();
883 ptri=std::copy(a1_1->begin(),a1_1->begin()+a1_1->getNbOfElems(),ptri);
885 ptri=std::copy(a1_2->begin(),a1_2->begin()+a1_2->getNbOfElems(),ptri);
887 std::copy(_mesh3D_ids->begin(),_mesh3D_ids->begin()+_mesh3D_ids->getNbOfElems(),ptri);
888 a2->alloc(a2_1->getNbOfElems()+a2_2->getNbOfElems(),1);
889 double *ptrd=a2->getPointer();
890 ptrd=std::copy(a2_1->begin(),a2_1->begin()+a2_1->getNbOfElems(),ptrd);
892 std::copy(a2_2->begin(),a2_2->begin()+a2_2->getNbOfElems(),ptrd);
896 void MEDCouplingMappedExtrudedMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
898 setName(littleStrings[littleStrings.size()-2]);
899 setDescription(littleStrings.back());
900 std::size_t sz=tinyInfo.size();
901 mcIdType sz1=tinyInfo[sz-2];
902 _cell_2D_id=tinyInfo[sz-3];
903 std::vector<mcIdType> ti1(tinyInfo.begin(),tinyInfo.begin()+sz1);
904 std::vector<mcIdType> ti2(tinyInfo.begin()+sz1,tinyInfo.end()-3);
905 DataArrayIdType *a1tmp=DataArrayIdType::New();
906 DataArrayDouble *a2tmp=DataArrayDouble::New();
907 const mcIdType *a1Ptr=a1->begin();
908 const double *a2Ptr=a2->begin();
909 _mesh2D=MEDCouplingUMesh::New();
910 std::vector<std::string> ls1,ls2;
911 _mesh2D->resizeForUnserialization(ti1,a1tmp,a2tmp,ls1);
912 std::copy(a2Ptr,a2Ptr+a2tmp->getNbOfElems(),a2tmp->getPointer());
913 std::copy(a1Ptr,a1Ptr+a1tmp->getNbOfElems(),a1tmp->getPointer());
914 a2Ptr+=a2tmp->getNbOfElems();
915 a1Ptr+=a1tmp->getNbOfElems();
916 ls2.insert(ls2.end(),littleStrings.begin(),littleStrings.begin()+ls1.size());
917 std::vector<double> d1(1);
918 _mesh2D->unserialization(d1,ti1,a1tmp,a2tmp,ls2);
919 a1tmp->decrRef(); a2tmp->decrRef();
922 ls2.insert(ls2.end(),littleStrings.begin()+ls1.size(),littleStrings.end()-2);
923 _mesh1D=MEDCouplingUMesh::New();
924 a1tmp=DataArrayIdType::New(); a2tmp=DataArrayDouble::New();
925 _mesh1D->resizeForUnserialization(ti2,a1tmp,a2tmp,ls1);
926 std::copy(a2Ptr,a2Ptr+a2tmp->getNbOfElems(),a2tmp->getPointer());
927 std::copy(a1Ptr,a1Ptr+a1tmp->getNbOfElems(),a1tmp->getPointer());
928 a1Ptr+=a1tmp->getNbOfElems();
929 _mesh1D->unserialization(d1,ti2,a1tmp,a2tmp,ls2);
930 a1tmp->decrRef(); a2tmp->decrRef();
932 _mesh3D_ids=DataArrayIdType::New();
933 mcIdType szIds=ToIdType(std::distance(a1Ptr,a1->begin()))+a1->getNbOfElems();
934 _mesh3D_ids->alloc(szIds,1);
935 std::copy(a1Ptr,a1Ptr+szIds,_mesh3D_ids->getPointer());
938 void MEDCouplingMappedExtrudedMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const
940 MCAuto<MEDCouplingUMesh> m=buildUnstructured();
941 m->writeVTKLL(ofs,cellData,pointData,byteData);
944 void MEDCouplingMappedExtrudedMesh::reprQuickOverview(std::ostream& stream) const
946 stream << "MEDCouplingMappedExtrudedMesh C++ instance at " << this << ". Name : \"" << getName() << "\".";
949 std::string MEDCouplingMappedExtrudedMesh::getVTKFileExtension() const
951 return _mesh2D->getVTKFileExtension();
954 std::string MEDCouplingMappedExtrudedMesh::getVTKDataSetType() const
956 return _mesh2D->getVTKDataSetType();