Version: 6.3.1
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Friends

SMDS_VtkVolume Class Reference

#include <SMDS_VtkVolume.hxx>

Inheritance diagram for SMDS_VtkVolume:
Inheritance graph
[legend]

Public Types

typedef SMDS_StdIterator
< const SMDS_MeshNode
*, SMDS_ElemIteratorPtr > 		iterator

Public Member Functions

 SMDS_VtkVolume ()
 SMDS_VtkVolume (std::vector< vtkIdType > nodeIds, SMDS_Mesh *mesh)
 ~SMDS_VtkVolume ()
void init (std::vector< vtkIdType > nodeIds, SMDS_Mesh *mesh)
 typed used are vtk types (
void initPoly (std::vector< vtkIdType > nodeIds, std::vector< int > nbNodesPerFace, SMDS_Mesh *mesh)
virtual bool ChangeNodes (const SMDS_MeshNode *nodes[], const int nbNodes)
virtual bool vtkOrder (const SMDS_MeshNode *nodes[], const int nbNodes)
 Reorder in VTK order a list of nodes given in SMDS order.
void Print (std::ostream &OS) const
int NbFaces () const
 Return the number of faces owned by or linked with the current element.
int NbNodes () const
 Return The number of nodes owned by the current element.
int NbEdges () const
 Return the number of edges owned by or linked with the current element.
int NbFaceNodes (const int face_ind) const
 polyhedron only, 1 <= face_ind <= NbFaces()
const SMDS_MeshNode * GetFaceNode (const int face_ind, const int node_ind) const
 polyhedron only, 1 <= face_ind <= NbFaces() 1 <= node_ind <= NbFaceNodes()
virtual SMDSAbs_ElementType GetType () const
 Return the type of the current element.
virtual vtkIdType GetVtkType () const
virtual SMDSAbs_EntityType GetEntityType () const
 Return type of entity.
virtual const SMDS_MeshNode * GetNode (const int ind) const
 Return node by its index.
virtual bool IsQuadratic () const
virtual bool IsPoly () const
virtual bool IsMediumNode (const SMDS_MeshNode *node) const
int NbUniqueNodes () const
 For polyhedron only.
SMDS_ElemIteratorPtr uniqueNodesIterator () const
 For polyhedron use only.
const std::vector< int > GetQuantities () const
 polyhedron only, return number of nodes for each face
virtual SMDS_ElemIteratorPtr elementsIterator (SMDSAbs_ElementType type) const
virtual SMDS_ElemIteratorPtr nodesIteratorToUNV () const
 virtual, redefined in vtkEdge, vtkFace and vtkVolume classes
virtual SMDS_ElemIteratorPtr interlacedNodesElemIterator () const
 virtual, redefined in vtkEdge, vtkFace and vtkVolume classes
SMDS_ElemIteratorPtr nodesIterator () const
 Create an iterator which iterate on nodes owned by the element.
SMDS_ElemIteratorPtr edgesIterator () const
 Create an iterator which iterate on edges linked with or owned by the element.
SMDS_ElemIteratorPtr facesIterator () const
 Create an iterator which iterate on faces linked with or owned by the element.
iterator begin_nodes () const
iterator end_nodes () const
int GetID () const
virtual int NbCornerNodes () const
 Return number of nodes excluding medium ones.
const SMDS_MeshNode * GetNodeWrap (const int ind) const
 Return node by its index.
virtual bool IsValidIndex (const int ind) const
 Return true if index of node is valid (0 <= ind < NbNodes())
int WrappedIndex (const int ind) const
 Return a valid node index, fixing the given one if necessary.
int GetNodeIndex (const SMDS_MeshNode *node) const
 Check if a node belongs to the element.
ShortType getMeshId () const
LongType getshapeId () const
int getIdInShape () const
int getVtkId () const

Static Public Member Functions

static void gravityCenter (SMDS_UnstructuredGrid *grid, vtkIdType *nodeIds, int nbNodes, double *result)
static bool isForward (double *a, double *b, double *c, double *d)

Static Public Attributes

static int nbCells = 0

Protected Member Functions

void exchange (const SMDS_MeshNode *nodes[], int a, int b)
void setId (int id)
void setShapeId (LongType shapeId)
void setIdInShape (int id)
void setVtkId (int vtkId)
virtual void init (int id=-1, ShortType meshId=-1, LongType shapeId=0)

Protected Attributes

int myID
 Element index in vector SMDS_Mesh.myNodes or SMDS_Mesh.myCells.
int myVtkID
 index in vtkUnstructuredGrid
ShortType myMeshId
 SMDS_Mesh identification in SMESH.
LongType myShapeId
 SubShape and SubMesh identification in SMESHDS.
int myIdInShape
 Element index in SMESHDS_SubMesh vector.

Friends

class SMDS_Mesh
class SMESHDS_Mesh
class SMESHDS_SubMesh
class SMDS_MeshElementIDFactory
std::ostream & operator<< (std::ostream &OS, const SMDS_MeshElement *)
bool SMDS_MeshElementIDFactory::BindID (int ID, SMDS_MeshElement *elem)

Detailed Description

Definition at line 29 of file SMDS_VtkVolume.hxx.

Member Typedef Documentation

typedef SMDS_StdIterator< const SMDS_MeshNode*, SMDS_ElemIteratorPtr > SMDS_MeshElement.iterator [inherited]

Definition at line 72 of file SMDS_MeshElement.hxx.

Constructor & Destructor Documentation

SMDS_VtkVolume::SMDS_VtkVolume ( )

Definition at line 29 of file SMDS_VtkVolume.cxx.

{
}
SMDS_VtkVolume::SMDS_VtkVolume ( std::vector< vtkIdType >  nodeIds,
SMDS_Mesh *  mesh 
)

Definition at line 33 of file SMDS_VtkVolume.cxx.

References init().

{
  init(nodeIds, mesh);
}
SMDS_VtkVolume::~SMDS_VtkVolume ( )

Definition at line 195 of file SMDS_VtkVolume.cxx.

{
}

Member Function Documentation

iterator SMDS_MeshElement.begin_nodes ( ) const [inherited]

Definition at line 73 of file SMDS_MeshElement.hxx.

Referenced by SMESH_MeshEditor.convertElemToQuadratic(), SMESH_MeshEditor.ConvertToQuadratic(), StdMeshers_Import_1D.importMesh(), StdMeshers_QuadToTriaAdaptor.MergePiramids(), SMESH_MeshEditor.removeQuadElem(), and VISCOUS._ViscousBuilder.smoothAndCheck().

{ return iterator( nodesIterator() ); }
bool SMDS_VtkVolume::ChangeNodes ( const SMDS_MeshNode *  nodes[],
const int  nbNodes 
) [virtual]

Implements SMDS_MeshCell.

Definition at line 120 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, SMDS_MeshElement.getVtkId(), ex11_grid3partition.grid, MESSAGE, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType npts = 0;
  vtkIdType* pts = 0;
  grid->GetCellPoints(myVtkID, npts, pts);
  if (nbNodes != npts)
    {
      MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << nbNodes);
      return false;
    }
  for (int i = 0; i < nbNodes; i++)
    {
      pts[i] = nodes[i]->getVtkId();
    }
  SMDS_Mesh::_meshList[myMeshId]->setMyModified();
  return true;
}
SMDS_ElemIteratorPtr SMDS_MeshElement::edgesIterator ( ) const [inherited]

