tui/SMESH/SMDS__Mesh_8hxx_source.html

// Copyright (C) 2007-2026  CEA, EDF, OPEN CASCADE

//

// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,

// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS

//

// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Lesser General Public

// License as published by the Free Software Foundation; either

// version 2.1 of the License, or (at your option) any later version.

//

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

// Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA

//

// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com

//


//  SMESH SMDS : implementation of Salome mesh data structure

//  File   : SMDS_Mesh.hxx

//  Module : SMESH

//

#ifndef _SMDS_Mesh_HeaderFile

#define _SMDS_Mesh_HeaderFile


#include "SMESH_SMDS.hxx"


#include "SMDS_BallElement.hxx"

#include "SMDS_ElemIterator.hxx"

#include "SMDS_Mesh0DElement.hxx"

#include "SMDS_MeshCell.hxx"

#include "SMDS_MeshEdge.hxx"

#include "SMDS_MeshFace.hxx"

#include "SMDS_MeshInfo.hxx"

#include "SMDS_MeshNode.hxx"

#include "SMDS_MeshVolume.hxx"

#include "SMDS_UnstructuredGrid.hxx"


#include <set>

#include <list>

#include <vector>

#include <smIdType.hxx>


class SMDS_ElementHolder;

class SMDS_ElementFactory;

class SMDS_NodeFactory;


class SMDS_EXPORT SMDS_Mesh : public SMDS_MeshObject

{

public:


  SMDS_Mesh();


  inline SMDS_UnstructuredGrid* GetGrid() { return myGrid; }


  virtual SMDS_NodeIteratorPtr   nodesIterator  () const;

  virtual SMDS_EdgeIteratorPtr   edgesIterator  () const;

  virtual SMDS_FaceIteratorPtr   facesIterator  () const;

  virtual SMDS_VolumeIteratorPtr volumesIterator() const;


  virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;

  virtual SMDS_ElemIteratorPtr elementGeomIterator(SMDSAbs_GeometryType type) const;

  virtual SMDS_ElemIteratorPtr elementEntityIterator(SMDSAbs_EntityType type) const;


  virtual SMDS_NodeIteratorPtr shapeNodesIterator   (int                  shapeID,

                                                     size_t               nbElemsToReturn=-1,

                                                     const SMDS_MeshNode* sm1stNode=0) const;

  virtual SMDS_ElemIteratorPtr shapeElementsIterator(int                     shapeID,

                                                     size_t                  nbElemsToReturn=-1,

                                                     const SMDS_MeshElement* sm1stElem=0) const;


  SMDSAbs_ElementType GetElementType( const smIdType id, const bool iselem ) const;


  SMDS_Mesh *AddSubMesh();


  virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, smIdType ID);

  virtual SMDS_MeshNode* AddNode      (double x, double y, double z);


  virtual SMDS_Mesh0DElement* Add0DElementWithID(smIdType n,                   smIdType ID);

  virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, smIdType ID);

  virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * n);


  virtual SMDS_BallElement* AddBallWithID(smIdType n,                   double diameter, smIdType ID);

  virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID);

  virtual SMDS_BallElement* AddBall      (const SMDS_MeshNode * n, double diameter);


  virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID);

  virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       smIdType ID);

  virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2);


  // 2d order edge with 3 nodes: n12 - node between n1 and n2

  virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID);

  virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n12,

                                       smIdType ID);

  virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n12);


  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3);


  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n4,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n4);


  // 2d order triangle of 6 nodes

  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,

                                       smIdType n12,smIdType n23,smIdType n31, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n12,

                                       const SMDS_MeshNode * n23,

                                       const SMDS_MeshNode * n31,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n12,

                                 const SMDS_MeshNode * n23,

                                 const SMDS_MeshNode * n31);


  // 2d order triangle of 7 nodes

  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,

                                       smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n12,

                                       const SMDS_MeshNode * n23,

                                       const SMDS_MeshNode * n31,

                                       const SMDS_MeshNode * nCenter,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n12,

                                 const SMDS_MeshNode * n23,

                                 const SMDS_MeshNode * n31,

                                 const SMDS_MeshNode * nCenter);


  // 2d order quadrangle

  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                       smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n4,

                                       const SMDS_MeshNode * n12,

                                       const SMDS_MeshNode * n23,

                                       const SMDS_MeshNode * n34,

                                       const SMDS_MeshNode * n41,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n4,

                                 const SMDS_MeshNode * n12,

                                 const SMDS_MeshNode * n23,

                                 const SMDS_MeshNode * n34,

                                 const SMDS_MeshNode * n41);


  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                       smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType nCenter, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n4,

                                       const SMDS_MeshNode * n12,

                                       const SMDS_MeshNode * n23,

                                       const SMDS_MeshNode * n34,

                                       const SMDS_MeshNode * n41,

                                       const SMDS_MeshNode * nCenter,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n4,

                                 const SMDS_MeshNode * n12,

                                 const SMDS_MeshNode * n23,

                                 const SMDS_MeshNode * n34,

                                 const SMDS_MeshNode * n41,

                                 const SMDS_MeshNode * nCenter);


  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4);


  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                           smIdType n5, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5);


  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                           smIdType n5, smIdType n6, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6);


  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                           smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n7,

                                           const SMDS_MeshNode * n8,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n7,

                                     const SMDS_MeshNode * n8);


  // hexagonal prism

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6,

                                           smIdType n7, smIdType n8, smIdType n9, smIdType n10, smIdType n11, smIdType n12,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n7,

                                           const SMDS_MeshNode * n8,

                                           const SMDS_MeshNode * n9,

                                           const SMDS_MeshNode * n10,

                                           const SMDS_MeshNode * n11,

                                           const SMDS_MeshNode * n12,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n7,

                                     const SMDS_MeshNode * n8,

                                     const SMDS_MeshNode * n9,

                                     const SMDS_MeshNode * n10,

                                     const SMDS_MeshNode * n11,

                                     const SMDS_MeshNode * n12);


  // 2d order tetrahedron of 10 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                           smIdType n12,smIdType n23,smIdType n31,

                                           smIdType n14,smIdType n24,smIdType n34, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n31,

                                           const SMDS_MeshNode * n14,

                                           const SMDS_MeshNode * n24,

                                           const SMDS_MeshNode * n34,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n31,

                                     const SMDS_MeshNode * n14,

                                     const SMDS_MeshNode * n24,

                                     const SMDS_MeshNode * n34);


  // 2d order pyramid of 13 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,

                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,

                                           smIdType n15,smIdType n25,smIdType n35,smIdType n45,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n34,

                                           const SMDS_MeshNode * n41,

                                           const SMDS_MeshNode * n15,

                                           const SMDS_MeshNode * n25,

                                           const SMDS_MeshNode * n35,

                                           const SMDS_MeshNode * n45,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n34,

                                     const SMDS_MeshNode * n41,

                                     const SMDS_MeshNode * n15,

                                     const SMDS_MeshNode * n25,

                                     const SMDS_MeshNode * n35,

                                     const SMDS_MeshNode * n45);


  // 2d order Pentahedron with 15 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,

                                           smIdType n4, smIdType n5, smIdType n6,

                                           smIdType n12,smIdType n23,smIdType n31,

                                           smIdType n45,smIdType n56,smIdType n64,

                                           smIdType n14,smIdType n25,smIdType n36,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n31,

                                           const SMDS_MeshNode * n45,

                                           const SMDS_MeshNode * n56,

                                           const SMDS_MeshNode * n64,

                                           const SMDS_MeshNode * n14,

                                           const SMDS_MeshNode * n25,

                                           const SMDS_MeshNode * n36,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n31,

                                     const SMDS_MeshNode * n45,

                                     const SMDS_MeshNode * n56,

                                     const SMDS_MeshNode * n64,

                                     const SMDS_MeshNode * n14,

                                     const SMDS_MeshNode * n25,

                                     const SMDS_MeshNode * n36);


  // 2d order Pentahedron with 18 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,

                                           smIdType n4, smIdType n5, smIdType n6,

                                           smIdType n12,smIdType n23,smIdType n31,

                                           smIdType n45,smIdType n56,smIdType n64,

                                           smIdType n14,smIdType n25,smIdType n36,

                                           smIdType n1245, smIdType n2356, smIdType n1346,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n31,

                                           const SMDS_MeshNode * n45,

                                           const SMDS_MeshNode * n56,

                                           const SMDS_MeshNode * n64,

                                           const SMDS_MeshNode * n14,

                                           const SMDS_MeshNode * n25,

                                           const SMDS_MeshNode * n36,

                                           const SMDS_MeshNode * n1245,

                                           const SMDS_MeshNode * n2356,

                                           const SMDS_MeshNode * n1346,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n31,

                                     const SMDS_MeshNode * n45,

                                     const SMDS_MeshNode * n56,

                                     const SMDS_MeshNode * n64,

                                     const SMDS_MeshNode * n14,

                                     const SMDS_MeshNode * n25,

                                     const SMDS_MeshNode * n36,

                                     const SMDS_MeshNode * n1245,

                                     const SMDS_MeshNode * n2356,

                                     const SMDS_MeshNode * n1346);


  // 2d oreder Hexahedrons with 20 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                           smIdType n5, smIdType n6, smIdType n7, smIdType n8,

                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,

                                           smIdType n56,smIdType n67,smIdType n78,smIdType n85,

                                           smIdType n15,smIdType n26,smIdType n37,smIdType n48,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n7,

                                           const SMDS_MeshNode * n8,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n34,

                                           const SMDS_MeshNode * n41,

                                           const SMDS_MeshNode * n56,

                                           const SMDS_MeshNode * n67,

                                           const SMDS_MeshNode * n78,

                                           const SMDS_MeshNode * n85,

                                           const SMDS_MeshNode * n15,

                                           const SMDS_MeshNode * n26,

                                           const SMDS_MeshNode * n37,

                                           const SMDS_MeshNode * n48,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n7,

                                     const SMDS_MeshNode * n8,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n34,

                                     const SMDS_MeshNode * n41,

                                     const SMDS_MeshNode * n56,

                                     const SMDS_MeshNode * n67,

                                     const SMDS_MeshNode * n78,

                                     const SMDS_MeshNode * n85,

                                     const SMDS_MeshNode * n15,

                                     const SMDS_MeshNode * n26,

                                     const SMDS_MeshNode * n37,

                                     const SMDS_MeshNode * n48);


  // 2d oreder Hexahedrons with 27 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                           smIdType n5, smIdType n6, smIdType n7, smIdType n8,

                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,

                                           smIdType n56,smIdType n67,smIdType n78,smIdType n85,

                                           smIdType n15,smIdType n26,smIdType n37,smIdType n48,

                                           smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,

                                           smIdType n1458,smIdType n5678,smIdType nCenter,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n7,

                                           const SMDS_MeshNode * n8,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n34,

                                           const SMDS_MeshNode * n41,

                                           const SMDS_MeshNode * n56,

                                           const SMDS_MeshNode * n67,

                                           const SMDS_MeshNode * n78,

                                           const SMDS_MeshNode * n85,

                                           const SMDS_MeshNode * n15,

                                           const SMDS_MeshNode * n26,

                                           const SMDS_MeshNode * n37,

                                           const SMDS_MeshNode * n48,

                                           const SMDS_MeshNode * n1234,

                                           const SMDS_MeshNode * n1256,

                                           const SMDS_MeshNode * n2367,

                                           const SMDS_MeshNode * n3478,

                                           const SMDS_MeshNode * n1458,

                                           const SMDS_MeshNode * n5678,

                                           const SMDS_MeshNode * nCenter,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n7,

                                     const SMDS_MeshNode * n8,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n34,

                                     const SMDS_MeshNode * n41,

                                     const SMDS_MeshNode * n56,

                                     const SMDS_MeshNode * n67,

                                     const SMDS_MeshNode * n78,

                                     const SMDS_MeshNode * n85,

                                     const SMDS_MeshNode * n15,

                                     const SMDS_MeshNode * n26,

                                     const SMDS_MeshNode * n37,

                                     const SMDS_MeshNode * n48,

                                     const SMDS_MeshNode * n1234,

                                     const SMDS_MeshNode * n1256,

                                     const SMDS_MeshNode * n2367,

                                     const SMDS_MeshNode * n3478,

                                     const SMDS_MeshNode * n1458,

                                     const SMDS_MeshNode * n5678,

                                     const SMDS_MeshNode * nCenter);


  virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<smIdType> & nodes_ids,

                                                 const smIdType                ID);


  virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*> & nodes,

                                                 const smIdType                                 ID);


  virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*> & nodes);


  virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<smIdType> & nodes_ids,

                                                    const smIdType                ID);


  virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes,

                                                    const smIdType                                 ID);


  virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes);


  virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID

    (const std::vector<smIdType> & nodes_ids,

     const std::vector<int>      & quantities,

     const smIdType                ID);


  virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID

    (const std::vector<const SMDS_MeshNode*> & nodes,

     const std::vector<int>                  & quantities,

     const smIdType                            ID);


  virtual SMDS_MeshVolume* AddPolyhedralVolume

    (const std::vector<const SMDS_MeshNode*> & nodes,

     const std::vector<int>                  & quantities);


  virtual SMDS_MeshVolume* AddVolumeFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);


  virtual SMDS_MeshFace* AddFaceFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);


  virtual void MoveNode(const SMDS_MeshNode *n, double x, double y, double z);


  virtual void RemoveElement(const SMDS_MeshElement *               elem,

                             std::vector<const SMDS_MeshElement *>& removedElems,

                             std::vector<const SMDS_MeshElement *>& removedNodes,

                             const bool                             removenodes = false);

  virtual void RemoveElement(const SMDS_MeshElement * elem, bool removenodes = false);

  virtual void RemoveNode(const SMDS_MeshNode * node);


  virtual void RemoveFreeElement(const SMDS_MeshElement * elem);


  virtual void Clear();


  virtual bool RemoveFromParent();

  virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);


  bool ChangeElementNodes(const SMDS_MeshElement * elem,

                          const SMDS_MeshNode    * nodes[],

                          const int                nbnodes);

  bool ChangePolyhedronNodes(const SMDS_MeshElement *                 elem,

                             const std::vector<const SMDS_MeshNode*>& nodes,

                             const std::vector<int>&                  quantities);


  void SetAllNodesNotMarked();

  void SetAllCellsNotMarked();


  //virtual void Renumber (const bool isNodes, const int startID = 1, const int deltaID = 1);

  // Renumber all nodes or elements.


  virtual void CompactMesh();

  virtual bool IsCompacted();

  virtual bool HasNumerationHoles();


  template<class ELEMTYPE>

    static const ELEMTYPE* DownCast( const SMDS_MeshElement* e )

  {

    return (( e && !e->IsNull() && ELEMTYPE::Type() == e->GetType() ) ?

            static_cast<const ELEMTYPE*>(e) : 0 );

  }


  const SMDS_MeshNode *FindNode(smIdType idnode) const;

  const SMDS_MeshNode *FindNodeVtk(vtkIdType idnode) const;

  const SMDS_MeshElement *FindElementVtk(vtkIdType IDelem) const;

  virtual const SMDS_MeshElement * FindElement(smIdType IDelem) const;

  static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);

  static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n);

  static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2);

  static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3);

  static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,

                                       const SMDS_MeshNode *n2,

                                       const SMDS_MeshNode *n3);

  static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,

                                       const SMDS_MeshNode *n2,

                                       const SMDS_MeshNode *n3,

                                       const SMDS_MeshNode *n4);

  static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,

                                       const SMDS_MeshNode *n2,

                                       const SMDS_MeshNode *n3,

                                       const SMDS_MeshNode *n4,

                                       const SMDS_MeshNode *n5,

                                       const SMDS_MeshNode *n6);

  static const SMDS_MeshFace* FindFace(const SMDS_MeshNode *n1,

                                       const SMDS_MeshNode *n2,

                                       const SMDS_MeshNode *n3,

                                       const SMDS_MeshNode *n4,

                                       const SMDS_MeshNode *n5,

                                       const SMDS_MeshNode *n6,

                                       const SMDS_MeshNode *n7,

                                       const SMDS_MeshNode *n8);


  static const SMDS_MeshFace*    FindFace   (const std::vector<const SMDS_MeshNode *>& nodes);

  static const SMDS_MeshElement* FindElement(const std::vector<const SMDS_MeshNode *>& nodes,

                                             const SMDSAbs_ElementType                 type=SMDSAbs_All,

                                             const bool                                noMedium=true);

  static int GetElementsByNodes(const std::vector<const SMDS_MeshNode *>& nodes,

                                std::vector<const SMDS_MeshElement *>&    foundElems,

                                const SMDSAbs_ElementType                 type=SMDSAbs_All);


  virtual bool Contains( const SMDS_MeshElement* elem ) const;


  static int CheckMemory(const bool doNotRaise=false);


  virtual smIdType MaxNodeID() const;

  virtual smIdType MinNodeID() const;

  virtual smIdType MaxElementID() const;

  virtual smIdType MinElementID() const;


  const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }


  virtual smIdType NbNodes() const;

  virtual smIdType NbElements() const;

  virtual smIdType Nb0DElements() const;

  virtual smIdType NbBalls() const;

  virtual smIdType NbEdges() const;

  virtual smIdType NbFaces() const;

  virtual smIdType NbVolumes() const;

  virtual smIdType NbSubMesh() const;


  virtual ~SMDS_Mesh();


  double getMaxDim();

  smIdType FromVtkToSmds(vtkIdType  vtkid) const;


  void dumpGrid(std::string ficdump="dumpGrid");

  static int chunkSize;


  inline void setMyModified() { this->myModified = true; }


  void Modified();

  vtkMTimeType GetMTime() const;


 protected:

  SMDS_Mesh(SMDS_Mesh * parent);


  void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,

                            const SMDS_MeshElement *           element,

                            std::set<const SMDS_MeshElement*>& nodes);


  inline void adjustBoundingBox(double x, double y, double z)

  {

    if (x > xmax) xmax = x;

    else if (x < xmin) xmin = x;

    if (y > ymax) ymax = y;

    else if (y < ymin) ymin = y;

    if (z > zmax) zmax = z;

    else if (z < zmin) zmin = z;

  }


  void updateInverseElements( const SMDS_MeshElement *        element,

                              const SMDS_MeshNode* const*     nodes,

                              const int                       nbnodes,

                              std::set<const SMDS_MeshNode*>& oldNodes );


  void setNbShapes( size_t nbShapes );


  // Fields PRIVATE


  SMDS_UnstructuredGrid* myGrid;


  SMDS_NodeFactory*      myNodeFactory;

  SMDS_ElementFactory*   myCellFactory;


  SMDS_Mesh *            myParent;

  std::list<SMDS_Mesh *> myChildren;

  SMDS_MeshInfo          myInfo;


  bool                   myModified;

  unsigned long          myModifTime, myCompactTime;


  friend class SMDS_ElementHolder;

  std::set< SMDS_ElementHolder* > myElemHolders;


  double xmin;

  double xmax;

  double ymin;

  double ymax;

  double zmin;

  double zmax;

};


