OPTION(SALOME_SMESH_USE_CGNS "Enable import/export to CGNS format" OFF)
OPTION(SALOME_SMESH_USE_TBB "Enable parallel computation" OFF)
OPTION(SALOME_SMESH_DYNLOAD_LOCAL "Load plug-ins' symbols locally (Linux only)" ON)
+OPTION(SALOME_USE_64BIT_IDS "Size of IDs to refer cells and nodes. 32 bits when OFF (default), 64 bits when ON." ON)
OPTION(SMESH_USE_MESHGEMS_HYPOSET "Prefer MeshGems algorithms in sets of hypotheses" OFF)
CMAKE_DEPENDENT_OPTION(SALOME_SMESH_BUILD_FRENCH_DOC "Generate SALOME SMESH French documentation" OFF
"SALOME_BUILD_DOC" OFF)
SET(SALOME_INSTALL_RES "@SALOME_INSTALL_RES@")
SET(SALOME_INSTALL_DOC "@SALOME_INSTALL_DOC@")
SET(SALOME_INSTALL_AMCONFIG_LOCAL "@SALOME_INSTALL_AMCONFIG_LOCAL@")
+SET(SALOME_USE_64BIT_IDS @SALOME_USE_64BIT_IDS@)
# Include GEOM targets if they were not already loaded:
IF(NOT (TARGET GEOMbasic))
${PROJECT_BINARY_DIR}/idl
)
+IF(SALOME_USE_64_BITS_IDS)
+ SET(SMESH_ID_TYPE "long long")
+ELSE()
+ SET(SMESH_ID_TYPE "long")
+ENDIF()
+
+SALOME_CONFIGURE_FILE(SMESH_smIdType.idl.in SMESH_smIdType.idl)
+
SET(SalomeIDLSMESH_IDLSOURCES
SMESH_Gen.idl
SMESH_Mesh.idl
SMESH_Pattern.idl
SMESH_MeshEditor.idl
SMESH_Measurements.idl
- SMESH_smIdType.idl
+ ${CMAKE_CURRENT_BINARY_DIR}/SMESH_smIdType.idl
)
SET(_idl_include_dirs
${KERNEL_ROOT_DIR}/idl/salome
${GEOM_ROOT_DIR}/idl/salome
+ ${PROJECT_BINARY_DIR}/idl
)
SET(_idl_link_flags
#include "SALOME_Exception.idl"
#include "SALOME_GenericObj.idl"
#include "GEOM_Gen.idl"
+#include "SMESH_smIdType.idl"
module SMESH
{
+++ /dev/null
-// Copyright (C) 2007-2020 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, 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
-//
-
-#ifndef __SMESH_SMIDTYPE_IDL__
-#define __SMESH_SMIDTYPE_IDL__
-
-module SMESH
-{
- #ifndef SALOME_USE_64BIT_IDS
- typedef long smIdType;
- #else
- typedef long long smIdType;
- #endif
-};
-
-#endif
\ No newline at end of file
--- /dev/null
+// Copyright (C) 2007-2020 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, 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
+//
+
+#ifndef __SMESH_SMIDTYPE_IDL__
+#define __SMESH_SMIDTYPE_IDL__
+
+module SMESH
+{
+ typedef @SMESH_ID_TYPE@ smIdType;
+};
+
+#endif
\ No newline at end of file
// ...
// NfacesM, Face1M, Face2M, ... FaceNM
const int nbFaces = elemData[ pos++ ];
- vector<smIdType> quantities( nbFaces );
+ vector<int> quantities( nbFaces );
vector<const SMDS_MeshNode*> nodes, faceNodes;
nodes.reserve( nbFaces * 4 );
for ( int iF = 0; iF < nbFaces; ++iF )
if (( v = myMesh->DownCast< SMDS_MeshVolume >( elem )))
{
- std::vector<smIdType> quant = v->GetQuantities();
+ std::vector<int> quant = v->GetQuantities();
if ( !quant.empty() )
{
fprintf(aFileId, "%d %d ", (int)quant.size(), quant[0]);
for(TInt iElem = 0; iElem < aNbElem; iElem++){
MED::TCConnSliceArr aConnSliceArr = aPolyedreInfo->GetConnSliceArr(iElem);
TInt aNbFaces = aConnSliceArr.size();
- typedef MED::TVector<smIdType> TQuantities;
+ typedef MED::TVector<int> TQuantities;
TQuantities aQuantities(aNbFaces);
TInt aNbNodes = aPolyedreInfo->GetNbNodes(iElem);
TNodeIds aNodeIds(aNbNodes);
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdType> & nodes_ids,
- const std::vector<smIdType> & quantities,
+ const std::vector<int> & quantities,
const smIdType ID)
{
int nbNodes = nodes_ids.size();
SMDS_MeshVolume*
SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<smIdType> & quantities,
+ const std::vector<int> & quantities,
const smIdType ID)
{
if ( nodes.empty() || quantities.empty() )
SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolume
(const std::vector<const SMDS_MeshNode*> & nodes,
- const std::vector<smIdType> & quantities)
+ const std::vector<int> & quantities)
{
smIdType ID = myCellFactory->GetFreeID();
return SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
///////////////////////////////////////////////////////////////////////////////
/// Return the number of elements
///////////////////////////////////////////////////////////////////////////////
-int SMDS_Mesh::NbElements() const
+smIdType SMDS_Mesh::NbElements() const
{
return myInfo.NbElements();
}
///////////////////////////////////////////////////////////////////////////////
/// Return the number of 0D elements
///////////////////////////////////////////////////////////////////////////////
-int SMDS_Mesh::NbBalls() const
+smIdType SMDS_Mesh::NbBalls() const
{
return myInfo.NbBalls();
}
///////////////////////////////////////////////////////////////////////////////
/// Return the number of edges (including construction edges)
///////////////////////////////////////////////////////////////////////////////
-int SMDS_Mesh::NbEdges() const
+smIdType SMDS_Mesh::NbEdges() const
{
return myInfo.NbEdges();
}
///////////////////////////////////////////////////////////////////////////////
/// Return the number of faces (including construction faces)
///////////////////////////////////////////////////////////////////////////////
-int SMDS_Mesh::NbFaces() const
+smIdType SMDS_Mesh::NbFaces() const
{
return myInfo.NbFaces();
}
///////////////////////////////////////////////////////////////////////////////
/// Return the number of volumes
///////////////////////////////////////////////////////////////////////////////
-int SMDS_Mesh::NbVolumes() const
+smIdType SMDS_Mesh::NbVolumes() const
{
return myInfo.NbVolumes();
}
/// Return the number of child mesh of this mesh.
/// Note that the tree structure of SMDS_Mesh is unused in SMESH
///////////////////////////////////////////////////////////////////////////////
-int SMDS_Mesh::NbSubMesh() const
+smIdType SMDS_Mesh::NbSubMesh() const
{
return myChildren.size();
}
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<smIdType> & nodes_ids,
- const std::vector<smIdType> & quantities,
+ const std::vector<int> & quantities,
const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<const SMDS_MeshNode*> & nodes,
- const std::vector<smIdType> & quantities,
+ const std::vector<int> & quantities,
const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolume
(const std::vector<const SMDS_MeshNode*> & nodes,
- const std::vector<smIdType> & quantities);
+ const std::vector<int> & quantities);
virtual SMDS_MeshVolume* AddVolumeFromVtkIds(const std::vector<vtkIdType>& vtkNodeIds);
const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
virtual smIdType NbNodes() const;
- virtual int NbElements() const;
+ virtual smIdType NbElements() const;
virtual smIdType Nb0DElements() const;
- virtual int NbBalls() const;
- virtual int NbEdges() const;
- virtual int NbFaces() const;
- virtual int NbVolumes() const;
- virtual int NbSubMesh() const;
+ virtual smIdType NbBalls() const;
+ virtual smIdType NbEdges() const;
+ virtual smIdType NbFaces() const;
+ virtual smIdType NbVolumes() const;
+ virtual smIdType NbSubMesh() const;
virtual ~SMDS_Mesh();
// init a polyherdon
void SMDS_MeshVolume::init( const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<smIdType>& nbNodesPerFace )
+ const std::vector<int>& nbNodesPerFace )
{
std::vector<vtkIdType> ptIds;
ptIds.reserve( nodes.size() + nbNodesPerFace.size() + 1 );
size_t nbFaces = nbNodesPerFace.size();
for ( size_t iN = 0, iF = 0; iF < nbFaces; iF++ )
{
- smIdType nf = nbNodesPerFace[iF];
+ int nf = nbNodesPerFace[iF];
ptIds.push_back(nf);
- for (smIdType n = 0; n < nf; n++)
+ for (int n = 0; n < nf; n++)
ptIds.push_back( nodes[ iN++ ]->GetVtkID() );
}
return true;
}
-const SMDS_MeshNode* SMDS_MeshVolume::GetNode(const smIdType ind) const
+const SMDS_MeshNode* SMDS_MeshVolume::GetNode(const int ind) const
{
if ( !IsPoly() )
return SMDS_MeshCell::GetNode( ind );
return 0;
}
-std::vector<smIdType> SMDS_MeshVolume::GetQuantities() const
+std::vector<int> SMDS_MeshVolume::GetQuantities() const
{
- std::vector<smIdType> quantities;
+ std::vector<int> quantities;
if ( IsPoly() )
{
vtkIdType nFaces = 0;
vtkIdType const *ptIds(nullptr);
getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds );
- smIdType id = 0;
- for (smIdType i = 0; i < nFaces; i++)
+ int id = 0;
+ for (int i = 0; i < nFaces; i++)
{
- smIdType nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
+ int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
quantities.push_back( nodesInFace );
id += (nodesInFace + 1);
}
#include "SMDS_MeshCell.hxx"
-#include <smIdType.hxx>
-
/*!
* \brief Mesh volume. This type is not allocated.
* It is only used as function argument type to provide more clear semantic
class SMDS_EXPORT SMDS_MeshVolume : public SMDS_MeshCell
{
void init( const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<smIdType>& nbNodesPerFace ); // init a polyherdon
+ const std::vector<int>& nbNodesPerFace ); // init a polyherdon
void init( const std::vector<vtkIdType>& vtkNodeIds );
public:
virtual SMDSAbs_ElementType GetType() const { return SMDSAbs_Volume; }
- virtual const SMDS_MeshNode* GetNode(const smIdType ind) const;
+ virtual const SMDS_MeshNode* GetNode(const int ind) const;
virtual int NbNodes() const;
virtual int NbFaces() const;
virtual int NbEdges() const;
// 1 <= node_ind <= NbFaceNodes()
const SMDS_MeshNode* GetFaceNode (const int face_ind, const int node_ind) const;
- std::vector<smIdType> GetQuantities() const;
+ std::vector<int> GetQuantities() const;
static SMDSAbs_ElementType Type() { return SMDSAbs_Volume; }
};
myAllFacesNodeIndices_F = &Tetra_F [0][0];
//myAllFacesNodeIndices_FE = &Tetra_F [0][0];
myAllFacesNodeIndices_RE = &Tetra_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(Tetra_nbN);
+ myAllFacesNbNodes = Tetra_nbN;
myMaxFaceNbNodes = sizeof(Tetra_F[0])/sizeof(Tetra_F[0][0]);
break;
case 5:
myAllFacesNodeIndices_F = &Pyramid_F [0][0];
//myAllFacesNodeIndices_FE = &Pyramid_F [0][0];
myAllFacesNodeIndices_RE = &Pyramid_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(Pyramid_nbN);
+ myAllFacesNbNodes = Pyramid_nbN;
myMaxFaceNbNodes = sizeof(Pyramid_F[0])/sizeof(Pyramid_F[0][0]);
break;
case 6:
myAllFacesNodeIndices_F = &Penta_F [0][0];
//myAllFacesNodeIndices_FE = &Penta_FE[0][0];
myAllFacesNodeIndices_RE = &Penta_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(Penta_nbN);
+ myAllFacesNbNodes = Penta_nbN;
myMaxFaceNbNodes = sizeof(Penta_F[0])/sizeof(Penta_F[0][0]);
break;
case 8:
myAllFacesNodeIndices_F = &Hexa_F [0][0];
///myAllFacesNodeIndices_FE = &Hexa_FE[0][0];
myAllFacesNodeIndices_RE = &Hexa_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(Hexa_nbN);
+ myAllFacesNbNodes = Hexa_nbN;
myMaxFaceNbNodes = sizeof(Hexa_F[0])/sizeof(Hexa_F[0][0]);
break;
case 10:
myAllFacesNodeIndices_F = &QuadTetra_F [0][0];
//myAllFacesNodeIndices_FE = &QuadTetra_F [0][0];
myAllFacesNodeIndices_RE = &QuadTetra_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(QuadTetra_nbN);
+ myAllFacesNbNodes = QuadTetra_nbN;
myMaxFaceNbNodes = sizeof(QuadTetra_F[0])/sizeof(QuadTetra_F[0][0]);
break;
case 13:
myAllFacesNodeIndices_F = &QuadPyram_F [0][0];
//myAllFacesNodeIndices_FE = &QuadPyram_F [0][0];
myAllFacesNodeIndices_RE = &QuadPyram_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(QuadPyram_nbN);
+ myAllFacesNbNodes = QuadPyram_nbN;
myMaxFaceNbNodes = sizeof(QuadPyram_F[0])/sizeof(QuadPyram_F[0][0]);
break;
case 15:
myAllFacesNodeIndices_F = &QuadPenta_F [0][0];
//myAllFacesNodeIndices_FE = &QuadPenta_FE[0][0];
myAllFacesNodeIndices_RE = &QuadPenta_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(QuadPenta_nbN);
+ myAllFacesNbNodes = QuadPenta_nbN;
myMaxFaceNbNodes = sizeof(QuadPenta_F[0])/sizeof(QuadPenta_F[0][0]);
break;
case 20:
myAllFacesNodeIndices_F = &QuadHexa_F [0][0];
//myAllFacesNodeIndices_FE = &QuadHexa_FE[0][0];
myAllFacesNodeIndices_RE = &QuadHexa_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(QuadHexa_nbN);
+ myAllFacesNbNodes = QuadHexa_nbN;
myMaxFaceNbNodes = sizeof(QuadHexa_F[0])/sizeof(QuadHexa_F[0][0]);
if ( !myIgnoreCentralNodes && myVolumeNodes.size() == 27 )
{
myAllFacesNodeIndices_F = &TriQuadHexa_F [0][0];
//myAllFacesNodeIndices_FE = &TriQuadHexa_FE[0][0];
myAllFacesNodeIndices_RE = &TriQuadHexa_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(TriQuadHexa_nbN);
+ myAllFacesNbNodes = TriQuadHexa_nbN;
myMaxFaceNbNodes = sizeof(TriQuadHexa_F[0])/sizeof(TriQuadHexa_F[0][0]);
}
break;
myAllFacesNodeIndices_F = &HexPrism_F [0][0];
//myAllFacesNodeIndices_FE = &HexPrism_FE[0][0];
myAllFacesNodeIndices_RE = &HexPrism_RE[0][0];
- myAllFacesNbNodes = (smIdType*)(HexPrism_nbN);
+ myAllFacesNbNodes = HexPrism_nbN;
myMaxFaceNbNodes = sizeof(HexPrism_F[0])/sizeof(HexPrism_F[0][0]);
break;
default:
#include "SMESH_SMDS.hxx"
-#include <smIdType.hxx>
-
class SMDS_MeshElement;
class SMDS_MeshNode;
class SMDS_MeshVolume;
int myNbFaces;
std::vector<const SMDS_MeshNode*> myVolumeNodes;
std::vector< int > myPolyIndices; // of a myCurFace
- std::vector<smIdType> myPolyQuantities;
+ std::vector<int> myPolyQuantities;
std::vector< int > myPolyFacetOri; // -1-in, +1-out, 0-undef
typedef std::pair<int,int> Link;
mutable const int* myAllFacesNodeIndices_F;
mutable const int* myAllFacesNodeIndices_RE;
- mutable const smIdType* myAllFacesNbNodes;
+ mutable const int* myAllFacesNbNodes;
mutable int myMaxFaceNbNodes;
struct SaveFacet;
smIdType GetLinkID (const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2) const
{
- return ( Min(FromIdType<int>(n1->GetID()),FromIdType<int>(n2->GetID())) * myMaxID + Max(FromIdType<int>(n1->GetID()),FromIdType<int>(n2->GetID())));
+ return ( std::min(n1->GetID(),n2->GetID()) * myMaxID + std::max(n1->GetID(),n2->GetID()));
}
bool GetNodes (const long theLinkID,
baseType = SMDSEntity_Polygon; // WARNING: change baseType !!!!
}
vector<const SMDS_MeshNode*> polyedre_nodes (nbNodes*2 + 4*nbNodes);
- vector<smIdType> quantities (nbNodes + 2);
+ vector<int> quantities (nbNodes + 2);
polyedre_nodes.clear();
quantities.clear();
int SMESH_MeshEditor::SimplifyFace (const vector<const SMDS_MeshNode *>& faceNodes,
vector<const SMDS_MeshNode *>& poly_nodes,
- vector<smIdType>& quantities) const
+ vector<int>& quantities) const
{
int nbNodes = faceNodes.size();
while ( faceNodes[ 0 ] == faceNodes[ nbNodes-1 ] && nbNodes > 2 )
// a polygon can divide into several elements
vector<const SMDS_MeshNode *> polygons_nodes;
- vector<smIdType> quantities;
+ vector<int> quantities;
nbResElems = SimplifyFace( curNodes, polygons_nodes, quantities );
newElemDefs.resize( nbResElems );
for ( int inode = 0, iface = 0; iface < nbResElems; iface++ )
int nbFaces = aPolyedre->NbFaces();
vector<const SMDS_MeshNode *>& poly_nodes = newElemDefs[0].myNodes;
- vector<smIdType> & quantities = newElemDefs[0].myPolyhedQuantities;
+ vector<int> & quantities = newElemDefs[0].myPolyhedQuantities;
vector<const SMDS_MeshNode *> faceNodes;
poly_nodes.clear();
quantities.clear();
////////////////// HEXAHEDRON ---> polyhedron
hexa.SetExternalNormal();
vector<const SMDS_MeshNode *>& poly_nodes = newElemDefs[0].myNodes;
- vector<smIdType> & quantities = newElemDefs[0].myPolyhedQuantities;
+ vector<int> & quantities = newElemDefs[0].myPolyhedQuantities;
poly_nodes.reserve( 6 * 4 ); poly_nodes.clear();
quantities.reserve( 6 ); quantities.clear();
for ( int iFace = 0; iFace < 6; iFace++ )
// insert new nodes in all faces of the volume, sharing link theBetweenNode1 - theBetweenNode2
int iface, nbFaces = aVolume.NbFaces();
vector<const SMDS_MeshNode *> poly_nodes;
- vector<smIdType> quantities (nbFaces);
+ vector<int> quantities (nbFaces);
for (iface = 0; iface < nbFaces; iface++) {
int nbFaceNodes = aVolume.NbFaceNodes(iface), nbInserted = 0;
void volumeToPolyhedron( const SMDS_MeshElement* elem,
vector<const SMDS_MeshNode *> & nodes,
- vector<smIdType> & nbNodeInFaces )
+ vector<int> & nbNodeInFaces )
{
nodes.clear();
nbNodeInFaces.clear();
int nbElem = 0;
if( !theSm ) return nbElem;
- vector<smIdType> nbNodeInFaces;
+ vector<int> nbNodeInFaces;
vector<const SMDS_MeshNode *> nodes;
SMDS_ElemIteratorPtr ElemItr = theSm->GetElements();
while(ElemItr->more())
}
// convert volumes
- vector<smIdType> nbNodeInFaces;
+ vector<int> nbNodeInFaces;
SMDS_VolumeIteratorPtr aVolumeItr = meshDS->volumesIterator();
while(aVolumeItr->more())
{
bool myIsPoly, myIsQuad;
int myID;
double myBallDiameter;
- std::vector<smIdType> myPolyhedQuantities;
+ std::vector<int> myPolyhedQuantities;
std::vector<const SMDS_MeshNode*> myNodes; // not managed by ElemFeatures
SMESH_EXPORT ElemFeatures( SMDSAbs_ElementType type=SMDSAbs_All, bool isPoly=false, bool isQuad=false )
SMESH_EXPORT ElemFeatures& Init( double diameter )
{ myType = SMDSAbs_Ball; myBallDiameter = diameter; return *this; }
- SMESH_EXPORT ElemFeatures& Init( std::vector<smIdType>& quanities, bool isQuad=false )
+ SMESH_EXPORT ElemFeatures& Init( std::vector<int>& quanities, bool isQuad=false )
{ myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
myPolyhedQuantities.swap( quanities ); return *this; }
- SMESH_EXPORT ElemFeatures& Init( const std::vector<smIdType>& quanities, bool isQuad=false )
+ SMESH_EXPORT ElemFeatures& Init( const std::vector<int>& quanities, bool isQuad=false )
{ myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad;
myPolyhedQuantities = quanities; return *this; }
int SimplifyFace (const std::vector<const SMDS_MeshNode *>& faceNodes,
std::vector<const SMDS_MeshNode *>& poly_nodes,
- std::vector<smIdType>& quantities) const;
+ std::vector<int>& quantities) const;
// Split face, defined by <faceNodes>, into several faces by repeating nodes.
// Is used by MergeNodes()
SMDS_MeshVolume*
SMESH_MesherHelper::AddPolyhedralVolume (const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<smIdType>& quantities,
+ const std::vector<int>& quantities,
const int id,
const bool force3d)
{
else
{
vector<const SMDS_MeshNode*> newNodes;
- vector<smIdType> newQuantities;
+ vector<int> newQuantities;
for ( size_t iFace = 0, iN = 0; iFace < quantities.size(); ++iFace )
{
int nbNodesInFace = quantities[iFace];
* Creates polyhedron. In quadratic mesh, adds medium nodes
*/
SMDS_MeshVolume* AddPolyhedralVolume (const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<smIdType>& quantities,
+ const std::vector<int>& quantities,
const int ID=0,
const bool force3d = true);
/*!
if ( !volTool.Set( elem ) || !avoidSet.insert( elem ).second )
continue; // skip faces or refined elements
// add polyhedron definition
- myPolyhedronQuantities.push_back(vector<smIdType> ());
+ myPolyhedronQuantities.push_back(vector<int> ());
myPolyElemXYZIDs.push_back(TElemDef());
- vector<smIdType>& quantity = myPolyhedronQuantities.back();
+ vector<int>& quantity = myPolyhedronQuantities.back();
TElemDef & elemDef = myPolyElemXYZIDs.back();
// get definitions of new elements on volume faces
bool makePoly = false;
const int theNbBndNodes,
const vector< const SMDS_MeshNode* >& theNodes,
list< int >& theFaceDefs,
- vector<smIdType>& theQuantity)
+ vector<int>& theQuantity)
{
bool makePoly = false;
bool is2d = myIs2D;
list< TElemDef >::const_iterator enIt = theElemNodeIDs.begin();
- list< vector<smIdType> >::iterator quantity = myPolyhedronQuantities.begin();
+ list< vector<int> >::iterator quantity = myPolyhedronQuantities.begin();
for ( int iElem = 0; enIt != theElemNodeIDs.end(); enIt++, iElem++ )
{
const TElemDef & elemNodeInd = *enIt;
#define SMESH_Pattern_HeaderFile
#include "SMESH_SMESH.hxx"
-#include <smIdType.hxx>
#include <vector>
#include <list>
const int theNbBndNodes,
const std::vector< const SMDS_MeshNode* >& theNodes,
std::list< int >& theFaceDefs,
- std::vector<smIdType>& theQuantity);
+ std::vector<int>& theQuantity);
// fill faces definition for a volume face defined by theBndNodes
// return true if a face definition changes
std::vector<const SMDS_MeshElement*> myPolyElems;
// definitions of new poly elements
std::list< TElemDef > myPolyElemXYZIDs;
- std::list< std::vector<smIdType> > myPolyhedronQuantities;
+ std::list< std::vector<int> > myPolyhedronQuantities;
// map a boundary to XYZs on it;
// a boundary (edge or face) is defined as a set of its nodes,
//=======================================================================
inline void AddQuadsWithID(SMDS_Mesh* theMesh,
SMESH::log_array_var theSeq,
- CORBA::Long theId)
+ SMESH::smIdType theId)
{
const SMESH::long_array& anIndexes = theSeq[theId].indexes;
- CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
- if(5*aNbElems != (CORBA::Long) anIndexes.length())
+ SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
+ if(5*aNbElems != (SMESH::smIdType) anIndexes.length())
EXCEPTION(runtime_error,"AddQuadsWithID - 4*aNbElems != anIndexes.length()");
- for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){
+ for(SMESH::smIdType anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){
SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
anIndexes[anIndexId+2],
anIndexes[anIndexId+3],
//=======================================================================
inline void AddPolygonsWithID(SMDS_Mesh* theMesh,
SMESH::log_array_var& theSeq,
- CORBA::Long theId)
+ SMESH::smIdType theId)
{
const SMESH::long_array& anIndexes = theSeq[theId].indexes;
- CORBA::Long anIndexId = 0, aNbElems = theSeq[theId].number;
+ SMESH::smIdType anIndexId = 0, aNbElems = theSeq[theId].number;
- for (CORBA::Long anElemId = 0; anElemId < aNbElems; anElemId++) {
+ for (SMESH::smIdType anElemId = 0; anElemId < aNbElems; anElemId++) {
smIdType aFaceId = anIndexes[anIndexId++];
int aNbNodes = anIndexes[anIndexId++];
}
int aNbFaces = anIndexes[anIndexId++];
- std::vector<smIdType> quantities (aNbFaces);
+ std::vector<int> quantities (aNbFaces);
for (int i = 0; i < aNbFaces; i++) {
quantities[i] = anIndexes[anIndexId++];
}
//function :
//purpose :
//=======================================================================
-void SMESHDS_Command::AddNode(int NewNodeID, double x, double y, double z)
+void SMESHDS_Command::AddNode(smIdType NewNodeID, double x, double y, double z)
{
if ( myType != SMESHDS_AddNode)
{
//function :
//purpose :
//=======================================================================
-void SMESHDS_Command::MoveNode(int NodeID, double x, double y, double z)
+void SMESHDS_Command::MoveNode(smIdType NodeID, double x, double y, double z)
{
if ( myType != SMESHDS_MoveNode)
{
//function :
//purpose :
//=======================================================================
-void SMESHDS_Command::Add0DElement(int New0DElementID, int idnode)
+void SMESHDS_Command::Add0DElement(smIdType New0DElementID, smIdType idnode)
{
if ( myType != SMESHDS_Add0DElement)
{
//function :
//purpose :
//=======================================================================
-void SMESHDS_Command::AddEdge(int NewEdgeID, int idnode1, int idnode2)
+void SMESHDS_Command::AddEdge(smIdType NewEdgeID, smIdType idnode1, smIdType idnode2)
{
if ( myType != SMESHDS_AddEdge)
{
//function :
//purpose :
//=======================================================================
-void SMESHDS_Command::AddFace(int NewFaceID,
- int idnode1, int idnode2, int idnode3)
+void SMESHDS_Command::AddFace(smIdType NewFaceID,
+ smIdType idnode1, smIdType idnode2, smIdType idnode3)
{
if ( myType != SMESHDS_AddTriangle)
{
//function :
//purpose :
//=======================================================================
-void SMESHDS_Command::AddFace(int NewFaceID,
- int idnode1, int idnode2, int idnode3, int idnode4)
+void SMESHDS_Command::AddFace(smIdType NewFaceID,
+ smIdType idnode1, smIdType idnode2, smIdType idnode3, smIdType idnode4)
{
if ( myType != SMESHDS_AddQuadrangle)
{
}
myIntegers.push_back(ElementID);
- int i, nbNodes = nodes_ids.size();
+ smIdType i, nbNodes = nodes_ids.size();
myIntegers.push_back(nbNodes);
for (i = 0; i < nbNodes; i++) {
myIntegers.push_back(nodes_ids[i]);
}
myIntegers.push_back(ElementID);
- int i, nbNodes = nodes_ids.size();
+ smIdType i, nbNodes = nodes_ids.size();
myIntegers.push_back(nbNodes);
for (i = 0; i < nbNodes; i++) {
myIntegers.push_back(nodes_ids[i]);
//=======================================================================
void SMESHDS_Command::AddPolyhedralVolume (const smIdType ElementID,
const std::vector<smIdType>& nodes_ids,
- const std::vector<smIdType>& quantities)
+ const std::vector<int>& quantities)
{
if ( myType != SMESHDS_AddPolyhedron) {
MESSAGE("SMESHDS_Command::AddPolyhedralVolume : Bad Type");
}
myIntegers.push_back(ElementID);
- int i, nbNodes = nodes_ids.size();
+ smIdType i, nbNodes = nodes_ids.size();
myIntegers.push_back(nbNodes);
for (i = 0; i < nbNodes; i++) {
myIntegers.push_back(nodes_ids[i]);
}
- int nbFaces = quantities.size();
+ smIdType nbFaces = quantities.size();
myIntegers.push_back(nbFaces);
for (i = 0; i < nbFaces; i++) {
myIntegers.push_back(quantities[i]);
//function :
//purpose :
//=======================================================================
-void SMESHDS_Command::RemoveNode(int NodeID)
+void SMESHDS_Command::RemoveNode(smIdType NodeID)
{
if ( myType != SMESHDS_RemoveNode)
{
//function :
//purpose :
//=======================================================================
-void SMESHDS_Command::RemoveElement(int ElementID)
+void SMESHDS_Command::RemoveElement(smIdType ElementID)
{
if ( myType != SMESHDS_RemoveElement)
{
//purpose :
//=======================================================================
-void SMESHDS_Command::ChangeElementNodes(int ElementID, int nodes[], int nbnodes)
+void SMESHDS_Command::ChangeElementNodes(smIdType ElementID, smIdType nodes[], smIdType nbnodes)
{
if ( myType != SMESHDS_ChangeElementNodes)
{
}
myIntegers.push_back(ElementID);
myIntegers.push_back(nbnodes);
- for ( int i = 0; i < nbnodes; i++ )
+ for ( smIdType i = 0; i < nbnodes; i++ )
myIntegers.push_back( nodes[ i ] );
myNumber++;
//function : ChangePolyhedronNodes
//purpose :
//=======================================================================
-void SMESHDS_Command::ChangePolyhedronNodes (const int ElementID,
- const std::vector<int>& nodes_ids,
+void SMESHDS_Command::ChangePolyhedronNodes (const smIdType ElementID,
+ const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities)
{
if (myType != SMESHDS_ChangePolyhedronNodes)
}
myIntegers.push_back(ElementID);
- int i, nbNodes = nodes_ids.size();
+ smIdType i, nbNodes = nodes_ids.size();
myIntegers.push_back(nbNodes);
for (i = 0; i < nbNodes; i++) {
myIntegers.push_back(nodes_ids[i]);
//purpose :
//=======================================================================
-void SMESHDS_Command::Renumber (const bool isNodes, const int startID, const int deltaID)
+void SMESHDS_Command::Renumber (const bool isNodes, const smIdType startID, const smIdType deltaID)
{
if ( myType != SMESHDS_Renumber)
{
//function :
//purpose :
//=======================================================================
-int SMESHDS_Command::GetNumber()
+smIdType SMESHDS_Command::GetNumber()
{
return myNumber;
}
//function :
//purpose :
//=======================================================================
-const list < int >&SMESHDS_Command::GetIndexes()
+const list < smIdType >&SMESHDS_Command::GetIndexes()
{
return myIntegers;
}
//function : AddEdge
//purpose :
//=======================================================================
-void SMESHDS_Command::AddEdge(int NewEdgeID, int n1, int n2, int n12)
+void SMESHDS_Command::AddEdge(smIdType NewEdgeID, smIdType n1, smIdType n2, smIdType n12)
{
if ( myType != SMESHDS_AddQuadEdge) {
MESSAGE("SMESHDS_Command::AddEdge : Bad Type");
//function : AddFace
//purpose :
//=======================================================================
-void SMESHDS_Command::AddFace(int NewFaceID,
- int n1, int n2, int n3,
- int n12, int n23, int n31)
+void SMESHDS_Command::AddFace(smIdType NewFaceID,
+ smIdType n1, smIdType n2, smIdType n3,
+ smIdType n12, smIdType n23, smIdType n31)
{
if ( myType != SMESHDS_AddQuadTriangle) {
MESSAGE("SMESHDS_Command::AddFace : Bad Type");
//function : AddFace
//purpose :
//=======================================================================
-void SMESHDS_Command::AddFace(int NewFaceID,
- int n1, int n2, int n3,
- int n12, int n23, int n31, int nCenter)
+void SMESHDS_Command::AddFace(smIdType NewFaceID,
+ smIdType n1, smIdType n2, smIdType n3,
+ smIdType n12, smIdType n23, smIdType n31, smIdType nCenter)
{
if ( myType != SMESHDS_AddBiQuadTriangle) {
MESSAGE("SMESHDS_Command::AddFace : Bad Type");
//function : AddFace
//purpose :
//=======================================================================
-void SMESHDS_Command::AddFace(int NewFaceID,
- int n1, int n2, int n3, int n4,
- int n12, int n23, int n34, int n41)
+void SMESHDS_Command::AddFace(smIdType NewFaceID,
+ smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n34, smIdType n41)
{
if ( myType != SMESHDS_AddQuadQuadrangle) {
MESSAGE("SMESHDS_Command::AddFace : Bad Type");
//function : AddFace
//purpose :
//=======================================================================
-void SMESHDS_Command::AddFace(int NewFaceID,
- int n1, int n2, int n3, int n4,
- int n12, int n23, int n34, int n41, int nCenter)
+void SMESHDS_Command::AddFace(smIdType NewFaceID,
+ smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n34, smIdType n41, smIdType nCenter)
{
if (myType != SMESHDS_AddBiQuadQuadrangle) {
MESSAGE("SMESHDS_Command::AddFace : Bad Type");
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n31,
- int n14, int n24, int n34)
+void SMESHDS_Command::AddVolume(smIdType NewVolID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n31,
+ smIdType n14, smIdType n24, smIdType n34)
{
if ( myType != SMESHDS_AddQuadTetrahedron) {
MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
- int n3, int n4, int n5,
- int n12, int n23, int n34, int n41,
- int n15, int n25, int n35, int n45)
+void SMESHDS_Command::AddVolume(smIdType NewVolID, 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)
{
if ( myType != SMESHDS_AddQuadPyramid) {
MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
- int n3, int n4, int n5,int n6,
- int n12, int n23, int n31,
- int n45, int n56, int n64,
- int n14, int n25, int n36)
+void SMESHDS_Command::AddVolume(smIdType NewVolID, 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)
{
if ( myType != SMESHDS_AddQuadPentahedron) {
MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
- int n3, int n4, int n5,int n6,
- int n12, int n23, int n31,
- int n45, int n56, int n64,
- int n14, int n25, int n36,
- int n1245, int n2356, int n1346)
+void SMESHDS_Command::AddVolume(smIdType NewVolID, 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)
{
if ( myType != SMESHDS_AddBiQuadPentahedron) {
MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
- int n4, int n5, int n6, int n7, int n8,
- int n12, int n23, int n34, int n41,
- int n56, int n67, int n78, int n85,
- int n15, int n26, int n37, int n48)
+void SMESHDS_Command::AddVolume(smIdType NewVolID, 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)
{
if ( myType != SMESHDS_AddQuadHexahedron) {
MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
- int n4, int n5, int n6, int n7, int n8,
- int n12, int n23, int n34, int n41,
- int n56, int n67, int n78, int n85,
- int n15, int n26, int n37, int n48,
- int n1234,int n1256,int n2367,int n3478,
- int n1458,int n5678,int nCenter)
+void SMESHDS_Command::AddVolume(smIdType NewVolID, 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)
{
if ( myType != SMESHDS_AddTriQuadHexa) {
MESSAGE("SMESHDS_Command::AddVolume : Bad Type");
*/
//================================================================================
-void SMESHDS_Command::AddBall(int NewBallID, int node, double diameter)
+void SMESHDS_Command::AddBall(smIdType NewBallID, smIdType node, double diameter)
{
if ( myType != SMESHDS_AddBall)
{
public:
SMESHDS_Command(const SMESHDS_CommandType aType);
- void AddNode(int NewNodeID, double x, double y, double z);
- void Add0DElement(int New0DElementID, int idnode);
- void AddEdge(int NewEdgeID, int idnode1, int idnode2);
- void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3);
- void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3,
- int idnode4);
+ void AddNode(smIdType NewNodeID, double x, double y, double z);
+ void Add0DElement(smIdType New0DElementID, smIdType idnode);
+ void AddEdge(smIdType NewEdgeID, smIdType idnode1, smIdType idnode2);
+ void AddFace(smIdType NewFaceID, smIdType idnode1, smIdType idnode2, smIdType idnode3);
+ void AddFace(smIdType NewFaceID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
+ smIdType idnode4);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
const std::vector<smIdType>& nodes_ids);
void AddPolyhedralVolume (const smIdType ElementID,
const std::vector<smIdType>& nodes_ids,
- const std::vector<smIdType>& quantities);
- void AddBall(int NewBallID, int node, double diameter);
+ const std::vector<int>& quantities);
+ void AddBall(smIdType NewBallID, smIdType node, double diameter);
// special methods for quadratic elements
- void AddEdge(int NewEdgeID, int n1, int n2, int n12);
- void AddFace(int NewFaceID, int n1, int n2, int n3,
- int n12, int n23, int n31);
- void AddFace(int NewFaceID, int n1, int n2, int n3,
- int n12, int n23, int n31, int nCenter);
- void AddFace(int NewFaceID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n34, int n41);
- void AddFace(int NewFaceID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n34, int n41, int nCenter);
- void AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n31, int n14, int n24, int n34);
- void AddVolume(int NewVolID, int n1, int n2, int n3, int n4, int n5,
- int n12, int n23, int n34, int n41,
- int n15, int n25, int n35, int n45);
- void AddVolume(int NewVolID, int n1, int n2, int n3,
- int n4, int n5, int n6,
- int n12, int n23, int n31,
- int n45, int n56, int n64,
- int n14, int n25, int n36);
- void AddVolume(int NewVolID, int n1, int n2, int n3,
- int n4, int n5, int n6,
- int n12, int n23, int n31,
- int n45, int n56, int n64,
- int n14, int n25, int n36,
- int n1245, int n2356, int n1346);
- void AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n5, int n6, int n7, int n8,
- int n12, int n23, int n34, int n41,
- int n56, int n67, int n78, int n85,
- int n15, int n26, int n37, int n48);
- void AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n5, int n6, int n7, int n8,
- int n12, int n23, int n34, int n41,
- int n56, int n67, int n78, int n85,
- int n15, int n26, int n37, int n48,
- int n1234,int n1256,int n2367,int n3478,
- int n1458,int n5678,int nCenter);
+ void AddEdge(smIdType NewEdgeID, smIdType n1, smIdType n2, smIdType n12);
+ void AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3,
+ smIdType n12, smIdType n23, smIdType n31);
+ void AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3,
+ smIdType n12, smIdType n23, smIdType n31, smIdType nCenter);
+ void AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n34, smIdType n41);
+ void AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n34, smIdType n41, smIdType nCenter);
+ void AddVolume(smIdType NewVolID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n31, smIdType n14, smIdType n24, smIdType n34);
+ void AddVolume(smIdType NewVolID, 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);
+ void AddVolume(smIdType NewVolID, 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);
+ void AddVolume(smIdType NewVolID, 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);
+ void AddVolume(smIdType NewVolID, 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);
+ void AddVolume(smIdType NewVolID, 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);
- void MoveNode(int NewNodeID, double x, double y, double z);
- void RemoveNode(int NodeID);
- void RemoveElement(int ElementID);
- void ChangeElementNodes(int ElementID, int nodes[], int nbnodes);
- void ChangePolyhedronNodes(const int ElementID,
- const std::vector<int>& nodes_ids,
+ void MoveNode(smIdType NewNodeID, double x, double y, double z);
+ void RemoveNode(smIdType NodeID);
+ void RemoveElement(smIdType ElementID);
+ void ChangeElementNodes(smIdType ElementID, smIdType nodes[], smIdType nbnodes);
+ void ChangePolyhedronNodes(const smIdType ElementID,
+ const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities);
- void Renumber (const bool isNodes, const int startID, const int deltaID);
+ void Renumber (const bool isNodes, const smIdType startID, const smIdType deltaID);
SMESHDS_CommandType GetType();
- int GetNumber();
- const std::list<int> & GetIndexes();
+ smIdType GetNumber();
+ const std::list<smIdType> & GetIndexes();
const std::list<double> & GetCoords();
~SMESHDS_Command();
private:
SMESHDS_CommandType myType;
int myNumber;
std::list<double> myReals;
- std::list<int> myIntegers;
+ std::list<smIdType> myIntegers;
};
#endif
if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
return false;
- std::vector<int> IDs( nbnodes );
- for ( int i = 0; i < nbnodes; i++ )
+ std::vector<smIdType> IDs( nbnodes );
+ for ( smIdType i = 0; i < nbnodes; i++ )
IDs [ i ] = nodes[ i ]->GetID();
myScript->ChangeElementNodes( elem->GetID(), &IDs[0], nbnodes);
if ( !SMDS_Mesh::ChangePolyhedronNodes( elem, nodes, quantities ))
return false;
- int i, len = nodes.size();
- std::vector<int> nodes_ids (len);
+ smIdType i, len = nodes.size();
+ std::vector<smIdType> nodes_ids (len);
for (i = 0; i < len; i++) {
nodes_ids[i] = nodes[i]->GetID();
}
//purpose :
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdType>& nodes_ids,
- const std::vector<smIdType>& quantities,
+ const std::vector<int>& quantities,
const smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID);
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
(const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<smIdType>& quantities,
+ const std::vector<int>& quantities,
const smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
(const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<smIdType>& quantities)
+ const std::vector<int>& quantities)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolume(nodes, quantities);
if (anElem) {
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<smIdType>& nodes_ids,
- const std::vector<smIdType>& quantities,
+ const std::vector<int>& quantities,
const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<smIdType>& quantities,
+ const std::vector<int>& quantities,
const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolume
(const std::vector<const SMDS_MeshNode*>& nodes,
- const std::vector<smIdType>& quantities);
+ const std::vector<int>& quantities);
virtual void MoveNode(const SMDS_MeshNode *, double x, double y, double z);
virtual void RemoveNode(const SMDS_MeshNode *);
//function :
//purpose :
//=======================================================================
-void SMESHDS_Script::AddNode(int NewNodeID, double x, double y, double z)
+void SMESHDS_Script::AddNode(smIdType NewNodeID, double x, double y, double z)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function :
//purpose :
//=======================================================================
-void SMESHDS_Script::Add0DElement (int New0DElementID, int idnode)
+void SMESHDS_Script::Add0DElement (smIdType New0DElementID, smIdType idnode)
{
if (myIsEmbeddedMode) {
myIsModified = true;
//function :
//purpose :
//=======================================================================
-void SMESHDS_Script::AddEdge(int NewEdgeID, int idnode1, int idnode2)
+void SMESHDS_Script::AddEdge(smIdType NewEdgeID, smIdType idnode1, smIdType idnode2)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function :
//purpose :
//=======================================================================
-void SMESHDS_Script::AddFace(int NewFaceID,
- int idnode1, int idnode2, int idnode3)
+void SMESHDS_Script::AddFace(smIdType NewFaceID,
+ smIdType idnode1, smIdType idnode2, smIdType idnode3)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function :
//purpose :
//=======================================================================
-void SMESHDS_Script::AddFace(int NewFaceID,
- int idnode1, int idnode2,
- int idnode3, int idnode4)
+void SMESHDS_Script::AddFace(smIdType NewFaceID,
+ smIdType idnode1, smIdType idnode2,
+ smIdType idnode3, smIdType idnode4)
{
if(myIsEmbeddedMode){
myIsModified = true;
//=======================================================================
void SMESHDS_Script::AddPolyhedralVolume (smIdType NewID,
const std::vector<smIdType>& nodes_ids,
- const std::vector<smIdType>& quantities)
+ const std::vector<int>& quantities)
{
if(myIsEmbeddedMode){
myIsModified = true;
//purpose : Record adding a Ball
//=======================================================================
-void SMESHDS_Script::AddBall(int NewBallID, int node, double diameter)
+void SMESHDS_Script::AddBall(smIdType NewBallID, smIdType node, double diameter)
{
if ( myIsEmbeddedMode )
myIsModified = true;
//function :
//purpose :
//=======================================================================
-void SMESHDS_Script::MoveNode(int NewNodeID, double x, double y, double z)
+void SMESHDS_Script::MoveNode(smIdType NewNodeID, double x, double y, double z)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function :
//purpose :
//=======================================================================
-void SMESHDS_Script::RemoveNode(int ID)
+void SMESHDS_Script::RemoveNode(smIdType ID)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function :
//purpose :
//=======================================================================
-void SMESHDS_Script::RemoveElement(int ElementID)
+void SMESHDS_Script::RemoveElement(smIdType ElementID)
{
if(myIsEmbeddedMode){
myIsModified = true;
//purpose :
//=======================================================================
-void SMESHDS_Script::ChangeElementNodes(int ElementID, int nodes[], int nbnodes)
+void SMESHDS_Script::ChangeElementNodes(smIdType ElementID, smIdType nodes[], smIdType nbnodes)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : ChangePolyhedronNodes
//purpose :
//=======================================================================
-void SMESHDS_Script::ChangePolyhedronNodes (const int ElementID,
- const std::vector<int>& nodes_ids,
+void SMESHDS_Script::ChangePolyhedronNodes (const smIdType ElementID,
+ const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities)
{
if(myIsEmbeddedMode){
//function : Renumber
//purpose :
//=======================================================================
-void SMESHDS_Script::Renumber (const bool isNodes, const int startID, const int deltaID)
+void SMESHDS_Script::Renumber (const bool isNodes, const smIdType startID, const smIdType deltaID)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddEdge
//purpose :
//=======================================================================
-void SMESHDS_Script::AddEdge(int NewEdgeID, int n1, int n2, int n12)
+void SMESHDS_Script::AddEdge(smIdType NewEdgeID, smIdType n1, smIdType n2, smIdType n12)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddFace
//purpose :
//=======================================================================
-void SMESHDS_Script::AddFace(int NewFaceID, int n1, int n2, int n3,
- int n12, int n23, int n31)
+void SMESHDS_Script::AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3,
+ smIdType n12, smIdType n23, smIdType n31)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddFace
//purpose :
//=======================================================================
-void SMESHDS_Script::AddFace(int NewFaceID, int n1, int n2, int n3,
- int n12, int n23, int n31, int nCenter)
+void SMESHDS_Script::AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3,
+ smIdType n12, smIdType n23, smIdType n31, smIdType nCenter)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddFace
//purpose :
//=======================================================================
-void SMESHDS_Script::AddFace(int NewFaceID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n34, int n41)
+void SMESHDS_Script::AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n34, smIdType n41)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddFace
//purpose :
//=======================================================================
-void SMESHDS_Script::AddFace(int NewFaceID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n34, int n41, int nCenter)
+void SMESHDS_Script::AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n34, smIdType n41, smIdType nCenter)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n31,
- int n14, int n24, int n34)
+void SMESHDS_Script::AddVolume(smIdType NewVolID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n31,
+ smIdType n14, smIdType n24, smIdType n34)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n5, int n12, int n23, int n34, int n41,
- int n15, int n25, int n35, int n45)
+void SMESHDS_Script::AddVolume(smIdType NewVolID, 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)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n5,int n6, int n12, int n23, int n31,
- int n45, int n56, int n64,
- int n14, int n25, int n36)
+void SMESHDS_Script::AddVolume(smIdType NewVolID, 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)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n5,int n6, int n12, int n23, int n31,
- int n45, int n56, int n64,
- int n14, int n25, int n36,
- int n1245, int n2356, int n1346)
+void SMESHDS_Script::AddVolume(smIdType NewVolID, 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)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3,
- int n4, int n5, int n6, int n7, int n8,
- int n12, int n23, int n34, int n41,
- int n56, int n67, int n78, int n85,
- int n15, int n26, int n37, int n48)
+void SMESHDS_Script::AddVolume(smIdType NewVolID, 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)
{
if(myIsEmbeddedMode){
myIsModified = true;
//function : AddVolume
//purpose :
//=======================================================================
-void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3,
- int n4, int n5, int n6, int n7, int n8,
- int n12, int n23, int n34, int n41,
- int n56, int n67, int n78, int n85,
- int n15, int n26, int n37, int n48,
- int n1234,int n1256,int n2367,int n3478,
- int n1458,int n5678,int nCenter)
+void SMESHDS_Script::AddVolume(smIdType NewVolID, 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)
{
if(myIsEmbeddedMode){
myIsModified = true;
void SetModified(bool theModified);
bool IsModified();
- void AddNode(int NewNodeID, double x, double y, double z);
- void Add0DElement(int New0DElementID, int idnode);
- void AddEdge(int NewEdgeID, int idnode1, int idnode2);
- void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3);
- void AddFace(int NewFaceID, int idnode1, int idnode2, int idnode3,
- int idnode4);
+ void AddNode(smIdType NewNodeID, double x, double y, double z);
+ void Add0DElement(smIdType New0DElementID, smIdType idnode);
+ void AddEdge(smIdType NewEdgeID, smIdType idnode1, smIdType idnode2);
+ void AddFace(smIdType NewFaceID, smIdType idnode1, smIdType idnode2, smIdType idnode3);
+ void AddFace(smIdType NewFaceID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
+ smIdType idnode4);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
const std::vector<smIdType>& nodes_ids);
void AddPolyhedralVolume (const smIdType NewVolID,
const std::vector<smIdType>& nodes_ids,
- const std::vector<smIdType>& quantities);
- void AddBall(int NewBallID, int node, double diameter);
+ const std::vector<int>& quantities);
+ void AddBall(smIdType NewBallID, smIdType node, double diameter);
// special methods for quadratic elements
- void AddEdge(int NewEdgeID, int n1, int n2, int n12);
- void AddFace(int NewFaceID, int n1, int n2, int n3,
- int n12, int n23, int n31);
- void AddFace(int NewFaceID, int n1, int n2, int n3,
- int n12, int n23, int n31, int nCenter);
- void AddFace(int NewFaceID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n34, int n41);
- void AddFace(int NewFaceID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n34, int n41, int nCenter);
- void AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n12, int n23, int n31, int n14, int n24, int n34);
- void AddVolume(int NewVolID, int n1, int n2, int n3, int n4, int n5,
- int n12, int n23, int n34, int n41,
- int n15, int n25, int n35, int n45);
- void AddVolume(int NewVolID, int n1, int n2, int n3,
- int n4, int n5, int n6,
- int n12, int n23, int n31,
- int n45, int n56, int n64,
- int n14, int n25, int n36);
- void AddVolume(int NewVolID, int n1, int n2, int n3,
- int n4, int n5, int n6,
- int n12, int n23, int n31,
- int n45, int n56, int n64,
- int n14, int n25, int n36,
- int n1245, int n2356, int n1346);
- void AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n5, int n6, int n7, int n8,
- int n12, int n23, int n34, int n41,
- int n56, int n67, int n78, int n85,
- int n15, int n26, int n37, int n48);
- void AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
- int n5, int n6, int n7, int n8,
- int n12, int n23, int n34, int n41,
- int n56, int n67, int n78, int n85,
- int n15, int n26, int n37, int n48,
- int n1234,int n1256,int n2367,int n3478,
- int n1458,int n5678,int nCenter);
- void MoveNode(int NewNodeID, double x, double y, double z);
- void RemoveNode(int NodeID);
- void RemoveElement(int ElementID);
- void ChangeElementNodes(int ElementID, int nodes[], int nbnodes);
- void ChangePolyhedronNodes(const int ElementID,
- const std::vector<int>& nodes_ids,
+ void AddEdge(smIdType NewEdgeID, smIdType n1, smIdType n2, smIdType n12);
+ void AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3,
+ smIdType n12, smIdType n23, smIdType n31);
+ void AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3,
+ smIdType n12, smIdType n23, smIdType n31, smIdType nCenter);
+ void AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n34, smIdType n41);
+ void AddFace(smIdType NewFaceID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n34, smIdType n41, smIdType nCenter);
+ void AddVolume(smIdType NewVolID, smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+ smIdType n12, smIdType n23, smIdType n31, smIdType n14, smIdType n24, smIdType n34);
+ void AddVolume(smIdType NewVolID, 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);
+ void AddVolume(smIdType NewVolID, 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);
+ void AddVolume(smIdType NewVolID, 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);
+ void AddVolume(smIdType NewVolID, 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);
+ void AddVolume(smIdType NewVolID, 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);
+ void MoveNode(smIdType NewNodeID, double x, double y, double z);
+ void RemoveNode(smIdType NodeID);
+ void RemoveElement(smIdType ElementID);
+ void ChangeElementNodes(smIdType ElementID, smIdType nodes[], smIdType nbnodes);
+ void ChangePolyhedronNodes(const smIdType ElementID,
+ const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities);
- void Renumber (const bool isNodes, const int startID, const int deltaID);
+ void Renumber (const bool isNodes, const smIdType startID, const smIdType deltaID);
void ClearMesh();
void Clear();
const std::list<SMESHDS_Command*> & GetCommands();
}
int NbFaces = Quantities.length();
- std::vector<smIdType> q (NbFaces);
+ std::vector<int> q (NbFaces);
for (int j = 0; j < NbFaces; j++)
q[j] = Quantities[j];
int NbFaces = IdsOfFaces.length();
std::vector<const SMDS_MeshNode*> poly_nodes;
- std::vector<smIdType> quantities (NbFaces);
+ std::vector<int> quantities (NbFaces);
for (int i = 0; i < NbFaces; i++) {
const SMDS_MeshElement* aFace = getMeshDS()->FindElement(IdsOfFaces[i]);
SMESHDS_Command *com = *its;
int comType = com->GetType();
int lgcom = com->GetNumber();
- const list < int >&intList = com->GetIndexes();
+ const list < smIdType >&intList = com->GetIndexes();
int inum = intList.size();
- list < int >::const_iterator ii = intList.begin();
+ list < smIdType >::const_iterator ii = intList.begin();
const list < double >&coordList = com->GetCoords();
int rnum = coordList.size();
list < double >::const_iterator ir = coordList.begin();
};
vector< _nodeDef > _nodes;
- vector< smIdType > _quantities;
+ vector< int > _quantities;
_volumeDef* _next; // to store several _volumeDefs in a chain
TGeomID _solidID;
const SMDS_MeshElement* _volume; // new volume
if ( loopsJoined )
{
// set unchanged polygons
- std::vector< smIdType > newQuantities;
+ std::vector< int > newQuantities;
std::vector< _volumeDef::_nodeDef > newNodes;
vector< SMESH_Block::TShapeID > newNames;
newQuantities.reserve( volDef->_quantities.size() );
//=======================================================================
const SMDS_MeshElement* addHexa( std::vector< const SMDS_MeshElement* >& faces,
- const std::vector< smIdType > & quantities,
+ const std::vector< int > & quantities,
SMESH_MesherHelper & helper )
{
const SMDS_MeshElement* newHexa = 0;
//=======================================================================
const SMDS_MeshElement* addTetra( std::vector< const SMDS_MeshElement* >& faces,
- const std::vector< smIdType > & quantities,
+ const std::vector< int > & quantities,
SMESH_MesherHelper & helper )
{
const SMDS_MeshElement* newTetra = 0;
//=======================================================================
const SMDS_MeshElement* addPenta( std::vector< const SMDS_MeshElement* >& faces,
- const std::vector< smIdType > & quantities,
+ const std::vector< int > & quantities,
SMESH_MesherHelper & helper )
{
const SMDS_MeshElement* newPenta = 0;
//=======================================================================
const SMDS_MeshElement* addPyra( std::vector< const SMDS_MeshElement* >& faces,
- const std::vector< smIdType > & quantities,
+ const std::vector< int > & quantities,
SMESH_MesherHelper & helper )
{
const SMDS_MeshElement* newPyra = 0;
//=======================================================================
const SMDS_MeshElement* addHPrism( std::vector< const SMDS_MeshElement* >& faces,
- const std::vector< smIdType > & quantities,
+ const std::vector< int > & quantities,
SMESH_MesherHelper & helper )
{
const SMDS_MeshElement* newHexPrism = 0;
//=======================================================================
const SMDS_MeshElement* addPoly( std::vector< const SMDS_MeshElement* >& faces,
- const std::vector< smIdType > & quantities,
+ const std::vector< int > & quantities,
SMESH_MesherHelper & helper )
{
const SMDS_MeshElement* newPoly = 0;
for ( size_t i = 0; i < faces.size() && !useMediumNodes ; ++i )
useMediumNodes = faces[ i ]->IsQuadratic();
- std::vector< smIdType > quantities( faces.size() );
+ std::vector< int > quantities( faces.size() );
std::set< const SMDS_MeshNode* > nodes;
for ( size_t i = 0; i < faces.size(); ++i )
{
break;
}
default: // ---------- polyhedra
- vector<smIdType> quantities( 2 + nbNodes, 4 );
+ vector<int> quantities( 2 + nbNodes, 4 );
quantities[0] = quantities[1] = nbNodes;
columns.resize( nbNodes + 1 );
columns[ nbNodes ] = columns[ 0 ];