Create an iterator which iterate on edges linked with or owned by the element.

This method call elementsIterator().

Definition at line 80 of file SMDS_MeshElement.cxx.

References SMDSAbs_Edge.

Referenced by SMDS_Mesh.addChildrenWithNodes().

{
        return elementsIterator(SMDSAbs_Edge);
}
SMDS_ElemIteratorPtr SMDS_VtkVolume::elementsIterator ( SMDSAbs_ElementType  type) const [virtual]

Reimplemented from SMDS_MeshElement.

Definition at line 400 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, GetEntityType(), MESSAGE, SMDS_MeshElement.myMeshId, SMDS_MeshElement.myVtkID, SMDSAbs_Node, and SMDSEntity_Polyhedra.

{
  switch (type)
  {
    case SMDSAbs_Node:
      {
        SMDSAbs_EntityType aType = this->GetEntityType();
        if (aType == SMDSEntity_Polyhedra)
          return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorPolyH(SMDS_Mesh::_meshList[myMeshId], myVtkID, aType));
        else
          return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, aType));
      }
    default:
      MESSAGE("ERROR : Iterator not implemented");
      return SMDS_ElemIteratorPtr((SMDS_ElemIterator*) NULL);
  }
}
iterator SMDS_MeshElement.end_nodes ( ) const [inherited]

Definition at line 74 of file SMDS_MeshElement.hxx.

Referenced by SMESH_MeshEditor.convertElemToQuadratic(), SMESH_MeshEditor.ConvertToQuadratic(), StdMeshers_QuadToTriaAdaptor.MergePiramids(), and SMESH_MeshEditor.removeQuadElem().

{ return iterator(); }
void SMDS_MeshCell.exchange ( const SMDS_MeshNode *  nodes[],
int  a,
int  b 
) [protected, inherited]

Definition at line 41 of file SMDS_MeshCell.hxx.

References SMESH_demo_hexa2_upd.a.

Referenced by vtkOrder().

  {
    const SMDS_MeshNode* noda = nodes[a];
    nodes[a] = nodes[b];
    nodes[b] = noda;
  }
SMDS_ElemIteratorPtr SMDS_MeshElement::facesIterator ( ) const [inherited]

Create an iterator which iterate on faces linked with or owned by the element.

This method call elementsIterator().

Definition at line 89 of file SMDS_MeshElement.cxx.

References SMDSAbs_Face.

Referenced by SMDS_Mesh.addChildrenWithNodes(), and SMESH.Controls.ManifoldPart.getFacesByLink().

{
        return elementsIterator(SMDSAbs_Face);
}
SMDSAbs_EntityType SMDS_VtkVolume::GetEntityType ( ) const [virtual]

Return type of entity.

Implements SMDS_MeshElement.

Definition at line 512 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, ex11_grid3partition.grid, SMDS_MeshElement.myMeshId, SMDS_MeshElement.myVtkID, SMDSEntity_Hexa, SMDSEntity_Penta, SMDSEntity_Polyhedra, SMDSEntity_Pyramid, SMDSEntity_Quad_Hexa, SMDSEntity_Quad_Penta, SMDSEntity_Quad_Pyramid, SMDSEntity_Quad_Tetra, and SMDSEntity_Tetra.

Referenced by elementsIterator(), interlacedNodesElemIterator(), nodesIteratorToUNV(), and uniqueNodesIterator().

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);

  SMDSAbs_EntityType aType = SMDSEntity_Tetra;
  switch (aVtkType)
  {
    case VTK_TETRA:
      aType = SMDSEntity_Tetra;
      break;
    case VTK_PYRAMID:
      aType = SMDSEntity_Pyramid;
      break;
    case VTK_WEDGE:
      aType = SMDSEntity_Penta;
      break;
    case VTK_HEXAHEDRON:
      aType = SMDSEntity_Hexa;
      break;
    case VTK_QUADRATIC_TETRA:
      aType = SMDSEntity_Quad_Tetra;
      break;
    case VTK_QUADRATIC_PYRAMID:
      aType = SMDSEntity_Quad_Pyramid;
      break;
    case VTK_QUADRATIC_WEDGE:
      aType = SMDSEntity_Quad_Penta;
      break;
    case VTK_QUADRATIC_HEXAHEDRON:
      aType = SMDSEntity_Quad_Hexa;
      break;
//#ifdef VTK_HAVE_POLYHEDRON
    case VTK_POLYHEDRON:
      aType = SMDSEntity_Polyhedra;
      break;
//#endif
    default:
      aType = SMDSEntity_Polyhedra;
      break;
  }
  return aType;
}
const SMDS_MeshNode * SMDS_VtkVolume::GetFaceNode ( const int  face_ind,
const int  node_ind 
) const

polyhedron only, 1 <= face_ind <= NbFaces() 1 <= node_ind <= NbFaceNodes()

Definition at line 347 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, SMDS_Mesh.FindNodeVtk(), SMDS_Mesh.getGrid(), ex11_grid3partition.grid, PAL_MESH_041_mesh.mesh, SMDS_MeshElement.myMeshId, SMDS_MeshElement.myVtkID, and ex29_refine.node().

Referenced by SMDS_VolumeTool.IsFaceExternal(), SMDS_VolumeTool.IsLinked(), SMDS_VolumeTool.setFace(), and SMESH_MeshEditor.Transform().

{
  SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
  vtkUnstructuredGrid* grid = mesh->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  const SMDS_MeshNode* node = 0;
  if (aVtkType == VTK_POLYHEDRON)
    {
      vtkIdType nFaces = 0;
      vtkIdType* ptIds = 0;
      grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
      int id = 0;
      for (int i = 0; i < nFaces; i++)
        {
          int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
          if (i == face_ind - 1) // first face is number 1
            {
              if ((node_ind > 0) && (node_ind <= nodesInFace))
                node = mesh->FindNodeVtk(ptIds[id + node_ind]); // ptIds[id+1] : first node
              break;
            }
          id += (nodesInFace + 1);
        }
    }
  return node;
}
int SMDS_MeshElement.GetID ( ) const [inherited]

Definition at line 79 of file SMDS_MeshElement.hxx.