#endif

SMDSAbs_GeometryType
SMDSAbs_GeometryType
enumeration for element geometry type
Definition: SMDSAbs_ElementType.hxx:47

SMDSAbs_ElementType
SMDSAbs_ElementType
Type (node, edge, face or volume) of elements.
Definition: SMDSAbs_ElementType.hxx:34

SMDSAbs_All
@ SMDSAbs_All
Definition: SMDSAbs_ElementType.hxx:35

SMDSAbs_EntityType
SMDSAbs_EntityType
Enumeration of entity type used in mesh info array.
Definition: SMDSAbs_ElementType.hxx:79

SMDS_BallElement.hxx

SMDS_ElemIterator.hxx

SMDS_ElemIteratorPtr
boost::shared_ptr< SMDS_Iterator< const SMDS_MeshElement * > > SMDS_ElemIteratorPtr
Definition: SMDS_ElemIterator.hxx:43

SMDS_VolumeIteratorPtr
boost::shared_ptr< SMDS_Iterator< const SMDS_MeshVolume * > > SMDS_VolumeIteratorPtr
Definition: SMDS_ElemIterator.hxx:58

SMDS_EdgeIteratorPtr
boost::shared_ptr< SMDS_Iterator< const SMDS_MeshEdge * > > SMDS_EdgeIteratorPtr
Definition: SMDS_ElemIterator.hxx:52

