mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2025-01-24 05:30:33 +05:00
335 lines
10 KiB
C++
335 lines
10 KiB
C++
// Copyright (C) 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
|
|
//
|
|
// 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.
|
|
//
|
|
// 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
|
|
//
|
|
|
|
// File : SMDS_MeshInfo.hxx
|
|
// Created : Mon Sep 24 18:32:41 2007
|
|
// Author : Edward AGAPOV (eap)
|
|
//
|
|
#ifndef SMDS_MeshInfo_HeaderFile
|
|
#define SMDS_MeshInfo_HeaderFile
|
|
|
|
using namespace std;
|
|
|
|
#include "SMESH_SMDS.hxx"
|
|
|
|
#include "SMDS_MeshElement.hxx"
|
|
|
|
class SMDS_EXPORT SMDS_MeshInfo
|
|
{
|
|
public:
|
|
|
|
inline SMDS_MeshInfo();
|
|
inline void Clear();
|
|
|
|
int NbNodes() const { return myNbNodes; }
|
|
inline int NbElements(SMDSAbs_ElementType type=SMDSAbs_All) const;
|
|
inline int NbEntities(SMDSAbs_EntityType type) const;
|
|
|
|
int Nb0DElements() const { return myNb0DElements; }
|
|
inline int NbEdges (SMDSAbs_ElementOrder order = ORDER_ANY) const;
|
|
inline int NbFaces (SMDSAbs_ElementOrder order = ORDER_ANY) const;
|
|
inline int NbTriangles (SMDSAbs_ElementOrder order = ORDER_ANY) const;
|
|
inline int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
|
|
int NbPolygons() const { return myNbPolygons; }
|
|
|
|
inline int NbVolumes (SMDSAbs_ElementOrder order = ORDER_ANY) const;
|
|
inline int NbTetras (SMDSAbs_ElementOrder order = ORDER_ANY) const;
|
|
inline int NbHexas (SMDSAbs_ElementOrder order = ORDER_ANY) const;
|
|
inline int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
|
|
inline int NbPrisms (SMDSAbs_ElementOrder order = ORDER_ANY) const;
|
|
int NbPolyhedrons() const { return myNbPolyhedrons; }
|
|
|
|
protected:
|
|
inline void addWithPoly(const SMDS_MeshElement* el);
|
|
|
|
private:
|
|
friend class SMDS_Mesh;
|
|
|
|
// methods to count NOT POLY elements
|
|
inline void remove(const SMDS_MeshElement* el);
|
|
inline void add (const SMDS_MeshElement* el);
|
|
inline int index(SMDSAbs_ElementType type, int nbNodes) const;
|
|
// methods to remove elements of ANY kind
|
|
inline void RemoveEdge(const SMDS_MeshElement* el);
|
|
inline void RemoveFace(const SMDS_MeshElement* el);
|
|
inline void RemoveVolume(const SMDS_MeshElement* el);
|
|
|
|
int myNbNodes;
|
|
|
|
int myNb0DElements;
|
|
int myNbEdges , myNbQuadEdges ;
|
|
int myNbTriangles , myNbQuadTriangles ;
|
|
int myNbQuadrangles, myNbQuadQuadrangles;
|
|
int myNbPolygons;
|
|
|
|
int myNbTetras , myNbQuadTetras ;
|
|
int myNbHexas , myNbQuadHexas ;
|
|
int myNbPyramids, myNbQuadPyramids;
|
|
int myNbPrisms , myNbQuadPrisms ;
|
|
int myNbPolyhedrons;
|
|
|
|
std::vector<int*> myNb; // pointers to myNb... fields
|
|
std::vector<int> myShift; // shift to get an index in myNb by elem->NbNodes()
|
|
};
|
|
|
|
inline SMDS_MeshInfo::SMDS_MeshInfo():
|
|
myNbNodes(0),
|
|
myNb0DElements(0),
|
|
myNbEdges (0), myNbQuadEdges (0),
|
|
myNbTriangles (0), myNbQuadTriangles (0),
|
|
myNbQuadrangles(0), myNbQuadQuadrangles(0),
|
|
myNbPolygons(0),
|
|
myNbTetras (0), myNbQuadTetras (0),
|
|
myNbHexas (0), myNbQuadHexas (0),
|
|
myNbPyramids(0), myNbQuadPyramids(0),
|
|
myNbPrisms (0), myNbQuadPrisms (0),
|
|
myNbPolyhedrons(0)
|
|
{
|
|
// Number of nodes in standard element types
|
|
// n v f e 0 n
|
|
// o o a d d o
|
|
// d l c g d
|
|
// e e e e
|
|
// s
|
|
// -----------------
|
|
// 0 *
|
|
// 1 . *
|
|
// 2 *
|
|
// 3 . *
|
|
// 4 * . .
|
|
// 5 *
|
|
// 6 * .
|
|
// 7
|
|
// 8 * .
|
|
// 9
|
|
// 10 *
|
|
// 11 *
|
|
// 12 *
|
|
// 13 *
|
|
// 14 *
|
|
// 15 *
|
|
// 16 *
|
|
// 17
|
|
// 18
|
|
// 19
|
|
// 20 *
|
|
//
|
|
// So to have a unique index for each type basing on nb of nodes, we use a shift:
|
|
myShift.resize(SMDSAbs_NbElementTypes, 0);
|
|
|
|
myShift[ SMDSAbs_Face ] = +8; // 3->11, 4->12, 6->14, 8->16
|
|
myShift[ SMDSAbs_Edge ] = -2; // 2->0, 4->2
|
|
myShift[ SMDSAbs_0DElement ] = +2; // 1->3
|
|
|
|
myNb.resize( index( SMDSAbs_Volume,20 ) + 1, NULL);
|
|
|
|
myNb[ index( SMDSAbs_Node,1 )] = & myNbNodes;
|
|
|
|
myNb[ index( SMDSAbs_0DElement,1 )] = & myNb0DElements;
|
|
|
|
myNb[ index( SMDSAbs_Edge,2 )] = & myNbEdges;
|
|
myNb[ index( SMDSAbs_Edge,4 )] = & myNbQuadEdges;
|
|
|
|
myNb[ index( SMDSAbs_Face,3 )] = & myNbTriangles;
|
|
myNb[ index( SMDSAbs_Face,4 )] = & myNbQuadrangles;
|
|
myNb[ index( SMDSAbs_Face,6 )] = & myNbQuadTriangles;
|
|
myNb[ index( SMDSAbs_Face,8 )] = & myNbQuadQuadrangles;
|
|
|
|
myNb[ index( SMDSAbs_Volume, 4)] = & myNbTetras;
|
|
myNb[ index( SMDSAbs_Volume, 5)] = & myNbPyramids;
|
|
myNb[ index( SMDSAbs_Volume, 6)] = & myNbPrisms;
|
|
myNb[ index( SMDSAbs_Volume, 8)] = & myNbHexas;
|
|
myNb[ index( SMDSAbs_Volume, 10)] = & myNbQuadTetras;
|
|
myNb[ index( SMDSAbs_Volume, 13)] = & myNbQuadPyramids;
|
|
myNb[ index( SMDSAbs_Volume, 15)] = & myNbQuadPrisms;
|
|
myNb[ index( SMDSAbs_Volume, 20)] = & myNbQuadHexas;
|
|
}
|
|
|
|
inline void // Clear
|
|
SMDS_MeshInfo::Clear()
|
|
{ for ( int i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=0;
|
|
myNbPolygons=myNbPolyhedrons=0;
|
|
}
|
|
|
|
inline int // index
|
|
SMDS_MeshInfo::index(SMDSAbs_ElementType type, int nbNodes) const
|
|
{ return nbNodes + myShift[ type ]; }
|
|
|
|
inline void // remove
|
|
SMDS_MeshInfo::remove(const SMDS_MeshElement* el)
|
|
{ --(*myNb[ index(el->GetType(), el->NbNodes()) ]); }
|
|
|
|
inline void // add
|
|
SMDS_MeshInfo::add(const SMDS_MeshElement* el)
|
|
{ ++(*myNb[ index(el->GetType(), el->NbNodes()) ]); }
|
|
|
|
inline void // addWithPoly
|
|
SMDS_MeshInfo::addWithPoly(const SMDS_MeshElement* el)
|
|
{
|
|
if ( el->IsPoly() )
|
|
++( el->GetType()==SMDSAbs_Face ? myNbPolygons : myNbPolyhedrons );
|
|
else
|
|
add(el);
|
|
}
|
|
inline void // RemoveEdge
|
|
SMDS_MeshInfo::RemoveEdge(const SMDS_MeshElement* el)
|
|
{ if ( el->IsQuadratic() ) --myNbQuadEdges; else --myNbEdges; }
|
|
|
|
inline void // RemoveFace
|
|
SMDS_MeshInfo::RemoveFace(const SMDS_MeshElement* el)
|
|
{ if ( el->IsPoly() ) --myNbPolygons; else remove( el ); }
|
|
|
|
inline void // RemoveVolume
|
|
SMDS_MeshInfo::RemoveVolume(const SMDS_MeshElement* el)
|
|
{ if ( el->IsPoly() ) --myNbPolyhedrons; else remove( el ); }
|
|
|
|
inline int // NbEdges
|
|
SMDS_MeshInfo::NbEdges (SMDSAbs_ElementOrder order) const
|
|
{ return order == ORDER_ANY ? myNbEdges+myNbQuadEdges : order == ORDER_LINEAR ? myNbEdges : myNbQuadEdges; }
|
|
|
|
inline int // NbFaces
|
|
SMDS_MeshInfo::NbFaces (SMDSAbs_ElementOrder order) const
|
|
{ return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_QUADRATIC ? 0 : myNbPolygons); }
|
|
|
|
inline int // NbTriangles
|
|
SMDS_MeshInfo::NbTriangles (SMDSAbs_ElementOrder order) const
|
|
{ return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles; }
|
|
|
|
inline int // NbQuadrangles
|
|
SMDS_MeshInfo::NbQuadrangles(SMDSAbs_ElementOrder order) const
|
|
{ return order == ORDER_ANY ? myNbQuadrangles+myNbQuadQuadrangles : order == ORDER_LINEAR ? myNbQuadrangles : myNbQuadQuadrangles; }
|
|
|
|
inline int // NbVolumes
|
|
SMDS_MeshInfo::NbVolumes (SMDSAbs_ElementOrder order) const
|
|
{ return NbTetras(order) + NbHexas(order) + NbPyramids(order) + NbPrisms(order) + (order == ORDER_QUADRATIC ? 0 : myNbPolyhedrons); }
|
|
|
|
inline int // NbTetras
|
|
SMDS_MeshInfo::NbTetras (SMDSAbs_ElementOrder order) const
|
|
{ return order == ORDER_ANY ? myNbTetras+myNbQuadTetras : order == ORDER_LINEAR ? myNbTetras : myNbQuadTetras; }
|
|
|
|
inline int // NbHexas
|
|
SMDS_MeshInfo::NbHexas (SMDSAbs_ElementOrder order) const
|
|
{ return order == ORDER_ANY ? myNbHexas+myNbQuadHexas : order == ORDER_LINEAR ? myNbHexas : myNbQuadHexas; }
|
|
|
|
inline int // NbPyramids
|
|
SMDS_MeshInfo::NbPyramids(SMDSAbs_ElementOrder order) const
|
|
{ return order == ORDER_ANY ? myNbPyramids+myNbQuadPyramids : order == ORDER_LINEAR ? myNbPyramids : myNbQuadPyramids; }
|
|
|
|
inline int // NbPrisms
|
|
SMDS_MeshInfo::NbPrisms (SMDSAbs_ElementOrder order) const
|
|
{ return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms : order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms; }
|
|
|
|
inline int // NbElements
|
|
SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
|
|
{
|
|
int nb = 0;
|
|
switch (type) {
|
|
case SMDSAbs_All:
|
|
for ( int i=1+index( SMDSAbs_Node,1 ); i<myNb.size(); ++i ) if ( myNb[i] ) nb += *myNb[i];
|
|
nb += myNbPolygons + myNbPolyhedrons;
|
|
break;
|
|
case SMDSAbs_Volume:
|
|
nb = myNbTetras+ myNbPyramids+ myNbPrisms+ myNbHexas+
|
|
myNbQuadTetras+ myNbQuadPyramids+ myNbQuadPrisms+ myNbQuadHexas+myNbPolyhedrons;
|
|
break;
|
|
case SMDSAbs_Face:
|
|
nb = myNbTriangles+ myNbQuadrangles+ myNbQuadTriangles+ myNbQuadQuadrangles + myNbPolygons;
|
|
break;
|
|
case SMDSAbs_Edge:
|
|
nb = myNbEdges + myNbQuadEdges;
|
|
break;
|
|
case SMDSAbs_0DElement:
|
|
nb = myNb0DElements;
|
|
break;
|
|
case SMDSAbs_Node:
|
|
nb = myNbNodes;
|
|
break;
|
|
default:;
|
|
}
|
|
return nb;
|
|
}
|
|
|
|
int // NbEntities
|
|
SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
|
|
{
|
|
switch (type) {
|
|
case SMDSEntity_Node:
|
|
return myNbNodes;
|
|
break;
|
|
case SMDSEntity_0D:
|
|
return myNb0DElements;
|
|
break;
|
|
case SMDSEntity_Edge:
|
|
return myNbEdges;
|
|
break;
|
|
case SMDSEntity_Quad_Edge:
|
|
return myNbQuadEdges;
|
|
break;
|
|
case SMDSEntity_Triangle:
|
|
return myNbTriangles;
|
|
break;
|
|
case SMDSEntity_Quad_Triangle:
|
|
return myNbQuadTriangles;
|
|
break;
|
|
case SMDSEntity_Quadrangle:
|
|
return myNbQuadrangles;
|
|
break;
|
|
case SMDSEntity_Quad_Quadrangle:
|
|
return myNbQuadQuadrangles;
|
|
break;
|
|
case SMDSEntity_Polygon:
|
|
return myNbPolygons;
|
|
break;
|
|
case SMDSEntity_Tetra:
|
|
return myNbTetras;
|
|
break;
|
|
case SMDSEntity_Quad_Tetra:
|
|
return myNbQuadTetras;
|
|
break;
|
|
case SMDSEntity_Pyramid:
|
|
return myNbPyramids;
|
|
break;
|
|
case SMDSEntity_Quad_Pyramid:
|
|
return myNbQuadPyramids;
|
|
break;
|
|
case SMDSEntity_Hexa:
|
|
return myNbHexas;
|
|
break;
|
|
case SMDSEntity_Quad_Hexa:
|
|
return myNbQuadHexas;
|
|
break;
|
|
case SMDSEntity_Penta:
|
|
return myNbPrisms;
|
|
break;
|
|
case SMDSEntity_Quad_Penta:
|
|
return myNbQuadPrisms;
|
|
break;
|
|
case SMDSEntity_Polyhedra:
|
|
return myNbPolyhedrons;
|
|
break;
|
|
case SMDSEntity_Quad_Polygon:
|
|
case SMDSEntity_Quad_Polyhedra:
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#endif
|