Referenced by SMESHDS_Mesh.Add0DElement(), SMESH_MeshEditor_i.Add0DElement(), SMESHDS_Mesh.Add0DElementWithID(), SMESHDS_Mesh.AddEdge(), SMESH_MeshEditor_i.AddEdge(), SMESHDS_Mesh.AddEdgeWithID(), SMESHDS_SubMesh.AddElement(), SMESHDS_Mesh.AddFace(), SMESH_MeshEditor_i.AddFace(), SMESHDS_Mesh.AddFaceWithID(), SMESHDS_SubMesh.AddNode(), SMESHDS_Mesh.AddNode(), SMESH_MeshEditor_i.AddNode(), SMESHDS_Mesh.AddNodeWithID(), SMESHDS_Mesh.AddPolygonalFace(), SMESH_MeshEditor_i.AddPolygonalFace(), SMESHDS_Mesh.AddPolyhedralVolume(), SMESH_MeshEditor_i.AddPolyhedralVolume(), SMESH_MeshEditor_i.AddPolyhedralVolumeByFaces(), SMESHDS_Mesh.AddVolume(), SMESH_MeshEditor_i.AddVolume(), SMESHDS_Mesh.AddVolumeWithID(), SMESH_VisualObjDef.buildElemPrs(), SMESHDS_Mesh.ChangeElementNodes(), SMESHDS_Mesh.ChangePolyhedronNodes(), SMESHGUI_CreatePolyhedralVolumeDlg.checkEditLine(), SMESH_MesherHelper.CheckNodeU(), SMDS_Mesh.Clear(), collectMeshInfo(), StdMeshers_Projection_3D.Compute(), SMESH_Gen_i.ConcatenateCommon(), SMESHDS_GroupBase.Contains(), SMESH_MeshEditor.convertElemToQuadratic(), SMESH_MeshEditor.ConvertFromQuadratic(), SMESH_MeshEditor.ConvertToQuadratic(), SMESH_Gen_i.CopyMesh(), SMESH_Mesh_i.CreateDimGroup(), SMESH_MeshEditor.CreateFlatElementsOnFacesGroups(), SMESH_VisualObjDef.createPoints(), SMESHGUI_CuttingOfQuadsDlg.displayPreview(), SMESHGUI_CreatePolyhedralVolumeDlg.displaySimulation(), SMESH_MeshEditor.DoubleNodesOnGroupBoundaries(), StdMeshers_PrismAsBlock.THorizontalEdgeAdaptor.dumpNodes(), enlargeBoundingBox(), FillSequence(), SMESH_OctreeNode.FindCoincidentNodes(), SMESH.Controls.ManifoldPart.findConnected(), SMESH_Mesh_i.FindElementByNodes(), SMESH_MeshEditor.FindFreeBorder(), SMESH_MeshEditor.FindMatchingNodes(), SMESH_MeshEditor.FindShape(), findTriangles(), SMESH.Controls.FreeEdges.GetBoreders(), SMESH_subMesh_i.GetElementsByType(), SMESH_Mesh_i.GetElementsByType(), SMESH_Mesh_i.GetElemNode(), LinkID_Gen.GetLinkID(), SMESH_Mesh_i.GetNodeInverseElements(), getNodeNodeDistance(), SMESH_Mesh_i.GetSubMeshNodesId(), SMESH.Controls.MultiConnection2D.GetValue(), SMESH.Controls.MultiConnection2D.GetValues(), SMESH.Controls.Length2D.GetValues(), SMDS_VolumeTool.ID(), SMESHGUI_TreeElemInfo.information(), SMESHGUI_SimpleElemInfo.information(), SMESH.Controls.FreeEdges.IsFreeEdge(), SMESH.Controls.ManifoldPart.isInPlane(), SMESH.Controls.CoplanarFaces.IsSatisfy(), SMESH_ProxyMesh.IsTemporary(), VISCOUS._ViscousBuilder.makeGroupOfLE(), StdMeshers_Penta_3D.MakeMeshOnFxy1(), StdMeshers_Penta_3D.MakeNodes(), StdMeshers_Penta_3D.MakeVolumeMesh(), SMESH_MeshEditor_i.MoveClosestNodeToPoint(), SMESHDS_Mesh.MoveNode(), SMESHGUI_ElemInfo.nodeConnectivity(), SMESHGUI_WhatIsDlg.onTextChange(), SMESHGUI_TranslationDlg.onTextChange(), SMESHGUI_SymmetryDlg.onTextChange(), SMESHGUI_SingleEditDlg.onTextChange(), SMESHGUI_SewingDlg.onTextChange(), SMESHGUI_ScaleDlg.onTextChange(), SMESHGUI_RotationDlg.onTextChange(), SMESHGUI_RevolutionDlg.onTextChange(), SMESHGUI_ExtrusionAlongPathDlg.onTextChange(), SMESHGUI_CreatePolyhedralVolumeDlg.onTextChange(), SMESHGUI_MeshPatternDlg.onTextChanged(), TIDCompare.operator()(), TNode.operator<(), operator<<(), DriverUNV_W_SMDS_Mesh.Perform(), DriverMED_W_SMESHDS_Mesh.Perform(), DriverDAT_W_SMDS_Mesh.Perform(), Print(), SMDS_QuadraticEdge.Print(), SMDS_Mesh0DElement.Print(), SMDS_FaceOfEdges.Print(), SMESH.Controls.ElementsOnShape.process(), SMESH.Controls.ElementsOnSurface.process(), SMESH.Controls.ManifoldPart.process(), StdMeshers_Prism_3D.projectBottomToTop(), SMESHDS_Mesh.RemoveElement(), SMESHDS_Mesh.RemoveFreeElement(), SMDS_Mesh.RemoveFreeElement(), SMESHDS_Mesh.RemoveFreeNode(), SMESHDS_Mesh.RemoveNode(), SMESH_MeshEditor.removeQuadElem(), SMESH_ProxyMesh.removeTmpElement(), SMDS_Mesh.Renumber(), SMESH_Gen_i.Save(), SMESHGUI_WhatIsDlg.SelectionIntoArgument(), VISCOUS._ViscousBuilder.setEdgeData(), SMDS_Mesh0DElement.SMDS_Mesh0DElement(), SMESH_TLink.SMESH_TLink(), StdMeshers_MEFISTO_2D.StoreResult(), SMESH_MeshEditor_i.storeResult(), SMESH_MeshEditor.sweepElement(), and SMDS_Mesh.~SMDS_Mesh().

{ return myID; };
int SMDS_MeshElement.getIdInShape ( ) const [inherited]

Definition at line 145 of file SMDS_MeshElement.hxx.

Referenced by SMESHDS_SubMesh.AddElement(), SMESHDS_SubMesh.AddNode(), SMESHDS_SubMesh.Contains(), SMESHDS_SubMesh.RemoveElement(), and SMESHDS_SubMesh.RemoveNode().

{ return myIdInShape; }
ShortType SMDS_MeshElement.getMeshId ( ) const [inherited]

Definition at line 143 of file SMDS_MeshElement.hxx.

Referenced by SMDS_VolumeTool.GetSize(), and SMESH.Controls.AspectRatio3D.GetValue().

{return myMeshId; }
const SMDS_MeshNode * SMDS_VtkVolume::GetNode ( const int  ind) const [virtual]

Return node by its index.

Parameters:
ind- node index
Return values:
constSMDS_MeshNode* - the node

Reimplemented from SMDS_MeshElement.

Definition at line 438 of file SMDS_VtkVolume.cxx.

{
  // TODO optimize if possible (vtkCellIterator)
  return SMDS_MeshElement::GetNode(ind);
}
int SMDS_MeshElement::GetNodeIndex ( const SMDS_MeshNode *  node) const [inherited]

Check if a node belongs to the element.

Parameters:
node- the node to check
Return values:
int- node index within the element, -1 if not found

Definition at line 266 of file SMDS_MeshElement.cxx.

References ex29_refine.node().