SMDS_NodeIteratorPtr
boost::shared_ptr< SMDS_Iterator< const SMDS_MeshNode * > > SMDS_NodeIteratorPtr
Definition: SMDS_ElemIterator.hxx:46

SMDS_FaceIteratorPtr
boost::shared_ptr< SMDS_Iterator< const SMDS_MeshFace * > > SMDS_FaceIteratorPtr
Definition: SMDS_ElemIterator.hxx:55

SMDS_Mesh0DElement.hxx

SMDS_MeshCell.hxx

SMDS_MeshEdge.hxx

SMDS_MeshFace.hxx

SMDS_MeshInfo.hxx

SMDS_MeshNode.hxx

SMDS_MeshVolume.hxx

SMDS_UnstructuredGrid.hxx

vtkMTimeType
unsigned long int vtkMTimeType
Definition: SMDS_UnstructuredGrid.hxx:53

SMESH_SMDS.hxx

SMDS_EXPORT
#define SMDS_EXPORT
Definition: SMESH_SMDS.hxx:37

SMDS_BallElement
Ball element.
Definition: SMDS_BallElement.hxx:36

SMDS_ElementFactory
Allocate SMDS_MeshElement's (SMDS_MeshCell's or SMDS_MeshNode's ) and bind some attributes to element...
Definition: SMDS_ElementFactory.hxx:65