Referenced by VISCOUS._ViscousBuilder.addBoundaryElements(), StdMeshers_QuadToTriaAdaptor.Compute2ndPart(), SMDS_Mesh.FindEdge(), SMDS_Mesh.FindElement(), SMESH_MeshEditor.FindFaceInSet(), SMESH_MeshEditor.FindMatchingNodes(), SMESH_ElementSearcherImpl.findOuterBoundary(), SMESH_Algo.GetCommonNodes(), SMDS_VolumeTool.GetFaceNodesIndices(), VISCOUS._ViscousBuilder.getSimplices(), SMESH.Controls.OverConstrainedFace.IsSatisfy(), SMESH.Controls.BareBorderFace.IsSatisfy(), _QuadFaceGrid.LoadGrid(), SMESH_MeshEditor.makeWalls(), StdMeshers_QuadToTriaAdaptor.Preparation(), and StdMeshers_Quadrangle_2D.Smooth().

{
  SMDS_ElemIteratorPtr nIt = nodesIterator();
  for ( int i = 0; nIt->more(); ++i )
    if ( nIt->next() == node )
      return i;
  return -1;
}
const SMDS_MeshNode* SMDS_MeshElement.GetNodeWrap ( const int  ind) const [inherited]

Return node by its index.

Parameters:
ind- node index
Return values:
constSMDS_MeshNode* - the node

Index is wrapped if it is out of a valid range

Definition at line 116 of file SMDS_MeshElement.hxx.

Referenced by _MyEdgeIterator._MyEdgeIterator(), SMESH_MeshEditor.GetLinkedNodes(), and SMESH_MeshEditor.makeWalls().

{ return GetNode( WrappedIndex( ind )); }
const std::vector< int > SMDS_VtkVolume::GetQuantities ( ) const

polyhedron only, return number of nodes for each face

Definition at line 377 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, SMDS_Mesh.getGrid(), ex11_grid3partition.grid, PAL_MESH_041_mesh.mesh, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

Referenced by StdMeshers_Projection_3D.Compute(), and SMESH_Gen_i.ConcatenateCommon().

{
  vector<int> quantities;
  quantities.clear();
  SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
  vtkUnstructuredGrid* grid = mesh->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  if (aVtkType == VTK_POLYHEDRON)
    {
      vtkIdType nFaces = 0;
      vtkIdType* ptIds = 0;
      grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
      int id = 0;
      for (int i = 0; i < nFaces; i++)
        {
          int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
          quantities.push_back(nodesInFace);
          id += (nodesInFace + 1);
        }
    }
  return quantities;
}
LongType SMDS_MeshElement.getshapeId ( ) const [inherited]

Definition at line 144 of file SMDS_MeshElement.hxx.

Referenced by SMESHDS_SubMesh.AddElement(), SMESHDS_SubMesh.AddNode(), areNodesBound(), SMESH_MesherHelper.CheckNodeU(), SMESH_MesherHelper.CheckNodeUV(), StdMeshers_QuadToTriaAdaptor.Compute2ndPart(), SMESH_MeshEditor.ConvertToQuadratic(), SMESH_Pattern.createElements(), SMESH_MeshEditor.DeleteDiag(), StdMeshers_ProjectionUtils.FindMatchingNodesOnFaces(), VISCOUS._ViscousBuilder.findNeiborsOnEdge(), SMESH_MeshEditor.FindShape(), SMESH_MesherHelper.GetMediumNode(), StdMeshers_PrismAsBlock.GetNodeColumn(), SMESH_MesherHelper.GetNodeU(), SMESH_MesherHelper.GetNodeUV(), SMESH_ProxyMesh.GetProxyNode(), SMESH_Mesh_i.GetShapeID(), SMESH_MesherHelper.GetSubShapeByNode(), StdMeshers_FaceSide.GetUVPtStruct(), StdMeshers_PrismAsBlock.Init(), SMESH_Algo.IsReversedSubMesh(), VISCOUS._ViscousBuilder.makeLayer(), StdMeshers_QuadToTriaAdaptor.MergePiramids(), SMESH.SMESH_Group.Remove(), SMESHDS_SubMesh.RemoveElement(), SMESHDS_SubMesh.RemoveNode(), SMESHDS_Mesh.RemoveNode(), SMESH_MeshEditor.removeQuadElem(), VISCOUS._ViscousBuilder.setEdgeData(), StdMeshers_Quadrangle_2D.Smooth(), and SMESHDS_Mesh.UnSetNodeOnShape().

{return myShapeId; }
SMDSAbs_ElementType SMDS_VtkVolume::GetType ( ) const [virtual]

Return the type of the current element.

Reimplemented from SMDS_MeshVolume.

Definition at line 428 of file SMDS_VtkVolume.cxx.

References SMDSAbs_Volume.

{
  return SMDSAbs_Volume;
}
int SMDS_MeshElement.getVtkId ( ) const [inherited]

Definition at line 146 of file SMDS_MeshElement.hxx.

Referenced by SMDS_Mesh.AddEdgeWithID(), SMDS_Mesh.AddFaceWithID(), SMDS_MeshNode.AddInverseElement(), SMDS_Mesh.AddPolygonalFaceWithID(), SMDS_Mesh.AddPolyhedralVolumeWithID(), SMDS_Mesh.AddVolumeFromVtkIdsWithID(), SMDS_Mesh.AddVolumeWithID(), SMDS_VtkFace.ChangeApex(), ChangeNodes(), SMDS_VtkFace.ChangeNodes(), SMDS_VtkEdge.ChangeNodes(), SMDS_Mesh.Clear(), SMDS_Mesh.createQuadrangle(), SMDS_Mesh.createTriangle(), SMESH_MeshEditor.DoubleNodesOnGroupBoundaries(), SMDS_UnstructuredGrid.extrudeVolumeFromFace(), SMDS_Mesh.FindEdgeOrCreate(), SMESH_VisualObjDef.GetNodeVTKId(), SMESH.Controls.AspectRatio3D.GetValue(), IsMediumNode(), SMDS_VtkFace.IsMediumNode(), SMDS_VtkEdge.IsMediumNode(), operator<(), SMDS_Mesh.registerElement(), SMDS_Mesh.RemoveFreeElement(), SMDS_MeshNode.RemoveInverseElement(), SMDS_MeshElementIDFactory.SetInVtkGrid(), and SMDS_Mesh.~SMDS_Mesh().

{ return myVtkID; }
vtkIdType SMDS_VtkVolume::GetVtkType ( ) const [virtual]

Reimplemented from SMDS_MeshVolume.

Definition at line 556 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, ex11_grid3partition.grid, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

Referenced by SMDS_Mesh.AddVolumeFromVtkIdsWithID().

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aType = grid->GetCellType(myVtkID);
  return aType;
}
void SMDS_VtkVolume::gravityCenter ( SMDS_UnstructuredGrid *  grid,
vtkIdType *  nodeIds,
int  nbNodes,
double *  result 
) [static]

Definition at line 563 of file SMDS_VtkVolume.cxx.

Referenced by SMESH_MeshEditor.DoubleNodesOnGroupBoundaries(), and initPoly().

{
  for (int j = 0; j < 3; j++)
    result[j] = 0;
  if (nbNodes <= 0)
    return;
  for (int i = 0; i < nbNodes; i++)
    {
      double *coords = grid->GetPoint(nodeIds[i]);
      for (int j = 0; j < 3; j++)
        result[j] += coords[j];
    }
  for (int j = 0; j < 3; j++)
    result[j] = result[j] / nbNodes;
  //MESSAGE("center " << result[0] << " " << result[1] << " "  << result[2]);
  return;
}
void SMDS_VtkVolume::init ( std::vector< vtkIdType >  nodeIds,
SMDS_Mesh *  mesh 
)

typed used are vtk types (

See also:
vtkCellType.h) see GetEntityType() for conversion in SMDS type (
SMDSAbs_ElementType.hxx)

Definition at line 41 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh.getGrid(), SMDS_Mesh.getMeshId(), ex11_grid3partition.grid, SMDS_MeshElement.myMeshId, SMDS_MeshElement.myVtkID, and SMDS_Mesh.setMyModified().

Referenced by SMDS_Mesh.AddVolumeFromVtkIdsWithID(), SMDS_Mesh.AddVolumeWithID(), initPoly(), and SMDS_VtkVolume().

{
  SMDS_MeshVolume::init();
  vtkUnstructuredGrid* grid = mesh->getGrid();
  myMeshId = mesh->getMeshId();
  vtkIdType aType = VTK_TETRA;
  switch (nodeIds.size())
  {
    case 4:
      aType = VTK_TETRA;
      break;
    case 5:
      aType = VTK_PYRAMID;
      break;
    case 6:
      aType = VTK_WEDGE;
      break;
    case 8:
      aType = VTK_HEXAHEDRON;
      break;
    case 10:
      aType = VTK_QUADRATIC_TETRA;
      break;
    case 13:
      aType = VTK_QUADRATIC_PYRAMID;
      break;
    case 15:
      aType = VTK_QUADRATIC_WEDGE;
      break;
    case 20:
      aType = VTK_QUADRATIC_HEXAHEDRON;
      break;
    default:
      aType = VTK_HEXAHEDRON;
      break;
  }
  myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
  mesh->setMyModified();
  //MESSAGE("SMDS_VtkVolume::init myVtkID " << myVtkID);
}
void SMDS_MeshElement::init ( int  id = -1,
ShortType  meshId = -1,
LongType  shapeId = 0 
) [protected, virtual, inherited]

Definition at line 48 of file SMDS_MeshElement.cxx.

Referenced by SMDS_VtkFace.init(), SMDS_VtkEdge.init(), and SMDS_VtkFace.initPoly().

{
  myID = id;
  myMeshId = meshId;
  myShapeId = shapeId;
  myIdInShape = -1;
}
void SMDS_VtkVolume::initPoly ( std::vector< vtkIdType >  nodeIds,
std::vector< int >  nbNodesPerFace,
SMDS_Mesh *  mesh 
)

Definition at line 83 of file SMDS_VtkVolume.cxx.

References SMESH_demo_hexa2_upd.a, SMDS_Mesh.getGrid(), SMDS_UnstructuredGrid.GetPoints(), gravityCenter(), ex11_grid3partition.grid, init(), SMDS_UnstructuredGrid.InsertNextLinkedCell(), isForward(), SMDS_MeshElement.myVtkID, and SMDS_Mesh.setMyModified().

Referenced by SMDS_Mesh.AddPolyhedralVolumeWithID().

{
  SMDS_MeshVolume::init();
  //MESSAGE("SMDS_VtkVolume::initPoly");
  SMDS_UnstructuredGrid* grid = mesh->getGrid();
  double center[3];
  this->gravityCenter(grid, &nodeIds[0], nodeIds.size(), &center[0]);
  vector<vtkIdType> ptIds;
  ptIds.clear();
  vtkIdType nbFaces = nbNodesPerFace.size();
  int k = 0;
  for (int i = 0; i < nbFaces; i++)
    {
      int nf = nbNodesPerFace[i];
      ptIds.push_back(nf);
      double a[3];
      double b[3];
      double c[3];
      grid->GetPoints()->GetPoint(nodeIds[k], a);
      grid->GetPoints()->GetPoint(nodeIds[k + 1], b);
      grid->GetPoints()->GetPoint(nodeIds[k + 2], c);
      bool isFaceForward = this->isForward(a, b, c, center);
      //MESSAGE("isFaceForward " << i << " " << isFaceForward);
      vtkIdType *facePts = &nodeIds[k];
      if (isFaceForward)
        for (int n = 0; n < nf; n++)
          ptIds.push_back(facePts[n]);
      else
        for (int n = nf - 1; n >= 0; n--)
          ptIds.push_back(facePts[n]);
      k += nf;
    }
  myVtkID = grid->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]);
  mesh->setMyModified();
}
SMDS_ElemIteratorPtr SMDS_VtkVolume::interlacedNodesElemIterator ( ) const [virtual]

virtual, redefined in vtkEdge, vtkFace and vtkVolume classes

Reimplemented from SMDS_MeshElement.

Definition at line 423 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, GetEntityType(), SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

{
  return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
}
bool SMDS_VtkVolume::isForward ( double *  a,
double *  b,
double *  c,
double *  d 
) [static]

Definition at line 581 of file SMDS_VtkVolume.cxx.

Referenced by initPoly().

{
  double u[3], v[3], w[3];
  for (int j = 0; j < 3; j++)
    {
      //MESSAGE("a,b,c,d " << a[j] << " " << b[j] << " " << c[j] << " " << d[j]);
      u[j] = b[j] - a[j];
      v[j] = c[j] - a[j];
      w[j] = d[j] - a[j];
      //MESSAGE("u,v,w " << u[j] << " " << v[j] << " " << w[j]);
    }
  double prodmixte = (u[1]*v[2] - u[2]*v[1]) * w[0]
                   + (u[2]*v[0] - u[0]*v[2]) * w[1]
                   + (u[0]*v[1] - u[1]*v[0]) * w[2];
  return (prodmixte < 0);
}
bool SMDS_VtkVolume::IsMediumNode ( const SMDS_MeshNode *  node) const [virtual]

Reimplemented from SMDS_MeshElement.

Definition at line 469 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, SMDS_MeshElement.getVtkId(), ex11_grid3partition.grid, MESSAGE, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  int rankFirstMedium = 0;
  switch (aVtkType)
  {
    case VTK_QUADRATIC_TETRA:
      rankFirstMedium = 4; // medium nodes are of rank 4 to 9
      break;
    case VTK_QUADRATIC_PYRAMID:
      rankFirstMedium = 5; // medium nodes are of rank 5 to 12
      break;
    case VTK_QUADRATIC_WEDGE:
      rankFirstMedium = 6; // medium nodes are of rank 6 to 14
      break;
    case VTK_QUADRATIC_HEXAHEDRON:
      rankFirstMedium = 8; // medium nodes are of rank 8 to 19
      break;
    default:
      return false;
  }
  vtkIdType npts = 0;
  vtkIdType* pts = 0;
  grid->GetCellPoints(myVtkID, npts, pts);
  vtkIdType nodeId = node->getVtkId();
  for (int rank = 0; rank < npts; rank++)
    {
      if (pts[rank] == nodeId)
        {
          if (rank < rankFirstMedium)
            return false;
          else
            return true;
        }
    }
  //throw SALOME_Exception(LOCALIZED("node does not belong to this element"));
  MESSAGE("======================================================");
  MESSAGE("= IsMediumNode: node does not belong to this element =");
  MESSAGE("======================================================");
  return false;
}
bool SMDS_VtkVolume::IsPoly ( ) const [virtual]