SMDS_ElementHolder
Base class of object holding SMDS_MeshElement pointers.
Definition: SMDS_ElementHolder.hxx:48

SMDS_Mesh0DElement
0D mesh element.
Definition: SMDS_Mesh0DElement.hxx:36

SMDS_MeshEdge
Edge mesh element.
Definition: SMDS_MeshEdge.hxx:36

SMDS_MeshElement
Base class for elements.
Definition: SMDS_MeshElement.hxx:56

SMDS_MeshElement::IsNull
bool IsNull() const
Definition: SMDS_MeshElement.hxx:141

SMDS_MeshElement::GetType
virtual SMDSAbs_ElementType GetType() const =0

SMDS_MeshFace
Mesh face.
Definition: SMDS_MeshFace.hxx:41

SMDS_MeshInfo
Definition: SMDS_MeshInfo.hxx:36

SMDS_MeshNode
Definition: SMDS_MeshNode.hxx:36

SMDS_MeshObject
Definition: SMDS_MeshObject.hxx:33

SMDS_MeshVolume
Mesh volume.
Definition: SMDS_MeshVolume.hxx:40

SMDS_Mesh
Definition: SMDS_Mesh.hxx:53

SMDS_Mesh::zmax
double zmax
Definition: SMDS_Mesh.hxx:768

SMDS_Mesh::myNodeFactory
SMDS_NodeFactory * myNodeFactory
Small objects like SMDS_MeshNode are allocated by chunks to limit memory costs of new.
Definition: SMDS_Mesh.hxx:748

SMDS_Mesh::GetMeshInfo
const SMDS_MeshInfo & GetMeshInfo() const
Definition: SMDS_Mesh.hxx:693

SMDS_Mesh::xmax
double xmax
Definition: SMDS_Mesh.hxx:764

SMDS_Mesh::ymax
double ymax
Definition: SMDS_Mesh.hxx:766

SMDS_Mesh::myCompactTime
unsigned long myCompactTime
Definition: SMDS_Mesh.hxx:758

SMDS_Mesh::GetGrid
SMDS_UnstructuredGrid * GetGrid()
actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGr...
Definition: SMDS_Mesh.hxx:59

SMDS_Mesh::myParent
SMDS_Mesh * myParent
Definition: SMDS_Mesh.hxx:751

SMDS_Mesh::myCellFactory
SMDS_ElementFactory * myCellFactory
Definition: SMDS_Mesh.hxx:749

SMDS_Mesh::DownCast
static const ELEMTYPE * DownCast(const SMDS_MeshElement *e)
Definition: SMDS_Mesh.hxx:632

SMDS_Mesh::myGrid
SMDS_UnstructuredGrid * myGrid
actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGr...
Definition: SMDS_Mesh.hxx:745

SMDS_Mesh::myChildren
std::list< SMDS_Mesh * > myChildren
Definition: SMDS_Mesh.hxx:752

SMDS_Mesh::setMyModified
void setMyModified()
low level modification: add, change or remove node or element
Definition: SMDS_Mesh.hxx:713

SMDS_Mesh::xmin
double xmin
Definition: SMDS_Mesh.hxx:763

SMDS_Mesh::chunkSize
static int chunkSize
Definition: SMDS_Mesh.hxx:710

SMDS_Mesh::ymin
double ymin
Definition: SMDS_Mesh.hxx:765

SMDS_Mesh::myModified
bool myModified
any add, remove or change of node or cell
Definition: SMDS_Mesh.hxx:756

SMDS_Mesh::adjustBoundingBox
void adjustBoundingBox(double x, double y, double z)
Definition: SMDS_Mesh.hxx:725

SMDS_Mesh::zmin
double zmin
Definition: SMDS_Mesh.hxx:767

SMDS_Mesh::myInfo
SMDS_MeshInfo myInfo
Definition: SMDS_Mesh.hxx:753

SMDS_Mesh::myElemHolders
std::set< SMDS_ElementHolder * > myElemHolders
Definition: SMDS_Mesh.hxx:761

SMDS_NodeFactory
Allocate SMDS_MeshNode's.
Definition: SMDS_ElementFactory.hxx:147

SMDS_UnstructuredGrid
This class extends vtkUnstructuredGrid to deal with downward connectivity.
Definition: SMDS_UnstructuredGrid.hxx:108

DriverMED::FindNode
const SMDS_MeshNode * FindNode(const SMDS_Mesh *theMesh, TInt theId)
Definition: DriverMED_R_SMESHDS_Mesh.cxx:70

SMESH::AddNode
long AddNode(SMESH::SMESH_Mesh_ptr theMesh, float x, float y, float z, const QStringList &theParameters)
Definition: SMESHGUI_NodesDlg.cxx:96