Reimplemented from SMDS_MeshElement.

Definition at line 462 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, ex11_grid3partition.grid, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

Referenced by StdMeshers_Projection_3D.Compute(), and DriverMED_W_SMESHDS_Mesh.Perform().

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  return (aVtkType == VTK_POLYHEDRON);
}
bool SMDS_VtkVolume::IsQuadratic ( ) const [virtual]

Reimplemented from SMDS_MeshElement.

Definition at line 444 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, ex11_grid3partition.grid, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  // TODO quadratic polyhedrons ?
  switch (aVtkType)
  {
    case VTK_QUADRATIC_TETRA:
    case VTK_QUADRATIC_PYRAMID:
    case VTK_QUADRATIC_WEDGE:
    case VTK_QUADRATIC_HEXAHEDRON:
      return true;
      break;
    default:
      return false;
  }
}
bool SMDS_MeshElement::IsValidIndex ( const int  ind) const [virtual, inherited]

Return true if index of node is valid (0 <= ind < NbNodes())

Parameters:
ind- node index
Return values:
bool- index check result

Definition at line 220 of file SMDS_MeshElement.cxx.

{
  return ( ind>-1 && ind<NbNodes() );
}
int SMDS_MeshElement::NbCornerNodes ( ) const [virtual, inherited]

Return number of nodes excluding medium ones.

Definition at line 253 of file SMDS_MeshElement.cxx.

Referenced by SMESH_Pattern.Apply(), StdMeshers_QuadToTriaAdaptor.CheckIntersection(), StdMeshers_Hexa_3D.Compute(), StdMeshers_QuadToTriaAdaptor.Compute2ndPart(), SMESH_MeshEditor.ConvertFromQuadratic(), SMDS_Mesh.FindElement(), SMESH_MesherHelper.FixQuadraticElements(), VISCOUS._ViscousBuilder.getSimplices(), getTriangles(), SMDS_VolumeTool.IsLinked(), SMESH.Controls.CoplanarFaces.IsSatisfy(), VISCOUS._ViscousBuilder.limitStepSize(), SMESH_Pattern.Load(), VISCOUS._ViscousBuilder.makeGroupOfLE(), VISCOUS._ViscousBuilder.makeLayer(), StdMeshers_QuadToTriaAdaptor.MergeAdjacent(), StdMeshers_QuadToTriaAdaptor.Preparation(), VISCOUS._ViscousBuilder.refine(), SMESH_MeshEditor.removeQuadElem(), SMDS_VolumeTool.Set(), and StdMeshers_Quadrangle_2D.Smooth().

{
  return IsQuadratic() ? NbNodes() - NbEdges() : NbNodes();
}
int SMDS_VtkVolume::NbEdges ( ) const [virtual]

Return the number of edges owned by or linked with the current element.

Reimplemented from SMDS_MeshElement.

Definition at line 267 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, ex11_grid3partition.grid, MESSAGE, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  int nbEdges = 6;
  switch (aVtkType)
  {
    case VTK_TETRA:
    case VTK_QUADRATIC_TETRA:
      nbEdges = 6;
      break;
    case VTK_PYRAMID:
    case VTK_QUADRATIC_PYRAMID:
      nbEdges = 8;
      break;
    case VTK_WEDGE:
    case VTK_QUADRATIC_WEDGE:
      nbEdges = 9;
      break;
    case VTK_HEXAHEDRON:
    case VTK_QUADRATIC_HEXAHEDRON:
      nbEdges = 12;
      break;
    case VTK_POLYHEDRON:
      {
        vtkIdType nFaces = 0;
        vtkIdType* ptIds = 0;
        grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
        nbEdges = 0;
        int id = 0;
        for (int i = 0; i < nFaces; i++)
          {
            int edgesInFace = ptIds[id];
            id += (edgesInFace + 1);
            nbEdges += edgesInFace;
          }
        nbEdges = nbEdges / 2;
        break;
      }
    default:
      MESSAGE("invalid volume type")
      ;
      nbEdges = 0;
      break;
  }
  return nbEdges;
}
int SMDS_VtkVolume::NbFaceNodes ( const int  face_ind) const

polyhedron only, 1 <= face_ind <= NbFaces()

Definition at line 318 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, ex11_grid3partition.grid, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

Referenced by SMDS_VolumeTool.IsLinked(), DriverMED_W_SMESHDS_Mesh.Perform(), SMDS_VolumeTool.setFace(), and SMESH_MeshEditor.Transform().

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  int nbNodes = 0;
  if (aVtkType == VTK_POLYHEDRON)
    {
      vtkIdType nFaces = 0;
      vtkIdType* ptIds = 0;
      grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
      int id = 0;
      for (int i = 0; i < nFaces; i++)
        {
          int nodesInFace = ptIds[id];
          id += (nodesInFace + 1);
          if (i == face_ind - 1)
            {
              nbNodes = nodesInFace;
              break;
            }
        }
    }
  return nbNodes;
}
int SMDS_VtkVolume::NbFaces ( ) const [virtual]

Return the number of faces owned by or linked with the current element.

Reimplemented from SMDS_MeshElement.

Definition at line 204 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, ex11_grid3partition.grid, MESSAGE, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

Referenced by DriverMED_W_SMESHDS_Mesh.Perform(), and SMESH_MeshEditor.Transform().

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  int nbFaces = 4;
  switch (aVtkType)
  {
    case VTK_TETRA:
    case VTK_QUADRATIC_TETRA:
      nbFaces = 4;
      break;
    case VTK_PYRAMID:
    case VTK_WEDGE:
    case VTK_QUADRATIC_PYRAMID:
    case VTK_QUADRATIC_WEDGE:
      nbFaces = 5;
      break;
    case VTK_HEXAHEDRON:
    case VTK_QUADRATIC_HEXAHEDRON:
      nbFaces = 6;
      break;
    case VTK_POLYHEDRON:
      {
        vtkIdType nFaces = 0;
        vtkIdType* ptIds = 0;
        grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
        nbFaces = nFaces;
        break;
      }
    default:
      MESSAGE("invalid volume type")
      ;
      nbFaces = 0;
      break;
  }
  return nbFaces;
}
int SMDS_VtkVolume::NbNodes ( ) const [virtual]

Return The number of nodes owned by the current element.

Reimplemented from SMDS_MeshElement.

Definition at line 242 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, ex11_grid3partition.grid, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

Referenced by DriverMED_W_SMESHDS_Mesh.Perform(), and vtkOrder().

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  int nbPoints = 0;
  if (aVtkType != VTK_POLYHEDRON)
    {
      nbPoints = grid->GetCell(myVtkID)->GetNumberOfPoints();
    }
  else
    {
      vtkIdType nFaces = 0;
      vtkIdType* ptIds = 0;
      grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
      int id = 0;
      for (int i = 0; i < nFaces; i++)
        {
          int nodesInFace = ptIds[id];
          nbPoints += nodesInFace;
          id += (nodesInFace + 1);
        }
    }
  return nbPoints;
}
int SMDS_VtkVolume::NbUniqueNodes ( ) const

For polyhedron only.

Returns:
actual number of nodes (not the sum of nodes of all faces)

Definition at line 601 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, ex11_grid3partition.grid, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

{
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  return grid->GetCell(myVtkID)->GetNumberOfPoints();
}
SMDS_ElemIteratorPtr SMDS_MeshElement::nodesIterator ( ) const [inherited]

Create an iterator which iterate on nodes owned by the element.

This method call elementsIterator().

Definition at line 71 of file SMDS_MeshElement.cxx.

References SMDSAbs_Node.

Referenced by SMDS_Mesh.addChildrenWithNodes(), SMESH_MeshEditor_i.AddPolyhedralVolumeByFaces(), SMESH_Pattern.Apply(), SMESH_Mesh_i.BaryCenter(), SMESH_VisualObjDef.buildElemPrs(), centroidalSmooth(), SMDS_Mesh.ChangeElementNodes(), SMDS_Mesh.ChangePolyhedronNodes(), StdMeshers_QuadToTriaAdaptor.Compute2ndPart(), SMESH_Gen_i.ConcatenateCommon(), SMESH_MeshEditor.ConvertToQuadratic(), SMESH_Gen_i.CopyMesh(), SMESH_Mesh_i.CreateDimGroup(), SMESH_Pattern.createElements(), SMESH_MeshEditor.CreateFlatElementsOnFacesGroups(), SMESHGUI_CuttingOfQuadsDlg.displayPreview(), SMESHGUI_CreatePolyhedralVolumeDlg.displaySimulation(), SMESH_MeshEditor.DoubleNodes(), SMESH_MeshEditor.doubleNodes(), SMESH_MeshEditor.DoubleNodesInRegion(), enlargeBoundingBox(), SMESH_MeshEditor.ExtrusionSweep(), SMDS_Mesh.FindEdge(), SMDS_Mesh.FindFace(), SMESH_MeshEditor.FindFreeBorder(), SMESHGUI_MergeDlg.FindGravityCenter(), SMESH_MeshEditor.FindShape(), getAngle(), SMESH.Controls.FreeEdges.GetBoreders(), SMESH_VisualObjDef.GetEdgeNodes(), SMESH_subMesh_i.GetElementsByType(), getFinitElements(), SMESH_MeshEditor.GetLinkedNodes(), getLinks(), getNodesFromElems(), GetNodesFromTwoTria(), SMESH.getNormale(), SMESH_subMesh_i.GetNumberOfNodes(), SMESH.Controls.NumericalFunctor.GetPoints(), getQuadrangleNodes(), SMESH_Mesh_i.GetSubMeshNodesId(), SMESH_ElementSearcherImpl.getTolerance(), SMESH.Controls.MultiConnection2D.GetValue(), SMESH.Controls.MultiConnection2D.GetValues(), SMESH.Controls.Length2D.GetValues(), SMESHGUI_ElemInfo.gravityCenter(), SMESHGUI_TreeElemInfo.information(), SMESHGUI_SimpleElemInfo.information(), SMESH_MeshEditor.InsertNodesIntoLink(), SMESH_MeshEditor.InverseDiag(), SMESH_MeshEditor.isOut(), SMESH_Algo.IsReversedSubMesh(), SMESH.Controls.FreeFaces.IsSatisfy(), SMESH.Controls.FreeEdges.IsSatisfy(), StdMeshers_Penta_3D.LoadIJNodes(), SMESH_MeshEditor.MakeExtrElements(), StdMeshers_Penta_3D.MakeMeshOnFxy1(), SMESH_Pattern.makePolyElements(), SMESHGUI_SingleEditDlg.onTextChange(), DriverDAT_W_SMDS_Mesh.Perform(), StdMeshers_QuadToTriaAdaptor.Preparation(), SMESH.Controls.ElementsOnShape.process(), SMESH.Controls.ElementsOnSurface.process(), SMESH_MeshEditor.QuadToTri(), VISCOUS._ViscousBuilder.refine(), SMDS_Mesh.RemoveFreeElement(), SMESHGUI_WhatIsDlg.SelectionIntoArgument(), SMDS_VolumeTool.Set(), SMDS_MeshElementIDFactory.SetInVtkGrid(), SMESH_MeshEditor.SewFreeBorder(), VISCOUS._ViscousBuilder.shrink(), SortableElement.SortableElement(), StdMeshers_MEFISTO_2D.StoreResult(), SMESH_MeshEditor_i.storeResult(), VISCOUS._Shrinker1D.SwapSrcTgtNodes(), and SMESH_MeshEditor.Transform().

{
        return elementsIterator(SMDSAbs_Node);
}
SMDS_ElemIteratorPtr SMDS_VtkVolume::nodesIteratorToUNV ( ) const [virtual]

virtual, redefined in vtkEdge, vtkFace and vtkVolume classes

Reimplemented from SMDS_MeshElement.

Definition at line 418 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, GetEntityType(), SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

{
  return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
}
void SMDS_VtkVolume::Print ( std::ostream &  OS) const [virtual]

Reimplemented from SMDS_MeshElement.

Definition at line 199 of file SMDS_VtkVolume.cxx.

References SMDS_MeshElement.GetID().

{
  OS << "volume <" << GetID() << "> : ";
}
void SMDS_MeshElement.setId ( int  id) [protected, inherited]

Definition at line 149 of file SMDS_MeshElement.hxx.

{myID = id; }
void SMDS_MeshElement.setIdInShape ( int  id) [protected, inherited]

Definition at line 151 of file SMDS_MeshElement.hxx.

Referenced by SMESHDS_SubMesh.AddElement(), SMESHDS_SubMesh.AddNode(), SMESHDS_SubMesh.compactList(), SMESHDS_SubMesh.RemoveElement(), and SMESHDS_SubMesh.RemoveNode().

{ myIdInShape = id; }
void SMDS_MeshElement.setShapeId ( LongType  shapeId) [protected, inherited]

Definition at line 150 of file SMDS_MeshElement.hxx.

Referenced by SMESHDS_SubMesh.AddElement(), SMESHDS_SubMesh.AddNode(), SMESHDS_SubMesh.RemoveElement(), and SMESHDS_SubMesh.RemoveNode().

{myShapeId = shapeId; }
void SMDS_MeshElement.setVtkId ( int  vtkId) [protected, inherited]

Reimplemented in SMDS_MeshNode.

Definition at line 152 of file SMDS_MeshElement.hxx.

Referenced by SMDS_MeshElementIDFactory.SetInVtkGrid().

{ myVtkID = vtkId; }
SMDS_ElemIteratorPtr SMDS_VtkVolume::uniqueNodesIterator ( ) const

For polyhedron use only.

Returns:
iterator on actual nodes (not through the faces)

Definition at line 610 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, GetEntityType(), MESSAGE, SMDS_MeshElement.myMeshId, and SMDS_MeshElement.myVtkID.

{
  MESSAGE("uniqueNodesIterator");
  return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
}
bool SMDS_VtkVolume::vtkOrder ( const SMDS_MeshNode *  nodes[],
const int  nbNodes 
) [virtual]

Reorder in VTK order a list of nodes given in SMDS order.

To be used before ChangeNodes: lists are given or computed in SMDS order.

Reimplemented from SMDS_MeshCell.

Definition at line 143 of file SMDS_VtkVolume.cxx.

References SMDS_Mesh._meshList, SMDS_MeshCell.exchange(), ex11_grid3partition.grid, MESSAGE, SMDS_MeshElement.myMeshId, SMDS_MeshElement.myVtkID, and NbNodes().

{
  if (nbNodes != this->NbNodes())
    {
      MESSAGE("vtkOrder, wrong number of nodes " << nbNodes << " instead of "<< this->NbNodes());
      return false;
    }
  vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
  switch (aVtkType)
  {
    case VTK_TETRA:
      this->exchange(nodes, 1, 2);
      break;
    case VTK_QUADRATIC_TETRA:
      this->exchange(nodes, 1, 2);
      this->exchange(nodes, 4, 6);
      this->exchange(nodes, 8, 9);
      break;
    case VTK_PYRAMID:
      this->exchange(nodes, 1, 3);
      break;
    case VTK_WEDGE:
      break;
    case VTK_QUADRATIC_PYRAMID:
      this->exchange(nodes, 1, 3);
      this->exchange(nodes, 5, 8);
      this->exchange(nodes, 6, 7);
      this->exchange(nodes, 10, 12);
      break;
    case VTK_QUADRATIC_WEDGE:
      break;
    case VTK_HEXAHEDRON:
      this->exchange(nodes, 1, 3);
      this->exchange(nodes, 5, 7);
      break;
    case VTK_QUADRATIC_HEXAHEDRON:
      this->exchange(nodes, 1, 3);
      this->exchange(nodes, 5, 7);
      this->exchange(nodes, 8, 11);
      this->exchange(nodes, 9, 10);
      this->exchange(nodes, 12, 15);
      this->exchange(nodes, 13, 14);
      this->exchange(nodes, 17, 19);
      break;
    case VTK_POLYHEDRON:
    default:
      break;
  }
  return true;
}
int SMDS_MeshElement.WrappedIndex ( const int  ind) const [inherited]

Return a valid node index, fixing the given one if necessary.

Parameters:
ind- node index
Return values:
int- valid node index

Definition at line 130 of file SMDS_MeshElement.hxx.

References SMESH_test.ind.

                                        {
    if ( ind < 0 ) return NbNodes() + ind % NbNodes();
    if ( ind >= NbNodes() ) return ind % NbNodes();
    return ind;
  }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  OS,
const SMDS_MeshElement *  ME 
) [friend, inherited]

Definition at line 61 of file SMDS_MeshElement.cxx.

{
        ME->Print(OS);
        return OS;
}
friend class SMDS_Mesh [friend, inherited]

Reimplemented in SMDS_MeshNode.

Definition at line 94 of file SMDS_MeshElement.hxx.

friend class SMDS_MeshElementIDFactory [friend, inherited]

Definition at line 97 of file SMDS_MeshElement.hxx.

bool SMDS_MeshElementIDFactory::BindID ( int  ID,
SMDS_MeshElement *  elem 
) [friend, inherited]
friend class SMESHDS_Mesh [friend, inherited]

Reimplemented in SMDS_MeshNode.

Definition at line 95 of file SMDS_MeshElement.hxx.

friend class SMESHDS_SubMesh [friend, inherited]

Definition at line 96 of file SMDS_MeshElement.hxx.

Field Documentation

int SMDS_MeshElement.myID [protected, inherited]

Element index in vector SMDS_Mesh.myNodes or SMDS_Mesh.myCells.

Definition at line 159 of file SMDS_MeshElement.hxx.

Referenced by SMDS_MeshNode.Print(), and SMDS_Mesh.registerElement().

int SMDS_MeshElement.myIdInShape [protected, inherited]

Element index in SMESHDS_SubMesh vector.

Definition at line 167 of file SMDS_MeshElement.hxx.

ShortType SMDS_MeshElement.myMeshId [protected, inherited]

SMDS_Mesh identification in SMESH.

Definition at line 163 of file SMDS_MeshElement.hxx.

Referenced by SMDS_MeshNode.AddInverseElement(), ChangeNodes(), SMDS_MeshNode.ClearInverseElements(), elementsIterator(), SMDS_MeshNode.elementsIterator(), SMDS_MeshNode.emptyInverseElements(), SMDS_MeshNode.getCoord(), GetEntityType(), GetFaceNode(), SMDS_MeshNode.GetInverseElementIterator(), SMDS_Mesh.getMeshId(), GetQuantities(), GetVtkType(), init(), SMDS_MeshNode.init(), interlacedNodesElemIterator(), IsMediumNode(), IsPoly(), IsQuadratic(), NbEdges(), NbFaceNodes(), NbFaces(), SMDS_MeshNode.NbInverseElements(), NbNodes(), NbUniqueNodes(), nodesIteratorToUNV(), SMDS_Mesh.registerElement(), SMDS_MeshNode.RemoveInverseElement(), SMDS_MeshNode.setXYZ(), uniqueNodesIterator(), and vtkOrder().

LongType SMDS_MeshElement.myShapeId [protected, inherited]

SubShape and SubMesh identification in SMESHDS.

Definition at line 165 of file SMDS_MeshElement.hxx.

int SMDS_MeshElement.myVtkID [protected, inherited]

index in vtkUnstructuredGrid

Definition at line 161 of file SMDS_MeshElement.hxx.

Referenced by SMDS_MeshNode.AddInverseElement(), ChangeNodes(), SMDS_MeshNode.ClearInverseElements(), elementsIterator(), SMDS_MeshNode.elementsIterator(), SMDS_MeshNode.emptyInverseElements(), SMDS_MeshNode.getCoord(), GetEntityType(), GetFaceNode(), SMDS_MeshNode.GetInverseElementIterator(), GetQuantities(), GetVtkType(), init(), SMDS_MeshNode.init(), initPoly(), interlacedNodesElemIterator(), IsMediumNode(), IsPoly(), IsQuadratic(), NbEdges(), NbFaceNodes(), NbFaces(), SMDS_MeshNode.NbInverseElements(), NbNodes(), NbUniqueNodes(), nodesIteratorToUNV(), SMDS_MeshNode.RemoveInverseElement(), SMDS_MeshNode.setVtkId(), SMDS_MeshNode.setXYZ(), SMDS_MeshCell.SMDS_MeshCell(), uniqueNodesIterator(), and vtkOrder().

int SMDS_MeshCell::nbCells = 0 [static, inherited]

Definition at line 38 of file SMDS_MeshCell.hxx.

Referenced by SMDS_MeshCell.SMDS_MeshCell(), and SMDS_MeshCell.~SMDS_MeshCell().

Copyright © 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
Copyright © 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS