ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-25 17:00:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'V9_7_BR' into gni/evolution

Browse Source
This commit is contained in:
GERALD NICOLAS 2021-04-26 16:23:22 +02:00
commit db83efeef8
228 changed files with 3786 additions and 3371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CMakeLists.txt
View File

@ -79,6 +79,12 @@ IF(SALOME_SMESH_DYNLOAD_LOCAL)
ADD_DEFINITIONS(-DDYNLOAD_LOCAL)
ENDIF(SALOME_SMESH_DYNLOAD_LOCAL)
IF(SALOME_USE_64BIT_IDS)
SET(SMESH_ID_TYPE "long long")
ELSE()
SET(SMESH_ID_TYPE "long")
ENDIF()
IF(SMESH_USE_MESHGEMS_HYPOSET)
SET(SMESH_USE_MESHGEMS_HYPOSET_VAR "true")
ELSE(SMESH_USE_MESHGEMS_HYPOSET)

1
SalomeSMESHConfig.cmake.in
View File

@ -127,6 +127,7 @@ SET(SALOME_INSTALL_PYTHON_SHARED "@SALOME_INSTALL_PYTHON_SHARED@")
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))

4
idl/CMakeLists.txt
View File

@ -26,6 +26,8 @@ INCLUDE_DIRECTORIES(
${PROJECT_BINARY_DIR}/idl
)
SALOME_CONFIGURE_FILE(SMESH_smIdType.idl.in SMESH_smIdType.idl)
SET(SalomeIDLSMESH_IDLSOURCES
SMESH_Gen.idl
SMESH_Mesh.idl
@ -36,12 +38,14 @@ SET(SalomeIDLSMESH_IDLSOURCES
SMESH_Pattern.idl
SMESH_MeshEditor.idl
SMESH_Measurements.idl
${CMAKE_CURRENT_BINARY_DIR}/SMESH_smIdType.idl
MG_ADAPT.idl
)
SET(_idl_include_dirs
${KERNEL_ROOT_DIR}/idl/salome
${GEOM_ROOT_DIR}/idl/salome
${PROJECT_BINARY_DIR}/idl
)
SET(_idl_link_flags

40
idl/SMESH_BasicHypothesis.idl
View File

@ -161,32 +161,32 @@ module StdMeshers
/*!
* Builds and returns point distribution according to passed density function
*/
SMESH::double_array BuildDistributionExpr( in string func, in long nbSeg, in long conv )
SMESH::double_array BuildDistributionExpr( in string func, in long nbSeg, in long conv )
raises (SALOME::SALOME_Exception);
SMESH::double_array BuildDistributionTab( in SMESH::double_array func, in long nbSeg, in long conv )
SMESH::double_array BuildDistributionTab( in SMESH::double_array func, in long nbSeg, in long conv )
raises (SALOME::SALOME_Exception);
/*!
* Sets <number of segments> parameter value
*/
void SetNumberOfSegments(in long segmentsNumber)
void SetNumberOfSegments(in SMESH::smIdType segmentsNumber)
raises (SALOME::SALOME_Exception);
/*!
* Returns <number of segments> parameter value
*/
long GetNumberOfSegments();
long GetNumberOfSegments();
/*!
* Sets <distribution type> parameter value
*/
void SetDistrType(in long typ)
void SetDistrType(in long typ)
raises (SALOME::SALOME_Exception);
/*!
* Returns <distribution type> parameter value
*/
long GetDistrType();
long GetDistrType();
/*!
* Sets <scale factor> parameter value
@ -227,13 +227,13 @@ module StdMeshers
/*!
* Sets <conversion mode> parameter value for functional distributions
*/
void SetConversionMode(in long conv )
void SetConversionMode(in long conv )
raises (SALOME::SALOME_Exception);
/*!
* Returns <conversion mode> parameter value for functional distributions
*/
long ConversionMode()
long ConversionMode()
raises (SALOME::SALOME_Exception);
};
@ -323,13 +323,13 @@ module StdMeshers
/*!
* Sets <mode> parameter value
*/
void SetMode(in long mode)
void SetMode(in long mode)
raises (SALOME::SALOME_Exception);
/*!
* Returns <mode> parameter value
*/
long GetMode();
long GetMode();
};
/*!
@ -395,7 +395,7 @@ module StdMeshers
*/
void SetPoints(in SMESH::double_array listParams)
raises (SALOME::SALOME_Exception);
void SetNbSegments(in SMESH::long_array listNbSeg)
void SetNbSegments(in SMESH::smIdType_array listNbSeg)
raises (SALOME::SALOME_Exception);
/*!
@ -406,7 +406,7 @@ module StdMeshers
/*!
* Returns list of numbers of segments
*/
SMESH::long_array GetNbSegments();
SMESH::smIdType_array GetNbSegments();
};
@ -519,13 +519,13 @@ module StdMeshers
/*!
* Sets <number of segments> parameter value
*/
void SetNumberOfLayers(in long numberOfLayers)
void SetNumberOfLayers(in long numberOfLayers)
raises (SALOME::SALOME_Exception);
/*!
* Returns <number of layers> parameter value
*/
long GetNumberOfLayers();
long GetNumberOfLayers();
};
@ -665,7 +665,7 @@ module StdMeshers
* Result may be nil if association not set.
* Valid indices are 1 and 2
*/
GEOM::GEOM_Object GetSourceVertex(in long i)
GEOM::GEOM_Object GetSourceVertex(in long i)
raises (SALOME::SALOME_Exception);
/*!
@ -673,7 +673,7 @@ module StdMeshers
* Result may be nil if association not set.
* Valid indices are 1 and 2
*/
GEOM::GEOM_Object GetTargetVertex(in long i)
GEOM::GEOM_Object GetTargetVertex(in long i)
raises (SALOME::SALOME_Exception);
};
@ -722,7 +722,7 @@ module StdMeshers
* Result may be nil if association not set.
* Valid indices are 1 and 2
*/
GEOM::GEOM_Object GetSourceVertex(in long i)
GEOM::GEOM_Object GetSourceVertex(in long i)
raises (SALOME::SALOME_Exception);
/*!
@ -730,7 +730,7 @@ module StdMeshers
* Result may be nil if association not set.
* Valid indices are 1 and 2
*/
GEOM::GEOM_Object GetTargetVertex(in long i)
GEOM::GEOM_Object GetTargetVertex(in long i)
raises (SALOME::SALOME_Exception);
};
@ -771,12 +771,12 @@ module StdMeshers
/*!
* Set base vertex for triangles
*/
void SetTriaVertex( in long vertID );
void SetTriaVertex( in long vertID );
/*!
* Returns base vertex for triangles
*/
long GetTriaVertex();
long GetTriaVertex();
/*!
* Set entry of the main object

25
idl/SMESH_Filter.idl
View File

@ -30,6 +30,7 @@
#include "SALOME_GenericObj.idl"
#include "GEOM_Gen.idl"
#include "SMESH_Mesh.idl"
#include "SMESH_smIdType.idl"
module SMESH
{
@ -119,8 +120,8 @@ module SMESH
*/
interface NumericalFunctor: Functor
{
double GetValue ( in long theElementId );
boolean IsApplicable( in long theElementId );
double GetValue ( in smIdType theElementId );
boolean IsApplicable( in smIdType theElementId );
Histogram GetHistogram ( in short nbIntervals, in boolean isLogarithmic );
Histogram GetLocalHistogram( in short nbIntervals, in boolean isLogarithmic,
@ -374,7 +375,7 @@ module SMESH
*/
interface RangeOfIds: Predicate
{
void SetRange( in long_array theIds );
void SetRange( in smIdType_array theIds );
boolean SetRangeStr( in string theRange );
string GetRangeStr();
@ -474,7 +475,7 @@ module SMESH
void SetElementType( in ElementType type );
void SetPoint ( in double x, in double y, in double z );
void SetVertex ( in GEOM::GEOM_Object vertex );
void SetNode ( in long nodeID );
void SetNode ( in smIdType nodeID );
string GetThreshold ( out ThresholdType type );
void SetThreshold ( in string threshold, in ThresholdType type )
raises (SALOME::SALOME_Exception);
@ -522,16 +523,16 @@ module SMESH
typedef sequence<Criterion> Criteria;
void SetPredicate( in Predicate thePredicate );
void SetMesh( in SMESH_Mesh theMesh );
void SetPredicate( in Predicate thePredicate );
void SetMesh( in SMESH_Mesh theMesh );
long_array GetElementsId( in SMESH_Mesh theMesh );
long_array GetElementsIdFromParts( in ListOfIDSources theParts );
ElementType GetElementType();
Predicate GetPredicate();
smIdType_array GetElementsId( in SMESH_Mesh theMesh );
smIdType_array GetElementsIdFromParts( in ListOfIDSources theParts );
ElementType GetElementType();
Predicate GetPredicate();
boolean GetCriteria( out Criteria theCriteria );
boolean SetCriteria( in Criteria theCriteria );
boolean GetCriteria( out Criteria theCriteria );
boolean SetCriteria( in Criteria theCriteria );
};

15
idl/SMESH_Gen.idl
View File

@ -33,6 +33,7 @@
#include "SMESH_Mesh.idl"
#include "SMESH_Hypothesis.idl"
#include "SMESH_smIdType.idl"
module SMESH
{
@ -387,8 +388,8 @@ module SMESH
/*!
* Evaluates size of prospective mesh on a shape
*/
long_array Evaluate(in SMESH_Mesh theMesh,
in GEOM::GEOM_Object theSubObject)
smIdType_array Evaluate(in SMESH_Mesh theMesh,
in GEOM::GEOM_Object theSubObject)
raises ( SALOME::SALOME_Exception );
/*!
@ -446,17 +447,17 @@ module SMESH
* The returned geometrical object, if not nil, is either found in the
* study or is published by this method with the given name
*/
GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh theMesh,
in long theElementID,
in string theGeomName)
GEOM::GEOM_Object GetGeometryByMeshElement( in SMESH_Mesh theMesh,
in smIdType theElementID,
in string theGeomName)
raises ( SALOME::SALOME_Exception );
/*!
* Return geometrical object the given element is built on.
* The returned geometrical object not published in study by this method.
*/
GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh theMesh,
in long theElementID)
GEOM::GEOM_Object FindGeometryByMeshElement( in SMESH_Mesh theMesh,
in smIdType theElementID)
raises ( SALOME::SALOME_Exception );
/*!

23
idl/SMESH_Group.idl
View File

@ -32,6 +32,7 @@
#include "SALOMEDS_Attributes.idl"
#include "SMESH_Mesh.idl"
#include "SMESH_smIdType.idl"
module SMESH
{
@ -61,7 +62,7 @@ module SMESH
/*!
* Returns the number of elements in the group
*/
long Size();
smIdType Size();
/*!
* Returns true if the group does not contain any elements
@ -71,29 +72,29 @@ module SMESH
/*!
* returns true if the group contains an element with ID == <elem_id>
*/
boolean Contains( in long elem_id );
boolean Contains( in smIdType elem_id );
/*!
* Returns ID of an element at position <elem_index> counted from 1
*/
long GetID( in long elem_index );
smIdType GetID( in smIdType elem_index );
/*!
* Returns a sequence of all element IDs in the group
*/
long_array GetListOfID();
smIdType_array GetListOfID();
/*!
* Get the number of nodes of cells included to the group
* For a nodal group returns the same value as Size() function
*/
long GetNumberOfNodes();
smIdType GetNumberOfNodes();
/*!
* Get IDs of nodes of cells included to the group
* For a nodal group returns result of GetListOfID() function
*/
long_array GetNodeIDs();
smIdType_array GetNodeIDs();
/*!
* Return true if GetNumberOfNodes() won't take a long time for computation
@ -142,24 +143,24 @@ module SMESH
/*!
* Adds elements or nodes with specified identifiers to the group
*/
long Add( in long_array elem_ids );
smIdType Add( in smIdType_array elem_ids );
/*!
* Adds elements or nodes that match specified predicate to the group
*/
long AddByPredicate( in Predicate thePredicate );
smIdType AddByPredicate( in Predicate thePredicate );
/*!
* Add all elements or nodes from the specified source to the group
*/
long AddFrom( in SMESH_IDSource theSource );
smIdType AddFrom( in SMESH_IDSource theSource );
/*!
* Removes elements or nodes with specified identifiers from the group
*/
long Remove( in long_array elem_ids );
smIdType Remove( in smIdType_array elem_ids );
/*!
* Removes elements or nodes that match specified predicate from the group
*/
long RemoveByPredicate( in Predicate thePredicate );
smIdType RemoveByPredicate( in Predicate thePredicate );
};

2
idl/SMESH_Hypothesis.idl
View File

@ -57,7 +57,7 @@ module SMESH
/*!
* Get the internal Id
*/
long GetId();
short GetId();
/*!
* Set the variable parameter

5
idl/SMESH_Measurements.idl
View File

@ -28,6 +28,7 @@
#include "SALOME_GenericObj.idl"
#include "SMESH_Mesh.idl"
#include "SMESH_smIdType.idl"
module SMESH
{
@ -37,8 +38,8 @@ module SMESH
struct Measure {
double minX, minY, minZ;
double maxX, maxY, maxZ;
long node1, node2;
long elem1, elem2;
smIdType node1, node2;
smIdType elem1, elem2;
double value;
};

148
idl/SMESH_Mesh.idl
View File

@ -29,6 +29,7 @@
#include "SALOME_Exception.idl"
#include "SALOME_GenericObj.idl"
#include "GEOM_Gen.idl"
#include "SMESH_smIdType.idl"
module SMESH
{
@ -41,6 +42,7 @@ module SMESH
typedef sequence<double > double_array ;
typedef sequence<long > long_array ;
typedef sequence<smIdType > smIdType_array ;
typedef sequence<string > string_array ;
typedef sequence<long_array> array_of_long_array ;
@ -228,12 +230,12 @@ module SMESH
enum DriverMED_ReadStatus // in the order of severity
{
DRS_OK,
DRS_EMPTY, // a file contains no mesh with the given name
DRS_WARN_RENUMBER, // a MED file has overlapped ranges of element numbers,
// so the numbers from the file are ignored
DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
DRS_EMPTY, // a file contains no mesh with the given name
DRS_WARN_RENUMBER, // a MED file has overlapped ranges of element numbers,
// so the numbers from the file are ignored
DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
DRS_WARN_DESCENDING, // some elements were skipped due to descending connectivity
DRS_FAIL // general failure (exception etc.)
DRS_FAIL // general failure (exception etc.)
};
/*!
@ -267,7 +269,7 @@ module SMESH
*/
struct ElementSubType { ElementType SMDS_ElementType;
boolean isPoly;
long nbNodesInElement; };
short nbNodesInElement; };
typedef sequence<ElementSubType> types_array;
@ -285,19 +287,19 @@ module SMESH
/*!
* Returns a sequence of all element IDs
*/
long_array GetIDs();
smIdType_array GetIDs();
/*!
* Returns number of mesh elements of each \a EntityType
* @return array of number of elements per \a EntityType
*/
long_array GetMeshInfo();
smIdType_array GetMeshInfo();
/*!
* Returns number of mesh elements of each \a ElementType
* @return array of number of elements per \a ElementType
*/
long_array GetNbElementsByType();
smIdType_array GetNbElementsByType();
/*!
* Returns types of elements it contains.
@ -747,121 +749,121 @@ module SMESH
/*!
* Get information about mesh contents
*/
long NbNodes()
smIdType NbNodes()
raises (SALOME::SALOME_Exception);
long NbElements()
smIdType NbElements()
raises (SALOME::SALOME_Exception);
long Nb0DElements()
smIdType Nb0DElements()
raises (SALOME::SALOME_Exception);
long NbBalls()
smIdType NbBalls()
raises (SALOME::SALOME_Exception);
long NbEdges()
smIdType NbEdges()
raises (SALOME::SALOME_Exception);
long NbEdgesOfOrder(in ElementOrder order)
smIdType NbEdgesOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbFaces()
smIdType NbFaces()
raises (SALOME::SALOME_Exception);
long NbFacesOfOrder(in ElementOrder order)
smIdType NbFacesOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbTriangles()
smIdType NbTriangles()
raises (SALOME::SALOME_Exception);
long NbTrianglesOfOrder(in ElementOrder order)
smIdType NbTrianglesOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbBiQuadTriangles()
smIdType NbBiQuadTriangles()
raises (SALOME::SALOME_Exception);
long NbQuadrangles()
smIdType NbQuadrangles()
raises (SALOME::SALOME_Exception);
long NbQuadranglesOfOrder(in ElementOrder order)
smIdType NbQuadranglesOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbBiQuadQuadrangles()
smIdType NbBiQuadQuadrangles()
raises (SALOME::SALOME_Exception);
long NbPolygons()
smIdType NbPolygons()
raises (SALOME::SALOME_Exception);
long NbPolygonsOfOrder(in ElementOrder order)
smIdType NbPolygonsOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbVolumes()
smIdType NbVolumes()
raises (SALOME::SALOME_Exception);
long NbVolumesOfOrder(in ElementOrder order)
smIdType NbVolumesOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbTetras()
smIdType NbTetras()
raises (SALOME::SALOME_Exception);
long NbTetrasOfOrder(in ElementOrder order)
smIdType NbTetrasOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbHexas()
smIdType NbHexas()
raises (SALOME::SALOME_Exception);
long NbHexasOfOrder(in ElementOrder order)
smIdType NbHexasOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbTriQuadraticHexas()
smIdType NbTriQuadraticHexas()
raises (SALOME::SALOME_Exception);
long NbPyramids()
smIdType NbPyramids()
raises (SALOME::SALOME_Exception);
long NbPyramidsOfOrder(in ElementOrder order)
smIdType NbPyramidsOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbPrisms()
smIdType NbPrisms()
raises (SALOME::SALOME_Exception);
long NbPrismsOfOrder(in ElementOrder order)
smIdType NbPrismsOfOrder(in ElementOrder order)
raises (SALOME::SALOME_Exception);
long NbHexagonalPrisms()
smIdType NbHexagonalPrisms()
raises (SALOME::SALOME_Exception);
long NbPolyhedrons()
smIdType NbPolyhedrons()
raises (SALOME::SALOME_Exception);
long NbSubMesh()
smIdType NbSubMesh()
raises (SALOME::SALOME_Exception);
long_array GetElementsId()
smIdType_array GetElementsId()
raises (SALOME::SALOME_Exception);
long_array GetElementsByType( in ElementType theType )
smIdType_array GetElementsByType( in ElementType theType )
raises (SALOME::SALOME_Exception);
long_array GetNodesId()
smIdType_array GetNodesId()
raises (SALOME::SALOME_Exception);
/*!
* Returns type of mesh element
*/
ElementType GetElementType( in long id, in boolean iselem )
ElementType GetElementType( in smIdType id, in boolean iselem )
raises (SALOME::SALOME_Exception);
EntityType GetElementGeomType( in long id )
EntityType GetElementGeomType( in smIdType id )
raises (SALOME::SALOME_Exception);
GeometryType GetElementShape( in long id )
GeometryType GetElementShape( in smIdType id )
raises (SALOME::SALOME_Exception);
long_array GetSubMeshElementsId(in long ShapeID)
smIdType_array GetSubMeshElementsId(in long ShapeID)
raises (SALOME::SALOME_Exception);
long_array GetSubMeshNodesId(in long ShapeID, in boolean all )
smIdType_array GetSubMeshNodesId(in long ShapeID, in boolean all )
raises (SALOME::SALOME_Exception);
ElementType GetSubMeshElementType(in long ShapeID)
@ -902,81 +904,81 @@ module SMESH
* Get XYZ coordinates of node as list of double
* If there is not node for given ID - returns empty list
*/
double_array GetNodeXYZ(in long id);
double_array GetNodeXYZ(in smIdType id);
/*!
* For given node returns list of IDs of inverse elements
* If there is not node for given ID - returns empty list
*/
long_array GetNodeInverseElements(in long id, in ElementType elemType);
smIdType_array GetNodeInverseElements(in smIdType id, in ElementType elemType);
/*!
* \brief Return position of a node on shape
*/
NodePosition GetNodePosition(in long NodeID);
NodePosition GetNodePosition(in smIdType NodeID);
/*!
* \brief Return position of an element on shape
*/
ElementPosition GetElementPosition(in long ElemID);
ElementPosition GetElementPosition(in smIdType ElemID);
/*!
* If given element is node returns IDs of shape from position
* If there is not node for given ID - returns -1
*/
long GetShapeID(in long id);
long GetShapeID(in smIdType id);
/*!
* For given element returns ID of result shape after
* ::FindShape() from SMESH_MeshEditor
* If there is not element for given ID - returns -1
*/
long GetShapeIDForElem(in long id);
long GetShapeIDForElem(in smIdType id);
/*!
* Returns number of nodes for given element
* If there is not element for given ID - returns -1
*/
long GetElemNbNodes(in long id);
short GetElemNbNodes(in smIdType id);
/*!
* Returns IDs of nodes of given element
*/
long_array GetElemNodes(in long id);
smIdType_array GetElemNodes(in smIdType id);
/*!
* Returns ID of node by given index for given element
* If there is not element for given ID - returns -1
* If there is not node for given index - returns -2
*/
long GetElemNode(in long id, in long index);
smIdType GetElemNode(in smIdType id, in short index);
/*!
* Returns true if given node is medium node
* in given quadratic element
*/
boolean IsMediumNode(in long ide, in long idn);
boolean IsMediumNode(in smIdType ide, in smIdType idn);
/*!
* Returns true if given node is medium node
* in one of quadratic elements
*/
boolean IsMediumNodeOfAnyElem(in long idn, in ElementType elem_type);
boolean IsMediumNodeOfAnyElem(in smIdType idn, in ElementType elem_type);
/*!
* Returns number of edges for given element
*/
long ElemNbEdges(in long id);
long ElemNbEdges(in smIdType id);
/*!
* Returns number of faces for given element
*/
long ElemNbFaces(in long id);
long ElemNbFaces(in smIdType id);
/*!
* Returns nodes of given face (counted from zero) for given volumic element.
*/
long_array GetElemFaceNodes(in long elemId, in short faceIndex);
smIdType_array GetElemFaceNodes(in smIdType elemId, in short faceIndex);
/*!
* Returns three components of normal of given mesh face (or an empty array in KO case)
@ -986,34 +988,34 @@ module SMESH
/*!
* Returns an element based on all given nodes.
*/
long FindElementByNodes(in long_array nodes);
smIdType FindElementByNodes(in smIdType_array nodes);
/*!
* Return elements including all given nodes.
*/
long_array GetElementsByNodes(in long_array nodes, in ElementType elem_type);
smIdType_array GetElementsByNodes(in smIdType_array nodes, in ElementType elem_type);
/*!
* Returns true if given element is polygon
*/
boolean IsPoly(in long id);
boolean IsPoly(in smIdType id);
/*!
* Returns true if given element is quadratic
*/
boolean IsQuadratic(in long id);
boolean IsQuadratic(in smIdType id);
/*!
* Returns diameter of a ball discrete element or zero in case of an invalid \a id
*/
double GetBallDiameter(in long id);
double GetBallDiameter(in smIdType id);
/*!
* Returns XYZ coordinates of bary center for given element
* as list of double
* If there is not element for given ID - returns empty list
*/
double_array BaryCenter(in long id);
double_array BaryCenter(in smIdType id);
/*! Gets information about imported MED file */
MedFileInfo GetMEDFileInfo();
@ -1040,37 +1042,37 @@ module SMESH
/*!
*
*/
long GetNumberOfElements()
smIdType GetNumberOfElements()
raises (SALOME::SALOME_Exception);
/*!
*
*/
long GetNumberOfNodes( in boolean all )
smIdType GetNumberOfNodes( in boolean all )
raises (SALOME::SALOME_Exception);
/*!
*
*/
long_array GetElementsId()
smIdType_array GetElementsId()
raises (SALOME::SALOME_Exception);
/*!
*
*/
long_array GetElementsByType( in ElementType theType )
smIdType_array GetElementsByType( in ElementType theType )
raises (SALOME::SALOME_Exception);
/*!
* Returns type of mesh element (same as SMESH_Mesh::GetElementType() )
*/
ElementType GetElementType( in long id, in boolean iselem )
ElementType GetElementType( in smIdType id, in boolean iselem )
raises (SALOME::SALOME_Exception);
/*!
*
*/
long_array GetNodesId()
smIdType_array GetNodesId()
raises (SALOME::SALOME_Exception);
/*!

297
idl/SMESH_MeshEditor.idl
View File

@ -26,6 +26,7 @@
#include "SMESH_Mesh.idl"
#include "SMESH_Gen.idl"
#include "SMESH_smIdType.idl"
module SMESH
{
@ -36,7 +37,7 @@ module SMESH
struct FreeBorder
{
SMESH::long_array nodeIDs; // all nodes defining a free border
SMESH::smIdType_array nodeIDs; // all nodes defining a free border
// 1st and last node is same in a closed border
};
struct FreeBorderPart
@ -66,13 +67,13 @@ module SMESH
// else ==> point is at xyz*
// point 1
long node1ID1;
long node1ID2;
smIdType node1ID1;
smIdType node1ID2;
PointStruct xyz1;
// point 2
long node2ID1;
long node2ID2;
smIdType node2ID1;
smIdType node2ID2;
PointStruct xyz2;
// vector on the plane; to use a default plane set vector = (0,0,0)
@ -83,9 +84,9 @@ module SMESH
// face edge defined by two nodes + optional medium node
struct FaceEdge
{
long node1;
long node2;
long medium;
smIdType node1;
smIdType node2;
smIdType medium;
};
typedef sequence<FaceEdge> ListOfEdges;
@ -112,14 +113,14 @@ module SMESH
* created, this method returns list of their IDs, if new nodes
* not created - returns empty list
*/
long_array GetLastCreatedNodes() raises (SALOME::SALOME_Exception);
smIdType_array GetLastCreatedNodes() raises (SALOME::SALOME_Exception);
/*!
* If during last operation of MeshEditor some elements were
* created, this method returns list of their IDs, if new elements
* not created - returns empty list
*/
long_array GetLastCreatedElems() raises (SALOME::SALOME_Exception);
smIdType_array GetLastCreatedElems() raises (SALOME::SALOME_Exception);
/*!
* \brief Clears sequences of last created elements and nodes
@ -136,27 +137,27 @@ module SMESH
* \param IDsOfElements list of mesh elements identifiers
* \return new ID source object
*/
SMESH_IDSource MakeIDSource(in long_array IDsOfElements, in ElementType type);
SMESH_IDSource MakeIDSource(in smIdType_array IDsOfElements, in ElementType type);
/*!
* \brief Remove mesh elements specified by their identifiers.
* \param IDsOfElements list of mesh elements identifiers
* \return \c true if elements are correctly removed or \c false otherwise
*/
boolean RemoveElements(in long_array IDsOfElements) raises (SALOME::SALOME_Exception);
boolean RemoveElements(in smIdType_array IDsOfElements) raises (SALOME::SALOME_Exception);
/*!
* \brief Remove mesh nodes specified by their identifiers.
* \param IDsOfNodes list of mesh nodes identifiers
* \return \c true if nodes are correctly removed or \c false otherwise
*/
boolean RemoveNodes(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
boolean RemoveNodes(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
/*!
* \brief Remove all orphan nodes.
* \return number of removed nodes
*/
long RemoveOrphanNodes() raises (SALOME::SALOME_Exception);
smIdType RemoveOrphanNodes() raises (SALOME::SALOME_Exception);
/*!
* \brief Add a new node.
@ -165,21 +166,21 @@ module SMESH
* \param z Z coordinate of new node
* \return integer identifier of new node
*/
long AddNode(in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
smIdType AddNode(in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
/*!
* Create a 0D element on the given node.
* \param IdOfNode Node IDs for creation of element.
* \param DuplicateElements to add one more 0D element to a node or not
*/
long Add0DElement(in long IDOfNode,
in boolean DuplicateElements) raises (SALOME::SALOME_Exception);
smIdType Add0DElement(in smIdType IDOfNode,
in boolean DuplicateElements) raises (SALOME::SALOME_Exception);
/*!
* Create a ball element on the given node.
* \param IdOfNode Node IDs for creation of element.
*/
long AddBall(in long IDOfNode, in double diameter) raises (SALOME::SALOME_Exception);
smIdType AddBall(in smIdType IDOfNode, in double diameter) raises (SALOME::SALOME_Exception);
/*!
* Create an edge, either linear and quadratic (this is determed
@ -189,7 +190,7 @@ module SMESH
* of MED. This description is located by the following link:
* http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
*/
long AddEdge(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
smIdType AddEdge(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
/*!
* Create face, either linear and quadratic (this is determed
@ -199,16 +200,16 @@ module SMESH
* of MED. This description is located by the following link:
* http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
*/
long AddFace(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
smIdType AddFace(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
long AddPolygonalFace(in long_array IdsOfNodes) raises (SALOME::SALOME_Exception);
smIdType AddPolygonalFace(in smIdType_array IdsOfNodes) raises (SALOME::SALOME_Exception);
/*!
* Create a quadratic polygonal face
* \param IdsOfNodes - nodes of the polygon; corner nodes follow first
* \return long - ID of a new polygon
* \return smIdType- ID of a new polygon
*/
long AddQuadPolygonalFace(in long_array IdsOfNodes) raises (SALOME::SALOME_Exception);
smIdType AddQuadPolygonalFace(in smIdType_array IdsOfNodes) raises (SALOME::SALOME_Exception);
/*!
* Create volume, either linear and quadratic (this is determed
@ -218,7 +219,7 @@ module SMESH
* of MED. This description is located by the following link:
* http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
*/
long AddVolume(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
smIdType AddVolume(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
/*!
* Create volume of many faces, giving nodes for each face.
@ -226,15 +227,15 @@ module SMESH
* \param Quantities List of integer values, Quantities[i]
* gives quantity of nodes in face number i.
*/
long AddPolyhedralVolume (in long_array IdsOfNodes,
in long_array Quantities) raises (SALOME::SALOME_Exception);
smIdType AddPolyhedralVolume (in smIdType_array IdsOfNodes,
in long_array Quantities) raises (SALOME::SALOME_Exception);
/*!
* Create volume of many faces, giving IDs of existing faces.
* \param IdsOfFaces List of face IDs for volume creation.
* \note The created volume will refer only to nodes
* of the given faces, not to the faces itself.
*/
long AddPolyhedralVolumeByFaces (in long_array IdsOfFaces) raises (SALOME::SALOME_Exception);
smIdType AddPolyhedralVolumeByFaces (in smIdType_array IdsOfFaces) raises (SALOME::SALOME_Exception);
/*!
* Create 0D elements on all nodes of the given object.
@ -255,7 +256,7 @@ module SMESH
* \param NodeID - node ID
* \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
*/
void SetNodeOnVertex(in long NodeID, in long VertexID)
void SetNodeOnVertex(in smIdType NodeID, in long VertexID)
raises (SALOME::SALOME_Exception);
/*!
* \brief Store node position on an edge
@ -263,7 +264,7 @@ module SMESH
* \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
* \param paramOnEdge - parameter on edge where the node is located
*/
void SetNodeOnEdge(in long NodeID, in long EdgeID, in double paramOnEdge)
void SetNodeOnEdge(in smIdType NodeID, in long EdgeID, in double paramOnEdge)
raises (SALOME::SALOME_Exception);
/*!
* \brief Store node position on a face
@ -272,34 +273,34 @@ module SMESH
* \param u - U parameter on face where the node is located
* \param v - V parameter on face where the node is located
*/
void SetNodeOnFace(in long NodeID, in long FaceID, in double u, in double v)
void SetNodeOnFace(in smIdType NodeID, in long FaceID, in double u, in double v)
raises (SALOME::SALOME_Exception);
/*!
* \brief Bind a node to a solid
* \param NodeID - node ID
* \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
*/
void SetNodeInVolume(in long NodeID, in long SolidID)
void SetNodeInVolume(in smIdType NodeID, in long SolidID)
raises (SALOME::SALOME_Exception);
/*!
* \brief Bind an element to a shape
* \param ElementID - element ID
* \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
*/
void SetMeshElementOnShape(in long ElementID, in long ShapeID)
void SetMeshElementOnShape(in smIdType ElementID, in long ShapeID)
raises (SALOME::SALOME_Exception);
boolean MoveNode(in long NodeID, in double x, in double y, in double z)
boolean MoveNode(in smIdType NodeID, in double x, in double y, in double z)
raises (SALOME::SALOME_Exception);
boolean InverseDiag(in long NodeID1, in long NodeID2)
boolean InverseDiag(in smIdType NodeID1, in smIdType NodeID2)
raises (SALOME::SALOME_Exception);
boolean DeleteDiag(in long NodeID1, in long NodeID2)
boolean DeleteDiag(in smIdType NodeID1, in smIdType NodeID2)
raises (SALOME::SALOME_Exception);
boolean Reorient(in long_array IDsOfElements)
boolean Reorient(in smIdType_array IDsOfElements)
raises (SALOME::SALOME_Exception);
boolean ReorientObject(in SMESH_IDSource theObject)
@ -337,7 +338,7 @@ module SMESH
* is still performed; theMaxAngle is measured in radians.
* \return \c true in case of success, FALSE otherwise.
*/
boolean TriToQuad (in long_array IDsOfElements,
boolean TriToQuad (in smIdType_array IDsOfElements,
in NumericalFunctor Criterion,
in double MaxAngle) raises (SALOME::SALOME_Exception);
/*!
@ -355,7 +356,7 @@ module SMESH
* \param theCriterion Is used to choose a diagonal for splitting.
* \return TRUE in case of success, FALSE otherwise.
*/
boolean QuadToTri (in long_array IDsOfElements,
boolean QuadToTri (in smIdType_array IDsOfElements,
in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
/*!
* \brief Split quadrangles into triangles.
@ -376,8 +377,8 @@ module SMESH
* \param the13Diag Is used to choose a diagonal for splitting.
* \return TRUE in case of success, FALSE otherwise.
*/
boolean SplitQuad (in long_array IDsOfElements,
in boolean Diag13) raises (SALOME::SALOME_Exception);
boolean SplitQuad (in smIdType_array IDsOfElements,
in boolean Diag13) raises (SALOME::SALOME_Exception);
/*!
* \brief Split quadrangles into triangles.
*
@ -393,7 +394,7 @@ module SMESH
* \return 1 if 1-3 diagonal is better, 2 if 2-4
* diagonal is better, 0 if error occurs.
*/
long BestSplit (in long IDOfQuad,
long BestSplit (in long IDOfQuad,
in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
/*!
@ -443,29 +444,29 @@ module SMESH
enum Smooth_Method { LAPLACIAN_SMOOTH, CENTROIDAL_SMOOTH };
boolean Smooth(in long_array IDsOfElements,
in long_array IDsOfFixedNodes,
in long MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean Smooth(in smIdType_array IDsOfElements,
in smIdType_array IDsOfFixedNodes,
in short MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothObject(in SMESH_IDSource theObject,
in long_array IDsOfFixedNodes,
in long MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothObject(in SMESH_IDSource theObject,
in smIdType_array IDsOfFixedNodes,
in short MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothParametric(in long_array IDsOfElements,
in long_array IDsOfFixedNodes,
in long MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothParametric(in smIdType_array IDsOfElements,
in smIdType_array IDsOfFixedNodes,
in short MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothParametricObject(in SMESH_IDSource theObject,
in long_array IDsOfFixedNodes,
in long MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothParametricObject(in SMESH_IDSource theObject,
in smIdType_array IDsOfFixedNodes,
in short MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
void ConvertToQuadratic(in boolean theForce3d)
raises (SALOME::SALOME_Exception);
@ -561,12 +562,12 @@ module SMESH
* corresponding to groups the input elements included in.
* \return ListOfGroups - new groups created if \a ToMakeGroups is true
*/
ListOfGroups AdvancedExtrusion(in long_array IDsOfElements,
in DirStruct StepVector,
in long NbOfSteps,
in long ExtrFlags,
in double SewTolerance,
in boolean ToMakeGroups)
ListOfGroups AdvancedExtrusion(in smIdType_array IDsOfElements,
in DirStruct StepVector,
in long NbOfSteps,
in long ExtrFlags,
in double SewTolerance,
in boolean ToMakeGroups)
raises (SALOME::SALOME_Exception);
enum Extrusion_Error {
@ -584,7 +585,7 @@ module SMESH
in ListOfIDSources Faces,
in SMESH_IDSource Path,
in GEOM::GEOM_Object PathShape,
in long NodeStart,
in smIdType NodeStart,
in boolean HasAngles,
in double_array Angles,
in boolean AnglesVariation,
@ -610,20 +611,20 @@ module SMESH
enum MirrorType { POINT, AXIS, PLANE };
void Mirror (in long_array IDsOfElements,
in AxisStruct Mirror,
in MirrorType Type,
in boolean Copy)
void Mirror (in smIdType_array IDsOfElements,
in AxisStruct Mirror,
in MirrorType Type,
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups MirrorMakeGroups (in long_array IDsOfElements,
in AxisStruct Mirror,
in MirrorType Type)
ListOfGroups MirrorMakeGroups (in smIdType_array IDsOfElements,
in AxisStruct Mirror,
in MirrorType Type)
raises (SALOME::SALOME_Exception);
SMESH_Mesh MirrorMakeMesh (in long_array IDsOfElements,
in AxisStruct Mirror,
in MirrorType Type,
in boolean CopyGroups,
in string MeshName)
SMESH_Mesh MirrorMakeMesh (in smIdType_array IDsOfElements,
in AxisStruct Mirror,
in MirrorType Type,
in boolean CopyGroups,
in string MeshName)
raises (SALOME::SALOME_Exception);
void MirrorObject (in SMESH_IDSource theObject,
@ -642,17 +643,17 @@ module SMESH
in string MeshName)
raises (SALOME::SALOME_Exception);
void Translate (in long_array IDsOfElements,
in DirStruct Vector,
in boolean Copy)
void Translate (in smIdType_array IDsOfElements,
in DirStruct Vector,
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups TranslateMakeGroups (in long_array IDsOfElements,
in DirStruct Vector)
ListOfGroups TranslateMakeGroups (in smIdType_array IDsOfElements,
in DirStruct Vector)
raises (SALOME::SALOME_Exception);
SMESH_Mesh TranslateMakeMesh (in long_array IDsOfElements,
in DirStruct Vector,
in boolean CopyGroups,
in string MeshName)
SMESH_Mesh TranslateMakeMesh (in smIdType_array IDsOfElements,
in DirStruct Vector,
in boolean CopyGroups,
in string MeshName)
raises (SALOME::SALOME_Exception);
void TranslateObject (in SMESH_IDSource theObject,
@ -684,20 +685,20 @@ module SMESH
in string MeshName)
raises (SALOME::SALOME_Exception);
void Rotate (in long_array IDsOfElements,
in AxisStruct Axis,
in double AngleInRadians,
in boolean Copy)
void Rotate (in smIdType_array IDsOfElements,
in AxisStruct Axis,
in double AngleInRadians,
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups RotateMakeGroups (in long_array IDsOfElements,
in AxisStruct Axis,
in double AngleInRadians)
ListOfGroups RotateMakeGroups (in smIdType_array IDsOfElements,
in AxisStruct Axis,
in double AngleInRadians)
raises (SALOME::SALOME_Exception);
SMESH_Mesh RotateMakeMesh (in long_array IDsOfElements,
in AxisStruct Axis,
in double AngleInRadians,
in boolean CopyGroups,
in string MeshName)
SMESH_Mesh RotateMakeMesh (in smIdType_array IDsOfElements,
in AxisStruct Axis,
in double AngleInRadians,
in boolean CopyGroups,
in string MeshName)
raises (SALOME::SALOME_Exception);
void RotateObject (in SMESH_IDSource theObject,
@ -775,13 +776,13 @@ module SMESH
* If the given ID is a valid node ID (nodeID > 0), just move this node, else
* move the node closest to the point to point's location and return ID of the node
*/
long MoveClosestNodeToPoint(in double x, in double y, in double z, in long nodeID)
smIdType MoveClosestNodeToPoint(in double x, in double y, in double z, in smIdType nodeID)
raises (SALOME::SALOME_Exception);
/*!
* Return ID of node closest to a given point
*/
long FindNodeClosestTo(in double x, in double y, in double z)
smIdType FindNodeClosestTo(in double x, in double y, in double z)
raises (SALOME::SALOME_Exception);
/*!
@ -789,7 +790,7 @@ module SMESH
*
* 'ALL' type means elements of any type excluding nodes and 0D elements
*/
long_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type)
smIdType_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type)
raises (SALOME::SALOME_Exception);
/*!
@ -798,9 +799,9 @@ module SMESH
*
* 'ALL' type means elements of any type excluding nodes and 0D elements
*/
long_array FindAmongElementsByPoint(in SMESH_IDSource elements,
in double x, in double y, in double z,
in ElementType type)
smIdType_array FindAmongElementsByPoint(in SMESH_IDSource elements,
in double x, in double y, in double z,
in ElementType type)
raises (SALOME::SALOME_Exception);
/*!
@ -809,12 +810,12 @@ module SMESH
* and coordinates of the projection point.
* In the case if nothing found, return -1 and []
*/
long ProjectPoint(in double x,
in double y,
in double z,
in ElementType type,
in SMESH_IDSource meshObject,
out double_array projecton)
smIdType ProjectPoint(in double x,
in double y,
in double z,
in ElementType type,
in SMESH_IDSource meshObject,
out double_array projecton)
raises (SALOME::SALOME_Exception);
/*!
@ -844,7 +845,7 @@ module SMESH
* If a group is closed, the first and last nodes of the group are same.
*/
array_of_long_array Get1DBranches( in SMESH_IDSource edges,
in long startNode,
in smIdType startNode,
out array_of_long_array nodeGroups)
raises (SALOME::SALOME_Exception);
@ -898,38 +899,38 @@ module SMESH
SEW_INTERNAL_ERROR
};
Sew_Error SewFreeBorders (in long FirstNodeID1,
in long SecondNodeID1,
in long LastNodeID1,
in long FirstNodeID2,
in long SecondNodeID2,
in long LastNodeID2,
in boolean CreatePolygons,
in boolean CreatePolyedrs)
Sew_Error SewFreeBorders (in smIdType FirstNodeID1,
in smIdType SecondNodeID1,
in smIdType LastNodeID1,
in smIdType FirstNodeID2,
in smIdType SecondNodeID2,
in smIdType LastNodeID2,
in boolean CreatePolygons,
in boolean CreatePolyedrs)
raises (SALOME::SALOME_Exception);
Sew_Error SewConformFreeBorders (in long FirstNodeID1,
in long SecondNodeID1,
in long LastNodeID1,
in long FirstNodeID2,
in long SecondNodeID2)
Sew_Error SewConformFreeBorders (in smIdType FirstNodeID1,
in smIdType SecondNodeID1,
in smIdType LastNodeID1,
in smIdType FirstNodeID2,
in smIdType SecondNodeID2)
raises (SALOME::SALOME_Exception);
Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder,
in long SecondNodeIDOnFreeBorder,
in long LastNodeIDOnFreeBorder,
in long FirstNodeIDOnSide,
in long LastNodeIDOnSide,
in boolean CreatePolygons,
in boolean CreatePolyedrs)
Sew_Error SewBorderToSide (in smIdType FirstNodeIDOnFreeBorder,
in smIdType SecondNodeIDOnFreeBorder,
in smIdType LastNodeIDOnFreeBorder,
in smIdType FirstNodeIDOnSide,
in smIdType LastNodeIDOnSide,
in boolean CreatePolygons,
in boolean CreatePolyedrs)
raises (SALOME::SALOME_Exception);
Sew_Error SewSideElements (in long_array IDsOfSide1Elements,
in long_array IDsOfSide2Elements,
in long NodeID1OfSide1ToMerge,
in long NodeID1OfSide2ToMerge,
in long NodeID2OfSide1ToMerge,
in long NodeID2OfSide2ToMerge)
Sew_Error SewSideElements (in smIdType_array IDsOfSide1Elements,
in smIdType_array IDsOfSide2Elements,
in smIdType NodeID1OfSide1ToMerge,
in smIdType NodeID1OfSide2ToMerge,
in smIdType NodeID2OfSide1ToMerge,
in smIdType NodeID2OfSide2ToMerge)
raises (SALOME::SALOME_Exception);
/*!
@ -937,7 +938,7 @@ module SMESH
* If number of nodes is not corresponded to type of
* element - returns false
*/
boolean ChangeElemNodes(in long ide, in long_array newIDs)
boolean ChangeElemNodes(in smIdType id, in smIdType_array newIDs)
raises (SALOME::SALOME_Exception);
/*!
@ -965,7 +966,7 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
*/
boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems )
boolean DoubleNodes( in smIdType_array theNodes, in smIdType_array theModifiedElems )
raises (SALOME::SALOME_Exception);
/*!
@ -976,7 +977,7 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
*/
boolean DoubleNode( in long theNodeId, in long_array theModifiedElems )
boolean DoubleNode( in smIdType theNodeId, in smIdType_array theModifiedElems )
raises (SALOME::SALOME_Exception);
/*!
@ -1037,9 +1038,9 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodeGroups()
*/
boolean DoubleNodeElem( in long_array theElems,
in long_array theNodesNot,
in long_array theAffectedElems )
boolean DoubleNodeElem( in smIdType_array theElems,
in smIdType_array theNodesNot,
in smIdType_array theAffectedElems )
raises (SALOME::SALOME_Exception);
/*!
@ -1053,8 +1054,8 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
*/
boolean DoubleNodeElemInRegion( in long_array theElems,
in long_array theNodesNot,
boolean DoubleNodeElemInRegion( in smIdType_array theElems,
in smIdType_array theNodesNot,
in GEOM::GEOM_Object theShape )
raises (SALOME::SALOME_Exception);

17
idl/SMESH_Pattern.idl
View File

@ -29,6 +29,7 @@
#define _SMESH_PATTERN_IDL_
#include "SMESH_Mesh.idl"
#include "SMESH_smIdType.idl"
module SMESH
{
@ -85,10 +86,10 @@ module SMESH
* the loaded pattern to mesh faces. The first key-point
* will be mapped into <theNodeIndexOnKeyPoint1>-th node of each face
*/
point_array ApplyToMeshFaces(in SMESH_Mesh theMesh,
in long_array theFacesIDs,
in long theNodeIndexOnKeyPoint1,
in boolean theReverse);
point_array ApplyToMeshFaces(in SMESH_Mesh theMesh,
in smIdType_array theFacesIDs,
in short theNodeIndexOnKeyPoint1,
in boolean theReverse);
/*!
* Compute nodes coordinates applying
@ -97,10 +98,10 @@ module SMESH
* The (0,0,1) key-point will be mapped into <theNode001Index>-th
* node of each volume.
*/
point_array ApplyToHexahedrons(in SMESH_Mesh theMesh,
in long_array theVolumesIDs,
in long theNode000Index,
in long theNode001Index);
point_array ApplyToHexahedrons(in SMESH_Mesh theMesh,
in smIdType_array theVolumesIDs,
in short theNode000Index,
in short theNode001Index);
/*!
* Create nodes and elements in <theMesh> using nodes

28
idl/SMESH_smIdType.idl.in Normal file
View File

@ -0,0 +1,28 @@
// 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

118
src/Controls/SMESH_Controls.cxx
View File

@ -34,6 +34,7 @@
#include "SMESHDS_Mesh.hxx"
#include "SMESH_MeshAlgos.hxx"
#include "SMESH_OctreeNode.hxx"
#include "SMESH_Comment.hxx"
#include <GEOMUtils.hxx>
#include <Basics_Utils.hxx>
@ -127,7 +128,7 @@ namespace {
return aDist;
}
int getNbMultiConnection( const SMDS_Mesh* theMesh, const int theId )
int getNbMultiConnection( const SMDS_Mesh* theMesh, const smIdType theId )
{
if ( theMesh == 0 )
return 0;
@ -225,7 +226,7 @@ void NumericalFunctor::SetMesh( const SMDS_Mesh* theMesh )
myMesh = theMesh;
}
bool NumericalFunctor::GetPoints(const int theId,
bool NumericalFunctor::GetPoints(const smIdType theId,
TSequenceOfXYZ& theRes ) const
{
theRes.clear();
@ -322,12 +323,12 @@ bool NumericalFunctor::IsApplicable( long theElementId ) const
*/
//================================================================================
void NumericalFunctor::GetHistogram(int nbIntervals,
std::vector<int>& nbEvents,
std::vector<double>& funValues,
const std::vector<int>& elements,
const double* minmax,
const bool isLogarithmic)
void NumericalFunctor::GetHistogram(int nbIntervals,
std::vector<int>& nbEvents,
std::vector<double>& funValues,
const std::vector<smIdType>& elements,
const double* minmax,
const bool isLogarithmic)
{
if ( nbIntervals < 1 ||
!myMesh ||
@ -346,7 +347,7 @@ void NumericalFunctor::GetHistogram(int nbIntervals,
}
else
{
std::vector<int>::const_iterator id = elements.begin();
std::vector<smIdType>::const_iterator id = elements.begin();
for ( ; id != elements.end(); ++id )
values.insert( GetValue( *id ));
}
@ -1971,7 +1972,7 @@ void Length2D::GetValues(TValues& theValues)
{
// use special nodes iterator
SMDS_NodeIteratorPtr anIter = anElem->interlacedNodesIterator();
long aNodeId[4] = { 0,0,0,0 };
smIdType aNodeId[4] = { 0,0,0,0 };
gp_Pnt P[4];
double aLength = 0;
@ -2008,7 +2009,7 @@ void Length2D::GetValues(TValues& theValues)
}
else {
SMDS_NodeIteratorPtr aNodesIter = anElem->nodeIterator();
long aNodeId[2] = {0,0};
smIdType aNodeId[2] = {0,0};
gp_Pnt P[3];
double aLength;
@ -2023,7 +2024,7 @@ void Length2D::GetValues(TValues& theValues)
for( ; aNodesIter->more(); )
{
aNode = aNodesIter->next();
long anId = aNode->GetID();
smIdType anId = aNode->GetID();
P[2] = SMESH_NodeXYZ( aNode );
@ -2192,7 +2193,7 @@ double MultiConnection2D::GetValue( long theElementId )
if (!anIter) break;
const SMDS_MeshNode *aNode, *aNode0 = 0;
TColStd_MapOfInteger aMap, aMapPrev;
NCollection_Map< smIdType, smIdHasher > aMap, aMapPrev;
for (i = 0; i <= len; i++) {
aMapPrev = aMap;
@ -2214,7 +2215,7 @@ double MultiConnection2D::GetValue( long theElementId )
while (anElemIter->more()) {
const SMDS_MeshElement* anElem = anElemIter->next();
if (anElem != 0 && anElem->GetType() == SMDSAbs_Face) {
int anId = anElem->GetID();
smIdType anId = anElem->GetID();
aMap.Add(anId);
if (aMapPrev.Contains(anId)) {
@ -2675,14 +2676,14 @@ void FreeEdges::SetMesh( const SMDS_Mesh* theMesh )
myMesh = theMesh;
}
bool FreeEdges::IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId )
bool FreeEdges::IsFreeEdge( const SMDS_MeshNode** theNodes, const smIdType theFaceId )
{
SMDS_ElemIteratorPtr anElemIter = theNodes[ 0 ]->GetInverseElementIterator(SMDSAbs_Face);
while( anElemIter->more() )
{
if ( const SMDS_MeshElement* anElem = anElemIter->next())
{
const int anId = anElem->GetID();
const smIdType anId = anElem->GetID();
if ( anId != theFaceId && anElem->GetNodeIndex( theNodes[1] ) >= 0 )
return false;
}
@ -2967,8 +2968,8 @@ void GroupColor::SetMesh( const SMDS_Mesh* theMesh )
SMDSAbs_ElementType aGrpElType = (SMDSAbs_ElementType)aGrp->GetType();
if ( myType == aGrpElType || (myType == SMDSAbs_All && aGrpElType != SMDSAbs_Node) ) {
// add elements IDS into control
int aSize = aGrp->Extent();
for (int i = 0; i < aSize; i++)
smIdType aSize = aGrp->Extent();
for (smIdType i = 0; i < aSize; i++)
myIDs.insert( aGrp->GetID(i+1) );
}
}
@ -3119,7 +3120,7 @@ ConnectedElements::ConnectedElements():
SMDSAbs_ElementType ConnectedElements::GetType() const
{ return myType; }
int ConnectedElements::GetNode() const
smIdType ConnectedElements::GetNode() const
{ return myXYZ.empty() ? myNodeID : 0; } // myNodeID can be found by myXYZ
std::vector<double> ConnectedElements::GetPoint() const
@ -3146,7 +3147,7 @@ void ConnectedElements::SetMesh( const SMDS_Mesh* theMesh )
}
}
void ConnectedElements::SetNode( int nodeID )
void ConnectedElements::SetNode( smIdType nodeID )
{
myNodeID = nodeID;
myXYZ.clear();
@ -3206,7 +3207,7 @@ bool ConnectedElements::IsSatisfy( long theElementId )
return false;
std::list< const SMDS_MeshNode* > nodeQueue( 1, node0 );
std::set< int > checkedNodeIDs;
std::set< smIdType > checkedNodeIDs;
// algo:
// foreach node in nodeQueue:
// foreach element sharing a node:
@ -3231,7 +3232,7 @@ bool ConnectedElements::IsSatisfy( long theElementId )
while ( nIt->more() )
{
const SMDS_MeshNode* n = static_cast< const SMDS_MeshNode* >( nIt->next() );
if ( checkedNodeIDs.insert( n->GetID() ).second )
if ( checkedNodeIDs.insert( n->GetID()).second )
nodeQueue.push_back( n );
}
}
@ -3378,56 +3379,56 @@ void RangeOfIds::GetRangeStr( TCollection_AsciiString& theResStr )
{
theResStr.Clear();
TColStd_SequenceOfInteger anIntSeq;
TColStd_SequenceOfAsciiString aStrSeq;
TIDsSeq anIntSeq;
NCollection_Sequence< std::string > aStrSeq;
TColStd_MapIteratorOfMapOfInteger anIter( myIds );
TIDsMap::Iterator anIter( myIds );
for ( ; anIter.More(); anIter.Next() )
{
int anId = anIter.Key();
TCollection_AsciiString aStr( anId );
smIdType anId = anIter.Key();
SMESH_Comment aStr( anId );
anIntSeq.Append( anId );
aStrSeq.Append( aStr );
}
for ( int i = 1, n = myMin.Length(); i <= n; i++ )
for ( smIdType i = 1, n = myMin.size(); i <= n; i++ )
{
int aMinId = myMin( i );
int aMaxId = myMax( i );
smIdType aMinId = myMin[i];
smIdType aMaxId = myMax[i];
TCollection_AsciiString aStr;
SMESH_Comment aStr;
if ( aMinId != IntegerFirst() )
aStr += aMinId;
aStr << aMinId;
aStr += "-";
aStr << "-";
if ( aMaxId != IntegerLast() )
aStr += aMaxId;
if ( aMaxId != std::numeric_limits<smIdType>::max() )
aStr << aMaxId;
// find position of the string in result sequence and insert string in it
if ( anIntSeq.Length() == 0 )
{
anIntSeq.Append( aMinId );
aStrSeq.Append( aStr );
aStrSeq.Append( (const char*)aStr );
}
else
{
if ( aMinId < anIntSeq.First() )
{
anIntSeq.Prepend( aMinId );
aStrSeq.Prepend( aStr );
aStrSeq.Prepend( (const char*)aStr );
}
else if ( aMinId > anIntSeq.Last() )
{
anIntSeq.Append( aMinId );
aStrSeq.Append( aStr );
aStrSeq.Append( (const char*)aStr );
}
else
for ( int j = 1, k = anIntSeq.Length(); j <= k; j++ )
if ( aMinId < anIntSeq( j ) )
{
anIntSeq.InsertBefore( j, aMinId );
aStrSeq.InsertBefore( j, aStr );
aStrSeq.InsertBefore( j, (const char*)aStr );
break;
}
}
@ -3435,13 +3436,14 @@ void RangeOfIds::GetRangeStr( TCollection_AsciiString& theResStr )
if ( aStrSeq.Length() == 0 )
return;
theResStr = aStrSeq( 1 );
std::string aResStr;
aResStr = aStrSeq( 1 );
for ( int j = 2, k = aStrSeq.Length(); j <= k; j++ )
{
theResStr += ",";
theResStr += aStrSeq( j );
aResStr += ",";
aResStr += aStrSeq( j );
}
theResStr = aResStr.c_str();
}
//=======================================================================
@ -3451,8 +3453,8 @@ void RangeOfIds::GetRangeStr( TCollection_AsciiString& theResStr )
//=======================================================================
bool RangeOfIds::SetRangeStr( const TCollection_AsciiString& theStr )
{
myMin.Clear();
myMax.Clear();
myMin.clear();
myMax.clear();
myIds.Clear();
TCollection_AsciiString aStr = theStr;
@ -3490,8 +3492,8 @@ bool RangeOfIds::SetRangeStr( const TCollection_AsciiString& theStr )
(!aMaxStr.IsEmpty() && !aMaxStr.IsIntegerValue()) )
return false;
myMin.Append( aMinStr.IsEmpty() ? IntegerFirst() : aMinStr.IntegerValue() );
myMax.Append( aMaxStr.IsEmpty() ? IntegerLast() : aMaxStr.IntegerValue() );
myMin.push_back( aMinStr.IsEmpty() ? IntegerFirst() : aMinStr.IntegerValue() );
myMax.push_back( aMaxStr.IsEmpty() ? IntegerLast() : aMaxStr.IntegerValue() );
}
}
@ -3540,8 +3542,8 @@ bool RangeOfIds::IsSatisfy( long theId )
if ( myIds.Contains( theId ) )
return true;
for ( int i = 1, n = myMin.Length(); i <= n; i++ )
if ( theId >= myMin( i ) && theId <= myMax( i ) )
for ( size_t i = 0; i < myMin.size(); i++ )
if ( theId >= myMin[i] && theId <= myMax[i] )
return true;
return false;
@ -3917,7 +3919,7 @@ bool ManifoldPart::process()
// the map of non manifold links and bad geometry
TMapOfLink aMapOfNonManifold;
TColStd_MapOfInteger aMapOfTreated;
TIDsMap aMapOfTreated;
// begin cycle on faces from start index and run on vector till the end
// and from begin to start index to cover whole vector
@ -3930,18 +3932,18 @@ bool ManifoldPart::process()
// as result next time when fi will be equal to aStartIndx
SMDS_MeshFace* aFacePtr = myAllFacePtr[ fi ];
if ( aMapOfTreated.Contains( aFacePtr->GetID() ) )
if ( aMapOfTreated.Contains( aFacePtr->GetID()) )
continue;
aMapOfTreated.Add( aFacePtr->GetID() );
TColStd_MapOfInteger aResFaces;
TIDsMap aResFaces;
if ( !findConnected( myAllFacePtrIntDMap, aFacePtr,
aMapOfNonManifold, aResFaces ) )
continue;
TColStd_MapIteratorOfMapOfInteger anItr( aResFaces );
TIDsMap::Iterator anItr( aResFaces );
for ( ; anItr.More(); anItr.Next() )
{
int aFaceId = anItr.Key();
smIdType aFaceId = anItr.Key();
aMapOfTreated.Add( aFaceId );
myMapIds.Add( aFaceId );
}
@ -3977,7 +3979,7 @@ bool ManifoldPart::findConnected
( const ManifoldPart::TDataMapFacePtrInt& theAllFacePtrInt,
SMDS_MeshFace* theStartFace,
ManifoldPart::TMapOfLink& theNonManifold,
TColStd_MapOfInteger& theResFaces )
TIDsMap& theResFaces )
{
theResFaces.Clear();
if ( !theAllFacePtrInt.size() )
@ -4045,7 +4047,7 @@ bool ManifoldPart::findConnected
SMDS_MeshFace* aNextFace = *pFace;
if ( aPrevFace == aNextFace )
continue;
int anNextFaceID = aNextFace->GetID();
smIdType anNextFaceID = aNextFace->GetID();
if ( myIsOnlyManifold && theResFaces.Contains( anNextFaceID ) )
// should not be with non manifold restriction. probably bad topology
continue;
@ -4276,7 +4278,9 @@ void ElementsOnSurface::process()
if ( !myMeshModifTracer.GetMesh() )
return;
myIds.ReSize( myMeshModifTracer.GetMesh()->GetMeshInfo().NbElements( myType ));
int nbElems = FromSmIdType<int>( myMeshModifTracer.GetMesh()->GetMeshInfo().NbElements( myType ));
if ( nbElems > 0 )
myIds.ReSize( nbElems );
SMDS_ElemIteratorPtr anIter = myMeshModifTracer.GetMesh()->elementsIterator( myType );
for(; anIter->more(); )

51
src/Controls/SMESH_ControlsDef.hxx
View File

@ -32,8 +32,8 @@
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <Quantity_Color.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <TCollection_AsciiString.hxx>
#include <NCollection_Map.hxx>
#include <TopAbs.hxx>
#include <TopoDS_Face.hxx>
#include <gp_XYZ.hxx>
@ -58,6 +58,9 @@ class ShapeAnalysis_Surface;
class gp_Pln;
class gp_Pnt;
typedef NCollection_Map< smIdType, smIdHasher > TIDsMap;
typedef NCollection_Sequence<smIdType> TIDsSeq;
namespace SMESH{
namespace Controls{
@ -130,12 +133,12 @@ namespace SMESH{
virtual void SetMesh( const SMDS_Mesh* theMesh );
virtual double GetValue( long theElementId );
virtual double GetValue(const TSequenceOfXYZ& /*thePoints*/) { return -1.0;};
void GetHistogram(int nbIntervals,
std::vector<int>& nbEvents,
std::vector<double>& funValues,
const std::vector<int>& elements,
const double* minmax=0,
const bool isLogarithmic = false);
void GetHistogram(int nbIntervals,
std::vector<int>& nbEvents,
std::vector<double>& funValues,
const std::vector<smIdType>& elements,
const double* minmax=0,
const bool isLogarithmic = false);
bool IsApplicable( long theElementId ) const;
virtual bool IsApplicable( const SMDS_MeshElement* element ) const;
virtual SMDSAbs_ElementType GetType() const = 0;
@ -144,7 +147,7 @@ namespace SMESH{
void SetPrecision( const long thePrecision );
double Round( const double & value );
bool GetPoints(const int theId, TSequenceOfXYZ& theRes) const;
bool GetPoints(const smIdType theId, TSequenceOfXYZ& theRes) const;
static bool GetPoints(const SMDS_MeshElement* theElem, TSequenceOfXYZ& theRes);
protected:
const SMDS_Mesh* myMesh;
@ -423,9 +426,9 @@ namespace SMESH{
double GetTolerance () const { return myToler; }
private:
double myToler;
TColStd_MapOfInteger myCoincidentIDs;
TMeshModifTracer myMeshModifTracer;
double myToler;
TIDsMap myCoincidentIDs;
TMeshModifTracer myMeshModifTracer;
};
typedef boost::shared_ptr<CoincidentNodes> CoincidentNodesPtr;
@ -591,7 +594,7 @@ namespace SMESH{
virtual void SetMesh( const SMDS_Mesh* theMesh );
virtual bool IsSatisfy( long theElementId );
virtual SMDSAbs_ElementType GetType() const;
static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId );
static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const smIdType theFaceId );
typedef long TElemId;
struct Border{
TElemId myElemId;
@ -650,9 +653,9 @@ namespace SMESH{
protected:
const SMDS_Mesh* myMesh;
TColStd_SequenceOfInteger myMin;
TColStd_SequenceOfInteger myMax;
TColStd_MapOfInteger myIds;
std::vector< smIdType > myMin;
std::vector< smIdType > myMax;
TIDsMap myIds;
SMDSAbs_ElementType myType;
};
@ -833,7 +836,7 @@ namespace SMESH{
bool findConnected( const TDataMapFacePtrInt& theAllFacePtrInt,
SMDS_MeshFace* theStartFace,
TMapOfLink& theNonManifold,
TColStd_MapOfInteger& theResFaces );
TIDsMap& theResFaces );
bool isInPlane( const SMDS_MeshFace* theFace1,
const SMDS_MeshFace* theFace2 );
void expandBoundary( TMapOfLink& theMapOfBoundary,
@ -847,8 +850,8 @@ namespace SMESH{
private:
const SMDS_Mesh* myMesh;
TColStd_MapOfInteger myMapIds;
TColStd_MapOfInteger myMapBadGeomIds;
TIDsMap myMapIds;
TIDsMap myMapBadGeomIds;
TVectorOfFacePtr myAllFacePtr;
TDataMapFacePtrInt myAllFacePtrIntDMap;
double myAngToler;
@ -909,7 +912,7 @@ namespace SMESH{
private:
TMeshModifTracer myMeshModifTracer;
TColStd_MapOfInteger myIds;
TIDsMap myIds;
SMDSAbs_ElementType myType;
TopoDS_Face mySurf;
double myToler;
@ -1149,7 +1152,7 @@ namespace SMESH{
TMeshModifTracer myMeshModifTracer;
long myFaceID;
double myToler;
TColStd_MapOfInteger myCoplanarIDs;
TIDsMap myCoplanarIDs;
};
typedef boost::shared_ptr<CoplanarFaces> CoplanarFacesPtr;
@ -1162,9 +1165,9 @@ namespace SMESH{
public:
ConnectedElements();
//virtual Predicate* clone() const { return new ConnectedElements( *this ); }
void SetNode( int nodeID );
void SetNode( smIdType nodeID );
void SetPoint( double x, double y, double z );
int GetNode() const;
smIdType GetNode() const;
std::vector<double> GetPoint() const;
void SetType( SMDSAbs_ElementType theType );
@ -1176,14 +1179,14 @@ namespace SMESH{
//const std::set<long>& GetDomainIDs() const { return myOkIDs; }
private:
int myNodeID;
smIdType myNodeID;
std::vector<double> myXYZ;
SMDSAbs_ElementType myType;
TMeshModifTracer myMeshModifTracer;
void clearOkIDs();
bool myOkIDsReady;
std::set< int > myOkIDs; // empty means that there is one domain
std::set<smIdType> myOkIDs; // empty means that there is one domain
};
typedef boost::shared_ptr<ConnectedElements> ConnectedElementsPtr;

28
src/Driver/Driver_Mesh.h
View File

@ -28,6 +28,7 @@
#define _INCLUDE_DRIVER_MESH
#include "SMESH_ComputeError.hxx"
#include "SMDS_Mesh.hxx"
#include <string>
#include <vector>
@ -50,12 +51,13 @@ class MESHDRIVER_EXPORT Driver_Mesh
enum Status {
DRS_OK,
DRS_EMPTY, // a file contains no mesh with the given name
DRS_WARN_RENUMBER, // a file has overlapped ranges of element numbers,
// so the numbers from the file are ignored
DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
DRS_EMPTY, // a file contains no mesh with the given name
DRS_WARN_RENUMBER, // a file has overlapped ranges of element numbers,
// so the numbers from the file are ignored
DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
DRS_WARN_DESCENDING, // some elements were skipped due to descending connectivity
DRS_FAIL // general failure (exception etc.)
DRS_FAIL, // general failure (exception etc.)
DRS_TOO_LARGE_MESH // mesh is too large for export
};
void SetMeshId(int theMeshId);
@ -70,6 +72,22 @@ class MESHDRIVER_EXPORT Driver_Mesh
virtual SMESH_ComputeErrorPtr GetError();
//virtual bool CanExportMesh() const { return false; } //= 0;
// check if a mesh is too large to export it using IDTYPE;
// check either max ID or number of elements
template< typename IDTYPE >
static bool IsMeshTooLarge( const SMDS_Mesh* mesh, bool checkIDs )
{
if ( sizeof( IDTYPE ) < sizeof( smIdType ))
{
const smIdType maxNB = std::numeric_limits< IDTYPE >::max();
return (( checkIDs ? mesh->MaxNodeID() : mesh->NbNodes() ) > maxNB ||
( checkIDs ? mesh->MaxElementID() : mesh->NbElements() > maxNB ));
}
return false;
}
protected:
std::string myFile;
std::string myMeshName;

24
src/DriverCGNS/DriverCGNS_Read.cxx
View File

@ -33,6 +33,8 @@
#include "SMESH_Comment.hxx"
#include "SMESH_TypeDefs.hxx"
#include <smIdType.hxx>
#include <gp_XYZ.hxx>
#include <cgnslib.h>
@ -59,9 +61,9 @@ namespace
struct TZoneData
{
int _id;
int _nodeIdShift; // nb nodes in previously read zones
int _elemIdShift; // nb faces in previously read zones
int _nbNodes, _nbElems;
smIdType _nodeIdShift; // nb nodes in previously read zones
smIdType _elemIdShift; // nb faces in previously read zones
smIdType _nbNodes, _nbElems;
int _meshDim;
int _sizeX, _sizeY, _sizeZ, _nbCells; // structured
cgsize_t _sizes[NB_ZONE_SIZE_VAL];
@ -550,10 +552,10 @@ namespace
nbNodes = ids[0];
++ids;
#endif
vector<int> idVec( nbNodes );
vector<smIdType> idVec( nbNodes );
for ( int i = 0; i < nbNodes; ++i )
idVec[ i ] = (int) ids[ i ];
return mesh->AddPolygonalFaceWithID( idVec, ID );
idVec[ i ] = ToSmIdType( ids[ i ]);
return mesh->AddPolygonalFaceWithID( idVec, ToSmIdType(ID) );
}
typedef SMDS_MeshElement* (* PAddElemFun) (cgsize_t* ids, SMESHDS_Mesh* mesh, int ID);
@ -890,6 +892,8 @@ Driver_Mesh::Status DriverCGNS_Read::Perform()
curAddElemFun = addElemFuns[ elemType ];
SMDS_MeshElement* newElem = 0;
const SMDS_MeshElement* face;
vector<int> quantities;
vector<const SMDS_MeshNode*> nodes, faceNodes;
while ( pos < eDataSize )
{
@ -921,9 +925,8 @@ Driver_Mesh::Status DriverCGNS_Read::Perform()
// Face1M, Face2M, ... FaceNM
nbFaces = polyOffset[ iElem + 1 ] - polyOffset[ iElem ];
vector<int> quantities( nbFaces );
vector<const SMDS_MeshNode*> nodes, faceNodes;
nodes.reserve( nbFaces * 4 );
quantities.resize( nbFaces ); quantities.back() = 0;
nodes.clear(); nodes.reserve( nbFaces * 4 );
for ( int iF = 0; iF < nbFaces; ++iF )
{
const int faceID = std::abs( elemData[ pos++ ]) + zone._elemIdShift;
@ -945,6 +948,7 @@ Driver_Mesh::Status DriverCGNS_Read::Perform()
}
else {
polyhedError = true;
pos += nbFaces - iF - 1;
break;
}
}
@ -1172,7 +1176,7 @@ Driver_Mesh::Status DriverCGNS_Read::Perform()
case 2: addElemFun = & add_QUAD_4; break;
case 3: addElemFun = & add_HEXA_8; break;
}
int elemID = meshInfo.NbElements();
smIdType elemID = meshInfo.NbElements();
const SMDS_MeshElement* elem = 0;
for ( size_t i = 0; i < ids.size(); i += nbElemNodes )
{

23
src/DriverCGNS/DriverCGNS_Write.cxx
View File

@ -201,17 +201,17 @@ namespace
*/
struct TPolyhedFace
{
int _id; // id of NGON_n
vector< int > _nodes; // lowest node IDs used for sorting
smIdType _id; // id of NGON_n
vector< smIdType > _nodes; // lowest node IDs used for sorting
TPolyhedFace( const SMDS_MeshNode** nodes, const int nbNodes, int ID):_id(ID)
TPolyhedFace( const SMDS_MeshNode** nodes, const smIdType nbNodes, smIdType ID):_id(ID)
{
set< int > ids;
for ( int i = 0; i < nbNodes; ++i )
set< smIdType > ids;
for ( smIdType i = 0; i < nbNodes; ++i )
ids.insert( nodes[i]->GetID() );
_nodes.resize( 3 ); // std::min( nbNodes, 4 )); hope 3 nodes is enough
set< int >::iterator idIt = ids.begin();
set< smIdType >::iterator idIt = ids.begin();
for ( size_t j = 0; j < _nodes.size(); ++j, ++idIt )
_nodes[j] = *idIt;
}
@ -267,6 +267,9 @@ Driver_Mesh::Status DriverCGNS_Write::Perform()
if ( !myMesh || myMesh->GetMeshInfo().NbElements() < 1 )
return addMessage( !myMesh ? "NULL mesh" : "Empty mesh (no elements)", /*fatal = */true );
if ( Driver_Mesh::IsMeshTooLarge< cgsize_t >( myMesh, /*checkIDs =*/ false))
return DRS_TOO_LARGE_MESH;
// open the file
if ( cg_open(myFile.c_str(), CG_MODE_MODIFY, &_fn) != CG_OK &&
cg_open(myFile.c_str(), CG_MODE_WRITE, &_fn) != CG_OK )
@ -295,13 +298,15 @@ Driver_Mesh::Status DriverCGNS_Write::Perform()
// create a Zone
// --------------
int nbCells = myMesh->NbEdges();
smIdType nbCells = myMesh->NbEdges();
if ( meshDim == 3 )
nbCells = myMesh->NbVolumes();
else if ( meshDim == 2 )
nbCells = myMesh->NbFaces();
cgsize_t size[9] = { myMesh->NbNodes(), nbCells, /*NBoundVertex=*/0, 0,0,0,0,0,0 };
cgsize_t size[9] = { FromSmIdType<cgsize_t>( myMesh->NbNodes() ),
FromSmIdType<cgsize_t>( nbCells ),
/*NBoundVertex=*/0, 0,0,0,0,0,0 };
int iZone;
if ( cg_zone_write( _fn, iBase, "SMESH_Mesh", size,
CGNS_ENUMV( Unstructured ), &iZone) != CG_OK )
@ -469,7 +474,7 @@ Driver_Mesh::Status DriverCGNS_Write::Perform()
cgID-1, /*nbndry=*/0, elemData.data(), &iSec) != CG_OK )
return addMessage( cg_get_error(), /*fatal = */true );
}
}
} // while ( elem )
// Write polyhedral volumes
// -------------------------

2
src/DriverDAT/DriverDAT_R_SMDS_Mesh.cxx
View File

@ -76,7 +76,7 @@ Driver_Mesh::Status DriverDAT_R_SMDS_Mesh::Perform()
myMesh->AddNodeWithID(coordX, coordY, coordZ, intNumPoint);
}
fprintf(stdout, "%d noeuds\n", myMesh->NbNodes());
fprintf(stdout, "%ld noeuds\n", myMesh->NbNodes());
/****************************************************************************
* LECTURE DES ELEMENTS *
****************************************************************************/

18
src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
View File

@ -37,7 +37,7 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
Kernel_Utils::Localizer loc;
Status aResult = DRS_OK;
int nbNodes, nbCells;
smIdType nbNodes, nbCells;
#if defined(WIN32) && defined(UNICODE)
std::wstring file2Read = Kernel_Utils::utf8_decode_s(myFile);
FILE* aFileId = _wfopen(file2Read.c_str(), L"w+");
@ -60,7 +60,7 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
nbNodes = myMesh->NbNodes();
/* Combien de mailles, faces ou aretes ? */
int nb_of_edges, nb_of_faces, nb_of_volumes;
smIdType nb_of_edges, nb_of_faces, nb_of_volumes;
nb_of_edges = myMesh->NbEdges();
nb_of_faces = myMesh->NbFaces();
nb_of_volumes = myMesh->NbVolumes();
@ -70,7 +70,7 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
SCRUTE(nb_of_volumes);
//fprintf(stdout, "%d %d\n", nbNodes, nbCells);
fprintf(aFileId, "%d %d\n", nbNodes, nbCells);
fprintf(aFileId, "%ld %ld\n", nbNodes, nbCells);
/****************************************************************************
* ECRITURE DES NOEUDS *
@ -104,10 +104,10 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
for ( SMDS_ElemIteratorPtr it = elem->nodesIterator(); it->more(); )
{
int nodeID = it->next()->GetID();
smIdType nodeID = it->next()->GetID();
if ( !nodeNumByID.empty() )
nodeID = nodeNumByID[ nodeID ];
fprintf(aFileId, "%d ", nodeID );
fprintf(aFileId, "%ld ", nodeID );
}
fprintf(aFileId, "\n");
}
@ -120,10 +120,10 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
for( SMDS_ElemIteratorPtr it = elem->nodesIterator(); it->more(); )
{
int nodeID = it->next()->GetID();
smIdType nodeID = it->next()->GetID();
if ( !nodeNumByID.empty() )
nodeID = nodeNumByID[ nodeID ];
fprintf(aFileId, "%d ", nodeID );
fprintf(aFileId, "%ld ", nodeID );
}
fprintf(aFileId, "\n");
}
@ -155,10 +155,10 @@ Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
for( SMDS_ElemIteratorPtr it = elem->nodesIterator(); it->more(); )
{
int nodeID = it->next()->GetID();
smIdType nodeID = it->next()->GetID();
if ( !nodeNumByID.empty() )
nodeID = nodeNumByID[ nodeID ];
fprintf(aFileId, "%d ", nodeID );
fprintf(aFileId, "%ld ", nodeID );
}
fprintf(aFileId, "\n");

68
src/DriverGMF/DriverGMF_Read.cxx
View File

@ -89,7 +89,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
int ref;
const int nodeIDShift = myMesh->GetMeshInfo().NbNodes();
const smIdType nodeIDShift = myMesh->GetMeshInfo().NbNodes();
if ( version != GmfFloat )
{
double x, y, z;
@ -114,7 +114,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
int iN[28]; // 28 - nb nodes in HEX27 (+ 1 for safety :)
/* Read edges */
const int edgeIDShift = myMesh->GetMeshInfo().NbElements();
const smIdType edgeIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbEdges = GmfStatKwd(meshID, GmfEdges))
{
// read extra vertices for quadratic edges
@ -150,7 +150,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
}
/* Read triangles */
const int triaIDShift = myMesh->GetMeshInfo().NbElements();
const smIdType triaIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbTria = GmfStatKwd(meshID, GmfTriangles))
{
// read extra vertices for quadratic triangles
@ -194,7 +194,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
}
/* Read quadrangles */
const int quadIDShift = myMesh->GetMeshInfo().NbElements();
const smIdType quadIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbQuad = GmfStatKwd(meshID, GmfQuadrilaterals))
{
// read extra vertices for quadratic quadrangles
@ -248,7 +248,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
}
/* Read terahedra */
const int tetIDShift = myMesh->GetMeshInfo().NbElements();
const smIdType tetIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbTet = GmfStatKwd( meshID, GmfTetrahedra ))
{
// read extra vertices for quadratic tetrahedra
@ -293,7 +293,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
}
/* Read pyramids */
const int pyrIDShift = myMesh->GetMeshInfo().NbElements();
const smIdType pyrIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbPyr = GmfStatKwd(meshID, GmfPyramids))
{
GmfGotoKwd(meshID, GmfPyramids);
@ -306,7 +306,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
}
/* Read hexahedra */
const int hexIDShift = myMesh->GetMeshInfo().NbElements();
const smIdType hexIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbHex = GmfStatKwd(meshID, GmfHexahedra))
{
// read extra vertices for quadratic hexahedra
@ -389,7 +389,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
}
/* Read prism */
const int prismIDShift = myMesh->GetMeshInfo().NbElements();
const smIdType prismIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbPrism = GmfStatKwd(meshID, GmfPrisms))
{
GmfGotoKwd(meshID, GmfPrisms);
@ -405,33 +405,33 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
// Read some entities into groups
// see MeshGems/Docs/meshgems_formats_description.pdf
// get ids of existing groups
std::set< int > groupIDs;
const std::set<SMESHDS_GroupBase*>& groups = myMesh->GetGroups();
std::set<SMESHDS_GroupBase*>::const_iterator grIter = groups.begin();
for ( ; grIter != groups.end(); ++grIter )
groupIDs.insert( (*grIter)->GetID() );
if ( groupIDs.empty() ) groupIDs.insert( 0 );
// get ids of existing groups
std::set< int > groupIDs;
const std::set<SMESHDS_GroupBase*>& groups = myMesh->GetGroups();
std::set<SMESHDS_GroupBase*>::const_iterator grIter = groups.begin();
for ( ; grIter != groups.end(); ++grIter )
groupIDs.insert( (*grIter)->GetID() );
if ( groupIDs.empty() ) groupIDs.insert( 0 );
// Read required entities into groups
if ( _makeRequiredGroups )
{
const int kes[4][3] = { { GmfRequiredVertices, SMDSAbs_Node, nodeIDShift },
{ GmfRequiredEdges, SMDSAbs_Edge, edgeIDShift },
{ GmfRequiredTriangles, SMDSAbs_Face, triaIDShift },
{ GmfRequiredQuadrilaterals,SMDSAbs_Face, quadIDShift }
};
const smIdType kes[4][3] = { { GmfRequiredVertices, SMDSAbs_Node, nodeIDShift },
{ GmfRequiredEdges, SMDSAbs_Edge, edgeIDShift },
{ GmfRequiredTriangles, SMDSAbs_Face, triaIDShift },
{ GmfRequiredQuadrilaterals,SMDSAbs_Face, quadIDShift }
};
const char* names[4] = { "_required_Vertices" ,
"_required_Edges" ,
"_required_Triangles" ,
"_required_Quadrilaterals"
};
};
for ( int i = 0; i < 4; ++i )
{
int gmfKwd = kes[i][0];
int gmfKwd = FromSmIdType<int>( kes[i][0] );
SMDSAbs_ElementType entity = (SMDSAbs_ElementType) kes[i][1];
int shift = kes[i][2];
smIdType shift = kes[i][2];
if ( int nb = GmfStatKwd(meshID, gmfKwd))
{
const int newID = *groupIDs.rbegin() + 1;
@ -454,14 +454,14 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
if ( _makeFaultGroups )
{
const int kes[7][3] = { { GmfFault_SmallTri, SMDSAbs_Face, triaIDShift },
{ GmfFault_BadShape, SMDSAbs_Face, triaIDShift },
{ GmfFault_Overlap, SMDSAbs_Face, triaIDShift },
{ GmfFault_Inter, SMDSAbs_Face, triaIDShift },
{ GmfFault_NearTri, SMDSAbs_Face, triaIDShift },
{ GmfFault_FreeEdge, SMDSAbs_Face, triaIDShift },
{ GmfFault_MultipleEdge, SMDSAbs_Face, triaIDShift }
};
const smIdType kes[7][3] = { { GmfFault_SmallTri, SMDSAbs_Face, triaIDShift },
{ GmfFault_BadShape, SMDSAbs_Face, triaIDShift },
{ GmfFault_Overlap, SMDSAbs_Face, triaIDShift },
{ GmfFault_Inter, SMDSAbs_Face, triaIDShift },
{ GmfFault_NearTri, SMDSAbs_Face, triaIDShift },
{ GmfFault_FreeEdge, SMDSAbs_Face, triaIDShift },
{ GmfFault_MultipleEdge, SMDSAbs_Face, triaIDShift }
};
const char* names[7] = { "Fault_SmallTri",
"Fault_BadShape",
"Fault_Overlap",
@ -469,12 +469,12 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
"Fault_NearTri",
"Fault_FreeEdge",
"Fault_MultipleEdge"
};
};
for ( int i = 0; i < 7; ++i )
{
int gmfKwd = kes[i][0];
int gmfKwd = FromSmIdType<int>( kes[i][0] );
SMDSAbs_ElementType entity = (SMDSAbs_ElementType) kes[i][1];
int shift = kes[i][2];
smIdType shift = kes[i][2];
if ( int nb = GmfStatKwd(meshID, gmfKwd))
{
const int newID = *groupIDs.rbegin() + 1;

9
src/DriverGMF/DriverGMF_Write.cxx
View File

@ -57,8 +57,8 @@ extern "C"
elemIt = elementIterator( SMDSGeom ); \
if ( elemIt->more() ) \
{ \
int totalNbElems = myMesh->GetMeshInfo().NbElements( SMDSGeom ); \
int nbLinearElems = myMesh->GetMeshInfo().NbElements( LinType ); \
smIdType totalNbElems = myMesh->GetMeshInfo().NbElements( SMDSGeom );\
smIdType nbLinearElems = myMesh->GetMeshInfo().NbElements( LinType ); \
if ( totalNbElems - nbLinearElems > 0 ) \
{ \
GmfSetKwd(meshID, GmfKwd, totalNbElems - nbLinearElems); \
@ -100,6 +100,9 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
{
Kernel_Utils::Localizer loc;
if ( Driver_Mesh::IsMeshTooLarge< int >( myMesh, /*checkIDs =*/ false))
return DRS_TOO_LARGE_MESH;
const int dim = 3, version = sizeof(double) < 8 ? 1 : 2;
int meshID = GmfOpenMesh( myFile.c_str(), GmfWrite, version, dim );
@ -115,7 +118,7 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
// nodes
std::map< const SMDS_MeshNode* , int > node2IdMap;
int iN = 0, nbNodes = myMesh->NbNodes();
smIdType iN = 0, nbNodes = myMesh->NbNodes();
GmfSetKwd( meshID, GmfVertices, nbNodes );
double xyz[3];
SMDS_NodeIteratorPtr nodeIt = myMesh->nodesIterator();

11
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -36,6 +36,7 @@
#include "MED_Utilities.hxx"
#include <NCollection_Map.hxx>
#include <smIdType.hxx>
#include "utilities.h"
@ -225,7 +226,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
// Reading pre information about all MED cells
//--------------------------------------------
typedef MED::TVector<int> TNodeIds;
typedef MED::TVector<smIdType> TNodeIds;
bool takeNumbers = true; // initially we trust the numbers from file
MED::TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo, eNOD);
MED::TEntityInfo::iterator anEntityIter = aEntityInfo.begin();
@ -269,7 +270,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
aNodeIds.assign( aBallInfo->myConn->begin(), aBallInfo->myConn->end());
// allocate array of diameters
vtkIdType maxID = myMesh->MaxElementID() + aNbBalls;
vtkIdType maxID = FromSmIdType<vtkIdType>(myMesh->MaxElementID() + aNbBalls);
if ( anIsElemNum && !aBallInfo->myElemNum->empty() )
maxID = *std::max_element( aBallInfo->myElemNum->begin(),
aBallInfo->myElemNum->end() );
@ -318,7 +319,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
EBooleen anIsElemNum = takeNumbers ? aPolygoneInfo->IsElemNum() : eFAUX;
typedef SMDS_MeshFace* (SMESHDS_Mesh::* FAddPolyWithID)
(const std::vector<int> & nodes_ids, const int ID);
(const std::vector<smIdType> & nodes_ids, const smIdType ID);
typedef SMDS_MeshFace* (SMESHDS_Mesh::* FAddPolygon)
(const std::vector<const SMDS_MeshNode*> & nodes);
@ -355,7 +356,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
#endif
if ( anIsElemNum ) {
TInt anElemId = aPolygoneInfo->GetElemNum( iElem );
anElement = (myMesh->*addPolyWithID)( aNodeIds, anElemId );
anElement = (myMesh->*addPolyWithID)( aNodeIds, ToSmIdType(anElemId) );
}
if ( !anElement ) {
aNodes.resize( aNbConn );
@ -436,7 +437,7 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
#endif
if(anIsElemNum){
TInt anElemId = aPolyedreInfo->GetElemNum(iElem);
anElement = myMesh->AddPolyhedralVolumeWithID(aNodeIds,aQuantities,anElemId);
anElement = myMesh->AddPolyhedralVolumeWithID(aNodeIds,aQuantities,ToSmIdType(anElemId));
}
if(!anElement){
vector<const SMDS_MeshNode*> aNodes(aNbNodes);

2
src/DriverMED/DriverMED_W_Field.cxx
View File

@ -90,7 +90,7 @@ bool DriverMED_W_Field::Set(SMESHDS_Mesh * mesh,
}
// find out "MED order" of elements - sort elements by geom type
int nbElems;
smIdType nbElems;
if ( _nbElemsByGeom.empty() || _elemType != type )
{
_elemType = type;

101
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
View File

@ -246,7 +246,7 @@ namespace
const SMDS_MeshNode* GetNode(){
return myCurrentNode;
}
MED::TIntVector::value_type GetID(){
MED::TIDVector::value_type GetID(){
return myCurrentNode->GetID();
}
MED::TFloatVector::value_type GetCoord(TInt theCoodId){
@ -343,12 +343,21 @@ namespace
}
}
//================================================================================
/*!
* \brief Write my mesh
*/
//================================================================================
Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
{
Status aResult = DRS_OK;
try {
//MESSAGE("Perform - myFile : "<<myFile);
if ( Driver_Mesh::IsMeshTooLarge< TInt >( myMesh, /*checkIDs =*/ true ))
return DRS_TOO_LARGE_MESH;
// Creating the MED mesh for corresponding SMDS structure
//-------------------------------------------------------
string aMeshName;
@ -475,12 +484,12 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
int myEdgesDefaultFamilyId = 0;
int myFacesDefaultFamilyId = 0;
int myVolumesDefaultFamilyId = 0;
int nbNodes = myMesh->NbNodes();
int nb0DElements = myMesh->Nb0DElements();
int nbBalls = myMesh->NbBalls();
int nbEdges = myMesh->NbEdges();
int nbFaces = myMesh->NbFaces();
int nbVolumes = myMesh->NbVolumes();
smIdType nbNodes = myMesh->NbNodes();
smIdType nb0DElements = myMesh->Nb0DElements();
smIdType nbBalls = myMesh->NbBalls();
smIdType nbEdges = myMesh->NbEdges();
smIdType nbFaces = myMesh->NbFaces();
smIdType nbVolumes = myMesh->NbVolumes();
if (myDoGroupOfNodes) myNodesDefaultFamilyId = REST_NODES_FAMILY;
if (myDoGroupOfEdges) myEdgesDefaultFamilyId = REST_EDGES_FAMILY;
if (myDoGroupOfFaces) myFacesDefaultFamilyId = REST_FACES_FAMILY;
@ -539,7 +548,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
const EBooleen theIsElemNames = eFAUX;
const EConnectivite theConnMode = eNOD;
TInt aNbNodes = myMesh->NbNodes();
TInt aNbNodes = FromSmIdType<TInt>( myMesh->NbNodes() );
PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo, aNbNodes,
theMode, theSystem, theIsElemNum, theIsElemNames);
@ -559,7 +568,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
aTCoordSlice[2] = 0.;
// node number
int aNodeID = aCoordHelperPtr->GetID();
TInt aNodeID = FromSmIdType<TInt>( aCoordHelperPtr->GetID() );
aNodeInfo->SetElemNum( iNode, aNodeID );
#ifdef _EDF_NODE_IDS_
aNodeIdMap.insert( aNodeIdMap.end(), make_pair( aNodeID, iNode+1 ));
@ -625,66 +634,66 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
#endif
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eBALL,
nbElemInfo.NbBalls(),
FromSmIdType<TInt>(nbElemInfo.NbBalls()),
SMDSAbs_Ball));
#ifdef _ELEMENTS_BY_DIM_
anEntity = eARETE;
#endif
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eSEG2,
nbElemInfo.NbEdges( ORDER_LINEAR ),
FromSmIdType<TInt>(nbElemInfo.NbEdges( ORDER_LINEAR )),
SMDSAbs_Edge));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eSEG3,
nbElemInfo.NbEdges( ORDER_QUADRATIC ),
FromSmIdType<TInt>(nbElemInfo.NbEdges( ORDER_QUADRATIC )),
SMDSAbs_Edge));
#ifdef _ELEMENTS_BY_DIM_
anEntity = eFACE;
#endif
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eTRIA3,
nbElemInfo.NbTriangles( ORDER_LINEAR ),
FromSmIdType<TInt>(nbElemInfo.NbTriangles( ORDER_LINEAR )),
SMDSAbs_Face));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eTRIA6,
nbElemInfo.NbTriangles( ORDER_QUADRATIC ) -
nbElemInfo.NbBiQuadTriangles(),
FromSmIdType<TInt>(nbElemInfo.NbTriangles( ORDER_QUADRATIC ) -
nbElemInfo.NbBiQuadTriangles()),
SMDSAbs_Face));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eTRIA7,
nbElemInfo.NbBiQuadTriangles(),
FromSmIdType<TInt>(nbElemInfo.NbBiQuadTriangles()),
SMDSAbs_Face));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eQUAD4,
nbElemInfo.NbQuadrangles( ORDER_LINEAR ),
FromSmIdType<TInt>(nbElemInfo.NbQuadrangles( ORDER_LINEAR )),
SMDSAbs_Face));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eQUAD8,
nbElemInfo.NbQuadrangles( ORDER_QUADRATIC ) -
nbElemInfo.NbBiQuadQuadrangles(),
FromSmIdType<TInt>(nbElemInfo.NbQuadrangles( ORDER_QUADRATIC ) -
nbElemInfo.NbBiQuadQuadrangles()),
SMDSAbs_Face));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eQUAD9,
nbElemInfo.NbBiQuadQuadrangles(),
FromSmIdType<TInt>(nbElemInfo.NbBiQuadQuadrangles()),
SMDSAbs_Face));
if ( polyTypesSupported ) {
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYGONE,
nbElemInfo.NbPolygons( ORDER_LINEAR ),
FromSmIdType<TInt>(nbElemInfo.NbPolygons( ORDER_LINEAR )),
SMDSAbs_Face));
// we need one more loop on poly elements to count nb of their nodes
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYGONE,
nbElemInfo.NbPolygons( ORDER_LINEAR ),
FromSmIdType<TInt>(nbElemInfo.NbPolygons( ORDER_LINEAR )),
SMDSAbs_Face));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYGON2,
nbElemInfo.NbPolygons( ORDER_QUADRATIC ),
FromSmIdType<TInt>(nbElemInfo.NbPolygons( ORDER_QUADRATIC )),
SMDSAbs_Face));
// we need one more loop on QUAD poly elements to count nb of their nodes
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYGON2,
nbElemInfo.NbPolygons( ORDER_QUADRATIC ),
FromSmIdType<TInt>(nbElemInfo.NbPolygons( ORDER_QUADRATIC )),
SMDSAbs_Face));
}
#ifdef _ELEMENTS_BY_DIM_
@ -692,58 +701,58 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
#endif
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eTETRA4,
nbElemInfo.NbTetras( ORDER_LINEAR ),
FromSmIdType<TInt>(nbElemInfo.NbTetras( ORDER_LINEAR )),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eTETRA10,
nbElemInfo.NbTetras( ORDER_QUADRATIC ),
FromSmIdType<TInt>(nbElemInfo.NbTetras( ORDER_QUADRATIC )),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePYRA5,
nbElemInfo.NbPyramids( ORDER_LINEAR ),
FromSmIdType<TInt>(nbElemInfo.NbPyramids( ORDER_LINEAR )),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePYRA13,
nbElemInfo.NbPyramids( ORDER_QUADRATIC ),
FromSmIdType<TInt>(nbElemInfo.NbPyramids( ORDER_QUADRATIC )),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePENTA6,
nbElemInfo.NbPrisms( ORDER_LINEAR ),
FromSmIdType<TInt>(nbElemInfo.NbPrisms( ORDER_LINEAR )),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePENTA15,
nbElemInfo.NbQuadPrisms(),
FromSmIdType<TInt>(nbElemInfo.NbQuadPrisms()),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePENTA18,
nbElemInfo.NbBiQuadPrisms(),
FromSmIdType<TInt>(nbElemInfo.NbBiQuadPrisms()),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eHEXA8,
nbElemInfo.NbHexas( ORDER_LINEAR ),
FromSmIdType<TInt>(nbElemInfo.NbHexas( ORDER_LINEAR )),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eHEXA20,
nbElemInfo.NbHexas( ORDER_QUADRATIC )-
nbElemInfo.NbTriQuadHexas(),
FromSmIdType<TInt>(nbElemInfo.NbHexas( ORDER_QUADRATIC )-
nbElemInfo.NbTriQuadHexas()),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eHEXA27,
nbElemInfo.NbTriQuadHexas(),
FromSmIdType<TInt>(nbElemInfo.NbTriQuadHexas()),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eOCTA12,
nbElemInfo.NbHexPrisms(),
FromSmIdType<TInt>(nbElemInfo.NbHexPrisms()),
SMDSAbs_Volume));
if ( polyTypesSupported ) {
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYEDRE,
nbElemInfo.NbPolyhedrons(),
FromSmIdType<TInt>(nbElemInfo.NbPolyhedrons()),
SMDSAbs_Volume));
// we need one more loop on poly elements to count nb of their nodes
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYEDRE,
nbElemInfo.NbPolyhedrons(),
FromSmIdType<TInt>(nbElemInfo.NbPolyhedrons()),
SMDSAbs_Volume));
}
@ -822,13 +831,13 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
for(TInt iNode = 0; iNode < aNbNodes; iNode++) {
const SMDS_MeshElement* aNode = anElem->GetNode( iNode );
#ifdef _EDF_NODE_IDS_
aTConnSlice[ iNode ] = aNodeIdMap[aNode->GetID()];
aTConnSlice[ iNode ] = aNodeIdMap[FromSmIdType<TInt>(aNode->GetID())];
#else
aTConnSlice[ iNode ] = aNode->GetID();
#endif
}
// element number
aPolygoneInfo->SetElemNum( iElem, anElem->GetID() );
aPolygoneInfo->SetElemNum( iElem, FromSmIdType<TInt>(anElem->GetID()) );
// family number
int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId );
@ -896,14 +905,14 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
while ( nodeIt->more() ) {
const SMDS_MeshElement* aNode = nodeIt->next();
#ifdef _EDF_NODE_IDS_
conn[ iNode ] = aNodeIdMap[aNode->GetID()];
conn[ iNode ] = aNodeIdMap[FromSmIdType<TInt>(aNode->GetID())];
#else
conn[ iNode ] = aNode->GetID();
#endif
++iNode;
}
// element number
aPolyhInfo->SetElemNum( iElem, anElem->GetID() );
aPolyhInfo->SetElemNum( iElem, FromSmIdType<TInt>(anElem->GetID()) );
// family number
int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId );
@ -930,12 +939,12 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
// connectivity
const SMDS_MeshElement* aNode = anElem->GetNode( 0 );
#ifdef _EDF_NODE_IDS_
(*aBallInfo->myConn)[ iElem ] = aNodeIdMap[aNode->GetID()];
(*aBallInfo->myConn)[ iElem ] = aNodeIdMap[FromSmIdType<TInt>(aNode->GetID())];
#else
(*aBallInfo->myConn)[ iElem ] = aNode->GetID();
#endif
// element number
aBallInfo->SetElemNum( iElem, anElem->GetID() );
aBallInfo->SetElemNum( iElem, FromSmIdType<TInt>(anElem->GetID()) );
// diameter
aBallInfo->myDiameters[ iElem ] =
@ -978,13 +987,13 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
for (TInt iNode = 0; iNode < aNbNodes; iNode++) {
const SMDS_MeshElement* aNode = anElem->GetNode( iNode );
#ifdef _EDF_NODE_IDS_
aTConnSlice[ iNode ] = aNodeIdMap[aNode->GetID()];
aTConnSlice[ iNode ] = aNodeIdMap[FromSmIdType<TInt>(aNode->GetID())];
#else
aTConnSlice[ iNode ] = aNode->GetID();
#endif
}
// element number
aCellInfo->SetElemNum( iElem, anElem->GetID() );
aCellInfo->SetElemNum( iElem, FromSmIdType<TInt>(anElem->GetID()) );
// family number
int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId );

18
src/DriverUNV/DriverUNV_W_SMDS_Mesh.cxx
View File

@ -45,6 +45,10 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
{
Kernel_Utils::Localizer loc;
Status aResult = DRS_OK;
if ( Driver_Mesh::IsMeshTooLarge< int >( myMesh, /*checkIDs =*/ false))
return DRS_TOO_LARGE_MESH;
#if defined(WIN32) && defined(UNICODE)
std::wstring aFile = Kernel_Utils::utf8_decode_s(myFile);
std::ofstream out_stream(aFile.c_str());
@ -113,7 +117,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
{
const SMDS_MeshNode* aNode = aNodesIter->next();
if ( nodeLabelByID.empty() )
aRec.node_labels.push_back( aNode->GetID() );
aRec.node_labels.push_back( FromSmIdType<int>(aNode->GetID()) );
else
aRec.node_labels.push_back( nodeLabelByID[ aNode->GetID() ]);
}
@ -137,7 +141,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
for ( aRec.node_labels.clear(); aNodesIter->more(); ) {
const SMDS_MeshNode* aNode = aNodesIter->next();
if ( nodeLabelByID.empty() )
aRec.node_labels.push_back( aNode->GetID() );
aRec.node_labels.push_back( FromSmIdType<int>(aNode->GetID()) );
else
aRec.node_labels.push_back( nodeLabelByID[ aNode->GetID() ]);
}
@ -195,7 +199,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
{
const SMDS_MeshElement* aNode = aNodesIter->next();
if ( nodeLabelByID.empty() )
aRec.node_labels.push_back( aNode->GetID() );
aRec.node_labels.push_back( FromSmIdType<int>(aNode->GetID()) );
else
aRec.node_labels.push_back( nodeLabelByID[ aNode->GetID() ]);
}
@ -226,7 +230,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
while ( aIter->more() ) {
const SMDS_MeshElement* aNode = aIter->next();
if ( nodeLabelByID.empty() )
aRec.NodeList.push_back( aNode->GetID() );
aRec.NodeList.push_back( FromSmIdType<int>(aNode->GetID()) );
else
aRec.NodeList.push_back( nodeLabelByID[ aNode->GetID() ]);
}
@ -236,7 +240,7 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
while ( aIter->more() ) {
const SMDS_MeshElement* aElem = aIter->next();
if ( elemLabelByID.empty() )
aRec.ElementList.push_back( aElem->GetID() );
aRec.ElementList.push_back( FromSmIdType<int>(aElem->GetID()) );
else
aRec.ElementList.push_back( elemLabelByID[ aElem->GetID() ]);
}
@ -256,11 +260,11 @@ Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
EXCEPTION(runtime_error,"ERROR: Output file not good.");
}
catch(const std::exception& exc){
INFOS("Follow exception was cought:\n\t"<<exc.what());
INFOS("Follow exception was caught:\n\t"<<exc.what());
throw;
}
catch(...){
INFOS("Unknown exception was cought !!!");
INFOS("Unknown exception was caught !!!");
throw;
}
return aResult;

3
src/DriverUNV/DriverUNV_W_SMDS_Mesh.h
View File

@ -35,7 +35,8 @@ typedef std::list<SMESHDS_GroupBase*> TGroupList;
class MESHDRIVERUNV_EXPORT DriverUNV_W_SMDS_Mesh: public Driver_SMDS_Mesh
{
public:
virtual Status Perform();
virtual Status Perform() override;
void AddGroup(SMESHDS_GroupBase* theGroup) { myGroups.push_back(theGroup); }

2
src/MEDWrapper/MED_Common.hxx
View File

@ -32,6 +32,7 @@
#include <map>
#include <med.h>
#include <smIdType.hxx>
#ifdef WIN32
#pragma warning(disable:4099)
@ -77,6 +78,7 @@ namespace MED
typedef enum {eCOOR, eCONN, eNOM, eNUM, eFAM, eCOOR_IND1, eCOOR_IND2, eCOOR_IND3} ETable;
typedef TVector<TInt> TIntVector;
typedef TVector<smIdType> TIDVector;
typedef TVector<TFloat> TFloatVector;
typedef TVector<std::string> TStringVector;
typedef std::set<std::string> TStringSet;

88
src/OBJECT/SMESH_Actor.cxx
View File

@ -139,8 +139,8 @@ SMESH_ActorDef::SMESH_ActorDef()
myIsFacesOriented = false;
int controlsIncrement = SMESH_ActorProps::props()->controlsIncrement();
int selectionIncrement = SMESH_ActorProps::props()->selectionIncrement();
float controlsIncrement = (float) SMESH_ActorProps::props()->controlsIncrement();
float selectionIncrement = (float) SMESH_ActorProps::props()->selectionIncrement();
myControlsPrecision = -1;
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
@ -148,11 +148,11 @@ SMESH_ActorDef::SMESH_ActorDef()
if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
double aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
double aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
double aBallElemScale = SMESH::GetFloat("SMESH:ball_elem_scale",1.0);
double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
double aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
float aElem0DSize = (float) SMESH::GetFloat("SMESH:elem0d_size",5);
float aBallElemSize = (float) SMESH::GetFloat("SMESH:ball_elem_size",10);
float aBallElemScale = (float) SMESH::GetFloat("SMESH:ball_elem_scale",1.0);
float aLineWidth = (float) SMESH::GetFloat("SMESH:element_width",1);
float aOutlineWidth = (float) SMESH::GetFloat("SMESH:outline_width",1);
SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
bool aBoldNd = true;
@ -1035,7 +1035,7 @@ void SMESH_ActorDef::SetControlMode( eControl theMode, bool theCheckEntityMode )
return;
}
int aNbCells = myFunctor ? myVisualObj->GetNbEntities( myFunctor->GetType() ) : 0;
smIdType aNbCells = myFunctor ? myVisualObj->GetNbEntities( myFunctor->GetType() ) : 0;
bool aShowOnlyScalarBarTitle = false;
if(aNbCells) {
//myControlMode = theMode;
@ -1135,7 +1135,7 @@ void SMESH_ActorDef::SetControlMode( eControl theMode, bool theCheckEntityMode )
//Update();
}
int SMESH_ActorDef::GetNumberControlEntities()
smIdType SMESH_ActorDef::GetNumberControlEntities()
{
SMESH_DeviceActor* anAct = NULL;
switch(myControlMode){
@ -1161,7 +1161,7 @@ int SMESH_ActorDef::GetNumberControlEntities()
break;
default:;
}
return (anAct) ? anAct->GetUnstructuredGrid()->GetNumberOfCells() : -1;
return anAct ? anAct->GetUnstructuredGrid()->GetNumberOfCells() : -1;
}
void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer)
@ -1453,27 +1453,27 @@ void SMESH_ActorDef::UnShrink()
}
int SMESH_ActorDef::GetNodeObjId(int theVtkID)
vtkIdType SMESH_ActorDef::GetNodeObjId(vtkIdType theVtkID)
{
return myPickableActor->GetNodeObjId(theVtkID);
}
double* SMESH_ActorDef::GetNodeCoord(int theObjID)
double* SMESH_ActorDef::GetNodeCoord(vtkIdType theObjID)
{
return myPickableActor->GetNodeCoord(theObjID);
}
int SMESH_ActorDef::GetNodeVtkId(int theObjID)
vtkIdType SMESH_ActorDef::GetNodeVtkId(vtkIdType theObjID)
{
return myPickableActor->GetNodeVtkId(theObjID);
}
int SMESH_ActorDef::GetElemObjId(int theVtkID)
vtkIdType SMESH_ActorDef::GetElemObjId(vtkIdType theVtkID)
{
return myPickableActor->GetElemObjId(theVtkID);
}
vtkCell* SMESH_ActorDef::GetElemCell(int theObjID)
vtkCell* SMESH_ActorDef::GetElemCell(vtkIdType theObjID)
{
return myPickableActor->GetElemCell(theObjID);
}
@ -1665,11 +1665,11 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode)
void SMESH_ActorDef::SetRepresentation (int theMode)
{
int aNbEdges = myVisualObj->GetNbEntities(SMDSAbs_Edge);
int aNbFaces = myVisualObj->GetNbEntities(SMDSAbs_Face);
int aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume);
int aNb0Ds = myVisualObj->GetNbEntities(SMDSAbs_0DElement);
int aNbBalls = myVisualObj->GetNbEntities(SMDSAbs_Ball);
smIdType aNbEdges = myVisualObj->GetNbEntities(SMDSAbs_Edge);
smIdType aNbFaces = myVisualObj->GetNbEntities(SMDSAbs_Face);
smIdType aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume);
smIdType aNb0Ds = myVisualObj->GetNbEntities(SMDSAbs_0DElement);
smIdType aNbBalls = myVisualObj->GetNbEntities(SMDSAbs_Ball);
if ( myRepresentationCache && aNbEdges + aNbFaces + aNbVolumes + aNb0Ds + aNbBalls )
{
@ -1714,7 +1714,7 @@ void SMESH_ActorDef::SetRepresentation (int theMode)
myPickableActor = myBaseActor;
vtkProperty *aProp = NULL, *aBackProp = NULL;
vtkProperty *aPropVN = NULL, *aPropVR = NULL;
SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1);
SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::eNoneRepr;
SMESH_Actor::EQuadratic2DRepresentation aQuadraticMode = GetQuadratic2DRepresentation();
switch (myRepresentation) {
case ePoint:
@ -2126,8 +2126,8 @@ void SMESH_ActorDef::UpdateSelectionProps()
{
QColor selectionColor = SMESH_ActorProps::props()->selectionColor();
QColor highlightColor = SMESH_ActorProps::props()->highlightColor();
int selectionIncrement = SMESH_ActorProps::props()->selectionIncrement();
double width = GetLineWidth();
float selectionIncrement = (float) SMESH_ActorProps::props()->selectionIncrement();
float width = (float) GetLineWidth();
myHighlightProp->SetColor(selectionColor.redF(), selectionColor.greenF(), selectionColor.blueF());
myHighlightProp->SetLineWidth(width + selectionIncrement);
myPreselectProp->SetColor(highlightColor.redF(), highlightColor.greenF(), highlightColor.blueF());
@ -2143,17 +2143,17 @@ double SMESH_ActorDef::GetLineWidth()
void SMESH_ActorDef::SetLineWidth(double theVal)
{
int controlsIncrement = SMESH_ActorProps::props()->controlsIncrement();
int selectionIncrement = SMESH_ActorProps::props()->selectionIncrement();
float controlsIncrement = (float) SMESH_ActorProps::props()->controlsIncrement();
float selectionIncrement = (float) SMESH_ActorProps::props()->selectionIncrement();
myEdgeProp->SetLineWidth(theVal);
myEdgeProp->SetLineWidth((float) theVal);
my1DProp->SetLineWidth(theVal + controlsIncrement);
my1DExtProp->SetLineWidth(theVal + controlsIncrement);
my2DExtProp->SetLineWidth(theVal + controlsIncrement);
my3DExtProp->SetLineWidth(theVal + controlsIncrement);
myHighlightProp->SetLineWidth(theVal + selectionIncrement);
myPreselectProp->SetLineWidth(theVal + selectionIncrement);
my1DProp ->SetLineWidth((float) theVal + controlsIncrement);
my1DExtProp ->SetLineWidth((float) theVal + controlsIncrement);
my2DExtProp ->SetLineWidth((float) theVal + controlsIncrement);
my3DExtProp ->SetLineWidth((float) theVal + controlsIncrement);
myHighlightProp->SetLineWidth((float) theVal + selectionIncrement);
myPreselectProp->SetLineWidth((float) theVal + selectionIncrement);
Modified();
}
@ -2164,21 +2164,21 @@ double SMESH_ActorDef::GetOutlineWidth()
void SMESH_ActorDef::SetOutlineWidth(double theVal)
{
myOutLineProp->SetLineWidth(theVal);
myOutLineProp->SetLineWidth((float) theVal);
Modified();
}
void SMESH_ActorDef::Set0DSize(double theVal)
{
my0DProp->SetPointSize(theVal);
myHighlightProp->SetPointSize(theVal);
myPreselectProp->SetPointSize(theVal);
my0DProp ->SetPointSize((float) theVal);
myHighlightProp->SetPointSize((float) theVal);
myPreselectProp->SetPointSize((float) theVal);
if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
aCustom->Set0DSize(theVal);
aCustom->Set0DSize((float) theVal);
}
if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myPreHighlightActor )) {
aCustom->Set0DSize(theVal);
aCustom->Set0DSize((float) theVal);
}
Modified();
@ -2191,13 +2191,13 @@ double SMESH_ActorDef::Get0DSize()
void SMESH_ActorDef::SetBallSize(double theVal)
{
myBallProp->SetPointSize(theVal);
myBallProp->SetPointSize((float) theVal);
if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
aCustom->SetBallSize(theVal);
aCustom->SetBallSize((float) theVal);
}
if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myPreHighlightActor )) {
aCustom->SetBallSize(theVal);
aCustom->SetBallSize((float) theVal);
}
Modified();
@ -2226,7 +2226,7 @@ void SMESH_ActorDef::SetBallScale( double theVal )
Modified();
}
int SMESH_ActorDef::GetObjDimension( const int theObjId )
int SMESH_ActorDef::GetObjDimension( const vtkIdType theObjId )
{
return myVisualObj->GetElemDimension( theObjId );
}
@ -2496,7 +2496,7 @@ void SMESH_ActorDef::UpdateDistribution()
SMESH_VisualObjDef::TEntityList elems;
if ( dynamic_cast<SMESH_SubMeshObj*>(myVisualObj.get()))
dynamic_cast<SMESH_SubMeshObj*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
std::vector<int> elemIds; elemIds.reserve( elems.size() );
std::vector<smIdType> elemIds; elemIds.reserve( elems.size() );
for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
elemIds.push_back( (*e)->GetID());
vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
@ -2682,7 +2682,7 @@ SPlot2d_Histogram* SMESH_ActorDef::UpdatePlot2Histogram()
SMESH_VisualObjDef::TEntityList elems;
if ( dynamic_cast<SMESH_SubMeshObj*>(myVisualObj.get()))
dynamic_cast<SMESH_SubMeshObj*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
std::vector<int> elemIds;
std::vector<smIdType> elemIds;
for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
elemIds.push_back( (*e)->GetID());

2
src/OBJECT/SMESH_Actor.h
View File

@ -148,7 +148,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual void SetControl(SMESH::Controls::FunctorPtr) = 0;
virtual eControl GetControlMode() = 0;
virtual SMESH::Controls::FunctorPtr GetFunctor() = 0;
virtual int GetNumberControlEntities() = 0;
virtual smIdType GetNumberControlEntities() = 0;
virtual SMESH_ScalarBarActor* GetScalarBarActor() = 0;

14
src/OBJECT/SMESH_ActorDef.h
View File

@ -144,14 +144,14 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetBallScale(double size);
virtual double GetBallScale();
virtual int GetNodeObjId(int theVtkID);
virtual double* GetNodeCoord(int theObjID);
virtual int GetNodeVtkId(int theObjID);
virtual vtkIdType GetNodeObjId(vtkIdType theVtkID);
virtual double* GetNodeCoord(vtkIdType theObjID);
virtual vtkIdType GetNodeVtkId(vtkIdType theObjID);
virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID);
virtual vtkIdType GetElemObjId(vtkIdType theVtkID);
virtual vtkCell* GetElemCell(vtkIdType theObjID);
virtual int GetObjDimension( const int theObjId );
virtual int GetObjDimension( const vtkIdType theObjId ) override;
virtual void SetVisibility(int theMode);
void SetVisibility(int theMode, bool theIsUpdateRepersentation);
@ -206,7 +206,7 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetControlMode(eControl theMode);
virtual void SetControl(SMESH::Controls::FunctorPtr theFunctor);
virtual int GetNumberControlEntities();
virtual smIdType GetNumberControlEntities();
virtual eControl GetControlMode(){ return myControlMode;}
virtual SMESH::Controls::FunctorPtr GetFunctor() { return myFunctor; }

14
src/OBJECT/SMESH_ActorUtils.cxx
View File

@ -157,17 +157,17 @@ namespace SMESH
}
}
std::map<SMDSAbs_ElementType,int> GetEntitiesFromObject(SMESH_VisualObj *theObject) {
std::map<SMDSAbs_ElementType,int> entities;
entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_0DElement,
std::map<SMDSAbs_ElementType,smIdType> GetEntitiesFromObject(SMESH_VisualObj *theObject) {
std::map<SMDSAbs_ElementType,smIdType> entities;
entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_0DElement,
theObject ? theObject->GetNbEntities(SMDSAbs_0DElement) : 0));
entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_Ball,
entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_Ball,
theObject ? theObject->GetNbEntities(SMDSAbs_Ball) : 0));
entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_Edge,
entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_Edge,
theObject ? theObject->GetNbEntities(SMDSAbs_Edge) : 0));
entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_Face,
entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_Face,
theObject ? theObject->GetNbEntities(SMDSAbs_Face) : 0));
entities.insert(std::pair<SMDSAbs_ElementType,int>(SMDSAbs_Volume,
entities.insert(std::pair<SMDSAbs_ElementType,smIdType>(SMDSAbs_Volume,
theObject ? theObject->GetNbEntities(SMDSAbs_Volume) : 0));
return entities;
}

2
src/OBJECT/SMESH_ActorUtils.h
View File

@ -84,7 +84,7 @@ SMESHOBJECT_EXPORT
QString def);
SMESHOBJECT_EXPORT
std::map<SMDSAbs_ElementType,int>
std::map<SMDSAbs_ElementType,smIdType>
GetEntitiesFromObject(SMESH_VisualObj *theObject);
SMESHOBJECT_EXPORT

11
src/OBJECT/SMESH_CellLabelActor.cxx
View File

@ -43,6 +43,7 @@
#include <vtkRenderer.h>
#include <vtkUnstructuredGrid.h>
#include <vtkCellData.h>
#include <iostream>
vtkStandardNewMacro(SMESH_CellLabelActor)
@ -70,7 +71,7 @@ SMESH_CellLabelActor::SMESH_CellLabelActor()
myClsLabeledDataMapper = vtkLabeledDataMapper::New();
myClsLabeledDataMapper->SetInputConnection(myClsSelectVisiblePoints->GetOutputPort());
myClsLabeledDataMapper->SetLabelFormat("%d");
//myClsLabeledDataMapper->SetLabelFormat("%d");
myClsLabeledDataMapper->SetLabelModeToLabelScalars();
myClsTextProp = vtkTextProperty::New();
@ -156,18 +157,18 @@ void SMESH_CellLabelActor::SetCellsLabeled(bool theIsCellsLabeled)
{
myCellsNumDataSet->ShallowCopy(aGrid);
vtkUnstructuredGrid *aDataSet = myCellsNumDataSet;
int aNbElem = aDataSet->GetNumberOfCells();
vtkIntArray *anArray = vtkIntArray::New();
vtkIdType aNbElem = aDataSet->GetNumberOfCells();
vtkIdTypeArray *anArray = vtkIdTypeArray::New();
anArray->SetNumberOfValues(aNbElem);
myExtractUnstructuredGrid->BuildOut2InMap();
for(int anId = 0; anId < aNbElem; anId++)
for(vtkIdType anId = 0; anId < aNbElem; anId++)
{
vtkIdType id = anId;
if(IsImplicitFunctionUsed())
id = myExtractGeometry->GetElemObjId(id);
id = myExtractUnstructuredGrid->GetInputId(id);
id = (id >=0) ? id : anId;
int aSMDSId = myVisualObj->GetElemObjId(id);
vtkIdType aSMDSId = myVisualObj->GetElemObjId(id);
anArray->SetValue(anId,aSMDSId);
}
aDataSet->GetCellData()->SetScalars(anArray);

30
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -31,7 +31,7 @@
#include "SMESH_ControlsDef.hxx"
#include "SMESH_ActorUtils.h"
#include "SMESH_FaceOrientationFilter.h"
#include "VTKViewer_CellLocationsArray.h"
//#include "VTKViewer_CellLocationsArray.h"
#include "VTKViewer_PolyDataMapper.h"
#include <VTKViewer_Transform.h>
@ -161,7 +161,7 @@ SMESH_DeviceActor
myTransformFilter->Delete();
for(int i = 0, iEnd = myPassFilter.size(); i < iEnd; i++)
for(size_t i = 0, iEnd = myPassFilter.size(); i < iEnd; i++)
myPassFilter[i]->Delete();
myShrinkFilter->Delete();
@ -426,7 +426,7 @@ SMESH_DeviceActor
aCellTypesArray->SetNumberOfTuples( aNbCells );
aScalars->SetNumberOfTuples( aNbCells );
VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents( 1 );
aCellLocationsArray->SetNumberOfTuples( aNbCells );
@ -491,7 +491,7 @@ SMESH_DeviceActor
aCellTypesArray->SetNumberOfTuples( aNbCells );
aScalars->SetNumberOfTuples( aNbCells );
VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents( 1 );
aCellLocationsArray->SetNumberOfTuples( aNbCells );
@ -586,7 +586,7 @@ SMESH_DeviceActor
}
}
VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents( 1 );
aCellLocationsArray->SetNumberOfTuples( aNbCells );
@ -604,7 +604,7 @@ SMESH_DeviceActor
( aPredicate = dynamic_cast<CoincidentNodes*>(theFunctor.get())))
{
myExtractUnstructuredGrid->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
vtkIdType aNbNodes = myVisualObj->GetNbEntities(SMDSAbs_Node);
vtkIdType aNbNodes = FromSmIdType<vtkIdType>(myVisualObj->GetNbEntities(SMDSAbs_Node));
for( vtkIdType i = 0; i < aNbNodes; i++ ){
vtkIdType anObjId = myVisualObj->GetNodeObjId(i);
if(aPredicate->IsSatisfy(anObjId))
@ -783,6 +783,8 @@ SMESH_DeviceActor
myGeomFilter->SetInside(false);
myGeomFilter->SetWireframeMode(false);
GetProperty()->SetRepresentation(theMode);
case eNoneRepr:
return;
}
SetMarkerEnabled(theMode == ePoint);
myRepresentation = theMode;
@ -839,9 +841,9 @@ SMESH_DeviceActor
}
int
vtkIdType
SMESH_DeviceActor
::GetNodeObjId(int theVtkID)
::GetNodeObjId(vtkIdType theVtkID)
{
vtkIdType anID = theVtkID;
@ -855,7 +857,7 @@ SMESH_DeviceActor
double*
SMESH_DeviceActor
::GetNodeCoord(int theObjID)
::GetNodeCoord(vtkIdType theObjID)
{
vtkDataSet* aDataSet = myMergeFilter->GetOutput();
vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID);
@ -864,16 +866,16 @@ SMESH_DeviceActor
return aCoord;
}
int
vtkIdType
SMESH_DeviceActor
::GetNodeVtkId(int theObjID)
::GetNodeVtkId(vtkIdType theObjID)
{
return myVisualObj->GetNodeVTKId(theObjID);
}
int
vtkIdType
SMESH_DeviceActor
::GetElemObjId(int theVtkID)
::GetElemObjId(vtkIdType theVtkID)
{
vtkIdType anId = myGeomFilter->GetElemObjId(theVtkID);
if(anId < 0)
@ -897,7 +899,7 @@ SMESH_DeviceActor
vtkCell*
SMESH_DeviceActor
::GetElemCell(int theObjID)
::GetElemCell(vtkIdType theObjID)
{
vtkDataSet* aDataSet = myVisualObj->GetUnstructuredGrid();
vtkIdType aGridID = myVisualObj->GetElemVTKId(theObjID);

12
src/OBJECT/SMESH_DeviceActor.h
View File

@ -68,12 +68,12 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
void SetStoreGemetryMapping(bool theStoreMapping);
void SetStoreIDMapping(bool theStoreMapping);
virtual int GetNodeObjId(int theVtkID);
virtual double* GetNodeCoord(int theObjID);
virtual int GetNodeVtkId(int theObjID);
virtual vtkIdType GetNodeObjId(vtkIdType theVtkID);
virtual double* GetNodeCoord(vtkIdType theObjID);
virtual vtkIdType GetNodeVtkId(vtkIdType theObjID);
virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID);
virtual vtkIdType GetElemObjId(vtkIdType theVtkID);
virtual vtkCell* GetElemCell(vtkIdType theObjID);
virtual void SetTransform(VTKViewer_Transform* theTransform);
virtual vtkMTimeType GetMTime();
@ -108,7 +108,7 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
void SetShrink();
void UnShrink();
enum EReperesent { ePoint, eWireframe, eSurface, eInsideframe};
enum EReperesent { ePoint, eWireframe, eSurface, eInsideframe, eNoneRepr=-1};
EReperesent GetRepresentation(){ return myRepresentation;}
void SetRepresentation(EReperesent theMode);

8
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

@ -58,16 +58,16 @@ SMESH_ExtractGeometry::SMESH_ExtractGeometry()
SMESH_ExtractGeometry::~SMESH_ExtractGeometry()
{}
vtkIdType SMESH_ExtractGeometry::GetElemObjId(int theVtkID)
vtkIdType SMESH_ExtractGeometry::GetElemObjId(vtkIdType theVtkID)
{
if( theVtkID < 0 || theVtkID >= (int)myElemVTK2ObjIds.size()) return -1;
if( theVtkID < 0 || theVtkID >= myElemVTK2ObjIds.size()) return -1;
return myElemVTK2ObjIds[theVtkID];
}
vtkIdType SMESH_ExtractGeometry::GetNodeObjId(int theVtkID)
vtkIdType SMESH_ExtractGeometry::GetNodeObjId(vtkIdType theVtkID)
{
if ( theVtkID < 0 || theVtkID >= (int)myNodeVTK2ObjIds.size()) return -1;
if ( theVtkID < 0 || theVtkID >= myNodeVTK2ObjIds.size()) return -1;
return myNodeVTK2ObjIds[theVtkID];
}

4
src/OBJECT/SMESH_ExtractGeometry.h
View File

@ -42,8 +42,8 @@ public:
}
bool GetStoreMapping(){ return myStoreMapping;}
virtual vtkIdType GetNodeObjId(int theVtkID);
virtual vtkIdType GetElemObjId(int theVtkID);
virtual vtkIdType GetNodeObjId(vtkIdType theVtkID);
virtual vtkIdType GetElemObjId(vtkIdType theVtkID);
protected:
SMESH_ExtractGeometry();

8
src/OBJECT/SMESH_NodeLabelActor.cxx
View File

@ -61,7 +61,7 @@ SMESH_NodeLabelActor::SMESH_NodeLabelActor()
myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
myPtsLabeledDataMapper->SetInputConnection(myPtsSelectVisiblePoints->GetOutputPort());
myPtsLabeledDataMapper->SetLabelFormat("%d");
//myPtsLabeledDataMapper->SetLabelFormat("%d");
myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
myPtsTextProp = vtkTextProperty::New();
@ -146,14 +146,14 @@ void SMESH_NodeLabelActor::SetPointsLabeled(bool theIsPointsLabeled)
myPointsNumDataSet->ShallowCopy(aGrid);
vtkUnstructuredGrid *aDataSet = myPointsNumDataSet;
int aNbElem = aDataSet->GetNumberOfPoints();
vtkIdType aNbElem = aDataSet->GetNumberOfPoints();
vtkIntArray *anArray = vtkIntArray::New();
vtkIdTypeArray *anArray = vtkIdTypeArray::New();
anArray->SetNumberOfValues( aNbElem );
for ( vtkIdType anId = 0; anId < aNbElem; anId++ )
{
int aSMDSId = myVisualObj->GetNodeObjId( anId );
vtkIdType aSMDSId = myVisualObj->GetNodeObjId( anId );
anArray->SetValue( anId, aSMDSId );
}

88
src/OBJECT/SMESH_Object.cxx
View File

@ -38,7 +38,7 @@
#include <SalomeApp_Application.h>
#include <VTKViewer_ExtractUnstructuredGrid.h>
#include <VTKViewer_CellLocationsArray.h>
//#include <VTKViewer_CellLocationsArray.h>
#include CORBA_SERVER_HEADER(SMESH_Gen)
#include CORBA_SERVER_HEADER(SALOME_Exception)
@ -103,7 +103,7 @@ SMESH_VisualObjDef::~SMESH_VisualObjDef()
// functions : GetNodeObjId, GetNodeVTKId, GetElemObjId, GetElemVTKId
// purpose : Methods for retrieving VTK IDs by SMDS IDs and vice versa
//=================================================================================
vtkIdType SMESH_VisualObjDef::GetNodeObjId( int theVTKID )
vtkIdType SMESH_VisualObjDef::GetNodeObjId( vtkIdType theVTKID )
{
if (myLocalGrid)
{
@ -114,10 +114,10 @@ vtkIdType SMESH_VisualObjDef::GetNodeObjId( int theVTKID )
if( this->GetMesh() )
aNode = this->GetMesh()->FindNodeVtk( theVTKID );
return aNode ? aNode->GetID() : -1;
return aNode ? FromSmIdType<vtkIdType>(aNode->GetID()) : -1;
}
vtkIdType SMESH_VisualObjDef::GetNodeVTKId( int theObjID )
vtkIdType SMESH_VisualObjDef::GetNodeVTKId( vtkIdType theObjID )
{
if (myLocalGrid)
{
@ -132,17 +132,17 @@ vtkIdType SMESH_VisualObjDef::GetNodeVTKId( int theObjID )
return aNode ? aNode->GetVtkID() : -1;
}
vtkIdType SMESH_VisualObjDef::GetElemObjId( int theVTKID )
vtkIdType SMESH_VisualObjDef::GetElemObjId( vtkIdType theVTKID )
{
if (myLocalGrid)
{
TMapOfIds::const_iterator i = myVTK2SMDSElems.find(theVTKID);
return i == myVTK2SMDSElems.end() ? -1 : i->second;
}
return this->GetMesh()->FromVtkToSmds(theVTKID);
return FromSmIdType<vtkIdType>(this->GetMesh()->FromVtkToSmds(theVTKID));
}
vtkIdType SMESH_VisualObjDef::GetElemVTKId( int theObjID )
vtkIdType SMESH_VisualObjDef::GetElemVTKId( vtkIdType theObjID )
{
if (myLocalGrid)
{
@ -171,7 +171,7 @@ void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
return;
TEntityList aNodes;
vtkIdType nbNodes = GetEntities( SMDSAbs_Node, aNodes );
vtkIdType nbNodes = FromSmIdType<vtkIdType>(GetEntities( SMDSAbs_Node, aNodes ));
thePoints->SetNumberOfPoints( nbNodes );
int nbPoints = 0;
@ -183,7 +183,7 @@ void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
if ( aNode != 0 )
{
thePoints->SetPoint( nbPoints, aNode->X(), aNode->Y(), aNode->Z() );
int anId = aNode->GetID();
smIdType anId = aNode->GetID();
mySMDS2VTKNodes.insert( mySMDS2VTKNodes.end(), std::make_pair( anId, nbPoints ));
myVTK2SMDSNodes.insert( myVTK2SMDSNodes.end(), std::make_pair( nbPoints, anId ));
nbPoints++;
@ -284,7 +284,7 @@ namespace{
theConnect.clear();
for(; theNodesIter->more();)
theConnect.push_back(theNodesIter->next());
return theConnect.size();
return (int) theConnect.size();
}
inline
@ -292,7 +292,7 @@ namespace{
const SMESH_VisualObjDef::TMapOfIds& theSMDS2VTKNodes,
const TConnect& theConnect,
int thePosition,
int theId)
vtkIdType theId)
{
theIdList->SetId(thePosition,theSMDS2VTKNodes.find(theConnect[theId]->GetID())->second);
}
@ -319,7 +319,7 @@ void SMESH_VisualObjDef::buildElemPrs()
{ SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, SMDSAbs_Ball, SMDSAbs_0DElement };
// get entity data
map<SMDSAbs_ElementType,int> nbEnts;
map<SMDSAbs_ElementType,smIdType> nbEnts;
map<SMDSAbs_ElementType,TEntityList> anEnts;
vtkIdType aNbCells = 0;
@ -404,9 +404,9 @@ void SMESH_VisualObjDef::buildElemPrs()
vtkIdType aNbNodes = anElem->NbNodes();
anIdList->SetNumberOfIds( aNbNodes );
const vtkIdType vtkElemType = SMDS_MeshCell::toVtkType( anElem->GetEntityType() );
const VTKCellType vtkElemType = SMDS_MeshCell::toVtkType( anElem->GetEntityType() );
int anId = anElem->GetID();
smIdType anId = anElem->GetID();
mySMDS2VTKElems.insert( mySMDS2VTKElems.end(), std::make_pair( anId, iElem ));
myVTK2SMDSElems.insert( myVTK2SMDSElems.end(), std::make_pair( iElem, anId ));
@ -424,7 +424,7 @@ void SMESH_VisualObjDef::buildElemPrs()
anIdList->InsertNextId(ph->NbFaceNodes(i));
for(int j = 1; j <= ph->NbFaceNodes(i); j++) {
if ( const SMDS_MeshNode* n = ph->GetFaceNode( i, j ))
anIdList->InsertNextId( mySMDS2VTKNodes[ n->GetID() ]);
anIdList->InsertNextId( mySMDS2VTKNodes[ FromSmIdType<vtkIdType>(n->GetID()) ]);
}
}
}
@ -435,13 +435,13 @@ void SMESH_VisualObjDef::buildElemPrs()
if (aConnectivities.size() > 0) {
aConnect.clear();
GetConnect(aNodesIter,aConnect);
for (vtkIdType aNodeId = 0; aNodeId < aNbNodes; aNodeId++)
for (int aNodeId = 0; aNodeId < aNbNodes; aNodeId++)
SetId(anIdList,mySMDS2VTKNodes,aConnect,aNodeId,aConnectivities[aNodeId]);
}
else {
for( vtkIdType aNodeId = 0; aNodesIter->more(); aNodeId++ ){
const SMDS_MeshElement* aNode = aNodesIter->next();
anIdList->SetId( aNodeId, mySMDS2VTKNodes[aNode->GetID()] );
anIdList->SetId( aNodeId, mySMDS2VTKNodes[FromSmIdType<vtkIdType>(aNode->GetID())]);
}
}
}
@ -465,7 +465,7 @@ void SMESH_VisualObjDef::buildElemPrs()
// Insert cells in grid
VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
aCellLocationsArray->SetNumberOfComponents( 1 );
aCellLocationsArray->SetNumberOfTuples( aNbCells );
@ -491,10 +491,10 @@ void SMESH_VisualObjDef::buildElemPrs()
// function : GetEdgeNodes
// purpose : Retrieve ids of nodes from edge of elements ( edge is numbered from 0 )
//=================================================================================
bool SMESH_VisualObjDef::GetEdgeNodes( const int theElemId,
const int theEdgeNum,
int& theNodeId1,
int& theNodeId2 ) const
bool SMESH_VisualObjDef::GetEdgeNodes( const smIdType theElemId,
const int theEdgeNum,
smIdType& theNodeId1,
smIdType& theNodeId2 ) const
{
const SMDS_Mesh* aMesh = GetMesh();
if ( aMesh == 0 )
@ -557,7 +557,7 @@ void SMESH_VisualObjDef::updateEntitiesFlags()
unsigned int tmp = myEntitiesState;
ClearEntitiesFlags();
map<SMDSAbs_ElementType,int> entities = SMESH::GetEntitiesFromObject(this);
map<SMDSAbs_ElementType,smIdType> entities = SMESH::GetEntitiesFromObject(this);
if( myEntitiesCache[SMDSAbs_0DElement] != 0 ||
@ -681,7 +681,7 @@ bool SMESH_MeshObj::NulData()
// function : GetElemDimension
// purpose : Get dimension of element
//=================================================================================
int SMESH_MeshObj::GetElemDimension( const int theObjId )
int SMESH_MeshObj::GetElemDimension( const smIdType theObjId )
{
const SMDS_MeshElement* anElem = myClient->FindElement( theObjId );
if ( anElem == 0 )
@ -703,7 +703,7 @@ int SMESH_MeshObj::GetElemDimension( const int theObjId )
// function : GetEntities
// purpose : Get entities of specified type. Return number of entities
//=================================================================================
int SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
smIdType SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
{
switch ( theType )
{
@ -742,7 +742,7 @@ int SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
}
}
int SMESH_MeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theObjs ) const
smIdType SMESH_MeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theObjs ) const
{
theObjs.clear();
@ -834,7 +834,7 @@ SMESH_SubMeshObj::~SMESH_SubMeshObj()
// function : GetElemDimension
// purpose : Get dimension of element
//=================================================================================
int SMESH_SubMeshObj::GetElemDimension( const int theObjId )
int SMESH_SubMeshObj::GetElemDimension( const smIdType theObjId )
{
return myMeshObj == 0 ? 0 : myMeshObj->GetElemDimension( theObjId );
}
@ -908,13 +908,13 @@ SMDSAbs_ElementType SMESH_GroupObj::GetElementType() const
// function : getNodesFromElems
// purpose : Retrieve nodes from elements
//=================================================================================
static int getNodesFromElems( SMESH::long_array_var& theElemIds,
static int getNodesFromElems( SMESH::smIdType_array_var& theElemIds,
const SMDS_Mesh* theMesh,
std::list<const SMDS_MeshElement*>& theResList )
{
set<const SMDS_MeshElement*> aNodeSet;
for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
for ( CORBA::ULong i = 0, n = theElemIds->length(); i < n; i++ )
{
const SMDS_MeshElement* anElem = theMesh->FindElement( theElemIds[ i ] );
if ( anElem != 0 )
@ -929,11 +929,9 @@ static int getNodesFromElems( SMESH::long_array_var& theElemIds,
}
}
set<const SMDS_MeshElement*>::const_iterator anIter;
for ( anIter = aNodeSet.begin(); anIter != aNodeSet.end(); ++anIter )
theResList.push_back( *anIter );
theResList.assign( aNodeSet.begin(), aNodeSet.end() );
return theResList.size();
return (int) aNodeSet.size();
}
//=================================================================================
@ -941,11 +939,11 @@ static int getNodesFromElems( SMESH::long_array_var& theElemIds,
// purpose : Get std::list<const SMDS_MeshElement*> from list of IDs
//=================================================================================
static int getPointers( const SMDSAbs_ElementType theRequestType,
SMESH::long_array_var& theElemIds,
SMESH::smIdType_array_var& theElemIds,
const SMDS_Mesh* theMesh,
std::list<const SMDS_MeshElement*>& theResList )
{
for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
for ( CORBA::ULong i = 0, n = theElemIds->length(); i < n; i++ )
{
const SMDS_MeshElement* anElem = theRequestType == SMDSAbs_Node
? theMesh->FindNode( theElemIds[ i ] ) : theMesh->FindElement( theElemIds[ i ] );
@ -954,7 +952,7 @@ static int getPointers( const SMDSAbs_ElementType theRequestType,
theResList.push_back( anElem );
}
return theResList.size();
return (int) theResList.size();
}
@ -962,7 +960,7 @@ static int getPointers( const SMDSAbs_ElementType theRequestType,
// function : GetEntities
// purpose : Get entities of specified type. Return number of entities
//=================================================================================
int SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
smIdType SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
{
if(SMDSAbs_ElementType(myGroupServer->GetType()) == theType) {
return myGroupServer->Size();
@ -973,7 +971,7 @@ int SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
return 0;
}
int SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
smIdType SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
{
theResList.clear();
SMDS_Mesh* aMesh = myMeshObj->GetMesh();
@ -985,7 +983,7 @@ int SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList&
if ( aGrpType != theType && theType != SMDSAbs_Node )
return 0;
SMESH::long_array_var anIds = myGroupServer->GetListOfID();
SMESH::smIdType_array_var anIds = myGroupServer->GetListOfID();
if ( anIds->length() == 0 )
return 0;
@ -1028,7 +1026,7 @@ SMESH_subMeshObj::~SMESH_subMeshObj()
// function : GetEntities
// purpose : Get entities of specified type. Return number of entities
//=================================================================================
int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
smIdType SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
{
switch ( theType )
{
@ -1043,7 +1041,7 @@ int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
case SMDSAbs_Face:
case SMDSAbs_Volume:
{
SMESH::long_array_var anIds =
SMESH::smIdType_array_var anIds =
mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
return anIds->length();
}
@ -1053,7 +1051,7 @@ int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
}
}
int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
smIdType SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
{
theResList.clear();
@ -1067,7 +1065,7 @@ int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityLis
{
if ( theType == SMDSAbs_Node )
{
SMESH::long_array_var anIds = mySubMeshServer->GetNodesId();
SMESH::smIdType_array_var anIds = mySubMeshServer->GetNodesId();
return getPointers( SMDSAbs_Node, anIds, aMesh, theResList );
}
}
@ -1075,12 +1073,12 @@ int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityLis
{
if ( theType == SMDSAbs_Node )
{
SMESH::long_array_var anIds = mySubMeshServer->GetElementsId();
SMESH::smIdType_array_var anIds = mySubMeshServer->GetElementsId();
return getNodesFromElems( anIds, aMesh, theResList );
}
else
{
SMESH::long_array_var anIds =
SMESH::smIdType_array_var anIds =
mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
return getPointers( theType, anIds, aMesh, theResList );
}

21
src/OBJECT/SMESH_Object.h
View File

@ -45,6 +45,7 @@
#include "SMDSAbs_ElementType.hxx"
#include <SALOMEconfig.h>
#include <smIdType.hxx>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
class SMDS_Mesh;
@ -61,24 +62,24 @@ public:
virtual bool Update( int theIsClear = true ) = 0;
virtual bool NulData() = 0;
virtual void UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor ) = 0;
virtual int GetElemDimension( const int theObjId ) = 0;
virtual int GetElemDimension( const smIdType theObjId ) = 0;
virtual int GetNbEntities( const SMDSAbs_ElementType theType) const = 0;
virtual smIdType GetNbEntities( const SMDSAbs_ElementType theType) const = 0;
virtual SMDS_Mesh* GetMesh() const = 0;
virtual SMESH::SMESH_Mesh_ptr GetMeshServer() = 0;
virtual bool GetEdgeNodes( const int theElemId,
const int theEdgeNum,
int& theNodeId1,
int& theNodeId2 ) const = 0;
virtual bool GetEdgeNodes( const smIdType theElemId,
const int theEdgeNum,
smIdType& theNodeId1,
smIdType& theNodeId2 ) const = 0;
virtual bool IsValid() const = 0;
virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0;
virtual vtkIdType GetNodeObjId( int theVTKID ) = 0;
virtual vtkIdType GetNodeVTKId( int theObjID ) = 0;
virtual vtkIdType GetElemObjId( int theVTKID ) = 0;
virtual vtkIdType GetElemVTKId( int theObjID ) = 0;
virtual vtkIdType GetNodeObjId( vtkIdType theVTKID ) = 0;
virtual vtkIdType GetNodeVTKId( vtkIdType theObjID ) = 0;
virtual vtkIdType GetElemObjId( vtkIdType theVTKID ) = 0;
virtual vtkIdType GetElemVTKId( vtkIdType theObjID ) = 0;
virtual void ClearEntitiesFlags() = 0;
virtual bool GetEntitiesFlag() = 0;
virtual unsigned int GetEntitiesState() = 0;

40
src/OBJECT/SMESH_ObjectDef.h
View File

@ -63,27 +63,27 @@ public:
virtual bool Update( int theIsClear = true ) = 0;
virtual bool NulData() {return 0; };
virtual void UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor ) = 0;
virtual int GetElemDimension( const int theObjId ) = 0;
virtual int GetElemDimension( const smIdType theObjId ) = 0;
virtual int GetNbEntities( const SMDSAbs_ElementType theType) const = 0;
virtual int GetEntities( const SMDSAbs_ElementType, TEntityList& ) const = 0;
virtual smIdType GetNbEntities( const SMDSAbs_ElementType theType) const = 0;
virtual smIdType GetEntities( const SMDSAbs_ElementType, TEntityList& ) const = 0;
virtual bool IsNodePrs() const = 0;
virtual SMDS_Mesh* GetMesh() const = 0;
virtual SMESH::SMESH_Mesh_ptr GetMeshServer() = 0;
virtual bool IsValid() const;
virtual bool GetEdgeNodes( const int theElemId,
const int theEdgeNum,
int& theNodeId1,
int& theNodeId2 ) const;
virtual bool GetEdgeNodes( const smIdType theElemId,
const int theEdgeNum,
smIdType& theNodeId1,
smIdType& theNodeId2 ) const;
virtual vtkUnstructuredGrid* GetUnstructuredGrid();
virtual vtkIdType GetNodeObjId( int theVTKID );
virtual vtkIdType GetNodeVTKId( int theObjID );
virtual vtkIdType GetElemObjId( int theVTKID );
virtual vtkIdType GetElemVTKId( int theObjID );
virtual vtkIdType GetNodeObjId( vtkIdType theVTKID );
virtual vtkIdType GetNodeVTKId( vtkIdType theObjID );
virtual vtkIdType GetElemObjId( vtkIdType theVTKID );
virtual vtkIdType GetElemVTKId( vtkIdType theObjID );
virtual void ClearEntitiesFlags();
virtual bool GetEntitiesFlag();
@ -108,7 +108,7 @@ protected:
unsigned int myEntitiesState;
vtkUnstructuredGrid* myGrid;
std::map<SMDSAbs_ElementType,int> myEntitiesCache;
std::map<SMDSAbs_ElementType,smIdType> myEntitiesCache;
};
@ -127,11 +127,11 @@ public:
virtual bool Update( int theIsClear = true );
virtual bool NulData();
virtual int GetNbEntities( const SMDSAbs_ElementType) const;
virtual int GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
virtual smIdType GetNbEntities( const SMDSAbs_ElementType) const;
virtual smIdType GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
virtual bool IsNodePrs() const;
virtual int GetElemDimension( const int theObjId );
virtual int GetElemDimension( const smIdType theObjId );
virtual void UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor );
@ -160,7 +160,7 @@ public:
virtual bool Update( int theIsClear = true );
virtual void UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor );
virtual int GetElemDimension( const int theObjId );
virtual int GetElemDimension( const smIdType theObjId );
virtual SMDS_Mesh* GetMesh() const { return myMeshObj->GetMesh(); }
virtual SMESH::SMESH_Mesh_ptr GetMeshServer() { return myMeshObj->GetMeshServer(); }
@ -181,8 +181,8 @@ public:
SMESH_GroupObj( SMESH::SMESH_GroupBase_ptr, SMESH_MeshObj* );
virtual ~SMESH_GroupObj();
virtual int GetNbEntities( const SMDSAbs_ElementType) const;
virtual int GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
virtual smIdType GetNbEntities( const SMDSAbs_ElementType) const;
virtual smIdType GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
virtual bool IsNodePrs() const;
virtual SMDSAbs_ElementType GetElementType() const;
@ -206,8 +206,8 @@ public:
SMESH_MeshObj* );
virtual ~SMESH_subMeshObj();
virtual int GetNbEntities( const SMDSAbs_ElementType) const;
virtual int GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
virtual smIdType GetNbEntities( const SMDSAbs_ElementType) const;
virtual smIdType GetEntities( const SMDSAbs_ElementType, TEntityList& ) const;
virtual bool IsNodePrs() const;
protected:

7
src/OBJECT/SMESH_SVTKActor.cxx
View File

@ -108,7 +108,7 @@ SMESH_SVTKActor
void
SMESH_SVTKActor
::MapCells(SALOME_Actor* theMapActor,
const TColStd_IndexedMapOfInteger& theMapIndex)
const SVTK_TIndexedMapOfVtkId& theMapIndex)
{
myUnstructuredGrid->Initialize();
myUnstructuredGrid->Allocate();
@ -134,8 +134,9 @@ SMESH_SVTKActor
cd = aSourceGrid->GetCellData();
}
outputCD->CopyAllocate(cd,aNbOfParts,aNbOfParts/2);
for(int ind = 1; ind <= aNbOfParts; ind++){
int aPartId = theMapIndex( ind );
for(int ind = 1; ind <= aNbOfParts; ind++)
{
vtkIdType aPartId = theMapIndex( ind );
if(vtkCell* aCell = theMapActor->GetElemCell(aPartId))
{
if (aCell->GetCellType() != VTK_POLYHEDRON)

2
src/OBJECT/SMESH_SVTKActor.h
View File

@ -61,7 +61,7 @@ public:
//! Allow to recostruct selected cells from source SALOME_Actor and map of subindexes
virtual void
MapCells(SALOME_Actor* theMapActor,
const TColStd_IndexedMapOfInteger& theMapIndex);
const SVTK_TIndexedMapOfVtkId& theMapIndex);
//! To remove the actor an all its internal devices

2
src/SMDS/SMDS_BallElement.cxx
View File

@ -30,7 +30,7 @@
void SMDS_BallElement::init(const SMDS_MeshNode * node, double diameter )
{
vtkIdType nodeVtkID = node->GetVtkID();
int vtkID = getGrid()->InsertNextLinkedCell( toVtkType( SMDSEntity_Ball ), 1, &nodeVtkID );
vtkIdType vtkID = getGrid()->InsertNextLinkedCell( toVtkType( SMDSEntity_Ball ), 1, &nodeVtkID );
setVtkID( vtkID );
getGrid()->SetBallDiameter( GetVtkID(), diameter );
}

6
src/SMDS/SMDS_CellOfNodes.cxx
View File

@ -25,18 +25,18 @@
#include "SMDS_CellOfNodes.hxx"
SMDS_CellOfNodes::SMDS_CellOfNodes( int id, int shapeID )
SMDS_CellOfNodes::SMDS_CellOfNodes( smIdType id, int shapeID )
: myID( id )
{
setShapeID( shapeID );
}
void SMDS_CellOfNodes::setID(const int id)
void SMDS_CellOfNodes::setID(const smIdType id)
{
myID = id;
}
int SMDS_CellOfNodes::GetID() const
smIdType SMDS_CellOfNodes::GetID() const
{
return myID;
}

14
src/SMDS/SMDS_CellOfNodes.hxx
View File

@ -31,6 +31,8 @@
#include "SMDS_MeshElement.hxx"
#include <smIdType.hxx>
// ============================================================
/*!
* \brief Base class for elements not contained in the mesh
@ -42,8 +44,8 @@ class SMDS_EXPORT SMDS_CellOfNodes : public SMDS_MeshElement
{
public:
virtual int GetID() const;
virtual int GetShapeID() const;
virtual smIdType GetID() const;
virtual int GetShapeID() const;
virtual void setIsMarked( bool is ) const;
virtual bool isMarked() const;
@ -52,13 +54,13 @@ public:
protected:
SMDS_CellOfNodes( int id = -1, int shapeID = 0);
SMDS_CellOfNodes( smIdType id = -1, int shapeID = 0);
virtual void setID( const int id);
virtual void setID( const smIdType id);
virtual void setShapeID( const int shapeID );
int myID;
int myShapeID;
smIdType myID;
int myShapeID;
enum Bits { // use the 1st right bit of myShapeId to set/unset a mark
BIT_IS_MARKED = 1,

7
src/SMDS/SMDS_Downward.cxx
View File

@ -27,6 +27,7 @@
#include <vtkCellType.h>
#include <vtkCellLinks.h>
#include <smIdType.hxx>
#include <map>
@ -232,7 +233,7 @@ void SMDS_Down1D::compactStorage()
_cellIds.resize(_nbDownCells * _maxId);
_vtkCellIds.resize(_maxId);
int sizeUpCells = 0;
smIdType sizeUpCells = 0;
for (int i = 0; i < _maxId; i++)
sizeUpCells += _upCellIdsVector[i].size();
_upCellIds.resize(sizeUpCells, -1);
@ -258,8 +259,8 @@ void SMDS_Down1D::compactStorage()
void SMDS_Down1D::addUpCell(int cellId, int upCellId, unsigned char aType)
{
//ASSERT((cellId >=0) && (cellId < _maxId));
int nbFaces = _upCellIdsVector[cellId].size();
for (int i = 0; i < nbFaces; i++)
smIdType nbFaces = _upCellIdsVector[cellId].size();
for (smIdType i = 0; i < nbFaces; i++)
{
if ((_upCellIdsVector[cellId][i] == upCellId) && (_upCellTypesVector[cellId][i] == aType))
{

103
src/SMDS/SMDS_ElementFactory.cxx
View File

@ -104,15 +104,15 @@ int SMDS_ElementFactory::ChunkSize()
//================================================================================
/*!
* \brief Return minimal ID of a non-used element
* \return int - minimal element ID
* \return smIdType - minimal element ID
*/
//================================================================================
int SMDS_ElementFactory::GetFreeID()
smIdType SMDS_ElementFactory::GetFreeID()
{
if ( myChunksWithUnused.empty() )
{
int id0 = myChunks.size() * theChunkSize + 1;
smIdType id0 = myChunks.size() * theChunkSize + 1;
myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
}
SMDS_ElementChunk * chunk = (*myChunksWithUnused.begin());
@ -122,15 +122,15 @@ int SMDS_ElementFactory::GetFreeID()
//================================================================================
/*!
* \brief Return maximal ID of an used element
* \return int - element ID
* \return smIdType - element ID
*/
//================================================================================
int SMDS_ElementFactory::GetMaxID()
smIdType SMDS_ElementFactory::GetMaxID()
{
int id = 0;
smIdType id = 0;
TIndexRanges usedRanges;
for ( int i = myChunks.size() - 1; i >= 0; --i )
for ( smIdType i = myChunks.size() - 1; i >= 0; --i )
if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges ))
{
int index = usedRanges.back().second-1;
@ -143,13 +143,13 @@ int SMDS_ElementFactory::GetMaxID()
//================================================================================
/*!
* \brief Return minimal ID of an used element
* \return int - element ID
* \return smIdType - element ID
*/
//================================================================================
int SMDS_ElementFactory::GetMinID()
smIdType SMDS_ElementFactory::GetMinID()
{
int id = 0;
smIdType id = 0;
TIndexRanges usedRanges;
for ( size_t i = 0; i < myChunks.size(); ++i )
if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges ))
@ -169,20 +169,20 @@ int SMDS_ElementFactory::GetMinID()
*/
//================================================================================
SMDS_MeshElement* SMDS_ElementFactory::NewElement( const int id )
SMDS_MeshElement* SMDS_ElementFactory::NewElement( const smIdType id )
{
int iChunk = ( id - 1 ) / theChunkSize;
int index = ( id - 1 ) % theChunkSize;
while ((int) myChunks.size() <= iChunk )
smIdType iChunk = ( id - 1 ) / theChunkSize;
smIdType index = ( id - 1 ) % theChunkSize;
while ((smIdType) myChunks.size() <= iChunk )
{
int id0 = myChunks.size() * theChunkSize + 1;
smIdType id0 = myChunks.size() * theChunkSize + 1;
myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
}
SMDS_MeshElement* e = myChunks[iChunk].Element( index );
SMDS_MeshElement* e = myChunks[iChunk].Element( FromSmIdType<int>(index) );
if ( !e->IsNull() )
return 0; // element with given ID already exists
myChunks[iChunk].UseElement( index );
myChunks[iChunk].UseElement( FromSmIdType<int>(index) );
++myNbUsedElements;
e->myHolder = & myChunks[iChunk];
@ -200,15 +200,15 @@ SMDS_MeshElement* SMDS_ElementFactory::NewElement( const int id )
*/
//================================================================================
const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const int id ) const
const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const smIdType id ) const
{
if ( id > 0 )
{
int iChunk = ( id - 1 ) / theChunkSize;
int index = ( id - 1 ) % theChunkSize;
if ( iChunk < (int) myChunks.size() )
smIdType iChunk = ( id - 1 ) / theChunkSize;
smIdType index = ( id - 1 ) % theChunkSize;
if ( iChunk < (smIdType) myChunks.size() )
{
const SMDS_MeshElement* e = myChunks[iChunk].Element( index );
const SMDS_MeshElement* e = myChunks[iChunk].Element( FromSmIdType<int>(index) );
return e->IsNull() ? 0 : e;
}
}
@ -218,12 +218,12 @@ const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const int id ) const
//================================================================================
/*!
* \brief Return an SMDS ID by a Vtk one
* \param [inout] vtkID - Vtk ID
* \return int - SMDS ID
* \param [in] vtkID - Vtk ID
* \return smIdType - SMDS ID
*/
//================================================================================
int SMDS_ElementFactory::FromVtkToSmds( vtkIdType vtkID )
smIdType SMDS_ElementFactory::FromVtkToSmds( vtkIdType vtkID )
{
if ( vtkID >= 0 && vtkID < (vtkIdType)mySmdsIDs.size() )
return mySmdsIDs[vtkID] + 1;
@ -281,11 +281,11 @@ void SMDS_ElementFactory::Clear()
*/
//================================================================================
void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld )
void SMDS_ElementFactory::Compact( std::vector<smIdType>& theVtkIDsNewToOld )
{
int newNbCells = NbUsedElements();
int maxCellID = GetMaxID();
int newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
smIdType newNbCells = NbUsedElements();
smIdType maxCellID = GetMaxID();
smIdType newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
theVtkIDsNewToOld.resize( newNbCells );
@ -295,7 +295,7 @@ void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld )
}
else if ( newNbCells == maxCellID ) // no holes
{
int newID, minLastID = std::min( myVtkIDs.size(), theVtkIDsNewToOld.size() );
smIdType newID, minLastID = std::min( myVtkIDs.size(), theVtkIDsNewToOld.size() );
for ( newID = 0; newID < minLastID; ++newID )
theVtkIDsNewToOld[ newID ] = myVtkIDs[ newID ];
for ( ; newID < newNbCells; ++newID )
@ -303,8 +303,8 @@ void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld )
}
else // there are holes in SMDS IDs
{
int newVtkID = 0; // same as new smds ID (-1)
for ( int oldID = 1; oldID <= maxCellID; ++oldID ) // smds IDs
smIdType newVtkID = 0; // same as new smds ID (-1)
for ( smIdType oldID = 1; oldID <= maxCellID; ++oldID ) // smds IDs
{
const SMDS_MeshElement* oldElem = FindElement( oldID );
if ( !oldElem ) continue;
@ -377,16 +377,16 @@ SMDS_NodeFactory::~SMDS_NodeFactory()
*/
//================================================================================
void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew )
void SMDS_NodeFactory::Compact( std::vector<smIdType>& theVtkIDsOldToNew )
{
// IDs of VTK nodes always correspond to SMDS IDs but there can be "holes"
// in the chunks. So we remove holes and report relocation in theVtkIDsOldToNew:
// theVtkIDsOldToNew[ old VtkID ] = new VtkID
int oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
int newNbNodes = NbUsedElements();
int newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
int maxNodeID = GetMaxID();
smIdType oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
smIdType newNbNodes = NbUsedElements();
smIdType newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
smIdType maxNodeID = GetMaxID();
theVtkIDsOldToNew.resize( oldNbNodes, -1 );
@ -408,13 +408,13 @@ void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew )
const SMDS_MeshElement* newNode = FindElement( newID+1 );
if ( !newNode )
newNode = NewElement( newID+1 );
int shapeID = oldNode->GetShapeID();
int shapeDim = GetShapeDim( shapeID );
int iChunk = newID / theChunkSize;
int shapeID = oldNode->GetShapeID();
int shapeDim = GetShapeDim( shapeID );
smIdType iChunk = newID / theChunkSize;
myChunks[ iChunk ].SetShapeID( newNode, shapeID );
if ( shapeDim == 2 || shapeDim == 1 )
{
int iChunkOld = oldID / theChunkSize;
smIdType iChunkOld = oldID / theChunkSize;
TParam* oldPos = myChunks[ iChunkOld ].GetPositionPtr( oldNode );
TParam* newPos = myChunks[ iChunk ].GetPositionPtr( newNode, /*allocate=*/true );
if ( oldPos )
@ -431,7 +431,7 @@ void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew )
}
else // no holes
{
for ( int i = 0; i < newNbNodes; ++i )
for ( smIdType i = 0; i < newNbNodes; ++i )
theVtkIDsOldToNew[ i ] = i;
}
myChunks.resize( newNbChunks );
@ -514,7 +514,7 @@ void SMDS_NodeFactory::SetShapeDim( int shapeID, int dim )
*/
//================================================================================
SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, int id0 ):
SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, smIdType id0 ):
myFactory( factory ),
my1stID( id0 )//,
//mySubIDSet( 0 )
@ -565,7 +565,7 @@ void SMDS_ElementChunk::UseElement( const int index )
*/
//================================================================================
int SMDS_ElementChunk::GetUnusedID() const
smIdType SMDS_ElementChunk::GetUnusedID() const
{
TUsedRangeSet::set_iterator r = myUsedRanges.mySet.begin();
for ( ; r != myUsedRanges.mySet.end(); ++r )
@ -603,7 +603,7 @@ void SMDS_ElementChunk::Free( const SMDS_MeshElement* e )
*/
//================================================================================
int SMDS_ElementChunk::GetID( const SMDS_MeshElement* e ) const
smIdType SMDS_ElementChunk::GetID( const SMDS_MeshElement* e ) const
{
return my1stID + Index( e );
}
@ -618,11 +618,12 @@ void SMDS_ElementChunk::SetVTKID( const SMDS_MeshElement* e, const vtkIdType vtk
{
if ( e->GetID() - 1 != vtkID )
{
if ((int) myFactory->myVtkIDs.size() <= e->GetID() - 1 )
if ((smIdType) myFactory->myVtkIDs.size() <= e->GetID() - 1 )
{
size_t i = myFactory->myVtkIDs.size();
vtkIdType i = (vtkIdType) myFactory->myVtkIDs.size();
myFactory->myVtkIDs.resize( e->GetID() + 100 );
for ( ; i < myFactory->myVtkIDs.size(); ++i )
vtkIdType newSize = (vtkIdType) myFactory->myVtkIDs.size();
for ( ; i < newSize; ++i )
myFactory->myVtkIDs[i] = i;
}
myFactory->myVtkIDs[ e->GetID() - 1 ] = vtkID;
@ -644,10 +645,10 @@ void SMDS_ElementChunk::SetVTKID( const SMDS_MeshElement* e, const vtkIdType vtk
*/
//================================================================================
int SMDS_ElementChunk::GetVtkID( const SMDS_MeshElement* e ) const
vtkIdType SMDS_ElementChunk::GetVtkID( const SMDS_MeshElement* e ) const
{
size_t dfltVtkID = e->GetID() - 1;
return ( dfltVtkID < myFactory->myVtkIDs.size() ) ? myFactory->myVtkIDs[ dfltVtkID ] : dfltVtkID;
vtkIdType dfltVtkID = FromSmIdType<vtkIdType>(e->GetID() - 1);
return ( dfltVtkID < (vtkIdType)myFactory->myVtkIDs.size() ) ? myFactory->myVtkIDs[ dfltVtkID ] : dfltVtkID;
}
//================================================================================

48
src/SMDS/SMDS_ElementFactory.hxx
View File

@ -40,6 +40,8 @@
#include <vtkType.h>
#include <smIdType.hxx>
class SMDS_ElementChunk;
class SMDS_Mesh;
class SMDS_MeshCell;
@ -67,8 +69,8 @@ protected:
TChunkVector myChunks; // array of chunks of elements
TChunkPtrSet myChunksWithUnused; // sorted chunks having unused elements
std::vector< vtkIdType > myVtkIDs; // myVtkIDs[ smdsID-1 ] == vtkID
std::vector< int > mySmdsIDs; // mySmdsIDs[ vtkID ] == smdsID - 1
int myNbUsedElements; // counter of elements
std::vector< smIdType > mySmdsIDs; // mySmdsIDs[ vtkID ] == smdsID - 1
smIdType myNbUsedElements; // counter of elements
friend class SMDS_ElementChunk;
@ -78,25 +80,25 @@ public:
virtual ~SMDS_ElementFactory();
//! Return minimal ID of a non-used element
int GetFreeID();
smIdType GetFreeID();
//! Return maximal ID of an used element
int GetMaxID();
smIdType GetMaxID();
//! Return minimal ID of an used element
int GetMinID();
smIdType GetMinID();
//! Return an element by ID. NULL if the element with the given ID is already used
SMDS_MeshElement* NewElement( const int id );
SMDS_MeshElement* NewElement( const smIdType id );
//! Return a SMDS_MeshCell by ID. NULL if the cell with the given ID is already used
SMDS_MeshCell* NewCell( const int id ) { return static_cast<SMDS_MeshCell*>( NewElement( id )); }
SMDS_MeshCell* NewCell( const smIdType id ) { return static_cast<SMDS_MeshCell*>( NewElement( id )); }
//! Return an used element by ID. NULL if the element with the given ID is not yet used
const SMDS_MeshElement* FindElement( const int id ) const;
const SMDS_MeshElement* FindElement( const smIdType id ) const;
//! Return a number of used elements
int NbUsedElements() const { return myNbUsedElements; }
smIdType NbUsedElements() const { return myNbUsedElements; }
//! Return an iterator on all element filtered using a given filter.
// nbElemsToReturn is used to optimize by stopping the iteration as soon as
@ -119,14 +121,14 @@ public:
void Free( const SMDS_MeshElement* );
//! Return an SMDS ID by a Vtk one
int FromVtkToSmds( vtkIdType vtkID );
smIdType FromVtkToSmds( vtkIdType vtkID );
//! De-allocate all elements
virtual void Clear();
//! Remove unused elements located not at the end of the last chunk.
// Minimize allocated memory
virtual void Compact(std::vector<int>& idCellsOldToNew);
virtual void Compact(std::vector<smIdType>& idCellsOldToNew);
//! Return true if Compact() will change IDs of elements
virtual bool CompactChangePointers();
@ -149,10 +151,10 @@ public:
~SMDS_NodeFactory();
//! Return a SMDS_MeshNode by ID. NULL if the node with the given ID is already used
SMDS_MeshNode* NewNode( int id ) { return (SMDS_MeshNode*) NewElement(id); }
SMDS_MeshNode* NewNode( smIdType id ) { return (SMDS_MeshNode*) NewElement(id); }
//! Return an used node by ID. NULL if the node with the given ID is not yet used
const SMDS_MeshNode* FindNode( int id ) { return (const SMDS_MeshNode*) FindElement(id); }
const SMDS_MeshNode* FindNode( smIdType id ) { return (const SMDS_MeshNode*) FindElement(id); }
//! Set a total number of sub-shapes in the main shape
void SetNbShapes( size_t nbShapes );
@ -168,7 +170,7 @@ public:
//! Remove unused nodes located not at the end of the last chunk.
// Minimize allocated memory
virtual void Compact(std::vector<int>& idNodesOldToNew);
virtual void Compact(std::vector<smIdType>& idNodesOldToNew);
//! Return true if Compact() will change IDs of node
virtual bool CompactChangePointers();
@ -277,7 +279,7 @@ struct _RangeSet
rNext = mySet.upper_bound( theIndex );
r = rNext - 1;
}
int rSize = Size( r ); // range size
int rSize = Size( r ); // range size
attr_t rValue = r->myValue;
if ( rValue == theValue )
return rValue; // it happens while compacting
@ -370,7 +372,7 @@ class SMDS_ElementChunk
{
SMDS_ElementFactory* myFactory; // holder of this chunk
SMDS_MeshElement* myElements; // array of elements
int my1stID; // ID of myElements[0]
smIdType my1stID; // ID of myElements[0]
TBitSet myMarkedSet; // mark some elements
TUsedRangeSet myUsedRanges; // ranges of used/unused elements
TSubIDRangeSet mySubIDRanges; // ranges of elements on the same sub-shape
@ -381,7 +383,7 @@ class SMDS_ElementChunk
public:
SMDS_ElementChunk( SMDS_ElementFactory* factory = 0, int id0 = 0 );
SMDS_ElementChunk( SMDS_ElementFactory* factory = 0, smIdType id0 = 0 );
~SMDS_ElementChunk();
//! Return an element by an index [0,ChunkSize()]
@ -391,7 +393,7 @@ public:
const SMDS_MeshElement* Element(int index) const { return & myElements[index]; }
//! Return ID of the first non-used element
int GetUnusedID() const;
smIdType GetUnusedID() const;
//! Mark an element as used
void UseElement( const int index );
@ -403,10 +405,10 @@ public:
static bool IsUsed( const _UsedRange& r ) { return r.myValue; }
//! Return index of an element in the chunk
int Index( const SMDS_MeshElement* e ) const { return e - myElements; }
int Index( const SMDS_MeshElement* e ) const { return (int)( e - myElements ); }
//! Return ID of the 1st element in the chunk
int Get1stID() const { return my1stID; }
smIdType Get1stID() const { return my1stID; }
//! Return pointer to on-shape-parameters of a node
TParam* GetPositionPtr( const SMDS_MeshElement* node, bool allocate=false );
@ -429,9 +431,9 @@ public:
// Methods called by SMDS_MeshElement
int GetID( const SMDS_MeshElement* e ) const;
smIdType GetID( const SMDS_MeshElement* e ) const;
int GetVtkID( const SMDS_MeshElement* e ) const;
vtkIdType GetVtkID( const SMDS_MeshElement* e ) const;
void SetVTKID( const SMDS_MeshElement* e, const vtkIdType id );
int GetShapeID( const SMDS_MeshElement* e ) const;
@ -563,7 +565,7 @@ SMDS_ElementFactory::GetShapeIterator( int shapeID,
size_t nbElemsToReturn,
const SMDS_MeshElement* sm1stElem )
{
int iChunk = sm1stElem ? (( sm1stElem->GetID() - 1 ) / ChunkSize()) : 0;
smIdType iChunk = sm1stElem ? (( sm1stElem->GetID() - 1 ) / ChunkSize()) : 0;
typedef _ChunkIterator< ElemIterator, TSubIDRangeSet > TChuckIterator;
return boost::make_shared< TChuckIterator >( myChunks,
& SMDS_ElementChunk::GetSubIDRangesMinMax,

15
src/SMDS/SMDS_ElementHolder.cxx
View File

@ -59,8 +59,7 @@ SMDS_ElementHolder::~SMDS_ElementHolder()
void SMDS_ElementHolder::beforeCompacting()
{
int i = 0;
for ( SMDS_ElemIteratorPtr it = getElements(); it->more(); ++i )
for ( SMDS_ElemIteratorPtr it = getElements(); it->more(); )
{
const SMDS_MeshElement* e = it->next();
if ( !e ) continue;
@ -74,7 +73,7 @@ void SMDS_ElementHolder::beforeCompacting()
else
{
myExternalElems.push_back( e );
myVtkIDs.push_back( -1 * (int)myExternalElems.size() );
myVtkIDs.push_back( -1 * (vtkIdType) myExternalElems.size() );
}
}
}
@ -84,8 +83,8 @@ void SMDS_ElementHolder::beforeCompacting()
//purpose : restore pointers to elements
//=======================================================================
void SMDS_ElementHolder::restoreElements( const std::vector<int>& idNodesOldToNew,
const std::vector<int>& idCellsOldToNew )
void SMDS_ElementHolder::restoreElements( const std::vector<smIdType>& idNodesOldToNew,
const std::vector<smIdType>& idCellsOldToNew )
{
tmpClear();
@ -94,21 +93,21 @@ void SMDS_ElementHolder::restoreElements( const std::vector<int>& idNodesOldToNe
std::vector< bool >::iterator isNode = myIsNode.begin();
for ( size_t i = 0; i < myVtkIDs.size(); ++i, ++isNode )
{
int vtkID = myVtkIDs[i];
vtkIdType vtkID = myVtkIDs[i];
if ( vtkID < 0 )
{
elem = myExternalElems[ (-vtkID)-1 ];
}
else if ( *isNode )
{
if ( vtkID < (int)idNodesOldToNew.size() )
if ( vtkID < (vtkIdType)idNodesOldToNew.size() )
elem = myMesh->FindNodeVtk( idNodesOldToNew[ vtkID ]);
else
elem = myMesh->FindNodeVtk( vtkID );
}
else
{
if ( vtkID < (int)idCellsOldToNew.size() )
if ( vtkID < (vtkIdType)idCellsOldToNew.size() )
elem = myMesh->FindElementVtk( idCellsOldToNew[ vtkID ]);
else
elem = myMesh->FindElementVtk( vtkID );

9
src/SMDS/SMDS_ElementHolder.hxx
View File

@ -29,6 +29,9 @@
#include "SMDS_ElemIterator.hxx"
#include <smIdType.hxx>
#include <vtkType.h>
#include <vector>
#include <set>
@ -80,12 +83,12 @@ class SMDS_EXPORT SMDS_ElementHolder
void beforeCompacting();
//! restore pointers to elements
void restoreElements( const std::vector<int>& idNodessOldToNew,
const std::vector<int>& idCellsOldToNew );
void restoreElements( const std::vector<smIdType>& idNodessOldToNew,
const std::vector<smIdType>& idCellsOldToNew );
std::vector<const SMDS_MeshElement*> myExternalElems; //!< elements not contained in the mesh
std::vector< int > myVtkIDs; //!< vtk IDs of elements
std::vector< vtkIdType > myVtkIDs; //!< vtk IDs of elements
std::vector< bool > myIsNode;
std::set< SMDS_ElementHolder* >::iterator myPtrInMesh;
};

321
src/SMDS/SMDS_Mesh.cxx
View File

@ -183,7 +183,7 @@ SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z)
///@param ID : The ID of the MeshNode to create
///@return : The created node or NULL if a node with this ID already exists
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshNode * SMDS_Mesh::AddNodeWithID( double x, double y, double z, int ID )
SMDS_MeshNode * SMDS_Mesh::AddNodeWithID( double x, double y, double z, smIdType ID )
{
// find the MeshNode corresponding to ID
SMDS_MeshNode *node = myNodeFactory->NewNode( ID );
@ -201,7 +201,7 @@ SMDS_MeshNode * SMDS_Mesh::AddNodeWithID( double x, double y, double z, int ID )
/// create a Mesh0DElement and add it to the current Mesh
/// @return : The created Mesh0DElement
///////////////////////////////////////////////////////////////////////////////
SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(int idnode, int ID)
SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(smIdType idnode, smIdType ID)
{
const SMDS_MeshNode * node = myNodeFactory->FindNode(idnode);
if (!node) return NULL;
@ -224,7 +224,7 @@ SMDS_Mesh0DElement* SMDS_Mesh::Add0DElement(const SMDS_MeshNode * node)
/// @return The created 0D element or NULL if an element with this
/// ID already exists or if input node is not found.
///////////////////////////////////////////////////////////////////////////////
SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(const SMDS_MeshNode * n, int ID)
SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(const SMDS_MeshNode * n, smIdType ID)
{
if (!n) return 0;
@ -244,7 +244,7 @@ SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(const SMDS_MeshNode * n, int I
/// create a Ball and add it to the current Mesh
/// @return : The created Ball
///////////////////////////////////////////////////////////////////////////////
SMDS_BallElement* SMDS_Mesh::AddBallWithID( int idnode, double diameter, int ID )
SMDS_BallElement* SMDS_Mesh::AddBallWithID( smIdType idnode, double diameter, smIdType ID )
{
const SMDS_MeshNode * node = myNodeFactory->FindNode( idnode );
if (!node) return NULL;
@ -268,7 +268,7 @@ SMDS_BallElement* SMDS_Mesh::AddBall(const SMDS_MeshNode * node, double diameter
/// @return The created 0D element or NULL if an element with this
/// ID already exists or if input node is not found.
///////////////////////////////////////////////////////////////////////////////
SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID)
SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID)
{
if (!n) return 0;
@ -288,7 +288,7 @@ SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diame
/// @return : The created MeshEdge
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID)
SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(smIdType idnode1, smIdType idnode2, smIdType ID)
{
const SMDS_MeshNode * node1 = myNodeFactory->FindNode(idnode1);
const SMDS_MeshNode * node2 = myNodeFactory->FindNode(idnode2);
@ -318,7 +318,7 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1,
SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
int ID)
smIdType ID)
{
if ( !n1 || !n2 ) return 0;
@ -347,7 +347,10 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
/// Add a triangle defined by its nodes IDs
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, int ID)
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(smIdType idnode1,
smIdType idnode2,
smIdType idnode3,
smIdType ID)
{
const SMDS_MeshNode * node1 = myNodeFactory->FindNode(idnode1);
const SMDS_MeshNode * node2 = myNodeFactory->FindNode(idnode2);
@ -363,7 +366,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, i
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 ) return 0;
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -394,11 +397,11 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
/// Add a quadrangle defined by its nodes IDs
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1,
int idnode2,
int idnode3,
int idnode4,
int ID)
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(smIdType idnode1,
smIdType idnode2,
smIdType idnode3,
smIdType idnode4,
smIdType ID)
{
const SMDS_MeshNode *node1, *node2, *node3, *node4;
node1 = myNodeFactory->FindNode(idnode1);
@ -417,7 +420,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 || !n4 ) return 0;
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -451,11 +454,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
///or if input nodes are not found.
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
int idnode2,
int idnode3,
int idnode4,
int ID)
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(smIdType idnode1,
smIdType idnode2,
smIdType idnode3,
smIdType idnode4,
smIdType ID)
{
const SMDS_MeshNode *node1, *node2, *node3, *node4;
node1 = myNodeFactory->FindNode(idnode1);
@ -476,7 +479,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 || !n4 ) return 0;
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -513,12 +516,12 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
///or if input nodes are not found.
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
int idnode2,
int idnode3,
int idnode4,
int idnode5,
int ID)
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(smIdType idnode1,
smIdType idnode2,
smIdType idnode3,
smIdType idnode4,
smIdType idnode5,
smIdType ID)
{
const SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
node1 = myNodeFactory->FindNode(idnode1);
@ -542,7 +545,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 || !n4 || !n5 ) return 0;
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -569,7 +572,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6)
{
int ID = myCellFactory->GetFreeID();
smIdType ID = myCellFactory->GetFreeID();
return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
}
@ -581,13 +584,13 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
///or if input nodes are not found.
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
int idnode2,
int idnode3,
int idnode4,
int idnode5,
int idnode6,
int ID)
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(smIdType idnode1,
smIdType idnode2,
smIdType idnode3,
smIdType idnode4,
smIdType idnode5,
smIdType idnode6,
smIdType ID)
{
const SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
node1 = myNodeFactory->FindNode(idnode1);
@ -612,7 +615,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 ) return 0;
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -656,19 +659,19 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
///or if input nodes are not found.
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
int idnode2,
int idnode3,
int idnode4,
int idnode5,
int idnode6,
int idnode7,
int idnode8,
int idnode9,
int idnode10,
int idnode11,
int idnode12,
int ID)
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(smIdType idnode1,
smIdType idnode2,
smIdType idnode3,
smIdType idnode4,
smIdType idnode5,
smIdType idnode6,
smIdType idnode7,
smIdType idnode8,
smIdType idnode9,
smIdType idnode10,
smIdType idnode11,
smIdType idnode12,
smIdType ID)
{
const SMDS_MeshNode *node1 = myNodeFactory->FindNode(idnode1);
const SMDS_MeshNode *node2 = myNodeFactory->FindNode(idnode2);
@ -705,7 +708,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n10,
const SMDS_MeshNode * n11,
const SMDS_MeshNode * n12,
int ID)
smIdType ID)
{
SMDS_MeshVolume* volume = 0;
if(!n1 || !n2 || !n3 || !n4 || !n5 || !n6 ||
@ -738,7 +741,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8)
{
int ID = myCellFactory->GetFreeID();
smIdType ID = myCellFactory->GetFreeID();
return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
}
@ -750,15 +753,15 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
///exists or if input nodes are not found.
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
int idnode2,
int idnode3,
int idnode4,
int idnode5,
int idnode6,
int idnode7,
int idnode8,
int ID)
SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(smIdType idnode1,
smIdType idnode2,
smIdType idnode3,
smIdType idnode4,
smIdType idnode5,
smIdType idnode6,
smIdType idnode7,
smIdType idnode8,
smIdType ID)
{
const SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
node1 = myNodeFactory->FindNode(idnode1);
@ -789,7 +792,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
int ID)
smIdType ID)
{
SMDS_MeshVolume* volume = 0;
if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume;
@ -809,12 +812,12 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
/// Add a polygon defined by its nodes IDs
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (const std::vector<int> & nodes_ids,
const int ID)
SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (const std::vector<smIdType> & nodes_ids,
const smIdType ID)
{
int nbNodes = nodes_ids.size();
size_t nbNodes = nodes_ids.size();
std::vector<const SMDS_MeshNode*> nodes (nbNodes);
for (int i = 0; i < nbNodes; i++) {
for ( size_t i = 0; i < nbNodes; i++) {
nodes[i] = myNodeFactory->FindNode( nodes_ids[i] );
if (!nodes[i]) return NULL;
}
@ -827,7 +830,7 @@ SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (const std::vector<int> & nodes
SMDS_MeshFace*
SMDS_Mesh::AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*> & nodes,
const int ID)
const smIdType ID)
{
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -856,8 +859,8 @@ SMDS_MeshFace* SMDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNod
/// Add a quadratic polygon defined by its nodes IDs
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int> & nodes_ids,
const int ID)
SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<smIdType> & nodes_ids,
const smIdType ID)
{
std::vector<const SMDS_MeshNode*> nodes( nodes_ids.size() );
for ( size_t i = 0; i < nodes.size(); i++) {
@ -873,7 +876,7 @@ SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int> & n
SMDS_MeshFace*
SMDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*> & nodes,
const int ID)
const smIdType ID)
{
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if ( nodes.empty() )
@ -904,13 +907,13 @@ SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_Mes
/// or if input nodes are not found.
///////////////////////////////////////////////////////////////////////////////
SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int> & nodes_ids,
const std::vector<int> & quantities,
const int ID)
SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdType> & nodes_ids,
const std::vector<int> & quantities,
const smIdType ID)
{
int nbNodes = nodes_ids.size();
size_t nbNodes = nodes_ids.size();
std::vector<const SMDS_MeshNode*> nodes (nbNodes);
for (int i = 0; i < nbNodes; i++) {
for ( size_t i = 0; i < nbNodes; i++) {
nodes[i] = myNodeFactory->FindNode(nodes_ids[i]);
if (!nodes[i]) return NULL;
}
@ -926,7 +929,7 @@ SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int> &
SMDS_MeshVolume*
SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<const SMDS_MeshNode*>& nodes,
const std::vector<int> & quantities,
const int ID)
const smIdType ID)
{
if ( nodes.empty() || quantities.empty() )
return NULL;
@ -951,7 +954,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolume
(const std::vector<const SMDS_MeshNode*> & nodes,
const std::vector<int> & quantities)
{
int ID = myCellFactory->GetFreeID();
smIdType ID = myCellFactory->GetFreeID();
return SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
}
@ -987,7 +990,7 @@ void SMDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z)
///////////////////////////////////////////////////////////////////////////////
/// Return the node whose SMDS ID is 'ID'.
///////////////////////////////////////////////////////////////////////////////
const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
const SMDS_MeshNode * SMDS_Mesh::FindNode(smIdType ID) const
{
return myNodeFactory->FindNode( ID );
}
@ -995,12 +998,12 @@ const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
///////////////////////////////////////////////////////////////////////////////
/// Return the node whose VTK ID is 'vtkId'.
///////////////////////////////////////////////////////////////////////////////
const SMDS_MeshNode * SMDS_Mesh::FindNodeVtk(int vtkId) const
const SMDS_MeshNode * SMDS_Mesh::FindNodeVtk(vtkIdType vtkId) const
{
return myNodeFactory->FindNode( vtkId + 1 );
}
const SMDS_MeshElement * SMDS_Mesh::FindElementVtk(int IDelem) const
const SMDS_MeshElement * SMDS_Mesh::FindElementVtk(vtkIdType IDelem) const
{
return myCellFactory->FindElement( FromVtkToSmds( IDelem ));
}
@ -1356,7 +1359,7 @@ const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
//purpose :
//=======================================================================
const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
const SMDS_MeshElement* SMDS_Mesh::FindElement(smIdType IDelem) const
{
return myCellFactory->FindElement( IDelem );
}
@ -1435,7 +1438,7 @@ int SMDS_Mesh::GetElementsByNodes(const std::vector<const SMDS_MeshNode *>& node
}
foundElems.clear();
if ( n0 )
if ( n0 && minNbInverse > 0 )
{
foundElems.reserve( minNbInverse );
SMDS_ElemIteratorPtr eIt = n0->GetInverseElementIterator( type );
@ -1456,7 +1459,7 @@ int SMDS_Mesh::GetElementsByNodes(const std::vector<const SMDS_MeshNode *>& node
///////////////////////////////////////////////////////////////////////////////
/// Return the number of nodes
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbNodes() const
smIdType SMDS_Mesh::NbNodes() const
{
return myInfo.NbNodes();
}
@ -1464,14 +1467,14 @@ int SMDS_Mesh::NbNodes() const
///////////////////////////////////////////////////////////////////////////////
/// 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::Nb0DElements() const
smIdType SMDS_Mesh::Nb0DElements() const
{
return myInfo.Nb0DElements();
}
@ -1479,7 +1482,7 @@ int SMDS_Mesh::Nb0DElements() const
///////////////////////////////////////////////////////////////////////////////
/// Return the number of 0D elements
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbBalls() const
smIdType SMDS_Mesh::NbBalls() const
{
return myInfo.NbBalls();
}
@ -1487,7 +1490,7 @@ int SMDS_Mesh::NbBalls() const
///////////////////////////////////////////////////////////////////////////////
/// Return the number of edges (including construction edges)
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbEdges() const
smIdType SMDS_Mesh::NbEdges() const
{
return myInfo.NbEdges();
}
@ -1495,7 +1498,7 @@ int SMDS_Mesh::NbEdges() const
///////////////////////////////////////////////////////////////////////////////
/// Return the number of faces (including construction faces)
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbFaces() const
smIdType SMDS_Mesh::NbFaces() const
{
return myInfo.NbFaces();
}
@ -1503,7 +1506,7 @@ int SMDS_Mesh::NbFaces() const
///////////////////////////////////////////////////////////////////////////////
/// Return the number of volumes
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbVolumes() const
smIdType SMDS_Mesh::NbVolumes() const
{
return myInfo.NbVolumes();
}
@ -1512,7 +1515,7 @@ int SMDS_Mesh::NbVolumes() const
/// 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();
}
@ -1586,7 +1589,7 @@ SMDS_NodeIteratorPtr SMDS_Mesh::nodesIterator() const
SMDS_ElemIteratorPtr SMDS_Mesh::elementGeomIterator(SMDSAbs_GeometryType type) const
{
int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
return myCellFactory->GetIterator< SMDS_ElemIterator >( new SMDS_MeshElement::GeomFilter( type ),
nbElems);
}
@ -1597,7 +1600,7 @@ SMDS_ElemIteratorPtr SMDS_Mesh::elementEntityIterator(SMDSAbs_EntityType type) c
{
return myNodeFactory->GetIterator< SMDS_ElemIterator >( new SMDS_MeshElement::NonNullFilter );
}
int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
return myCellFactory->GetIterator<SMDS_ElemIterator>( new SMDS_MeshElement::EntityFilter( type ),
nbElems);
}
@ -1617,7 +1620,7 @@ SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const
return myNodeFactory->GetIterator< TIterator >( new SMDS_MeshElement::NonNullFilter );
default:
int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbElements( type );
return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( type ),
nbElems);
}
@ -1631,7 +1634,7 @@ SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const
SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator() const
{
typedef SMDS_EdgeIterator TIterator;
int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbEdges();
smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbEdges();
return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( SMDSAbs_Edge ),
nbElems);
}
@ -1643,7 +1646,7 @@ SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator() const
SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator() const
{
typedef SMDS_FaceIterator TIterator;
int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbFaces();
smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbFaces();
return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( SMDSAbs_Face ),
nbElems);
}
@ -1655,7 +1658,7 @@ SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator() const
SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator() const
{
typedef SMDS_VolumeIterator TIterator;
int nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbVolumes();
smIdType nbElems = myCellFactory->CompactChangePointers() ? -1 : myInfo.NbVolumes();
return
myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( SMDSAbs_Volume ),
nbElems );
@ -1871,7 +1874,7 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
n->RemoveInverseElement((*it));
}
int vtkid = (*it)->GetVtkID();
vtkIdType vtkid = (*it)->GetVtkID();
switch ((*it)->GetType()) {
case SMDSAbs_Node:
@ -1916,7 +1919,7 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
///////////////////////////////////////////////////////////////////////////////
void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
{
const int vtkId = elem->GetVtkID();
const vtkIdType vtkId = elem->GetVtkID();
SMDSAbs_ElementType aType = elem->GetType();
if ( aType == SMDSAbs_Node )
{
@ -1977,7 +1980,7 @@ bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const
//purpose :
//=======================================================================
int SMDS_Mesh::MaxNodeID() const
smIdType SMDS_Mesh::MaxNodeID() const
{
return myNodeFactory->GetMaxID();
}
@ -1987,7 +1990,7 @@ int SMDS_Mesh::MaxNodeID() const
//purpose :
//=======================================================================
int SMDS_Mesh::MinNodeID() const
smIdType SMDS_Mesh::MinNodeID() const
{
return myNodeFactory->GetMinID();
}
@ -1997,7 +2000,7 @@ int SMDS_Mesh::MinNodeID() const
//purpose :
//=======================================================================
int SMDS_Mesh::MaxElementID() const
smIdType SMDS_Mesh::MaxElementID() const
{
return myCellFactory->GetMaxID();
}
@ -2007,7 +2010,7 @@ int SMDS_Mesh::MaxElementID() const
//purpose :
//=======================================================================
int SMDS_Mesh::MinElementID() const
smIdType SMDS_Mesh::MinElementID() const
{
return myCellFactory->GetMinID();
}
@ -2029,7 +2032,7 @@ int SMDS_Mesh::MinElementID() const
//purpose : Return type of element or node with id
//=======================================================================
SMDSAbs_ElementType SMDS_Mesh::GetElementType( const int id, const bool iselem ) const
SMDSAbs_ElementType SMDS_Mesh::GetElementType( const smIdType id, const bool iselem ) const
{
const SMDS_MeshElement* elem = 0;
if( iselem )
@ -2054,7 +2057,7 @@ SMDSAbs_ElementType SMDS_Mesh::GetElementType( const int id, const bool iselem )
//function : AddEdgeWithID
//purpose :
//=======================================================================
SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID)
SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID)
{
return SMDS_Mesh::AddEdgeWithID (myNodeFactory->FindNode(n1),
myNodeFactory->FindNode(n2),
@ -2080,7 +2083,7 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n12 ) return 0;
@ -2113,8 +2116,8 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID
//purpose :
//=======================================================================
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int ID)
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n12,smIdType n23,smIdType n31, smIdType ID)
{
return SMDS_Mesh::AddFaceWithID (myNodeFactory->FindNode(n1) ,
myNodeFactory->FindNode(n2) ,
@ -2135,7 +2138,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31 ) return 0;
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -2170,8 +2173,8 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID
//purpose :
//=======================================================================
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int nCenter, int ID)
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID)
{
return SMDS_Mesh::AddFaceWithID (myNodeFactory->FindNode(n1) ,
myNodeFactory->FindNode(n2) ,
@ -2194,7 +2197,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * nCenter,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31 || !nCenter) return 0;
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -2230,8 +2233,8 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID
//purpose :
//=======================================================================
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41, int ID)
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID)
{
return SMDS_Mesh::AddFaceWithID (myNodeFactory->FindNode(n1) ,
myNodeFactory->FindNode(n2) ,
@ -2256,7 +2259,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41) return 0;
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -2292,8 +2295,8 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID
//purpose :
//=======================================================================
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41, int nCenter, int ID)
SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType nCenter, smIdType ID)
{
return SMDS_Mesh::AddFaceWithID (myNodeFactory->FindNode(n1) ,
myNodeFactory->FindNode(n2) ,
@ -2320,7 +2323,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * nCenter,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41 || !nCenter) return 0;
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -2359,9 +2362,9 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose :
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n31,
int n14,int n24,int n34, int ID)
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n31,
smIdType n14,smIdType n24,smIdType n34, smIdType ID)
{
return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1) ,
myNodeFactory->FindNode(n2) ,
@ -2390,7 +2393,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34,
int ID)
smIdType ID)
{
if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n31 || !n14 || !n24 || !n34)
return 0;
@ -2433,9 +2436,9 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose :
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(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, int ID)
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n15,smIdType n25,smIdType n35,smIdType n45, smIdType ID)
{
return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1) ,
myNodeFactory->FindNode(n2) ,
@ -2470,7 +2473,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45,
int ID)
smIdType ID)
{
if (!n1 || !n2 || !n3 || !n4 || !n5 || !n12 || !n23 ||
!n34 || !n41 || !n15 || !n25 || !n35 || !n45)
@ -2516,11 +2519,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose : 2d order Pentahedron (prism) with 15 nodes
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(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 ID)
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n4, smIdType n5, smIdType n6,
smIdType n12,smIdType n23,smIdType n31,
smIdType n45,smIdType n56,smIdType n64,
smIdType n14,smIdType n25,smIdType n36, smIdType ID)
{
return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1) ,
myNodeFactory->FindNode(n2) ,
@ -2559,7 +2562,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
int ID)
smIdType ID)
{
if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n12 || !n23 ||
!n31 || !n45 || !n56 || !n64 || !n14 || !n25 || !n36)
@ -2608,12 +2611,12 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose : 2d order Pentahedron (prism) with 18 nodes
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(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, int ID)
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n4, smIdType n5, smIdType n6,
smIdType n12,smIdType n23,smIdType n31,
smIdType n45,smIdType n56,smIdType n64,
smIdType n14,smIdType n25,smIdType n36,
smIdType n1245, smIdType n2356, smIdType n1346, smIdType ID)
{
return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1) ,
myNodeFactory->FindNode(n2) ,
@ -2658,7 +2661,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346,
int ID)
smIdType ID)
{
//MESSAGE("AddVolumeWithID penta18 "<< ID);
if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n12 || !n23 ||
@ -2711,11 +2714,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose :
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(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 ID)
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n56,smIdType n67,smIdType n78,smIdType n85,
smIdType n15,smIdType n26,smIdType n37,smIdType n48, smIdType ID)
{
return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1),
myNodeFactory->FindNode(n2),
@ -2764,7 +2767,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48,
int ID)
smIdType ID)
{
if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8 || !n12 || !n23 ||
!n34 || !n41 || !n56 || !n67 || !n78 || !n85 || !n15 || !n26 || !n37 || !n48)
@ -2823,13 +2826,13 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose :
//=======================================================================
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(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, int ID)
SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n56,smIdType n67,smIdType n78,smIdType n85,
smIdType n15,smIdType n26,smIdType n37,smIdType n48,
smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
smIdType n1458,smIdType n5678,smIdType nCenter, smIdType ID)
{
return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1),
myNodeFactory->FindNode(n2),
@ -2892,7 +2895,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n1458,
const SMDS_MeshNode * n5678,
const SMDS_MeshNode * nCenter,
int ID)
smIdType ID)
{
if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8 || !n12 || !n23 ||
!n34 || !n41 || !n56 || !n67 || !n78 || !n85 || !n15 || !n26 || !n37 || !n48 ||
@ -2931,7 +2934,7 @@ void SMDS_Mesh::dumpGrid(std::string ficdump)
}
int nbCells = myGrid->GetNumberOfCells();
ficcon << "-------------------------------- cells " << nbCells << endl;
for (int i=0; i<nbCells; i++)
for (vtkIdType i=0; i<nbCells; i++)
{
ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -";
int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints();
@ -2970,16 +2973,16 @@ void SMDS_Mesh::CompactMesh()
for ( ; holder != myElemHolders.end(); ++holder )
(*holder)->beforeCompacting();
}
int oldCellSize = myCellFactory->GetMaxID();
smIdType oldCellSize = myCellFactory->GetMaxID();
// remove "holes" in SMDS numeration
std::vector<int> idNodesOldToNew, idCellsNewToOld, idCellsOldToNew;
std::vector<smIdType> idNodesOldToNew, idCellsNewToOld, idCellsOldToNew;
myNodeFactory->Compact( idNodesOldToNew );
myCellFactory->Compact( idCellsNewToOld );
// make VTK IDs correspond to SMDS IDs
int newNodeSize = myNodeFactory->NbUsedElements();
int newCellSize = myCellFactory->NbUsedElements();
smIdType newNodeSize = myNodeFactory->NbUsedElements();
smIdType newCellSize = myCellFactory->NbUsedElements();
myGrid->compactGrid( idNodesOldToNew, newNodeSize, idCellsNewToOld, newCellSize );
if ( idsChange && !myElemHolders.empty() )
@ -2988,7 +2991,7 @@ void SMDS_Mesh::CompactMesh()
idCellsOldToNew.resize( oldCellSize, oldCellSize );
for ( size_t iNew = 0; iNew < idCellsNewToOld.size(); ++iNew )
{
if ( idCellsNewToOld[ iNew ] >= (int) idCellsOldToNew.size() )
if ( idCellsNewToOld[ iNew ] >= (smIdType) idCellsOldToNew.size() )
idCellsOldToNew.resize( ( 1 + idCellsNewToOld[ iNew ]) * 1.5, oldCellSize );
idCellsOldToNew[ idCellsNewToOld[ iNew ]] = iNew;
}
@ -3004,7 +3007,7 @@ void SMDS_Mesh::CompactMesh()
return;
}
int SMDS_Mesh::FromVtkToSmds( int vtkid ) const
smIdType SMDS_Mesh::FromVtkToSmds( vtkIdType vtkid ) const
{
return myCellFactory->FromVtkToSmds( vtkid );
}

217
src/SMDS/SMDS_Mesh.hxx
View File

@ -43,6 +43,7 @@
#include <set>
#include <list>
#include <vector>
#include <smIdType.hxx>
class SMDS_ElementHolder;
class SMDS_ElementFactory;
@ -73,53 +74,53 @@ public:
size_t nbElemsToReturn=-1,
const SMDS_MeshElement* sm1stElem=0) const;
SMDSAbs_ElementType GetElementType( const int id, const bool iselem ) const;
SMDSAbs_ElementType GetElementType( const smIdType id, const bool iselem ) const;
SMDS_Mesh *AddSubMesh();
virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, smIdType ID);
virtual SMDS_MeshNode* AddNode (double x, double y, double z);
virtual SMDS_Mesh0DElement* Add0DElementWithID(int n, int ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, int ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(smIdType n, smIdType ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, smIdType ID);
virtual SMDS_Mesh0DElement* Add0DElement (const SMDS_MeshNode * n);
virtual SMDS_BallElement* AddBallWithID(int n, double diameter, int ID);
virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID);
virtual SMDS_BallElement* AddBallWithID(smIdType n, double diameter, smIdType ID);
virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID);
virtual SMDS_BallElement* AddBall (const SMDS_MeshNode * n, double diameter);
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
int ID);
smIdType ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2);
// 2d order edge with 3 nodes: n12 - node between n1 and n2
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12,
int ID);
smIdType ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12);
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3);
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -127,15 +128,15 @@ public:
// 2d order triangle of 6 nodes
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n12,smIdType n23,smIdType n31, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -144,8 +145,8 @@ public:
const SMDS_MeshNode * n31);
// 2d order triangle of 7 nodes
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int nCenter, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -153,7 +154,7 @@ public:
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * nCenter,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -163,8 +164,8 @@ public:
const SMDS_MeshNode * nCenter);
// 2d order quadrangle
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -173,7 +174,7 @@ public:
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -183,8 +184,8 @@ public:
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41);
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41, int nCenter, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType nCenter, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -194,7 +195,7 @@ public:
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * nCenter,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -205,40 +206,40 @@ public:
const SMDS_MeshNode * n41,
const SMDS_MeshNode * nCenter);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n5, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n5, int n6, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -246,8 +247,8 @@ public:
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6);
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n5, int n6, int n7, int n8, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -256,7 +257,7 @@ public:
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -268,9 +269,9 @@ public:
// hexagonal prism
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6,
int n7, int n8, int n9, int n10, int n11, int n12,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6,
smIdType n7, smIdType n8, smIdType n9, smIdType n10, smIdType n11, smIdType n12,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -283,7 +284,7 @@ public:
const SMDS_MeshNode * n10,
const SMDS_MeshNode * n11,
const SMDS_MeshNode * n12,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -298,9 +299,9 @@ public:
const SMDS_MeshNode * n12);
// 2d order tetrahedron of 10 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n31,
int n14,int n24,int n34, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n31,
smIdType n14,smIdType n24,smIdType n34, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -311,7 +312,7 @@ public:
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -324,10 +325,10 @@ public:
const SMDS_MeshNode * n34);
// 2d order pyramid of 13 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n15,smIdType n25,smIdType n35,smIdType n45,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -341,7 +342,7 @@ public:
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -357,12 +358,12 @@ public:
const SMDS_MeshNode * n45);
// 2d order Pentahedron with 15 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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 ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n4, smIdType n5, smIdType n6,
smIdType n12,smIdType n23,smIdType n31,
smIdType n45,smIdType n56,smIdType n64,
smIdType n14,smIdType n25,smIdType n36,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -378,7 +379,7 @@ public:
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -396,13 +397,13 @@ public:
const SMDS_MeshNode * n36);
// 2d order Pentahedron with 18 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n4, smIdType n5, smIdType n6,
smIdType n12,smIdType n23,smIdType n31,
smIdType n45,smIdType n56,smIdType n64,
smIdType n14,smIdType n25,smIdType n36,
smIdType n1245, smIdType n2356, smIdType n1346,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -421,7 +422,7 @@ public:
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -443,12 +444,12 @@ public:
// 2d oreder Hexahedrons with 20 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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 ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n56,smIdType n67,smIdType n78,smIdType n85,
smIdType n15,smIdType n26,smIdType n37,smIdType n48,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -469,7 +470,7 @@ public:
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -492,14 +493,14 @@ public:
const SMDS_MeshNode * n48);
// 2d oreder Hexahedrons with 27 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n56,smIdType n67,smIdType n78,smIdType n85,
smIdType n15,smIdType n26,smIdType n37,smIdType n48,
smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
smIdType n1458,smIdType n5678,smIdType nCenter,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -527,7 +528,7 @@ public:
const SMDS_MeshNode * n1458,
const SMDS_MeshNode * n5678,
const SMDS_MeshNode * nCenter,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -556,31 +557,31 @@ public:
const SMDS_MeshNode * n5678,
const SMDS_MeshNode * nCenter);
virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<int> & nodes_ids,
const int ID);
virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<smIdType> & nodes_ids,
const smIdType ID);
virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*> & nodes,
const int ID);
const smIdType ID);
virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*> & nodes);
virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<int> & nodes_ids,
const int ID);
virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<smIdType> & nodes_ids,
const smIdType ID);
virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes,
const int ID);
const smIdType ID);
virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes);
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<int> & nodes_ids,
const std::vector<int> & quantities,
const int ID);
(const std::vector<smIdType> & nodes_ids,
const std::vector<int> & quantities,
const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<const SMDS_MeshNode*> & nodes,
const std::vector<int> & quantities,
const int ID);
const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolume
(const std::vector<const SMDS_MeshNode*> & nodes,
@ -631,10 +632,10 @@ public:
static_cast<const ELEMTYPE*>(e) : 0 );
}
const SMDS_MeshNode *FindNode(int idnode) const;
const SMDS_MeshNode *FindNodeVtk(int idnode) const;
const SMDS_MeshElement *FindElementVtk(int IDelem) const;
virtual const SMDS_MeshElement * FindElement(int IDelem) const;
const SMDS_MeshNode *FindNode(smIdType idnode) const;
const SMDS_MeshNode *FindNodeVtk(vtkIdType idnode) const;
const SMDS_MeshElement *FindElementVtk(vtkIdType IDelem) const;
virtual const SMDS_MeshElement * FindElement(smIdType IDelem) const;
static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n);
static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
@ -681,26 +682,26 @@ public:
*/
static int CheckMemory(const bool doNotRaise=false);
virtual int MaxNodeID() const;
virtual int MinNodeID() const;
virtual int MaxElementID() const;
virtual int MinElementID() const;
virtual smIdType MaxNodeID() const;
virtual smIdType MinNodeID() const;
virtual smIdType MaxElementID() const;
virtual smIdType MinElementID() const;
const SMDS_MeshInfo& GetMeshInfo() const { return myInfo; }
virtual int NbNodes() const;
virtual int NbElements() const;
virtual int Nb0DElements() const;
virtual int NbBalls() const;
virtual int NbEdges() const;
virtual int NbFaces() const;
virtual int NbVolumes() const;
virtual int NbSubMesh() const;
virtual smIdType NbNodes() const;
virtual smIdType NbElements() const;
virtual smIdType Nb0DElements() const;
virtual smIdType NbBalls() const;
virtual smIdType NbEdges() const;
virtual smIdType NbFaces() const;
virtual smIdType NbVolumes() const;
virtual smIdType NbSubMesh() const;
virtual ~SMDS_Mesh();
double getMaxDim();
int FromVtkToSmds(int vtkid) const;
smIdType FromVtkToSmds(vtkIdType vtkid) const;
void dumpGrid(std::string ficdump="dumpGrid");
static int chunkSize;

14
src/SMDS/SMDS_MeshCell.cxx
View File

@ -461,8 +461,8 @@ void SMDS_MeshCell::init( SMDSAbs_EntityType theEntity, int theNbNodes, ... )
}
va_end( vl );
int vtkType = toVtkType( theEntity );
int vtkID = getGrid()->InsertNextLinkedCell( vtkType, theNbNodes, vtkIds );
int vtkType = toVtkType( theEntity );
vtkIdType vtkID = getGrid()->InsertNextLinkedCell( vtkType, theNbNodes, vtkIds );
setVtkID( vtkID );
}
@ -473,17 +473,17 @@ void SMDS_MeshCell::init( SMDSAbs_EntityType theEntity,
for ( size_t i = 0; i < nodes.size(); ++i )
vtkIds[i] = nodes[i]->GetVtkID();
int vtkType = toVtkType( theEntity );
int vtkID = getGrid()->InsertNextLinkedCell( vtkType, nodes.size(), &vtkIds[0] );
int vtkType = toVtkType( theEntity );
vtkIdType vtkID = getGrid()->InsertNextLinkedCell( vtkType, nodes.size(), &vtkIds[0] );
setVtkID( vtkID );
}
void SMDS_MeshCell::init( SMDSAbs_EntityType theEntity,
const std::vector<vtkIdType>& vtkNodeIds )
{
int vtkType = toVtkType( theEntity );
int vtkID = getGrid()->InsertNextLinkedCell( vtkType, vtkNodeIds.size(),
const_cast< vtkIdType* > ( &vtkNodeIds[0] ));
int vtkType = toVtkType( theEntity );
vtkIdType vtkID = getGrid()->InsertNextLinkedCell( vtkType, vtkNodeIds.size(),
const_cast< vtkIdType* > ( &vtkNodeIds[0] ));
setVtkID( vtkID );
}

6
src/SMDS/SMDS_MeshElement.cxx
View File

@ -105,7 +105,7 @@ int SMDS_MeshElement::GetNodeIndex( const SMDS_MeshNode* node ) const
*/
//================================================================================
int SMDS_MeshElement::GetID() const
smIdType SMDS_MeshElement::GetID() const
{
return myHolder ? myHolder->GetID( this ) : -1;
}
@ -138,7 +138,7 @@ int SMDS_MeshElement::GetShapeID() const
*/
//================================================================================
int SMDS_MeshElement::GetVtkID() const
vtkIdType SMDS_MeshElement::GetVtkID() const
{
return myHolder->GetVtkID( this );
}
@ -171,7 +171,7 @@ bool SMDS_MeshElement::isMarked() const
*/
//================================================================================
void SMDS_MeshElement::setVtkID( const int vtkID )
void SMDS_MeshElement::setVtkID( const vtkIdType vtkID )
{
myHolder->SetVTKID( this, vtkID );
}

11
src/SMDS/SMDS_MeshElement.hxx
View File

@ -38,6 +38,7 @@
#include <vtkType.h>
#include <vtkCellType.h>
#include <smIdType.hxx>
class SMDS_ElementChunk;
class SMDS_Mesh;
@ -127,10 +128,10 @@ public:
virtual int GetNodeIndex( const SMDS_MeshNode* node ) const;
virtual int GetID() const;
virtual int GetVtkID() const;
virtual int getshapeId() const { return GetShapeID(); }
virtual int GetShapeID() const;
virtual smIdType GetID() const;
virtual vtkIdType GetVtkID() const;
virtual int getshapeId() const { return GetShapeID(); }
virtual int GetShapeID() const;
// mark this element; to be used in algos
virtual void setIsMarked( bool is ) const;
@ -182,7 +183,7 @@ public:
SMDS_MeshElement();
void setVtkID(const int vtkID );
void setVtkID(const vtkIdType vtkID );
virtual void setShapeID( const int shapeID ) const;
SMDS_UnstructuredGrid* getGrid() const;

2
src/SMDS/SMDS_MeshGroup.hxx
View File

@ -45,7 +45,7 @@ class SMDS_EXPORT SMDS_MeshGroup: public SMDS_MeshObject, SMDS_ElementHolder
bool Add(const SMDS_MeshElement * theElem);
bool Remove(const SMDS_MeshElement * theElem);
bool IsEmpty() const { return myElements.empty(); }
int Extent() const { return myElements.size(); }
smIdType Extent() const { return (smIdType) myElements.size(); }
int Tic() const { return myTic; }
bool Contains(const SMDS_MeshElement * theElem) const;

117
src/SMDS/SMDS_MeshInfo.hxx
View File

@ -30,6 +30,7 @@
#include "SMDS_MeshElement.hxx"
#include<utilities.h>
#include <smIdType.hxx>
class SMDS_EXPORT SMDS_MeshInfo
{
@ -39,39 +40,39 @@ public:
inline SMDS_MeshInfo& operator=(const SMDS_MeshInfo& other);
inline void Clear();
inline int NbElements(SMDSAbs_ElementType type=SMDSAbs_All) const;
inline int NbElements(SMDSAbs_EntityType type) const { return NbEntities(type); }
inline int NbElements(SMDSAbs_GeometryType type) const { return NbElementsOfGeom(type); }
inline smIdType NbElements(SMDSAbs_ElementType type=SMDSAbs_All) const;
inline smIdType NbElements(SMDSAbs_EntityType type) const { return NbEntities(type); }
inline smIdType NbElements(SMDSAbs_GeometryType type) const { return NbElementsOfGeom(type); }
inline int NbEntities(SMDSAbs_EntityType type) const;
inline int NbElementsOfGeom(SMDSAbs_GeometryType geom) const;
inline smIdType NbEntities(SMDSAbs_EntityType type) const;
inline smIdType NbElementsOfGeom(SMDSAbs_GeometryType geom) const;
int NbNodes() const { return myNbNodes; }
int Nb0DElements() const { return myNb0DElements; }
int NbBalls() const { return myNbBalls; }
inline int NbEdges (SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbNodes() const { return myNbNodes; }
smIdType Nb0DElements() const { return myNb0DElements; }
smIdType NbBalls() const { return myNbBalls; }
inline smIdType 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 NbBiQuadTriangles() const { return myNbBiQuadTriangles; }
int NbBiQuadQuadrangles() const { return myNbBiQuadQuadrangles; }
inline int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline smIdType NbFaces (SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline smIdType NbTriangles (SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline smIdType NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbBiQuadTriangles() const { return myNbBiQuadTriangles; }
smIdType NbBiQuadQuadrangles() const { return myNbBiQuadQuadrangles; }
inline smIdType NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
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;
inline int NbHexPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTriQuadHexas() const { return myNbTriQuadHexas; }
int NbQuadPrisms() const { return myNbQuadPrisms; }
int NbBiQuadPrisms() const { return myNbBiQuadPrisms; }
int NbPolyhedrons() const { return myNbPolyhedrons; }
inline smIdType NbVolumes (SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline smIdType NbTetras (SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline smIdType NbHexas (SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline smIdType NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline smIdType NbPrisms (SMDSAbs_ElementOrder order = ORDER_ANY) const;
inline smIdType NbHexPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbTriQuadHexas() const { return myNbTriQuadHexas; }
smIdType NbQuadPrisms() const { return myNbQuadPrisms; }
smIdType NbBiQuadPrisms() const { return myNbBiQuadPrisms; }
smIdType NbPolyhedrons() const { return myNbPolyhedrons; }
protected:
inline void addWithPoly(const SMDS_MeshElement* el);
inline void setNb(const SMDSAbs_EntityType geomType, const int nb);
inline void setNb(const SMDSAbs_EntityType geomType, const smIdType nb);
private:
friend class SMDS_Mesh;
@ -79,29 +80,29 @@ private:
// 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;
inline smIdType 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;
smIdType myNbNodes;
int myNb0DElements;
int myNbBalls;
int myNbEdges , myNbQuadEdges ;
int myNbTriangles , myNbQuadTriangles, myNbBiQuadTriangles ;
int myNbQuadrangles, myNbQuadQuadrangles, myNbBiQuadQuadrangles;
int myNbPolygons , myNbQuadPolygons;
smIdType myNb0DElements;
smIdType myNbBalls;
smIdType myNbEdges , myNbQuadEdges ;
smIdType myNbTriangles , myNbQuadTriangles, myNbBiQuadTriangles ;
smIdType myNbQuadrangles, myNbQuadQuadrangles, myNbBiQuadQuadrangles;
smIdType myNbPolygons , myNbQuadPolygons;
int myNbTetras , myNbQuadTetras ;
int myNbHexas , myNbQuadHexas, myNbTriQuadHexas;
int myNbPyramids, myNbQuadPyramids;
int myNbPrisms , myNbQuadPrisms, myNbBiQuadPrisms;
int myNbHexPrism;
int myNbPolyhedrons;
smIdType myNbTetras , myNbQuadTetras ;
smIdType myNbHexas , myNbQuadHexas, myNbTriQuadHexas;
smIdType myNbPyramids, myNbQuadPyramids;
smIdType myNbPrisms , myNbQuadPrisms, myNbBiQuadPrisms;
smIdType myNbHexPrism;
smIdType myNbPolyhedrons;
std::vector<int*> myNb; // pointers to myNb... fields
std::vector<smIdType*> myNb; // pointers to myNb... fields
std::vector<int> myShift; // shift to get an index in myNb by elem->NbNodes()
};
@ -212,7 +213,7 @@ SMDS_MeshInfo::Clear()
myNbPolygons=myNbQuadPolygons=myNbPolyhedrons=0;
}
inline int // index
inline smIdType // index
SMDS_MeshInfo::index(SMDSAbs_ElementType type, int nbNodes) const
{ return nbNodes + myShift[ type ]; }
@ -250,54 +251,54 @@ inline void // RemoveVolume
SMDS_MeshInfo::RemoveVolume(const SMDS_MeshElement* el)
{ if ( el->IsPoly() ) --myNbPolyhedrons; else remove( el ); }
inline int // NbEdges
inline smIdType // NbEdges
SMDS_MeshInfo::NbEdges (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbEdges+myNbQuadEdges : order == ORDER_LINEAR ? myNbEdges : myNbQuadEdges; }
inline int // NbFaces
inline smIdType // NbFaces
SMDS_MeshInfo::NbFaces (SMDSAbs_ElementOrder order) const
{ return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_ANY ? myNbPolygons+myNbQuadPolygons : order == ORDER_LINEAR ? myNbPolygons : myNbQuadPolygons ); }
inline int // NbTriangles
inline smIdType // NbTriangles
SMDS_MeshInfo::NbTriangles (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles+myNbBiQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles+myNbBiQuadTriangles; }
inline int // NbQuadrangles
inline smIdType // NbQuadrangles
SMDS_MeshInfo::NbQuadrangles(SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbQuadrangles+myNbQuadQuadrangles+myNbBiQuadQuadrangles : order == ORDER_LINEAR ? myNbQuadrangles : myNbQuadQuadrangles+myNbBiQuadQuadrangles; }
inline int // NbPolygons
inline smIdType // NbPolygons
SMDS_MeshInfo::NbPolygons(SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbPolygons+myNbQuadPolygons : order == ORDER_LINEAR ? myNbPolygons : myNbQuadPolygons; }
inline int // NbVolumes
inline smIdType // NbVolumes
SMDS_MeshInfo::NbVolumes (SMDSAbs_ElementOrder order) const
{ return NbTetras(order) + NbHexas(order) + NbPyramids(order) + NbPrisms(order) + NbHexPrisms(order) + (order == ORDER_QUADRATIC ? 0 : myNbPolyhedrons); }
inline int // NbTetras
inline smIdType // NbTetras
SMDS_MeshInfo::NbTetras (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbTetras+myNbQuadTetras : order == ORDER_LINEAR ? myNbTetras : myNbQuadTetras; }
inline int // NbHexas
inline smIdType // NbHexas
SMDS_MeshInfo::NbHexas (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbHexas+myNbQuadHexas+myNbTriQuadHexas : order == ORDER_LINEAR ? myNbHexas : myNbQuadHexas+myNbTriQuadHexas; }
inline int // NbPyramids
inline smIdType // NbPyramids
SMDS_MeshInfo::NbPyramids(SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbPyramids+myNbQuadPyramids : order == ORDER_LINEAR ? myNbPyramids : myNbQuadPyramids; }
inline int // NbPrisms
inline smIdType // NbPrisms
SMDS_MeshInfo::NbPrisms (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms+myNbBiQuadPrisms: order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms+myNbBiQuadPrisms; }
inline int // NbHexPrisms
inline smIdType // NbHexPrisms
SMDS_MeshInfo::NbHexPrisms (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbHexPrism : order == ORDER_LINEAR ? myNbHexPrism : 0; }
inline int // NbElements
inline smIdType // NbElements
SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
{
int nb = 0;
smIdType nb = 0;
switch (type) {
case SMDSAbs_All:
for ( size_t i=1+index( SMDSAbs_Node,1 ); i<myNb.size(); ++i ) if ( myNb[i] ) nb += *myNb[i];
@ -330,7 +331,7 @@ SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
return nb;
}
inline int // NbEntities
inline smIdType // NbEntities
SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
{
switch (type) {
@ -366,7 +367,7 @@ SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
return 0;
}
inline int // NbElementsOfGeom
inline smIdType // NbElementsOfGeom
SMDS_MeshInfo::NbElementsOfGeom(SMDSAbs_GeometryType geom) const
{
switch ( geom ) {
@ -406,7 +407,7 @@ SMDS_MeshInfo::NbElementsOfGeom(SMDSAbs_GeometryType geom) const
}
inline void // setNb
SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const smIdType nb)
{
switch (geomType) {
case SMDSEntity_Node: myNbNodes = nb; break;

9
src/SMDS/SMDS_MeshNode.cxx
View File

@ -36,6 +36,7 @@
#include <utilities.h>
#include <Utils_SALOME_Exception.hxx>
#include <cassert>
#include <smIdType.hxx>
#include <boost/make_shared.hpp>
@ -122,8 +123,8 @@ namespace
{
for (int i = 0; i < ncells; i++)
{
int vtkId = cells[i];
int smdsId = myMesh->FromVtkToSmds( vtkId );
vtkIdType vtkId = cells[i];
smIdType smdsId = myMesh->FromVtkToSmds( vtkId );
const SMDS_MeshElement* elem = myMesh->FindElement( smdsId );
if ( elem->GetType() == type )
{
@ -141,8 +142,8 @@ namespace
const SMDS_MeshElement* next()
{
int vtkId = myCellList[ myIter++ ];
int smdsId = myMesh->FromVtkToSmds( vtkId );
vtkIdType vtkId = myCellList[ myIter++ ];
smIdType smdsId = myMesh->FromVtkToSmds( vtkId );
const SMDS_MeshElement* elem = myMesh->FindElement(smdsId);
if (!elem)
{

4
src/SMDS/SMDS_MeshVolume.cxx
View File

@ -50,7 +50,7 @@ void SMDS_MeshVolume::init( const std::vector<const SMDS_MeshNode*>& nodes,
ptIds.push_back( nodes[ iN++ ]->GetVtkID() );
}
int vtkID = getGrid()->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]);
vtkIdType vtkID = getGrid()->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]);
setVtkID( vtkID );
}
@ -88,7 +88,7 @@ bool SMDS_MeshVolume::ChangeNodes(const std::vector<const SMDS_MeshNode*>& nodes
// stream size and nb faces should not change
if ((int) quantities.size() != nFaces )
if ((vtkIdType) quantities.size() != nFaces )
{
return false;
}

102
src/SMDS/SMDS_UnstructuredGrid.cxx
View File

@ -135,7 +135,7 @@ vtkPoints* SMDS_UnstructuredGrid::GetPoints()
return this->Points;
}
int SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *pts)
vtkIdType SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *pts)
{
if ( !this->Links ) // don't create Links until they are needed
{
@ -146,7 +146,7 @@ int SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *p
return vtkUnstructuredGrid::InsertNextLinkedCell(type, npts, pts);
// --- type = VTK_POLYHEDRON
int cellid = this->InsertNextCell(type, npts, pts);
vtkIdType cellid = this->InsertNextCell(type, npts, pts);
std::set<vtkIdType> setOfNodes;
setOfNodes.clear();
@ -175,15 +175,15 @@ void SMDS_UnstructuredGrid::setSMDS_mesh(SMDS_Mesh *mesh)
_mesh = mesh;
}
void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int newNodeSize,
std::vector<int>& idCellsNewToOld, int newCellSize)
void SMDS_UnstructuredGrid::compactGrid(std::vector<smIdType>& idNodesOldToNew, smIdType newNodeSize,
std::vector<smIdType>& idCellsNewToOld, smIdType newCellSize)
{
this->DeleteLinks();
// IDs of VTK nodes always correspond to SMDS IDs but there can be "holes" in SMDS numeration.
// We compact only if there were holes
int oldNodeSize = this->GetNumberOfPoints();
vtkIdType oldNodeSize = this->GetNumberOfPoints();
bool updateNodes = ( oldNodeSize > newNodeSize );
if ( true /*updateNodes*/ )
{
@ -191,19 +191,19 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
// Use double type for storing coordinates of nodes instead float.
vtkPoints *newPoints = vtkPoints::New();
newPoints->SetDataType( VTK_DOUBLE );
newPoints->SetNumberOfPoints( newNodeSize );
newPoints->SetNumberOfPoints( FromSmIdType<vtkIdType>(newNodeSize) );
int i = 0, alreadyCopied = 0;
vtkIdType i = 0, alreadyCopied = 0;
while ( i < oldNodeSize )
{
// skip a hole if any
while ( i < oldNodeSize && idNodesOldToNew[i] < 0 )
++i;
int startBloc = i;
vtkIdType startBloc = i;
// look for a block end
while ( i < oldNodeSize && idNodesOldToNew[i] >= 0 )
++i;
int endBloc = i;
vtkIdType endBloc = i;
copyNodes(newPoints, idNodesOldToNew, alreadyCopied, startBloc, endBloc);
}
this->SetPoints(newPoints);
@ -217,9 +217,9 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
// Compact cells if VTK IDs do not correspond to SMDS IDs or nodes compacted
int oldCellSize = this->Types->GetNumberOfTuples();
bool updateCells = ( updateNodes || newCellSize != oldCellSize );
for ( int newID = 0, nbIDs = idCellsNewToOld.size(); newID < nbIDs && !updateCells; ++newID )
vtkIdType oldCellSize = this->Types->GetNumberOfTuples();
bool updateCells = ( updateNodes || newCellSize != oldCellSize );
for ( vtkIdType newID = 0, nbIDs = idCellsNewToOld.size(); newID < nbIDs && !updateCells; ++newID )
updateCells = ( idCellsNewToOld[ newID ] != newID );
if ( false /*!updateCells*/ ) // no holes in elements
@ -236,18 +236,18 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
return;
}
if ((int) idNodesOldToNew.size() < oldNodeSize )
if ((vtkIdType) idNodesOldToNew.size() < oldNodeSize )
{
idNodesOldToNew.reserve( oldNodeSize );
for ( int i = idNodesOldToNew.size(); i < oldNodeSize; ++i )
for ( vtkIdType i = idNodesOldToNew.size(); i < oldNodeSize; ++i )
idNodesOldToNew.push_back( i );
}
// --- create new compacted Connectivity, Locations and Types
int newConnectivitySize = this->Connectivity->GetNumberOfConnectivityEntries();
vtkIdType newConnectivitySize = this->Connectivity->GetNumberOfConnectivityEntries();
if ( newCellSize != oldCellSize )
for ( int i = 0; i < oldCellSize - 1; ++i )
for ( vtkIdType i = 0; i < oldCellSize - 1; ++i )
if ( this->Types->GetValue( i ) == VTK_EMPTY_CELL )
newConnectivitySize -= this->Connectivity->GetCellSize( i );
@ -257,11 +257,11 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
vtkUnsignedCharArray *newTypes = vtkUnsignedCharArray::New();
newTypes->Initialize();
newTypes->SetNumberOfValues(newCellSize);
newTypes->SetNumberOfValues(FromSmIdType<vtkIdType>(newCellSize));
vtkIdTypeArray *newLocations = vtkIdTypeArray::New();
newLocations->Initialize();
newLocations->SetNumberOfValues(newCellSize);
newLocations->SetNumberOfValues(FromSmIdType<vtkIdType>(newCellSize));
std::vector< vtkIdType > pointsCell(1024); // --- points id to fill a new cell
@ -273,11 +273,11 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
{
vtkDoubleArray* newDiameters = vtkDoubleArray::New();
newDiameters->SetNumberOfComponents(1);
for ( int newCellID = 0; newCellID < newCellSize; newCellID++ )
for ( vtkIdType newCellID = 0; newCellID < newCellSize; newCellID++ )
{
if ( newTypes->GetValue( newCellID ) == VTK_POLY_VERTEX )
{
int oldCellID = idCellsNewToOld[ newCellID ];
vtkIdType oldCellID = idCellsNewToOld[ newCellID ];
newDiameters->InsertValue( newCellID, diameters->GetValue( oldCellID ));
}
vtkDataSet::CellData->SetScalars( newDiameters );
@ -292,22 +292,22 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
vtkIdTypeArray *newFaces = vtkIdTypeArray::New();
newFaces->Initialize();
newFaces->Allocate(this->Faces->GetSize());
for ( int newCellID = 0; newCellID < newCellSize; newCellID++ )
for ( vtkIdType newCellID = 0; newCellID < newCellSize; newCellID++ )
{
if ( newTypes->GetValue( newCellID ) == VTK_POLYHEDRON )
{
int oldCellId = idCellsNewToOld[ newCellID ];
smIdType oldCellId = idCellsNewToOld[ newCellID ];
newFaceLocations->InsertNextValue( newFaces->GetMaxId()+1 );
int oldFaceLoc = this->FaceLocations->GetValue( oldCellId );
int nCellFaces = this->Faces->GetValue( oldFaceLoc++ );
newFaces->InsertNextValue( nCellFaces );
smIdType oldFaceLoc = this->FaceLocations->GetValue( FromSmIdType<vtkIdType>(oldCellId) );
smIdType nCellFaces = this->Faces->GetValue( FromSmIdType<vtkIdType>(oldFaceLoc++) );
newFaces->InsertNextValue( FromSmIdType<vtkIdType>(nCellFaces) );
for ( int n = 0; n < nCellFaces; n++ )
{
int nptsInFace = this->Faces->GetValue( oldFaceLoc++ );
int nptsInFace = this->Faces->GetValue( FromSmIdType<vtkIdType>(oldFaceLoc++) );
newFaces->InsertNextValue( nptsInFace );
for ( int k = 0; k < nptsInFace; k++ )
{
int oldpt = this->Faces->GetValue( oldFaceLoc++ );
vtkIdType oldpt = this->Faces->GetValue( FromSmIdType<vtkIdType>(oldFaceLoc++) );
newFaces->InsertNextValue( idNodesOldToNew[ oldpt ]);
}
}
@ -335,15 +335,15 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
newConnectivity->Delete();
}
void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
std::vector<int>& /*idNodesOldToNew*/,
int& alreadyCopied,
int start,
int end)
void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
std::vector<smIdType>& /*idNodesOldToNew*/,
vtkIdType& alreadyCopied,
vtkIdType start,
vtkIdType end)
{
void *target = newPoints->GetVoidPointer(3 * alreadyCopied);
void *source = this->Points->GetVoidPointer(3 * start);
int nbPoints = end - start;
vtkIdType nbPoints = end - start;
if (nbPoints > 0)
{
memcpy(target, source, 3 * sizeof(double) * nbPoints);
@ -352,15 +352,15 @@ void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
}
void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray * newTypes,
const std::vector<int>& idCellsNewToOld,
const std::vector<int>& idNodesOldToNew,
const std::vector<smIdType>& idCellsNewToOld,
const std::vector<smIdType>& idNodesOldToNew,
vtkCellArray* newConnectivity,
vtkIdTypeArray* newLocations,
std::vector<vtkIdType>& pointsCell)
{
for ( size_t iNew = 0; iNew < idCellsNewToOld.size(); iNew++ )
{
int iOld = idCellsNewToOld[ iNew ];
vtkIdType iOld = idCellsNewToOld[ iNew ];
newTypes->SetValue( iNew, this->Types->GetValue( iOld ));
vtkIdType oldLoc = ((vtkIdTypeArray *)(this->Connectivity->GetOffsetsArray()))->GetValue( iOld );
@ -371,25 +371,25 @@ void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray * newTypes,
pointsCell.resize( nbpts );
for ( int l = 0; l < nbpts; l++ )
{
int oldval = oldPtsCell[l];
vtkIdType oldval = oldPtsCell[l];
pointsCell[l] = idNodesOldToNew[oldval];
}
/*int newcnt = */newConnectivity->InsertNextCell( nbpts, pointsCell.data() );
int newLoc = newConnectivity->GetInsertLocation( nbpts );
/*vtkIdType newcnt = */newConnectivity->InsertNextCell( nbpts, pointsCell.data() );
vtkIdType newLoc = newConnectivity->GetInsertLocation( nbpts );
newLocations->SetValue( iNew, newLoc );
}
}
int SMDS_UnstructuredGrid::CellIdToDownId(int vtkCellId)
int SMDS_UnstructuredGrid::CellIdToDownId(vtkIdType vtkCellId)
{
if ((vtkCellId < 0) || (vtkCellId >= (int)_cellIdToDownId.size()))
if ((vtkCellId < 0) || (vtkCellId >= (vtkIdType)_cellIdToDownId.size()))
{
return -1;
}
return _cellIdToDownId[vtkCellId];
}
void SMDS_UnstructuredGrid::setCellIdToDownId(int vtkCellId, int downId)
void SMDS_UnstructuredGrid::setCellIdToDownId(vtkIdType vtkCellId, int downId)
{
// ASSERT((vtkCellId >= 0) && (vtkCellId < _cellIdToDownId.size()));
_cellIdToDownId[vtkCellId] = downId;
@ -446,15 +446,15 @@ void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool /*withEdges*/)
const SMDS_MeshInfo &meshInfo = _mesh->GetMeshInfo();
int nbLinTetra = meshInfo.NbTetras (ORDER_LINEAR);
int nbQuadTetra = meshInfo.NbTetras (ORDER_QUADRATIC);
int nbLinPyra = meshInfo.NbPyramids(ORDER_LINEAR);
int nbQuadPyra = meshInfo.NbPyramids(ORDER_QUADRATIC);
int nbLinPrism = meshInfo.NbPrisms (ORDER_LINEAR);
int nbQuadPrism = meshInfo.NbPrisms (ORDER_QUADRATIC);
int nbLinHexa = meshInfo.NbHexas (ORDER_LINEAR);
int nbQuadHexa = meshInfo.NbHexas (ORDER_QUADRATIC);
int nbHexPrism = meshInfo.NbHexPrisms();
int nbLinTetra = FromSmIdType<int>(meshInfo.NbTetras (ORDER_LINEAR));
int nbQuadTetra = FromSmIdType<int>(meshInfo.NbTetras (ORDER_QUADRATIC));
int nbLinPyra = FromSmIdType<int>(meshInfo.NbPyramids(ORDER_LINEAR));
int nbQuadPyra = FromSmIdType<int>(meshInfo.NbPyramids(ORDER_QUADRATIC));
int nbLinPrism = FromSmIdType<int>(meshInfo.NbPrisms (ORDER_LINEAR));
int nbQuadPrism = FromSmIdType<int>(meshInfo.NbPrisms (ORDER_QUADRATIC));
int nbLinHexa = FromSmIdType<int>(meshInfo.NbHexas (ORDER_LINEAR));
int nbQuadHexa = FromSmIdType<int>(meshInfo.NbHexas (ORDER_QUADRATIC));
int nbHexPrism = FromSmIdType<int>(meshInfo.NbHexPrisms());
int nbLineGuess = int((4.0 / 3.0) * nbLinTetra + 2 * nbLinPrism + 2.5 * nbLinPyra + 3 * nbLinHexa);
int nbQuadEdgeGuess = int((4.0 / 3.0) * nbQuadTetra + 2 * nbQuadPrism + 2.5 * nbQuadPyra + 3 * nbQuadHexa);

21
src/SMDS/SMDS_UnstructuredGrid.hxx
View File

@ -28,6 +28,7 @@
#include <vtkUnstructuredGrid.h>
#include <vtkCellLinks.h>
#include <smIdType.hxx>
#include <vector>
#include <set>
@ -73,17 +74,17 @@ class SMDS_EXPORT SMDS_UnstructuredGrid: public vtkUnstructuredGrid
{
public:
void setSMDS_mesh(SMDS_Mesh *mesh);
void compactGrid(std::vector<int>& idNodesOldToNew,
int newNodeSize,
std::vector<int>& idCellsOldToNew,
int newCellSize);
void compactGrid(std::vector<smIdType>& idNodesOldToNew,
smIdType newNodeSize,
std::vector<smIdType>& idCellsOldToNew,
smIdType newCellSize);
virtual vtkMTimeType GetMTime();
virtual vtkPoints *GetPoints();
int InsertNextLinkedCell(int type, int npts, vtkIdType *pts);
vtkIdType InsertNextLinkedCell(int type, int npts, vtkIdType *pts);
int CellIdToDownId(int vtkCellId);
void setCellIdToDownId(int vtkCellId, int downId);
int CellIdToDownId(vtkIdType vtkCellId);
void setCellIdToDownId(vtkIdType vtkCellId, int downId);
void CleanDownwardConnectivity();
void BuildDownwardConnectivity(bool withEdges);
int GetNeighbors(int* neighborsVtkIds, int* downIds, unsigned char* downTypes, int vtkId, bool getSkin=false);
@ -115,10 +116,10 @@ public:
protected:
SMDS_UnstructuredGrid();
~SMDS_UnstructuredGrid();
void copyNodes(vtkPoints *newPoints, std::vector<int>& idNodesOldToNew, int& alreadyCopied, int start, int end);
void copyNodes(vtkPoints *newPoints, std::vector<smIdType>& idNodesOldToNew, vtkIdType& alreadyCopied, vtkIdType start, vtkIdType end);
void copyBloc(vtkUnsignedCharArray *newTypes,
const std::vector<int>& idCellsOldToNew,
const std::vector<int>& idNodesOldToNew,
const std::vector<smIdType>& idCellsOldToNew,
const std::vector<smIdType>& idNodesOldToNew,
vtkCellArray* newConnectivity,
vtkIdTypeArray* newLocations,
std::vector<vtkIdType>& pointsCell);

4
src/SMDS/SMDS_VolumeTool.cxx
View File

@ -969,7 +969,7 @@ bool SMDS_VolumeTool::GetFaceNodes (int faceIndex,
namespace
{
struct NLink : public std::pair<int,int>
struct NLink : public std::pair<smIdType,smIdType>
{
int myOri;
NLink(const SMDS_MeshNode* n1=0, const SMDS_MeshNode* n2=0, int ori=1 )
@ -2210,7 +2210,7 @@ const SMDS_MeshVolume* SMDS_VolumeTool::Element() const
//purpose : return element ID
//=======================================================================
int SMDS_VolumeTool::ID() const
smIdType SMDS_VolumeTool::ID() const
{
return myVolume ? myVolume->GetID() : 0;
}

8
src/SMDS/SMDS_VolumeTool.hxx
View File

@ -31,6 +31,8 @@
#include "SMESH_SMDS.hxx"
#include <smIdType.hxx>
class SMDS_MeshElement;
class SMDS_MeshNode;
class SMDS_MeshVolume;
@ -72,7 +74,7 @@ class SMDS_EXPORT SMDS_VolumeTool
const SMDS_MeshVolume* Element() const;
// return element
int ID() const;
smIdType ID() const;
// return element ID
bool IsPoly() const { return myPolyedre; }
@ -95,7 +97,7 @@ class SMDS_EXPORT SMDS_VolumeTool
const SMDS_MeshNode** GetNodes() const { return (const SMDS_MeshNode**) &myVolumeNodes[0]; }
// Return array of volume nodes
int NbNodes() const { return myVolumeNodes.size(); }
int NbNodes() const { return (int) myVolumeNodes.size(); }
// Return array of volume nodes
double GetSize() const;
@ -261,7 +263,7 @@ class SMDS_EXPORT SMDS_VolumeTool
int myNbFaces;
std::vector<const SMDS_MeshNode*> myVolumeNodes;
std::vector< int > myPolyIndices; // of a myCurFace
std::vector< int > myPolyQuantities;
std::vector<int> myPolyQuantities;
std::vector< int > myPolyFacetOri; // -1-in, +1-out, 0-undef
typedef std::pair<int,int> Link;

6
src/SMDS/SMDS_VtkCellIterator.cxx
View File

@ -25,7 +25,7 @@
_GetVtkNodes::_GetVtkNodes( TVtkIdList& vtkIds,
SMDS_Mesh* mesh,
int vtkCellId,
vtkIdType vtkCellId,
SMDSAbs_EntityType type )
{
vtkUnstructuredGrid* grid = mesh->GetGrid();
@ -47,7 +47,7 @@ _GetVtkNodes::_GetVtkNodes( TVtkIdList& vtkIds,
_GetVtkNodesToUNV::_GetVtkNodesToUNV( TVtkIdList& vtkIds,
SMDS_Mesh* mesh,
int vtkCellId,
vtkIdType vtkCellId,
SMDSAbs_EntityType type )
{
vtkUnstructuredGrid* grid = mesh->GetGrid();
@ -133,7 +133,7 @@ _GetVtkNodesToUNV::_GetVtkNodesToUNV( TVtkIdList& vtkIds,
_GetVtkNodesPolyh::_GetVtkNodesPolyh( TVtkIdList& vtkIds,
SMDS_Mesh* mesh,
int vtkCellId,
vtkIdType vtkCellId,
SMDSAbs_EntityType type )
{
vtkUnstructuredGrid* grid = mesh->GetGrid();

12
src/SMDS/SMDS_VtkCellIterator.hxx
View File

@ -34,15 +34,15 @@ typedef std::vector< vtkIdType > TVtkIdList;
*/
struct _GetVtkNodes
{
_GetVtkNodes( TVtkIdList& nodeIds, SMDS_Mesh* mesh, int vtkCellId, SMDSAbs_EntityType type);
_GetVtkNodes( TVtkIdList& nodeIds, SMDS_Mesh* mesh, vtkIdType vtkCellId, SMDSAbs_EntityType type);
};
struct _GetVtkNodesToUNV
{
_GetVtkNodesToUNV( TVtkIdList& nodeIds, SMDS_Mesh* mesh, int vtkCellId, SMDSAbs_EntityType type);
_GetVtkNodesToUNV( TVtkIdList& nodeIds, SMDS_Mesh* mesh, vtkIdType vtkCellId, SMDSAbs_EntityType type);
};
struct _GetVtkNodesPolyh
{
_GetVtkNodesPolyh( TVtkIdList& nodeIds, SMDS_Mesh* mesh, int vtkCellId, SMDSAbs_EntityType type);
_GetVtkNodesPolyh( TVtkIdList& nodeIds, SMDS_Mesh* mesh, vtkIdType vtkCellId, SMDSAbs_EntityType type);
};
//--------------------------------------------------------------------------------
@ -55,7 +55,7 @@ class SMDS_VtkCellIterator: public SMDS_ITERATOR
public:
typedef typename SMDS_ITERATOR::value_type result_type;
SMDS_VtkCellIterator(SMDS_Mesh* mesh, int vtkCellId, SMDSAbs_EntityType aType)
SMDS_VtkCellIterator(SMDS_Mesh* mesh, vtkIdType vtkCellId, SMDSAbs_EntityType aType)
: _mesh(mesh), _index(0)
{
GET_VTK_NODES getNodes( _vtkIdList, mesh, vtkCellId, aType );
@ -78,7 +78,7 @@ class SMDS_VtkCellIteratorToUNV: public SMDS_VtkCellIterator< SMDS_ITERATOR, _Ge
{
typedef SMDS_VtkCellIterator< SMDS_ITERATOR, _GetVtkNodesToUNV > parent_t;
public:
SMDS_VtkCellIteratorToUNV(SMDS_Mesh* mesh, int vtkCellId, SMDSAbs_EntityType type):
SMDS_VtkCellIteratorToUNV(SMDS_Mesh* mesh, vtkIdType vtkCellId, SMDSAbs_EntityType type):
parent_t( mesh, vtkCellId, type ) {}
};
@ -88,7 +88,7 @@ class SMDS_VtkCellIteratorPolyH: public SMDS_VtkCellIterator< SMDS_ITERATOR, _Ge
{
typedef SMDS_VtkCellIterator< SMDS_ITERATOR, _GetVtkNodesPolyh > parent_t;
public:
SMDS_VtkCellIteratorPolyH(SMDS_Mesh* mesh, int vtkCellId, SMDSAbs_EntityType type):
SMDS_VtkCellIteratorPolyH(SMDS_Mesh* mesh, vtkIdType vtkCellId, SMDSAbs_EntityType type):
parent_t( mesh, vtkCellId, type ) {}
};

6
src/SMESH/SMESH_Algo.cxx
View File

@ -1038,12 +1038,12 @@ void SMESH_Algo::addBadInputElements(const SMESHDS_SubMesh* sm,
*/
//=============================================================================
int SMESH_Algo::NumberOfPoints(SMESH_Mesh& aMesh, const TopoDS_Wire& W)
smIdType SMESH_Algo::NumberOfPoints(SMESH_Mesh& aMesh, const TopoDS_Wire& W)
{
int nbPoints = 0;
smIdType nbPoints = 0;
for (TopExp_Explorer exp(W,TopAbs_EDGE); exp.More(); exp.Next()) {
const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
int nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
smIdType nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
if(_quadraticMesh)
nb = nb/2;
nbPoints += nb + 1; // internal points plus 1 vertex of 2 (last point ?)

6
src/SMESH/SMESH_Algo.hxx
View File

@ -60,8 +60,8 @@ class TopoDS_Vertex;
class TopoDS_Wire;
class gp_XYZ;
typedef std::map< SMESH_subMesh*, std::vector<int> > MapShapeNbElems;
typedef std::map< SMESH_subMesh*, std::vector<int> >::iterator MapShapeNbElemsItr;
typedef std::map< SMESH_subMesh*, std::vector<smIdType> > MapShapeNbElems;
typedef std::map< SMESH_subMesh*, std::vector<smIdType> >::iterator MapShapeNbElemsItr;
// ==================================================================================
/*!
@ -339,7 +339,7 @@ public:
*/
static double EdgeLength(const TopoDS_Edge & E);
int NumberOfPoints(SMESH_Mesh& aMesh,const TopoDS_Wire& W);
smIdType NumberOfPoints(SMESH_Mesh& aMesh,const TopoDS_Wire& W);
/*!
* \brief Return continuity of two edges

129
src/SMESH/SMESH_Mesh.cxx
View File

@ -1183,7 +1183,7 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
if ( !GetMeshDS()->IsUsedHypothesis( hyp ))
return;
int nbEntities = ( _myMeshDS->NbNodes() + _myMeshDS->NbElements() );
smIdType nbEntities = ( _myMeshDS->NbNodes() + _myMeshDS->NbElements() );
if ( hyp && _callUp && !_callUp->IsLoaded() ) // for not loaded mesh (#16648)
{
_callUp->HypothesisModified( hyp->GetID(), /*updateIcons=*/true );
@ -1257,7 +1257,7 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
HasModificationsToDiscard(); // to reset _isModified flag if mesh becomes empty
GetMeshDS()->Modified();
int newNbEntities = ( _myMeshDS->NbNodes() + _myMeshDS->NbElements() );
smIdType newNbEntities = ( _myMeshDS->NbNodes() + _myMeshDS->NbElements() );
if ( hyp && _callUp )
_callUp->HypothesisModified( hyp->GetID(), newNbEntities != nbEntities );
}
@ -1428,6 +1428,8 @@ void SMESH_Mesh::ExportMED(const char * file,
bool theAllElemsToGroup)
{
MESSAGE("MED_VERSION:"<< theVersion);
Driver_Mesh::Status status;
SMESH_TRY;
DriverMED_W_SMESHDS_Mesh myWriter;
@ -1482,9 +1484,12 @@ void SMESH_Mesh::ExportMED(const char * file,
}
}
// Perform export
myWriter.Perform();
status = myWriter.Perform();
SMESH_CATCH( SMESH::throwSalomeEx );
if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH )
throw TooLargeForExport("MED");
}
//================================================================================
@ -1509,9 +1514,15 @@ void SMESH_Mesh::ExportSAUV(const char *file,
cmd += "from medutilities import my_remove ; my_remove(r'" + medfilename + "')";
cmd += "\"";
system(cmd.c_str());
ExportMED(medfilename.c_str(), theMeshName, theAutoGroups, /*minor=*/-1,
/*meshPart=*/NULL, /*theAutoDimension=*/false, /*theAddODOnVertices=*/false,
/*zTol=*/-1, /*theAllElemsToGroup=*/true ); // theAllElemsToGroup is for PAL0023413
try {
ExportMED(medfilename.c_str(), theMeshName, theAutoGroups, /*minor=*/-1,
/*meshPart=*/NULL, /*theAutoDimension=*/false, /*theAddODOnVertices=*/false,
/*zTol=*/-1, /*theAllElemsToGroup=*/true ); // theAllElemsToGroup is for PAL0023413
}
catch ( TooLargeForExport )
{
throw TooLargeForExport("SAUV");
}
#ifdef WIN32
cmd = "%PYTHONBIN% ";
#else
@ -1541,12 +1552,19 @@ void SMESH_Mesh::ExportSAUV(const char *file,
void SMESH_Mesh::ExportDAT(const char * file,
const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
Driver_Mesh::Status status;
SMESH_TRY;
DriverDAT_W_SMDS_Mesh myWriter;
myWriter.SetFile( file );
myWriter.SetMesh( meshPart ? (SMESHDS_Mesh*) meshPart : _myMeshDS );
myWriter.SetMeshId(_id);
myWriter.Perform();
status = myWriter.Perform();
SMESH_CATCH( SMESH::throwSalomeEx );
if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH )
throw TooLargeForExport("DAT");
}
//================================================================================
@ -1558,7 +1576,9 @@ void SMESH_Mesh::ExportDAT(const char * file,
void SMESH_Mesh::ExportUNV(const char * file,
const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
Driver_Mesh::Status status;
SMESH_TRY;
DriverUNV_W_SMDS_Mesh myWriter;
myWriter.SetFile( file );
myWriter.SetMesh( meshPart ? (SMESHDS_Mesh*) meshPart : _myMeshDS );
@ -1579,7 +1599,12 @@ void SMESH_Mesh::ExportUNV(const char * file,
}
}
}
myWriter.Perform();
status = myWriter.Perform();
SMESH_CATCH( SMESH::throwSalomeEx );
if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH )
throw TooLargeForExport("UNV");
}
//================================================================================
@ -1593,14 +1618,21 @@ void SMESH_Mesh::ExportSTL(const char * file,
const char * name,
const SMESHDS_Mesh* meshPart)
{
Unexpect aCatch(SalomeException);
Driver_Mesh::Status status;
SMESH_TRY;
DriverSTL_W_SMDS_Mesh myWriter;
myWriter.SetFile( file );
myWriter.SetIsAscii( isascii );
myWriter.SetMesh( meshPart ? (SMESHDS_Mesh*) meshPart : _myMeshDS);
myWriter.SetMeshId(_id);
if ( name ) myWriter.SetName( name );
myWriter.Perform();
status = myWriter.Perform();
SMESH_CATCH( SMESH::throwSalomeEx );
if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH )
throw TooLargeForExport("STL");
}
//================================================================================
@ -1614,7 +1646,9 @@ void SMESH_Mesh::ExportCGNS(const char * file,
const char * meshName,
const bool groupElemsByType)
{
int res = Driver_Mesh::DRS_FAIL;
SMESH_TRY;
// pass group names to SMESHDS
std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin();
@ -1644,6 +1678,11 @@ void SMESH_Mesh::ExportCGNS(const char * file,
}
#endif
SMESH_CATCH( SMESH::throwSalomeEx );
if ( res == Driver_Mesh::DRS_TOO_LARGE_MESH )
throw TooLargeForExport("CGNS");
if ( res != Driver_Mesh::DRS_OK )
throw SALOME_Exception("Export failed");
}
@ -1658,12 +1697,20 @@ void SMESH_Mesh::ExportGMF(const char * file,
const SMESHDS_Mesh* meshDS,
bool withRequiredGroups)
{
Driver_Mesh::Status status;
SMESH_TRY;
DriverGMF_Write myWriter;
myWriter.SetFile( file );
myWriter.SetMesh( const_cast<SMESHDS_Mesh*>( meshDS ));
myWriter.SetExportRequiredGroups( withRequiredGroups );
myWriter.Perform();
status = myWriter.Perform();
SMESH_CATCH( SMESH::throwSalomeEx );
if ( status == Driver_Mesh::DRS_TOO_LARGE_MESH )
throw TooLargeForExport("GMF");
}
//================================================================================
@ -1746,7 +1793,7 @@ double SMESH_Mesh::GetComputeProgress() const
*/
//================================================================================
int SMESH_Mesh::NbNodes() const
smIdType SMESH_Mesh::NbNodes() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->NbNodes();
@ -1758,7 +1805,7 @@ int SMESH_Mesh::NbNodes() const
*/
//================================================================================
int SMESH_Mesh::Nb0DElements() const
smIdType SMESH_Mesh::Nb0DElements() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().Nb0DElements();
@ -1770,7 +1817,7 @@ int SMESH_Mesh::Nb0DElements() const
*/
//================================================================================
int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbEdges(order);
@ -1782,7 +1829,7 @@ int SMESH_Mesh::NbEdges(SMDSAbs_ElementOrder order) const
*/
//================================================================================
int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbFaces(order);
@ -1794,7 +1841,7 @@ int SMESH_Mesh::NbFaces(SMDSAbs_ElementOrder order) const
*/
//================================================================================
int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTriangles(order);
@ -1806,7 +1853,7 @@ int SMESH_Mesh::NbTriangles(SMDSAbs_ElementOrder order) const
*/
//================================================================================
int SMESH_Mesh::NbBiQuadTriangles() const
smIdType SMESH_Mesh::NbBiQuadTriangles() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadTriangles();
@ -1818,7 +1865,7 @@ int SMESH_Mesh::NbBiQuadTriangles() const
*/
//================================================================================
int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadrangles(order);
@ -1830,7 +1877,7 @@ int SMESH_Mesh::NbQuadrangles(SMDSAbs_ElementOrder order) const
*/
//================================================================================
int SMESH_Mesh::NbBiQuadQuadrangles() const
smIdType SMESH_Mesh::NbBiQuadQuadrangles() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadQuadrangles();
@ -1842,7 +1889,7 @@ int SMESH_Mesh::NbBiQuadQuadrangles() const
*/
//================================================================================
int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPolygons(order);
@ -1854,7 +1901,7 @@ int SMESH_Mesh::NbPolygons(SMDSAbs_ElementOrder order) const
*/
//================================================================================
int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbVolumes(order);
@ -1866,7 +1913,7 @@ int SMESH_Mesh::NbVolumes(SMDSAbs_ElementOrder order) const
*/
//================================================================================
int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTetras(order);
@ -1878,7 +1925,7 @@ int SMESH_Mesh::NbTetras(SMDSAbs_ElementOrder order) const
*/
//================================================================================
int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbHexas(order);
@ -1890,7 +1937,7 @@ int SMESH_Mesh::NbHexas(SMDSAbs_ElementOrder order) const
*/
//================================================================================
int SMESH_Mesh::NbTriQuadraticHexas() const
smIdType SMESH_Mesh::NbTriQuadraticHexas() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbTriQuadHexas();
@ -1902,7 +1949,7 @@ int SMESH_Mesh::NbTriQuadraticHexas() const
*/
//================================================================================
int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPyramids(order);
@ -1914,19 +1961,19 @@ int SMESH_Mesh::NbPyramids(SMDSAbs_ElementOrder order) const
*/
//================================================================================
int SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const
smIdType SMESH_Mesh::NbPrisms(SMDSAbs_ElementOrder order) const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPrisms(order);
}
int SMESH_Mesh::NbQuadPrisms() const
smIdType SMESH_Mesh::NbQuadPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbQuadPrisms();
}
int SMESH_Mesh::NbBiQuadPrisms() const
smIdType SMESH_Mesh::NbBiQuadPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBiQuadPrisms();
@ -1939,7 +1986,7 @@ int SMESH_Mesh::NbBiQuadPrisms() const
*/
//================================================================================
int SMESH_Mesh::NbHexagonalPrisms() const
smIdType SMESH_Mesh::NbHexagonalPrisms() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbHexPrisms();
@ -1951,7 +1998,7 @@ int SMESH_Mesh::NbHexagonalPrisms() const
*/
//================================================================================
int SMESH_Mesh::NbPolyhedrons() const
smIdType SMESH_Mesh::NbPolyhedrons() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbPolyhedrons();
@ -1963,7 +2010,7 @@ int SMESH_Mesh::NbPolyhedrons() const
*/
//================================================================================
int SMESH_Mesh::NbBalls() const
smIdType SMESH_Mesh::NbBalls() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->GetMeshInfo().NbBalls();
@ -1975,7 +2022,7 @@ int SMESH_Mesh::NbBalls() const
*/
//================================================================================
int SMESH_Mesh::NbSubMesh() const
smIdType SMESH_Mesh::NbSubMesh() const
{
Unexpect aCatch(SalomeException);
return _myMeshDS->NbSubMesh();
@ -2215,8 +2262,8 @@ ostream& SMESH_Mesh::Dump(ostream& save)
save << ++clause << ") Total number of " << orderStr << " edges:\t" << NbEdges(order) << endl;
save << ++clause << ") Total number of " << orderStr << " faces:\t" << NbFaces(order) << endl;
if ( NbFaces(order) > 0 ) {
int nb3 = NbTriangles(order);
int nb4 = NbQuadrangles(order);
smIdType nb3 = NbTriangles(order);
smIdType nb4 = NbQuadrangles(order);
save << clause << ".1) Number of " << orderStr << " triangles: \t" << nb3 << endl;
save << clause << ".2) Number of " << orderStr << " quadrangles:\t" << nb4 << endl;
if ( nb3 + nb4 != NbFaces(order) ) {
@ -2236,10 +2283,10 @@ ostream& SMESH_Mesh::Dump(ostream& save)
}
save << ++clause << ") Total number of " << orderStr << " volumes:\t" << NbVolumes(order) << endl;
if ( NbVolumes(order) > 0 ) {
int nb8 = NbHexas(order);
int nb4 = NbTetras(order);
int nb5 = NbPyramids(order);
int nb6 = NbPrisms(order);
smIdType nb8 = NbHexas(order);
smIdType nb4 = NbTetras(order);
smIdType nb5 = NbPyramids(order);
smIdType nb6 = NbPrisms(order);
save << clause << ".1) Number of " << orderStr << " hexahedrons: \t" << nb8 << endl;
save << clause << ".2) Number of " << orderStr << " tetrahedrons:\t" << nb4 << endl;
save << clause << ".3) Number of " << orderStr << " prisms: \t" << nb6 << endl;
@ -2270,7 +2317,7 @@ ostream& SMESH_Mesh::Dump(ostream& save)
//purpose : Returns type of mesh element with certain id
//=======================================================================
SMDSAbs_ElementType SMESH_Mesh::GetElementType( const int id, const bool iselem )
SMDSAbs_ElementType SMESH_Mesh::GetElementType( const smIdType id, const bool iselem )
{
return _myMeshDS->GetElementType( id, iselem );
}

56
src/SMESH/SMESH_Mesh.hxx
View File

@ -245,12 +245,22 @@ class SMESH_EXPORT SMESH_Mesh
*/
typedef TopTools_IndexedDataMapOfShapeListOfShape TAncestorMap;
const TAncestorMap& GetAncestorMap() const { return _mapAncestors; }
/*!
* \brief Check group names for duplications.
* Consider maximum group name length stored in MED file
*/
bool HasDuplicatedGroupNamesMED();
/*!
* \brief Exception thrown by Export*() in case if a mesh is too large for export
* due to limitation of a format
*/
struct TooLargeForExport : public std::runtime_error
{
TooLargeForExport(const char* format):runtime_error(format) {}
};
void ExportMED(const char * theFile,
const char* theMeshName = NULL,
bool theAutoGroups = true,
@ -282,33 +292,33 @@ class SMESH_EXPORT SMESH_Mesh
double GetComputeProgress() const;
int NbNodes() const;
int Nb0DElements() const;
int NbBalls() const;
smIdType NbNodes() const;
smIdType Nb0DElements() const;
smIdType NbBalls() const;
int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbBiQuadQuadrangles() const;
int NbBiQuadTriangles() const;
int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbBiQuadQuadrangles() const;
smIdType NbBiQuadTriangles() const;
smIdType NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTriQuadraticHexas() const;
int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbQuadPrisms() const;
int NbBiQuadPrisms() const;
int NbHexagonalPrisms() const;
int NbPolyhedrons() const;
smIdType NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbTriQuadraticHexas() const;
smIdType NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
smIdType NbQuadPrisms() const;
smIdType NbBiQuadPrisms() const;
smIdType NbHexagonalPrisms() const;
smIdType NbPolyhedrons() const;
int NbSubMesh() const;
smIdType NbSubMesh() const;
int NbGroup() const { return _mapGroup.size(); }
size_t NbGroup() const { return _mapGroup.size(); }
int NbMeshes() const; // nb meshes in the Study
@ -345,7 +355,7 @@ class SMESH_EXPORT SMESH_Mesh
bool SynchronizeGroups();
SMDSAbs_ElementType GetElementType( const int id, const bool iselem );
SMDSAbs_ElementType GetElementType( const smIdType id, const bool iselem );
void ClearMeshOrder();
void SetMeshOrder(const TListOfListOfInt& theOrder );

135
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -100,6 +100,8 @@
#include "SMESH_TryCatch.hxx" // include after OCCT headers!
#include <smIdType.hxx>
#define cast2Node(elem) static_cast<const SMDS_MeshNode*>( elem )
using namespace std;
@ -186,7 +188,7 @@ SMESH_MeshEditor::AddElement(const vector<const SMDS_MeshNode*> & node,
SMDS_MeshElement* e = 0;
int nbnode = node.size();
SMESHDS_Mesh* mesh = GetMeshDS();
const int ID = features.myID;
const smIdType ID = features.myID;
switch ( features.myType ) {
case SMDSAbs_Face:
@ -389,12 +391,12 @@ SMESH_MeshEditor::AddElement(const vector<const SMDS_MeshNode*> & node,
*/
//=======================================================================
SMDS_MeshElement* SMESH_MeshEditor::AddElement(const vector<int> & nodeIDs,
const ElemFeatures& features)
SMDS_MeshElement* SMESH_MeshEditor::AddElement(const vector<smIdType> & nodeIDs,
const ElemFeatures& features)
{
vector<const SMDS_MeshNode*> nodes;
nodes.reserve( nodeIDs.size() );
vector<int>::const_iterator id = nodeIDs.begin();
vector<smIdType>::const_iterator id = nodeIDs.begin();
while ( id != nodeIDs.end() ) {
if ( const SMDS_MeshNode* node = GetMeshDS()->FindNode( *id++ ))
nodes.push_back( node );
@ -410,7 +412,7 @@ SMDS_MeshElement* SMESH_MeshEditor::AddElement(const vector<int> & nodeIDs,
// Modify a compute state of sub-meshes which become empty
//=======================================================================
int SMESH_MeshEditor::Remove (const list< int >& theIDs,
smIdType SMESH_MeshEditor::Remove (const list< smIdType >& theIDs,
const bool isNodes )
{
ClearLastCreated();
@ -418,8 +420,8 @@ int SMESH_MeshEditor::Remove (const list< int >& theIDs,
SMESHDS_Mesh* aMesh = GetMeshDS();
set< SMESH_subMesh *> smmap;
int removed = 0;
list<int>::const_iterator it = theIDs.begin();
smIdType removed = 0;
list<smIdType>::const_iterator it = theIDs.begin();
for ( ; it != theIDs.end(); it++ ) {
const SMDS_MeshElement * elem;
if ( isNodes )
@ -1808,17 +1810,17 @@ namespace
TSplitMethod( int nbTet=0, const int* conn=0, bool addNode=false)
: _nbSplits(nbTet), _nbCorners(4), _connectivity(conn), _baryNode(addNode), _ownConn(false) {}
~TSplitMethod() { if ( _ownConn ) delete [] _connectivity; _connectivity = 0; }
TSplitMethod(const TSplitMethod &splitMethod)
: _nbSplits(splitMethod._nbSplits),
_nbCorners(splitMethod._nbCorners),
_baryNode(splitMethod._baryNode),
_ownConn(splitMethod._ownConn),
_faceBaryNode(splitMethod._faceBaryNode)
{
_connectivity = splitMethod._connectivity;
const_cast<TSplitMethod&>(splitMethod)._connectivity = nullptr;
const_cast<TSplitMethod&>(splitMethod)._ownConn = false;
}
TSplitMethod(const TSplitMethod &splitMethod)
: _nbSplits(splitMethod._nbSplits),
_nbCorners(splitMethod._nbCorners),
_baryNode(splitMethod._baryNode),
_ownConn(splitMethod._ownConn),
_faceBaryNode(splitMethod._faceBaryNode)
{
_connectivity = splitMethod._connectivity;
const_cast<TSplitMethod&>(splitMethod)._connectivity = nullptr;
const_cast<TSplitMethod&>(splitMethod)._ownConn = false;
}
bool hasFacet( const TTriangleFacet& facet ) const
{
if ( _nbCorners == 4 )
@ -2069,6 +2071,8 @@ namespace
const int methodFlags,
const int facetToSplit)
{
TSplitMethod method;
// order of facets in HEX according to SMDS_VolumeTool::Hexa_F :
// B, T, L, B, R, F
const int iF = ( facetToSplit < 2 ) ? 0 : 1 + ( facetToSplit-2 ) % 2; // [0,1,2]
@ -2099,12 +2103,12 @@ namespace
to4methods[iF]._nbSplits = 4;
to4methods[iF]._nbCorners = 6;
}
return to4methods[iF];
method = to4methods[iF];
to4methods[iF]._connectivity = method._connectivity; // as copy ctor resets _connectivity
return method;
}
// else if ( methodFlags == HEXA_TO_2_PRISMS )
TSplitMethod method;
const int iQ = vol.Element()->IsQuadratic() ? 2 : 1;
const int nbVariants = 2, nbSplits = 2;
@ -2216,7 +2220,7 @@ namespace
*/
//=======================================================================
struct TVolumeFaceKey: pair< pair< int, int>, pair< int, int> >
struct TVolumeFaceKey: pair< pair< smIdType, smIdType>, pair< smIdType, smIdType> >
{
TVolumeFaceKey( SMDS_VolumeTool& vol, int iF )
{
@ -2276,7 +2280,7 @@ void SMESH_MeshEditor::SplitVolumes (const TFacetOfElem & theElems,
TSplitMethod splitMethod = ( facetToSplit < 0 ?
getTetraSplitMethod( volTool, theMethodFlags ) :
getPrismSplitMethod( volTool, theMethodFlags, facetToSplit ));
if ( splitMethod._nbSplits < 1 ) continue;
if ( splitMethod._nbSplits < 1 ) continue;
// find submesh to add new tetras to
if ( !subMesh || !subMesh->Contains( elem ))
@ -3130,10 +3134,10 @@ public:
:myMesh( theMesh ), myMaxID( theMesh->MaxNodeID() + 1)
{}
long GetLinkID (const SMDS_MeshNode * n1,
smIdType GetLinkID (const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2) const
{
return ( Min(n1->GetID(),n2->GetID()) * myMaxID + Max(n1->GetID(),n2->GetID()));
return ( std::min(n1->GetID(),n2->GetID()) * myMaxID + std::max(n1->GetID(),n2->GetID()));
}
bool GetNodes (const long theLinkID,
@ -6479,7 +6483,7 @@ SMESH_MeshEditor::PGroupIDs SMESH_MeshEditor::Offset( TIDSortedElemSet & theElem
// copy offsetMesh to theTgtMesh
int idShift = meshDS->MaxNodeID();
smIdType idShift = meshDS->MaxNodeID();
for ( size_t i = 0; i < new2OldNodes.size(); ++i )
if ( const SMDS_MeshNode* n = new2OldNodes[ i ].first )
{
@ -6849,7 +6853,7 @@ void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes,
TNodeNodeMap nodeNodeMap; // node to replace - new node
set<const SMDS_MeshElement*> elems; // all elements with changed nodes
list< int > rmElemIds, rmNodeIds;
list< smIdType > rmElemIds, rmNodeIds;
vector< ElemFeatures > newElemDefs;
// Fill nodeNodeMap and elems
@ -7444,12 +7448,12 @@ bool SMESH_MeshEditor::applyMerge( const SMDS_MeshElement* elem,
// purpose : allow comparing elements basing on their nodes
// ========================================================
class ComparableElement : public boost::container::flat_set< int >
class ComparableElement : public boost::container::flat_set< smIdType >
{
typedef boost::container::flat_set< int > int_set;
typedef boost::container::flat_set< smIdType > int_set;
const SMDS_MeshElement* myElem;
int mySumID;
smIdType mySumID;
mutable int myGroupID;
public:
@ -7460,7 +7464,7 @@ public:
this->reserve( theElem->NbNodes() );
for ( SMDS_ElemIteratorPtr nodeIt = theElem->nodesIterator(); nodeIt->more(); )
{
int id = nodeIt->next()->GetID();
smIdType id = nodeIt->next()->GetID();
mySumID += id;
this->insert( id );
}
@ -7483,7 +7487,7 @@ public:
static int HashCode(const ComparableElement& se, int limit )
{
return ::HashCode( se.mySumID, limit );
return ::HashCode( FromSmIdType<int>(se.mySumID), limit );
}
static Standard_Boolean IsEqual(const ComparableElement& se1, const ComparableElement& se2 )
{
@ -7508,7 +7512,7 @@ void SMESH_MeshEditor::FindEqualElements( TIDSortedElemSet & theElements,
else elemIt = SMESHUtils::elemSetIterator( theElements );
typedef NCollection_Map< ComparableElement, ComparableElement > TMapOfElements;
typedef std::list<int> TGroupOfElems;
typedef std::list<smIdType> TGroupOfElems;
TMapOfElements mapOfElements;
std::vector< TGroupOfElems > arrayOfGroups;
TGroupOfElems groupOfElems;
@ -7554,7 +7558,7 @@ void SMESH_MeshEditor::MergeElements(TListOfListOfElementsID & theGroupsOfElemen
{
ClearLastCreated();
typedef list<int> TListOfIDs;
typedef list<smIdType> TListOfIDs;
TListOfIDs rmElemIds; // IDs of elems to remove
SMESHDS_Mesh* aMesh = GetMeshDS();
@ -8269,8 +8273,8 @@ SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
TListOfListOfElementsID::iterator itGroups = equalGroups.begin();
for ( ; itGroups != equalGroups.end(); ++itGroups )
{
list< int >& group = *itGroups;
list< int >::iterator id = group.begin();
list< smIdType >& group = *itGroups;
list< smIdType >::iterator id = group.begin();
for ( ++id; id != group.end(); ++id )
if ( const SMDS_MeshElement* seg = GetMeshDS()->FindElement( *id ))
segments.erase( seg );
@ -8702,12 +8706,12 @@ namespace
*/
//=======================================================================
int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
SMESH_MesherHelper& theHelper,
const bool theForce3d)
smIdType SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
SMESH_MesherHelper& theHelper,
const bool theForce3d)
{
//MESSAGE("convertElemToQuadratic");
int nbElem = 0;
smIdType nbElem = 0;
if( !theSm ) return nbElem;
vector<int> nbNodeInFaces;
@ -8760,7 +8764,7 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
}
// get elem data needed to re-create it
//
const int id = elem->GetID();
const smIdType id = elem->GetID();
const int nbNodes = elem->NbCornerNodes();
nodes.assign(elem->begin_nodes(), elem->end_nodes());
if ( aGeomType == SMDSEntity_Polyhedra )
@ -8855,7 +8859,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theT
aHelper.ToFixNodeParameters( true );
// convert elements assigned to sub-meshes
int nbCheckedElems = 0;
smIdType nbCheckedElems = 0;
if ( myMesh->HasShapeToMesh() )
{
if ( SMESH_subMesh *aSubMesh = myMesh->GetSubMeshContaining(myMesh->GetShapeToMesh()))
@ -8872,7 +8876,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theT
}
// convert elements NOT assigned to sub-meshes
int totalNbElems = meshDS->NbEdges() + meshDS->NbFaces() + meshDS->NbVolumes();
smIdType totalNbElems = meshDS->NbEdges() + meshDS->NbFaces() + meshDS->NbVolumes();
if ( nbCheckedElems < totalNbElems ) // not all elements are in sub-meshes
{
aHelper.SetElementsOnShape(false);
@ -8885,7 +8889,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theT
const SMDS_MeshEdge* edge = aEdgeItr->next();
if ( !edge->IsQuadratic() )
{
int id = edge->GetID();
smIdType id = edge->GetID();
const SMDS_MeshNode* n1 = edge->GetNode(0);
const SMDS_MeshNode* n2 = edge->GetNode(1);
@ -8926,7 +8930,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theT
if ( alreadyOK )
continue;
const int id = face->GetID();
const smIdType id = face->GetID();
vector<const SMDS_MeshNode *> nodes ( face->begin_nodes(), face->end_nodes());
meshDS->RemoveFreeElement(face, smDS, /*fromGroups=*/false);
@ -8982,7 +8986,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theT
continue;
}
}
const int id = volume->GetID();
const smIdType id = volume->GetID();
vector<const SMDS_MeshNode *> nodes (volume->begin_nodes(), volume->end_nodes());
if ( type == SMDSEntity_Polyhedra )
nbNodeInFaces = static_cast<const SMDS_MeshVolume* >(volume)->GetQuantities();
@ -9162,7 +9166,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
if ( alreadyOK ) continue;
const SMDSAbs_ElementType type = elem->GetType();
const int id = elem->GetID();
const smIdType id = elem->GetID();
const int nbNodes = elem->NbCornerNodes();
vector<const SMDS_MeshNode *> nodes ( elem->begin_nodes(), elem->end_nodes());
@ -9223,15 +9227,15 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
//=======================================================================
/*!
* \brief Convert quadratic elements to linear ones and remove quadratic nodes
* \return int - nb of checked elements
* \return smIdType - nb of checked elements
*/
//=======================================================================
int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr,
const int /*theShapeID*/)
smIdType SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr,
const int /*theShapeID*/)
{
int nbElem = 0;
smIdType nbElem = 0;
SMESHDS_Mesh* meshDS = GetMeshDS();
ElemFeatures elemType;
vector<const SMDS_MeshNode *> nodes;
@ -9276,7 +9280,7 @@ int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
bool SMESH_MeshEditor::ConvertFromQuadratic()
{
int nbCheckedElems = 0;
smIdType nbCheckedElems = 0;
if ( myMesh->HasShapeToMesh() )
{
if ( SMESH_subMesh *aSubMesh = myMesh->GetSubMeshContaining(myMesh->GetShapeToMesh()))
@ -9290,7 +9294,7 @@ bool SMESH_MeshEditor::ConvertFromQuadratic()
}
}
int totalNbElems =
smIdType totalNbElems =
GetMeshDS()->NbEdges() + GetMeshDS()->NbFaces() + GetMeshDS()->NbVolumes();
if ( nbCheckedElems < totalNbElems ) // not all elements are in submeshes
{
@ -9329,7 +9333,7 @@ void SMESH_MeshEditor::ConvertFromQuadratic(TIDSortedElemSet& theElements)
if ( theElements.empty() ) return;
// collect IDs of medium nodes of theElements; some of these nodes will be removed
set<int> mediumNodeIDs;
set<smIdType> mediumNodeIDs;
TIDSortedElemSet::iterator eIt = theElements.begin();
for ( ; eIt != theElements.end(); ++eIt )
{
@ -9348,7 +9352,7 @@ void SMESH_MeshEditor::ConvertFromQuadratic(TIDSortedElemSet& theElements)
// get remaining medium nodes
TIDSortedNodeSet mediumNodes;
set<int>::iterator nIdsIt = mediumNodeIDs.begin();
set<smIdType>::iterator nIdsIt = mediumNodeIDs.begin();
for ( ; nIdsIt != mediumNodeIDs.end(); ++nIdsIt )
if ( const SMDS_MeshNode* n = GetMeshDS()->FindNode( *nIdsIt ))
mediumNodes.insert( mediumNodes.end(), n );
@ -9837,7 +9841,7 @@ SMESH_MeshEditor::SewSideElements (TIDSortedElemSet& theSide1,
if ( aResult != SEW_OK)
return aResult;
list< int > nodeIDsToRemove;
list< smIdType > nodeIDsToRemove;
vector< const SMDS_MeshNode*> nodes;
ElemFeatures elemType;
@ -10237,7 +10241,8 @@ namespace // automatically find theAffectedElems for DoubleNodes()
if ( maxX < 0 )
{
_elems[0]->setIsMarked( false );
_elems[1]->setIsMarked( true );
if ( _elems[1] )
_elems[1]->setIsMarked( true );
}
}
@ -10409,7 +10414,11 @@ namespace // automatically find theAffectedElems for DoubleNodes()
{
fissure.reserve( theElemsOrNodes.size() );
for ( ; elIt != theElemsOrNodes.end(); ++elIt )
{
fissure.push_back( std::move( FissureBorder( *elIt, elemsByFacet )));
if ( !fissure.back()._elems[1] )
fissure.pop_back();
}
}
if ( fissure.empty() )
return;
@ -10916,7 +10925,7 @@ namespace {
\brief Identify the elements that will be affected by node duplication (actual duplication is not performed).
This method is the first step of DoubleNodeElemGroupsInRegion.
\param theElems - list of groups of elements (edges or faces) to be replicated
\param theNodesNot - list of groups of nodes not to replicated
\param theNodesNot - list of groups of nodes not to replicate
\param theShape - shape to detect affected elements (element which geometric center
located on or inside shape). If the shape is null, detection is done on faces orientations
(select elements with a gravity center on the side given by faces normals).
@ -11157,7 +11166,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
const SMDS_MeshElement* anElem = *elemItr;
if (!anElem)
continue;
int vtkId = anElem->GetVtkID();
vtkIdType vtkId = anElem->GetVtkID();
//MESSAGE(" vtkId " << vtkId << " smdsId " << anElem->GetID());
int neighborsVtkIds[NBMAXNEIGHBORS];
int downIds[NBMAXNEIGHBORS];
@ -11165,7 +11174,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
int nbNeighbors = grid->GetNeighbors(neighborsVtkIds, downIds, downTypes, vtkId);
for (int n = 0; n < nbNeighbors; n++)
{
int smdsId = meshDS->FromVtkToSmds(neighborsVtkIds[n]);
smIdType smdsId = meshDS->FromVtkToSmds(neighborsVtkIds[n]);
const SMDS_MeshElement* elem = meshDS->FindElement(smdsId);
if (elem && ! domain.count(elem)) // neighbor is in another domain : face is shared
{
@ -11394,7 +11403,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
const TIDSortedElemSet& domain = (idom == iRestDom) ? theRestDomElems : theElems[idom];
for ( int ivol = 0; ivol < nbvol; ivol++ )
{
int smdsId = meshDS->FromVtkToSmds(vtkVolIds[ivol]);
smIdType smdsId = meshDS->FromVtkToSmds(vtkVolIds[ivol]);
const SMDS_MeshElement* elem = meshDS->FindElement(smdsId);
if (domain.count(elem))
{
@ -12250,7 +12259,7 @@ void SMESH_MeshEditor::CreateHoleSkin(double radius,
{
if (neighborsVtkIds[n]<0) // only smds faces are considered as neighbors here
continue;
int smdsId = meshDS->FromVtkToSmds(neighborsVtkIds[n]);
smIdType smdsId = meshDS->FromVtkToSmds(neighborsVtkIds[n]);
const SMDS_MeshElement* elem = meshDS->FindElement(smdsId);
if ( shapeIds.count(elem->getshapeId()) && !sgrps->Contains(elem)) // edge : neighbor in the set of shape, not in the group
{

28
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -87,7 +87,7 @@ public:
{
SMDSAbs_ElementType myType;
bool myIsPoly, myIsQuad;
int myID;
smIdType myID;
double myBallDiameter;
std::vector<int> myPolyhedQuantities;
std::vector<const SMDS_MeshNode*> myNodes; // not managed by ElemFeatures
@ -113,7 +113,7 @@ public:
SMESH_EXPORT ElemFeatures& SetPoly(bool isPoly) { myIsPoly = isPoly; return *this; }
SMESH_EXPORT ElemFeatures& SetQuad(bool isQuad) { myIsQuad = isQuad; return *this; }
SMESH_EXPORT ElemFeatures& SetID (int ID) { myID = ID; return *this; }
SMESH_EXPORT ElemFeatures& SetID (smIdType ID) { myID = ID; return *this; }
};
/*!
@ -124,10 +124,10 @@ public:
/*!
* \brief Add element
*/
SMDS_MeshElement* AddElement(const std::vector<int> & nodeIDs,
const ElemFeatures& features);
SMDS_MeshElement* AddElement(const std::vector<smIdType> & nodeIDs,
const ElemFeatures& features);
int Remove (const std::list< int >& theElemIDs, const bool isNodes);
smIdType Remove (const std::list< smIdType >& theElemIDs, const bool isNodes);
// Remove a node or an element.
// Modify a compute state of sub-meshes which become empty
@ -352,7 +352,7 @@ public:
bool IsScaleVariation() const { return myFlags & EXTRUSION_FLAG_SCALE_LINEAR_VARIATION; }
bool IsAngleVariation() const { return myFlags & EXTRUSION_FLAG_ANGLE_LINEAR_VARIATION; }
int NbSteps() const {
return mySteps.IsNull() ? myPathPoints.size() - 1: mySteps->Length();
return mySteps.IsNull() ? (int)myPathPoints.size() - 1: mySteps->Length();
}
// stores elements to use for extrusion by normal, depending on
// state of EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY flag;
@ -501,7 +501,7 @@ public:
// In each group, the cdr of nodes are substituted by the first one
// in all elements.
typedef std::list< std::list< int > > TListOfListOfElementsID;
typedef std::list< std::list< smIdType > > TListOfListOfElementsID;
void FindEqualElements(TIDSortedElemSet & theElements,
TListOfListOfElementsID & theGroupsOfElementsID);
@ -735,19 +735,19 @@ public:
/*!
* \brief Convert elements contained in a submesh to quadratic
* \return int - nb of checked elements
* \return smIdType - nb of checked elements
*/
int convertElemToQuadratic(SMESHDS_SubMesh * theSm,
SMESH_MesherHelper& theHelper,
const bool theForce3d);
smIdType convertElemToQuadratic(SMESHDS_SubMesh * theSm,
SMESH_MesherHelper& theHelper,
const bool theForce3d);
/*!
* \brief Convert quadratic elements to linear ones and remove quadratic nodes
* \return nb of checked elements
*/
int removeQuadElem( SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr,
const int theShapeID);
smIdType removeQuadElem( SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr,
const int theShapeID);
/*!
* \brief Create groups of elements made during transformation
* \param nodeGens - nodes making corresponding myLastCreatedNodes

28
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -1924,7 +1924,7 @@ const SMDS_MeshNode* SMESH_MesherHelper::getMediumNodeOnComposedWire(const SMDS_
//purpose : Creates a node
//=======================================================================
SMDS_MeshNode* SMESH_MesherHelper::AddNode(double x, double y, double z, int ID,
SMDS_MeshNode* SMESH_MesherHelper::AddNode(double x, double y, double z, smIdType ID,
double u, double v)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -1953,7 +1953,7 @@ SMDS_MeshNode* SMESH_MesherHelper::AddNode(double x, double y, double z, int ID,
SMDS_MeshEdge* SMESH_MesherHelper::AddEdge(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const int id,
const smIdType id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -1987,7 +1987,7 @@ SMDS_MeshEdge* SMESH_MesherHelper::AddEdge(const SMDS_MeshNode* n1,
SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const int id,
const smIdType id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -2037,7 +2037,7 @@ SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id,
const smIdType id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -2101,7 +2101,7 @@ SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
//=======================================================================
SMDS_MeshFace* SMESH_MesherHelper::AddPolygonalFace (const vector<const SMDS_MeshNode*>& nodes,
const int id,
const smIdType id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -2147,7 +2147,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n5,
const SMDS_MeshNode* n6,
const int id,
const smIdType id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -2210,7 +2210,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id,
const smIdType id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -2251,7 +2251,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n5,
const int id,
const smIdType id,
const bool force3d)
{
SMDS_MeshVolume* elem = 0;
@ -2301,7 +2301,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n6,
const SMDS_MeshNode* n7,
const SMDS_MeshNode* n8,
const int id,
const smIdType id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -2420,7 +2420,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n10,
const SMDS_MeshNode* n11,
const SMDS_MeshNode* n12,
const int id,
const smIdType id,
bool /*force3d*/)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -2442,7 +2442,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
SMDS_MeshVolume*
SMESH_MesherHelper::AddPolyhedralVolume (const std::vector<const SMDS_MeshNode*>& nodes,
const std::vector<int>& quantities,
const int id,
const smIdType id,
const bool force3d)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
@ -3413,9 +3413,9 @@ TopoDS_Shape SMESH_MesherHelper::GetShapeOfHypothesis( const SMESHDS_Hypothesis
SMESH_MesherHelper:: MType SMESH_MesherHelper::IsQuadraticMesh()
{
int NbAllEdgsAndFaces=0;
int NbQuadFacesAndEdgs=0;
int NbFacesAndEdges=0;
smIdType NbAllEdgsAndFaces=0;
smIdType NbQuadFacesAndEdgs=0;
smIdType NbFacesAndEdges=0;
//All faces and edges
NbAllEdgsAndFaces = myMesh->NbEdges() + myMesh->NbFaces();
if ( NbAllEdgsAndFaces == 0 )

26
src/SMESH/SMESH_MesherHelper.hxx
View File

@ -100,7 +100,7 @@ class SMESH_EXPORT SMESH_MesherHelper
* \brief Load nodes bound to face into a map of node columns
* \param theParam2ColumnMap - map of node columns to fill
* \param theFace - the face on which nodes are searched for
* \param theBaseSide - the edges holding nodes on which columns' bases
* \param theBaseSide - the edges holding nodes on which columns base
* \param theMesh - the mesh containing nodes
* \retval bool - false if something is wrong
*
@ -343,13 +343,13 @@ public:
/*!
* Creates a node (!Note ID before u=0.,v0.)
*/
SMDS_MeshNode* AddNode(double x, double y, double z, int ID = 0, double u=0., double v=0.);
SMDS_MeshNode* AddNode(double x, double y, double z, smIdType ID = 0, double u=0., double v=0.);
/*!
* Creates quadratic or linear edge
*/
SMDS_MeshEdge* AddEdge(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const int id = 0,
const smIdType id = 0,
const bool force3d = true);
/*!
* Creates quadratic or linear triangle
@ -357,7 +357,7 @@ public:
SMDS_MeshFace* AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const int id=0,
const smIdType id=0,
const bool force3d = false);
/*!
* Creates bi-quadratic, quadratic or linear quadrangle
@ -366,13 +366,13 @@ public:
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id = 0,
const smIdType id = 0,
const bool force3d = false);
/*!
* Creates polygon, with additional nodes in quadratic mesh
*/
SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes,
const int id = 0,
const smIdType id = 0,
const bool force3d = false);
/*!
* Creates quadratic or linear tetrahedron
@ -381,7 +381,7 @@ public:
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const int id = 0,
const smIdType id = 0,
const bool force3d = true);
/*!
* Creates quadratic or linear pyramid
@ -391,7 +391,7 @@ public:
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n5,
const int id = 0,
const smIdType id = 0,
const bool force3d = true);
/*!
* Creates quadratic or linear pentahedron
@ -402,7 +402,7 @@ public:
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n5,
const SMDS_MeshNode* n6,
const int id = 0,
const smIdType id = 0,
const bool force3d = true);
/*!
* Creates bi-quadratic, quadratic or linear hexahedron
@ -415,7 +415,7 @@ public:
const SMDS_MeshNode* n6,
const SMDS_MeshNode* n7,
const SMDS_MeshNode* n8,
const int id = 0,
const smIdType id = 0,
bool force3d = true);
/*!
@ -433,7 +433,7 @@ public:
const SMDS_MeshNode* n10,
const SMDS_MeshNode* n11,
const SMDS_MeshNode* n12,
const int id = 0,
const smIdType id = 0,
bool force3d = true);
/*!
@ -441,7 +441,7 @@ public:
*/
SMDS_MeshVolume* AddPolyhedralVolume (const std::vector<const SMDS_MeshNode*>& nodes,
const std::vector<int>& quantities,
const int ID=0,
const smIdType ID=0,
const bool force3d = true);
/*!
* \brief Enables fixing node parameters on EDGEs and FACEs by
@ -753,7 +753,7 @@ public:
SMESH_MesherHelper (const SMESH_MesherHelper& theOther);
// key of a map of bi-quadratic face to it's central node
struct TBiQuad: public std::pair<int, std::pair<int, int> >
struct TBiQuad: public std::pair<smIdType, std::pair<smIdType, smIdType> >
{
TBiQuad(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,

8
src/SMESH/SMESH_Pattern.cxx
View File

@ -574,8 +574,8 @@ bool SMESH_Pattern::Load (SMESH_Mesh* theMesh,
SMESH_MesherHelper helper( *theMesh );
helper.SetSubShape( theFace );
int nbNodes = ( !fSubMesh ? 0 : fSubMesh->NbNodes() );
int nbElems = ( !fSubMesh ? 0 : fSubMesh->NbElements() );
smIdType nbNodes = ( !fSubMesh ? 0 : fSubMesh->NbNodes() );
smIdType nbElems = ( !fSubMesh ? 0 : fSubMesh->NbElements() );
if ( nbElems == 0 && aMeshDS->NbFaces() == 0 )
{
MESSAGE( "No elements bound to the face");
@ -3231,7 +3231,7 @@ bool SMESH_Pattern::Load (SMESH_Mesh* theMesh,
return setErrorCode( ERR_LOADV_BAD_SHAPE );
// count nodes
int nbNodes = 0, shapeID;
smIdType nbNodes = 0; int shapeID;
for ( shapeID = 1; shapeID <= myShapeIDMap.Extent(); shapeID++ )
{
const TopoDS_Shape& S = myShapeIDMap( shapeID );
@ -4366,7 +4366,7 @@ void SMESH_Pattern::createElements(SMESH_Mesh* theMes
subMesh->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
}
if ( onMeshElements ) {
list< int > elemIDs;
list< smIdType > elemIDs;
for ( size_t i = 0; i < theElements.size(); i++ )
{
subMesh = theMesh->GetSubMeshContaining( shapeIDs[ i ] );

8
src/SMESH/SMESH_ProxyMesh.cxx
View File

@ -402,9 +402,9 @@ SMDS_ElemIteratorPtr SMESH_ProxyMesh::GetFaces() const
*/
//================================================================================
int SMESH_ProxyMesh::NbFaces() const
smIdType SMESH_ProxyMesh::NbFaces() const
{
int nb = 0;
smIdType nb = 0;
if ( _mesh->HasShapeToMesh() )
{
TopTools_IndexedMapOfShape FF;
@ -715,7 +715,7 @@ void SMESH_ProxyMesh::SubMesh::Clear()
*/
//================================================================================
int SMESH_ProxyMesh::SubMesh::NbElements() const
smIdType SMESH_ProxyMesh::SubMesh::NbElements() const
{
return _uvPtStructVec.empty() ? _elements.size() : _uvPtStructVec.size() - 1;
}
@ -740,7 +740,7 @@ SMDS_ElemIteratorPtr SMESH_ProxyMesh::SubMesh::GetElements() const
*/
//================================================================================
int SMESH_ProxyMesh::SubMesh::NbNodes() const
smIdType SMESH_ProxyMesh::SubMesh::NbNodes() const
{
return _uvPtStructVec.size();
}

7
src/SMESH/SMESH_ProxyMesh.hxx
View File

@ -32,6 +32,7 @@
#include <TopoDS_Shape.hxx>
#include <NCollection_DataMap.hxx>
#include <smIdType.hxx>
#include <map>
#include <vector>
@ -66,8 +67,8 @@ public:
const SMDS_MeshNode* GetProxyNode( const SMDS_MeshNode* n ) const;
const UVPtStructVec& GetUVPtStructVec() const { return _uvPtStructVec; }
virtual void AddElement(const SMDS_MeshElement * e);
virtual int NbElements() const;
virtual int NbNodes() const;
virtual smIdType NbElements() const;
virtual smIdType NbNodes() const;
virtual SMDS_ElemIteratorPtr GetElements() const;
virtual SMDS_NodeIteratorPtr GetNodes() const;
virtual void Clear();
@ -127,7 +128,7 @@ public:
SMDS_ElemIteratorPtr GetFaces(const TopoDS_Shape& face) const;
// Return total nb of faces taking into account substitutions
int NbFaces() const;
smIdType NbFaces() const;
bool IsTemporary(const SMDS_MeshElement* elem ) const;

12
src/SMESH/SMESH_subMesh.cxx
View File

@ -1331,12 +1331,12 @@ static void cleanSubMesh( SMESH_subMesh * subMesh )
if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS())
{
SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS();
int nbElems = subMeshDS->NbElements();
smIdType nbElems = subMeshDS->NbElements();
if ( nbElems > 0 )
for ( SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); ite->more(); )
meshDS->RemoveFreeElement( ite->next(), subMeshDS );
int nbNodes = subMeshDS->NbNodes();
smIdType nbNodes = subMeshDS->NbNodes();
if ( nbNodes > 0 )
for ( SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); itn->more() ; )
{
@ -1917,7 +1917,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
bool ret = true;
if (_subShape.ShapeType() == TopAbs_VERTEX) {
vector<int> aVec(SMDSEntity_Last,0);
vector<smIdType> aVec(SMDSEntity_Last,0);
aVec[SMDSEntity_Node] = 1;
aResMap.insert(make_pair(this,aVec));
return ret;
@ -1944,7 +1944,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
SMESH_subMesh* sm = smIt->next();
int dim = SMESH_Gen::GetShapeDim( sm->GetSubShape() );
if (dim < dimToCheck) break; // the rest subMeshes are all of less dimension
const vector<int> & nbs = aResMap[ sm ];
const vector<smIdType> & nbs = aResMap[ sm ];
subMeshEvaluated = (std::accumulate( nbs.begin(), nbs.end(), 0 ) > 0 );
}
if ( !subMeshEvaluated )
@ -1954,7 +1954,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
if ( IsMeshComputed() )
{
vector<int> & nbEntities = aResMap[ this ];
vector<smIdType> & nbEntities = aResMap[ this ];
nbEntities.resize( SMDSEntity_Last, 0 );
if ( SMESHDS_SubMesh* sm = GetSubMeshDS() )
{
@ -1968,7 +1968,7 @@ bool SMESH_subMesh::Evaluate(MapShapeNbElems& aResMap)
{
ret = algo->Evaluate((*_father), _subShape, aResMap);
}
aResMap.insert( make_pair( this,vector<int>(0)));
aResMap.insert( make_pair( this,vector<smIdType>(0)));
}
return ret;

93
src/SMESHClient/SMESH_Client.cxx
View File

@ -34,6 +34,7 @@
#include "SALOME_LifeCycleCORBA.hxx"
#include <SALOMEconfig.h>
#include <smIdType.hxx>
#include CORBA_SERVER_HEADER(SALOME_Component)
#include CORBA_SERVER_HEADER(SALOME_Exception)
@ -89,14 +90,14 @@ namespace
//=======================================================================
inline void AddNodesWithID(SMDS_Mesh* theMesh,
SMESH::log_array_var& theSeq,
CORBA::Long theId)
SMESH::smIdType theId)
{
const SMESH::double_array& aCoords = theSeq[theId].coords;
const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(3*aNbElems != (CORBA::Long) aCoords.length())
SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
if(3*aNbElems != (SMESH::smIdType) aCoords.length())
EXCEPTION(runtime_error,"AddNodesWithID - 3*aNbElems != aCoords.length()");
for(CORBA::Long aCoordId = 0; anElemId < aNbElems; anElemId++, aCoordId+=3){
for(SMESH::smIdType aCoordId = 0; anElemId < aNbElems; anElemId++, aCoordId+=3){
SMDS_MeshElement* anElem = theMesh->AddNodeWithID(aCoords[aCoordId],
aCoords[aCoordId+1],
aCoords[aCoordId+2],
@ -112,13 +113,13 @@ namespace
//=======================================================================
inline void Add0DElementsWithID(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 (2*aNbElems != (CORBA::Long) anIndexes.length())
SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
if (2*aNbElems != (SMESH::smIdType) anIndexes.length())
EXCEPTION(runtime_error,"AddEdgeWithID - 2*aNbElems != aCoords.length()");
CORBA::Long anIndexId = 0;
SMESH::smIdType anIndexId = 0;
for (; anElemId < aNbElems; anElemId++, anIndexId+=2)
{
SMDS_MeshElement* anElem = theMesh->Add0DElementWithID(anIndexes[anIndexId+1],
@ -134,16 +135,16 @@ namespace
//=======================================================================
inline void AddBallsWithID(SMDS_Mesh* theMesh,
SMESH::log_array_var& theSeq,
CORBA::Long theId)
SMESH::smIdType theId)
{
const SMESH::double_array& aDiameter = theSeq[theId].coords;
const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if (2*aNbElems != (CORBA::Long) anIndexes.length() )
SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
if (2*aNbElems != (SMESH::smIdType) anIndexes.length() )
EXCEPTION(runtime_error,"AddEdgeWithID - 2*aNbElems != anIndexes.length()");
if (aNbElems != (CORBA::Long) aDiameter.length())
if (aNbElems != (SMESH::smIdType) aDiameter.length())
EXCEPTION(runtime_error,"AddEdgeWithID - aNbElems != aDiameter.length()");
CORBA::Long anIndexId = 0;
SMESH::smIdType anIndexId = 0;
for (; anElemId < aNbElems; anElemId++, anIndexId+=2)
{
SMDS_MeshElement* anElem = theMesh->AddBallWithID(anIndexes[anIndexId+1],
@ -160,13 +161,13 @@ namespace
//=======================================================================
inline void AddEdgesWithID(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(3*aNbElems != (CORBA::Long) anIndexes.length())
SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
if(3*aNbElems != (SMESH::smIdType) anIndexes.length())
EXCEPTION(runtime_error,"AddEdgeWithID - 3*aNbElems != aCoords.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=3){
for(SMESH::smIdType anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=3){
SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1],
anIndexes[anIndexId+2],
anIndexes[anIndexId]);
@ -181,13 +182,13 @@ namespace
//=======================================================================
inline void AddTriasWithID(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(4*aNbElems != (CORBA::Long) anIndexes.length())
SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
if(4*aNbElems != (SMESH::smIdType) anIndexes.length())
EXCEPTION(runtime_error,"AddTriasWithID - 4*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){
for(SMESH::smIdType anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){
SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
anIndexes[anIndexId+2],
anIndexes[anIndexId+3],
@ -203,13 +204,13 @@ namespace
//=======================================================================
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],
@ -226,16 +227,16 @@ namespace
//=======================================================================
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++) {
int aFaceId = anIndexes[anIndexId++];
for (SMESH::smIdType anElemId = 0; anElemId < aNbElems; anElemId++) {
smIdType aFaceId = anIndexes[anIndexId++];
int aNbNodes = anIndexes[anIndexId++];
std::vector<int> nodes_ids (aNbNodes);
std::vector<smIdType> nodes_ids (aNbNodes);
for (int i = 0; i < aNbNodes; i++) {
nodes_ids[i] = anIndexes[anIndexId++];
}
@ -253,16 +254,16 @@ namespace
//=======================================================================
inline void AddQuadPolygonsWithID(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++) {
int aFaceId = anIndexes[anIndexId++];
for (SMESH::smIdType anElemId = 0; anElemId < aNbElems; anElemId++) {
smIdType aFaceId = anIndexes[anIndexId++];
int aNbNodes = anIndexes[anIndexId++];
std::vector<int> nodes_ids (aNbNodes);
std::vector<smIdType> nodes_ids (aNbNodes);
for (int i = 0; i < aNbNodes; i++) {
nodes_ids[i] = anIndexes[anIndexId++];
}
@ -280,13 +281,13 @@ namespace
//=======================================================================
inline void AddTetrasWithID(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,"AddTetrasWithID - 5*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->AddVolumeWithID(anIndexes[anIndexId+1],
anIndexes[anIndexId+2],
anIndexes[anIndexId+3],
@ -303,13 +304,13 @@ namespace
//=======================================================================
inline void AddPiramidsWithID(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(6*aNbElems != (CORBA::Long) anIndexes.length())
SMESH::smIdType anElemId = 0, aNbElems = theSeq[theId].number;
if(6*aNbElems != (SMESH::smIdType) anIndexes.length())
EXCEPTION(runtime_error,"AddPiramidsWithID - 6*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=6){
for(SMESH::smIdType anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=6){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
anIndexes[anIndexId+2],
anIndexes[anIndexId+3],
@ -327,7 +328,7 @@ namespace
//=======================================================================
inline void AddPrismsWithID(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;
@ -415,10 +416,10 @@ namespace
CORBA::Long anIndexId = 0, aNbElems = theSeq[theId].number;
for (CORBA::Long anElemId = 0; anElemId < aNbElems; anElemId++) {
int aFaceId = anIndexes[anIndexId++];
smIdType aFaceId = anIndexes[anIndexId++];
int aNbNodes = anIndexes[anIndexId++];
std::vector<int> nodes_ids (aNbNodes);
std::vector<smIdType> nodes_ids (aNbNodes);
for (int i = 0; i < aNbNodes; i++) {
nodes_ids[i] = anIndexes[anIndexId++];
}

178
src/SMESHDS/SMESHDS_Command.cxx
View File

@ -52,7 +52,7 @@ SMESHDS_Command::~SMESHDS_Command()
//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)
{
@ -70,7 +70,7 @@ void SMESHDS_Command::AddNode(int NewNodeID, double x, double y, double z)
//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)
{
@ -88,7 +88,7 @@ void SMESHDS_Command::MoveNode(int NodeID, double x, double y, double z)
//function :
//purpose :
//=======================================================================
void SMESHDS_Command::Add0DElement(int New0DElementID, int idnode)
void SMESHDS_Command::Add0DElement(smIdType New0DElementID, smIdType idnode)
{
if ( myType != SMESHDS_Add0DElement)
{
@ -104,7 +104,7 @@ void SMESHDS_Command::Add0DElement(int New0DElementID, int idnode)
//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)
{
@ -121,8 +121,8 @@ void SMESHDS_Command::AddEdge(int NewEdgeID, int idnode1, int idnode2)
//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)
{
@ -140,8 +140,8 @@ void SMESHDS_Command::AddFace(int NewFaceID,
//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)
{
@ -160,8 +160,8 @@ void SMESHDS_Command::AddFace(int NewFaceID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Command::AddVolume(int NewVolID,
int idnode1, int idnode2, int idnode3, int idnode4)
void SMESHDS_Command::AddVolume(smIdType NewVolID,
smIdType idnode1, smIdType idnode2, smIdType idnode3, smIdType idnode4)
{
if ( myType != SMESHDS_AddTetrahedron)
{
@ -180,8 +180,8 @@ void SMESHDS_Command::AddVolume(int NewVolID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Command::AddVolume(int NewVolID,
int idnode1, int idnode2, int idnode3, int idnode4, int idnode5)
void SMESHDS_Command::AddVolume(smIdType NewVolID,
smIdType idnode1, smIdType idnode2, smIdType idnode3, smIdType idnode4, smIdType idnode5)
{
if ( myType != SMESHDS_AddPyramid)
{
@ -201,9 +201,9 @@ void SMESHDS_Command::AddVolume(int NewVolID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Command::AddVolume(int NewVolID,
int idnode1,
int idnode2, int idnode3, int idnode4, int idnode5, int idnode6)
void SMESHDS_Command::AddVolume(smIdType NewVolID,
smIdType idnode1,
smIdType idnode2, smIdType idnode3, smIdType idnode4, smIdType idnode5, smIdType idnode6)
{
if ( myType != SMESHDS_AddPrism)
{
@ -224,11 +224,11 @@ void SMESHDS_Command::AddVolume(int NewVolID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Command::AddVolume(int NewVolID,
int idnode1,
int idnode2,
int idnode3,
int idnode4, int idnode5, int idnode6, int idnode7, int idnode8)
void SMESHDS_Command::AddVolume(smIdType NewVolID,
smIdType idnode1,
smIdType idnode2,
smIdType idnode3,
smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8)
{
if ( myType != SMESHDS_AddHexahedron)
{
@ -247,10 +247,10 @@ void SMESHDS_Command::AddVolume(int NewVolID,
myNumber++;
}
void SMESHDS_Command::AddVolume(int NewVolID,
int idnode1,int idnode2,int idnode3,int idnode4,
int idnode5, int idnode6, int idnode7, int idnode8,
int idnode9, int idnode10, int idnode11, int idnode12)
void SMESHDS_Command::AddVolume(smIdType NewVolID,
smIdType idnode1,smIdType idnode2,smIdType idnode3,smIdType idnode4,
smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8,
smIdType idnode9, smIdType idnode10, smIdType idnode11, smIdType idnode12)
{
if (myType != SMESHDS_AddHexagonalPrism)
{
@ -277,8 +277,8 @@ void SMESHDS_Command::AddVolume(int NewVolID,
//function : AddPolygonalFace
//purpose :
//=======================================================================
void SMESHDS_Command::AddPolygonalFace (const int ElementID,
const std::vector<int>& nodes_ids)
void SMESHDS_Command::AddPolygonalFace (const smIdType ElementID,
const std::vector<smIdType>& nodes_ids)
{
if ( myType != SMESHDS_AddPolygon) {
MESSAGE("SMESHDS_Command::AddPolygonalFace : Bad Type");
@ -286,7 +286,7 @@ void SMESHDS_Command::AddPolygonalFace (const int ElementID,
}
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]);
@ -299,8 +299,8 @@ void SMESHDS_Command::AddPolygonalFace (const int ElementID,
//function : AddQuadPolygonalFace
//purpose :
//=======================================================================
void SMESHDS_Command::AddQuadPolygonalFace (const int ElementID,
const std::vector<int>& nodes_ids)
void SMESHDS_Command::AddQuadPolygonalFace (const smIdType ElementID,
const std::vector<smIdType>& nodes_ids)
{
if ( myType != SMESHDS_AddQuadPolygon) {
MESSAGE("SMESHDS_Command::AddQuadraticPolygonalFace : Bad Type");
@ -308,7 +308,7 @@ void SMESHDS_Command::AddQuadPolygonalFace (const int ElementID,
}
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]);
@ -321,9 +321,9 @@ void SMESHDS_Command::AddQuadPolygonalFace (const int ElementID,
//function : AddPolyhedralVolume
//purpose :
//=======================================================================
void SMESHDS_Command::AddPolyhedralVolume (const int ElementID,
const std::vector<int>& nodes_ids,
const std::vector<int>& quantities)
void SMESHDS_Command::AddPolyhedralVolume (const smIdType ElementID,
const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities)
{
if ( myType != SMESHDS_AddPolyhedron) {
MESSAGE("SMESHDS_Command::AddPolyhedralVolume : Bad Type");
@ -331,13 +331,13 @@ void SMESHDS_Command::AddPolyhedralVolume (const int ElementID,
}
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]);
@ -350,7 +350,7 @@ void SMESHDS_Command::AddPolyhedralVolume (const int ElementID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Command::RemoveNode(int NodeID)
void SMESHDS_Command::RemoveNode(smIdType NodeID)
{
if ( myType != SMESHDS_RemoveNode)
{
@ -365,7 +365,7 @@ void SMESHDS_Command::RemoveNode(int NodeID)
//function :
//purpose :
//=======================================================================
void SMESHDS_Command::RemoveElement(int ElementID)
void SMESHDS_Command::RemoveElement(smIdType ElementID)
{
if ( myType != SMESHDS_RemoveElement)
{
@ -381,7 +381,7 @@ void SMESHDS_Command::RemoveElement(int ElementID)
//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)
{
@ -390,7 +390,7 @@ void SMESHDS_Command::ChangeElementNodes(int ElementID, int nodes[], int nbnodes
}
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++;
@ -400,8 +400,8 @@ void SMESHDS_Command::ChangeElementNodes(int ElementID, int nodes[], int nbnodes
//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)
@ -411,7 +411,7 @@ void SMESHDS_Command::ChangePolyhedronNodes (const int ElementID,
}
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]);
@ -431,7 +431,7 @@ void SMESHDS_Command::ChangePolyhedronNodes (const int ElementID,
//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)
{
@ -457,7 +457,7 @@ SMESHDS_CommandType SMESHDS_Command::GetType()
//function :
//purpose :
//=======================================================================
int SMESHDS_Command::GetNumber()
smIdType SMESHDS_Command::GetNumber()
{
return myNumber;
}
@ -466,7 +466,7 @@ int SMESHDS_Command::GetNumber()
//function :
//purpose :
//=======================================================================
const list < int >&SMESHDS_Command::GetIndexes()
const list < smIdType >&SMESHDS_Command::GetIndexes()
{
return myIntegers;
}
@ -489,7 +489,7 @@ const list < double >&SMESHDS_Command::GetCoords()
//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");
@ -506,9 +506,9 @@ void SMESHDS_Command::AddEdge(int NewEdgeID, int n1, int n2, int n12)
//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");
@ -528,9 +528,9 @@ void SMESHDS_Command::AddFace(int NewFaceID,
//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");
@ -551,9 +551,9 @@ void SMESHDS_Command::AddFace(int NewFaceID,
//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");
@ -575,9 +575,9 @@ void SMESHDS_Command::AddFace(int NewFaceID,
//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");
@ -600,9 +600,9 @@ void SMESHDS_Command::AddFace(int NewFaceID,
//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");
@ -626,10 +626,10 @@ void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
//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");
@ -656,11 +656,11 @@ void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
//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");
@ -688,12 +688,12 @@ void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
//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");
@ -726,11 +726,11 @@ void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2,
//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");
@ -764,13 +764,13 @@ void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
//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");
@ -813,7 +813,7 @@ void SMESHDS_Command::AddVolume(int NewVolID, int n1, int n2, int n3,
*/
//================================================================================
void SMESHDS_Command::AddBall(int NewBallID, int node, double diameter)
void SMESHDS_Command::AddBall(smIdType NewBallID, smIdType node, double diameter)
{
if ( myType != SMESHDS_AddBall)
{

145
src/SMESHDS/SMESHDS_Command.hxx
View File

@ -30,6 +30,7 @@
#include "SMESH_SMESHDS.hxx"
#include "SMESHDS_CommandType.hxx"
#include <smIdType.hxx>
#include <list>
#include <vector>
@ -38,87 +39,87 @@ class SMESHDS_EXPORT SMESHDS_Command
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 AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4);
void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5);
void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5, int idnode6);
void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5, int idnode6, int idnode7, int idnode8);
void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5, int idnode6, int idnode7, int idnode8,
int idnode9, int idnode10, int idnode11, int idnode12);
void AddPolygonalFace (const int ElementID,
const std::vector<int>& nodes_ids);
void AddQuadPolygonalFace (const int ElementID,
const std::vector<int>& nodes_ids);
void AddPolyhedralVolume (const int ElementID,
const std::vector<int>& nodes_ids,
const std::vector<int>& quantities);
void AddBall(int NewBallID, int node, double diameter);
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,
smIdType idnode4, smIdType idnode5);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4, smIdType idnode5, smIdType idnode6);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8,
smIdType idnode9, smIdType idnode10, smIdType idnode11, smIdType idnode12);
void AddPolygonalFace (const smIdType ElementID,
const std::vector<smIdType>& nodes_ids);
void AddQuadPolygonalFace (const smIdType ElementID,
const std::vector<smIdType>& nodes_ids);
void AddPolyhedralVolume (const smIdType ElementID,
const std::vector<smIdType>& nodes_ids,
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

8
src/SMESHDS/SMESHDS_Group.cxx
View File

@ -45,7 +45,7 @@ SMESHDS_Group::SMESHDS_Group (const int theID,
//purpose :
//=======================================================================
int SMESHDS_Group::Extent() const
smIdType SMESHDS_Group::Extent() const
{
return myGroup.Extent();
}
@ -66,7 +66,7 @@ bool SMESHDS_Group::IsEmpty()
*/
//=============================================================================
bool SMESHDS_Group::Contains (const int theID)
bool SMESHDS_Group::Contains (const smIdType theID)
{
const SMDS_MeshElement* aElem = findInMesh (theID);
if (aElem)
@ -92,7 +92,7 @@ bool SMESHDS_Group::Contains (const SMDS_MeshElement* elem)
*/
//=============================================================================
bool SMESHDS_Group::Add (const int theID)
bool SMESHDS_Group::Add (const smIdType theID)
{
return Add( findInMesh( theID ));
}
@ -121,7 +121,7 @@ bool SMESHDS_Group::Add (const SMDS_MeshElement* aElem )
*/
//=============================================================================
bool SMESHDS_Group::Remove (const int theID)
bool SMESHDS_Group::Remove (const smIdType theID)
{
bool removed = false;
if ( const SMDS_MeshElement* aElem = findInMesh( theID ))

8
src/SMESHDS/SMESHDS_Group.hxx
View File

@ -46,11 +46,11 @@ class SMESHDS_EXPORT SMESHDS_Group : public SMESHDS_GroupBase
virtual void SetType(SMDSAbs_ElementType theType);
virtual int Extent() const;
virtual smIdType Extent() const;
virtual bool IsEmpty();
virtual bool Contains (const int theID);
virtual bool Contains (const smIdType theID);
virtual bool Contains (const SMDS_MeshElement* elem);
@ -58,11 +58,11 @@ class SMESHDS_EXPORT SMESHDS_Group : public SMESHDS_GroupBase
virtual int GetTic() const;
bool Add (const int theID);
bool Add (const smIdType theID);
bool Add (const SMDS_MeshElement* theElem );
bool Remove (const int theID);
bool Remove (const smIdType theID);
void Clear();

10
src/SMESHDS/SMESHDS_GroupBase.cxx
View File

@ -55,7 +55,7 @@ SMESHDS_GroupBase::SMESHDS_GroupBase (const int theID,
*/
//=============================================================================
int SMESHDS_GroupBase::GetID (const int theIndex)
smIdType SMESHDS_GroupBase::GetID (const int theIndex)
{
if (myCurIndex < 1 || myCurIndex > theIndex) {
myIterator = GetElements();
@ -75,7 +75,7 @@ int SMESHDS_GroupBase::GetID (const int theIndex)
*/
//=============================================================================
const SMDS_MeshElement* SMESHDS_GroupBase::findInMesh (const int theID) const
const SMDS_MeshElement* SMESHDS_GroupBase::findInMesh (const smIdType theID) const
{
SMDSAbs_ElementType aType = GetType();
const SMDS_MeshElement* aElem = NULL;
@ -107,10 +107,10 @@ void SMESHDS_GroupBase::resetIterator()
//purpose :
//=======================================================================
int SMESHDS_GroupBase::Extent() const
smIdType SMESHDS_GroupBase::Extent() const
{
SMDS_ElemIteratorPtr it = GetElements();
int nb = 0;
smIdType nb = 0;
if ( it )
for ( ; it->more(); it->next() )
nb++;
@ -136,7 +136,7 @@ bool SMESHDS_GroupBase::IsEmpty()
//purpose :
//=======================================================================
bool SMESHDS_GroupBase::Contains (const int theID)
bool SMESHDS_GroupBase::Contains (const smIdType theID)
{
if ( SMDS_ElemIteratorPtr it = GetElements() ) {
while ( it->more() )

12
src/SMESHDS/SMESHDS_GroupBase.hxx
View File

@ -58,17 +58,17 @@ class SMESHDS_EXPORT SMESHDS_GroupBase
const char* GetStoreName () const { return myStoreName.c_str(); }
virtual int Extent() const;
virtual smIdType Extent() const;
virtual bool IsEmpty();
virtual bool Contains (const int theID);
virtual bool Contains (const smIdType theID);
virtual bool Contains (const SMDS_MeshElement* elem);
virtual SMDS_ElemIteratorPtr GetElements() const = 0;
virtual int GetID (const int theIndex);
virtual smIdType GetID (const int theIndex);
// DON'T use it for iterations 1..Extent()
virtual int GetTic() const = 0;
@ -89,7 +89,7 @@ class SMESHDS_EXPORT SMESHDS_GroupBase
{ myDefaultColor = theColor;}
protected:
const SMDS_MeshElement* findInMesh (const int theID) const;
const SMDS_MeshElement* findInMesh (const smIdType theID) const;
void resetIterator();
private:
@ -105,8 +105,8 @@ class SMESHDS_EXPORT SMESHDS_GroupBase
Quantity_Color myColor;
// for GetID()
int myCurIndex;
int myCurID;
smIdType myCurIndex;
smIdType myCurID;
SMDS_ElemIteratorPtr myIterator;
static Quantity_Color myDefaultColor;

16
src/SMESHDS/SMESHDS_GroupOnFilter.cxx
View File

@ -79,7 +79,7 @@ void SMESHDS_GroupOnFilter::SetPredicate( const SMESH_PredicatePtr& thePredicate
*/
//================================================================================
int SMESHDS_GroupOnFilter::Extent() const
smIdType SMESHDS_GroupOnFilter::Extent() const
{
update();
return std::accumulate( myMeshInfo.begin(), myMeshInfo.end(), 0 );
@ -120,7 +120,7 @@ bool SMESHDS_GroupOnFilter::IsEmpty()
*/
//================================================================================
bool SMESHDS_GroupOnFilter::Contains (const int theID)
bool SMESHDS_GroupOnFilter::Contains (const smIdType theID)
{
return myPredicate && myPredicate->IsSatisfy( theID );
}
@ -288,7 +288,7 @@ SMDS_ElemIteratorPtr SMESHDS_GroupOnFilter::GetElements() const
*/
//================================================================================
std::vector< int > SMESHDS_GroupOnFilter::GetMeshInfo() const
std::vector< smIdType > SMESHDS_GroupOnFilter::GetMeshInfo() const
{
update();
return myMeshInfo;
@ -315,7 +315,7 @@ int SMESHDS_GroupOnFilter::getElementIds( void* ids, size_t idSize ) const
if ( IsUpToDate() )
{
for ( ; elIt->more(); curID += idSize )
(*(int*) curID) = elIt->next()->GetID();
(*(smIdType*) curID) = elIt->next()->GetID();
}
else
{
@ -325,11 +325,11 @@ int SMESHDS_GroupOnFilter::getElementIds( void* ids, size_t idSize ) const
me->myMeshInfo.assign( SMDSEntity_Last, 0 );
me->myMeshInfo[ firstOkElem->GetEntityType() ]++;
(*(int*) curID) = firstOkElem->GetID();
(*(smIdType*) curID) = firstOkElem->GetID();
for ( curID += idSize; elIt->more(); curID += idSize )
{
const SMDS_MeshElement* e = elIt->next();
(*(int*) curID) = e->GetID();
(*(smIdType*) curID) = e->GetID();
me->myMeshInfo[ e->GetEntityType() ]++;
}
}
@ -443,7 +443,7 @@ bool SMESHDS_GroupOnFilter::updateParallel() const
return false; // no sense in parallel work
SMDS_ElemIteratorPtr elemIt = GetMesh()->elementsIterator( GetType() );
const int minID = elemIt->next()->GetID();
const smIdType minID = elemIt->next()->GetID();
myPredicate->IsSatisfy( minID ); // make myPredicate fully initialized for clone()
SMESH_PredicatePtr clone( myPredicate->clone() );
if ( !clone )
@ -452,7 +452,7 @@ bool SMESHDS_GroupOnFilter::updateParallel() const
TLocalPredicat threadPredicates;
threadPredicates.local() = clone;
int maxID = ( GetType() == SMDSAbs_Node ) ? GetMesh()->MaxNodeID() : GetMesh()->MaxElementID();
smIdType maxID = ( GetType() == SMDSAbs_Node ) ? GetMesh()->MaxNodeID() : GetMesh()->MaxElementID();
vector< char > isElemOK( 1 + maxID );
tbb::parallel_for ( tbb::blocked_range<size_t>( 0, isElemOK.size() ),

10
src/SMESHDS/SMESHDS_GroupOnFilter.hxx
View File

@ -47,20 +47,20 @@ class SMESHDS_EXPORT SMESHDS_GroupOnFilter: public SMESHDS_GroupBase, SMDS_Eleme
SMESH_PredicatePtr GetPredicate() const { return myPredicate; }
std::vector< int > GetMeshInfo() const;
std::vector< smIdType > GetMeshInfo() const;
template< typename IDTYPE >
int GetElementIds( IDTYPE* ids ) const
smIdType GetElementIds( IDTYPE* ids ) const
{
return getElementIds( (void*)ids, sizeof(IDTYPE));
}
virtual int Extent() const;
virtual smIdType Extent() const;
virtual bool IsEmpty();
virtual bool Contains (const int theID);
virtual bool Contains (const smIdType theID);
virtual bool Contains (const SMDS_MeshElement* elem);
@ -92,7 +92,7 @@ class SMESHDS_EXPORT SMESHDS_GroupOnFilter: public SMESHDS_GroupBase, SMDS_Eleme
// 2) The case of enough free memory. Remember all OK elements (myElements).
SMESH_PredicatePtr myPredicate;
std::vector< int > myMeshInfo;
std::vector< smIdType > myMeshInfo;
std::vector< const SMDS_MeshElement*> myElements;
bool myElementsOK;
size_t myMeshModifTime; // when myMeshInfo was updated

2
src/SMESHDS/SMESHDS_GroupOnGeom.cxx
View File

@ -132,7 +132,7 @@ SMDS_ElemIteratorPtr SMESHDS_GroupOnGeom::GetElements() const
//purpose :
//=======================================================================
bool SMESHDS_GroupOnGeom::Contains (const int theID)
bool SMESHDS_GroupOnGeom::Contains (const smIdType theID)
{
return mySubMesh->Contains( findInMesh( theID ));
}

2
src/SMESHDS/SMESHDS_GroupOnGeom.hxx
View File

@ -47,7 +47,7 @@ class SMESHDS_EXPORT SMESHDS_GroupOnGeom: public SMESHDS_GroupBase
TopoDS_Shape GetShape() const { return myShape; }
virtual bool Contains (const int theID);
virtual bool Contains (const smIdType theID);
virtual bool Contains (const SMDS_MeshElement* elem);

208
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -194,7 +194,7 @@ SMDS_MeshNode* SMESHDS_Mesh::AddNode(double x, double y, double z){
return node;
}
SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, int ID){
SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, smIdType ID){
SMDS_MeshNode* node = SMDS_Mesh::AddNodeWithID(x,y,z,ID);
if(node!=NULL) myScript->AddNode(node->GetID(), x, y, z);
return node;
@ -223,8 +223,8 @@ bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
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);
@ -258,8 +258,8 @@ bool SMESHDS_Mesh
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();
}
@ -273,7 +273,7 @@ bool SMESHDS_Mesh
//purpose :
//=======================================================================
void SMESHDS_Mesh::Renumber (const bool /*isNodes*/, const int /*startID*/, const int /*deltaID*/)
void SMESHDS_Mesh::Renumber (const bool /*isNodes*/, const smIdType /*startID*/, const smIdType /*deltaID*/)
{
// TODO not possible yet to have node numbers not starting to O and continuous.
if ( !this->IsCompacted() )
@ -286,7 +286,7 @@ void SMESHDS_Mesh::Renumber (const bool /*isNodes*/, const int /*startID*/, cons
//function : Add0DElement
//purpose :
//=======================================================================
SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID)
SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(smIdType nodeID, smIdType ID)
{
SMDS_Mesh0DElement* anElem = SMDS_Mesh::Add0DElementWithID(nodeID, ID);
if (anElem) myScript->Add0DElement(ID, nodeID);
@ -294,7 +294,7 @@ SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID)
}
SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID
(const SMDS_MeshNode * node, int ID)
(const SMDS_MeshNode * node, smIdType ID)
{
return Add0DElementWithID(node->GetID(), ID);
}
@ -311,7 +311,7 @@ SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElement(const SMDS_MeshNode * node)
//purpose :
//=======================================================================
SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID)
SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(smIdType node, double diameter, smIdType ID)
{
SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
if (anElem) myScript->AddBall(anElem->GetID(), node, diameter);
@ -320,7 +320,7 @@ SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID)
SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(const SMDS_MeshNode * node,
double diameter,
int ID)
smIdType ID)
{
SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
if (anElem) myScript->AddBall(anElem->GetID(), node->GetID(), diameter);
@ -340,7 +340,7 @@ SMDS_BallElement* SMESHDS_Mesh::AddBall (const SMDS_MeshNode * node,
//purpose :
//=======================================================================
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID)
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID)
{
SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,ID);
if(anElem) myScript->AddEdge(ID,n1,n2);
@ -349,7 +349,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID)
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
int ID)
smIdType ID)
{
return AddEdgeWithID(n1->GetID(),
n2->GetID(),
@ -370,7 +370,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode * n1,
//function :AddFace
//purpose :
//=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3);
@ -380,7 +380,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
int ID)
smIdType ID)
{
return AddFaceWithID(n1->GetID(),
n2->GetID(),
@ -404,7 +404,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace( const SMDS_MeshNode * n1,
//function :AddFace
//purpose :
//=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, n4, ID);
if(anElem) myScript->AddFace(ID, n1, n2, n3, n4);
@ -415,7 +415,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID)
smIdType ID)
{
return AddFaceWithID(n1->GetID(),
n2->GetID(),
@ -442,7 +442,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function :AddVolume
//purpose :
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4);
@ -453,7 +453,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(),
n2->GetID(),
@ -480,7 +480,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function :AddVolume
//purpose :
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5);
@ -492,7 +492,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(),
n2->GetID(),
@ -522,7 +522,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function :AddVolume
//purpose :
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType ID)
{
SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6);
@ -535,7 +535,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(),
n2->GetID(),
@ -568,7 +568,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function :AddVolume
//purpose :
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID)
{
SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8);
@ -583,7 +583,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(),
n2->GetID(),
@ -623,10 +623,10 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function :AddVolume
//purpose : add hexagonal prism
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
int n5, int n6, int n7, int n8,
int n9, int n10, int n11, int n12,
int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8,
smIdType n9, smIdType n10, smIdType n11, smIdType n12,
smIdType ID)
{
SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12);
@ -645,7 +645,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n10,
const SMDS_MeshNode * n11,
const SMDS_MeshNode * n12,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(),
n2->GetID(),
@ -697,8 +697,8 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddPolygonalFace
//purpose :
//=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
const int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
const smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes_ids, ID);
if (anElem) {
@ -709,12 +709,12 @@ SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nod
SMDS_MeshFace*
SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
const int ID)
const smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
if (anElem) {
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();
}
@ -728,8 +728,8 @@ SMESHDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFace(nodes);
if (anElem) {
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();
}
@ -743,8 +743,8 @@ SMESHDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
//function : AddQuadPolygonalFace
//purpose :
//=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int>& nodes_ids,
const int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
const smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes_ids, ID);
if (anElem) {
@ -755,12 +755,12 @@ SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int>&
SMDS_MeshFace*
SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
const int ID)
const smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID);
if (anElem) {
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();
}
@ -774,8 +774,8 @@ SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nod
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFace(nodes);
if (anElem) {
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();
}
@ -789,9 +789,9 @@ SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nod
//function : AddPolyhedralVolume
//purpose :
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>& nodes_ids,
const std::vector<int>& quantities,
const int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities,
const smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID);
if (anElem) {
@ -803,12 +803,12 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
(const std::vector<const SMDS_MeshNode*>& nodes,
const std::vector<int>& quantities,
const int ID)
const smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
if (anElem) {
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();
}
@ -823,8 +823,8 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolume(nodes, quantities);
if (anElem) {
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();
}
@ -1489,7 +1489,7 @@ SMESHDS_Mesh::~SMESHDS_Mesh()
//function : AddEdgeWithID
//purpose :
//=======================================================================
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID)
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID)
{
SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,n12,ID);
if(anElem) myScript->AddEdge(ID,n1,n2,n12);
@ -1519,7 +1519,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12,
int ID)
smIdType ID)
{
return AddEdgeWithID(n1->GetID(),
n2->GetID(),
@ -1550,8 +1550,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID
//purpose :
//=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n12,smIdType n23,smIdType n31, smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31);
@ -1568,7 +1568,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
int ID)
smIdType ID)
{
return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n12->GetID(), n23->GetID(), n31->GetID(),
@ -1599,8 +1599,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID
//purpose :
//=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int nCenter, int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31,nCenter);
@ -1618,7 +1618,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * nCenter,
int ID)
smIdType ID)
{
return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n12->GetID(), n23->GetID(), n31->GetID(),
@ -1650,8 +1650,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID
//purpose :
//=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41, int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41);
@ -1670,7 +1670,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
int ID)
smIdType ID)
{
return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
@ -1704,9 +1704,9 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID
//purpose :
//=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41,
int nCenter, int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType nCenter, smIdType ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
@ -1726,7 +1726,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * nCenter,
int ID)
smIdType ID)
{
return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
@ -1761,9 +1761,9 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose :
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n31,
int n14,int n24,int n34, int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n31,
smIdType n14,smIdType n24,smIdType n34, smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n12,n23,
n31,n14,n24,n34,ID);
@ -1785,7 +1785,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n12->GetID(), n23->GetID(), n31->GetID(),
@ -1825,9 +1825,9 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose :
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(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, int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n15,smIdType n25,smIdType n35,smIdType n45, smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,
n12,n23,n34,n41,
@ -1854,7 +1854,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n4->GetID(), n5->GetID(),
@ -1899,11 +1899,11 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose : 2nd order pentahedron (prism) with 15 nodes
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(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 ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n4, smIdType n5, smIdType n6,
smIdType n12,smIdType n23,smIdType n31,
smIdType n45,smIdType n56,smIdType n64,
smIdType n14,smIdType n25,smIdType n36, smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
n12,n23,n31,
@ -1933,7 +1933,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n4->GetID(), n5->GetID(), n6->GetID(),
@ -1982,13 +1982,13 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose : 2nd order pentahedron (prism) with 18 nodes
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(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,
int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n4, smIdType n5, smIdType n6,
smIdType n12,smIdType n23,smIdType n31,
smIdType n45,smIdType n56,smIdType n64,
smIdType n14,smIdType n25,smIdType n36,
smIdType n1245, smIdType n2356, smIdType n1346,
smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
n12,n23,n31,
@ -2022,7 +2022,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n4->GetID(), n5->GetID(), n6->GetID(),
@ -2076,11 +2076,11 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID
//purpose :
//=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(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 ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n56,smIdType n67,smIdType n78,smIdType n85,
smIdType n15,smIdType n26,smIdType n37,smIdType n48, smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
n12,n23,n34,n41,
@ -2115,7 +2115,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
@ -2175,14 +2175,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
return anElem;
}
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(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,
int ID)
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n56,smIdType n67,smIdType n78,smIdType n85,
smIdType n15,smIdType n26,smIdType n37,smIdType n48,
smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
smIdType n1458,smIdType n5678,smIdType nCenter,
smIdType ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
n12,n23,n34,n41,
@ -2225,7 +2225,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n1458,
const SMDS_MeshNode * n5678,
const SMDS_MeshNode * nCenter,
int ID)
smIdType ID)
{
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
@ -2262,7 +2262,7 @@ void SMESHDS_Mesh::BuildDownWardConnectivity(bool withEdges)
* @param localClonedNodeIds map old node id to new node id.
* @return ok if success.
*/
bool SMESHDS_Mesh::ModifyCellNodes(int vtkVolId, std::map<int,int> localClonedNodeIds)
bool SMESHDS_Mesh::ModifyCellNodes(vtkIdType vtkVolId, std::map<int,int> localClonedNodeIds)
{
myGrid->ModifyCellNodes(vtkVolId, localClonedNodeIds);
return true;

178
src/SMESHDS/SMESHDS_Mesh.hxx
View File

@ -77,64 +77,64 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
bool AddHypothesis(const TopoDS_Shape & SS, const SMESHDS_Hypothesis * H);
bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H);
virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, smIdType ID);
virtual SMDS_MeshNode* AddNode(double x, double y, double z);
virtual SMDS_Mesh0DElement* Add0DElementWithID(int nodeID, int ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, int ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(smIdType nodeID, smIdType ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, smIdType ID);
virtual SMDS_Mesh0DElement* Add0DElement (const SMDS_MeshNode * node);
virtual SMDS_BallElement* AddBallWithID(int n, double diameter, int ID);
virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID);
virtual SMDS_BallElement* AddBallWithID(smIdType n, double diameter, smIdType ID);
virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID);
virtual SMDS_BallElement* AddBall (const SMDS_MeshNode * n, double diameter);
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
int ID);
smIdType ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2);
// 2d order edge with 3 nodes: n12 - node between n1 and n2
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12,
int ID);
smIdType ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12);
// tria 3
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3);
// quad 4
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
// 2d order triangle of 6 nodes
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n12,smIdType n23,smIdType n31, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -143,8 +143,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n31);
// biquadratic triangle of 7 nodes
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
int n12,int n23,int n31, int nCenter, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -152,7 +152,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31,
const SMDS_MeshNode * nCenter,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -162,8 +162,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * nCenter);
// 2d order quadrangle
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -172,7 +172,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -183,8 +183,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n41);
// biquadratic quadrangle of 9 nodes
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n34,int n41, int nCenter, int ID);
virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType nCenter, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -194,7 +194,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * nCenter,
int ID);
smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -205,38 +205,38 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n41,
const SMDS_MeshNode * nCenter);
// tetra 4
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4);
// pyra 5
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5);
// penta 6
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -244,7 +244,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6);
// hexa 8
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -253,7 +253,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -263,8 +263,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8);
// hexagonal prism of 12 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6,
int n7, int n8, int n9, int n10, int n11, int n12, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6,
smIdType n7, smIdType n8, smIdType n9, smIdType n10, smIdType n11, smIdType n12, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -277,7 +277,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n10,
const SMDS_MeshNode * n11,
const SMDS_MeshNode * n12,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -292,9 +292,9 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n12);
// 2d order tetrahedron of 10 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
int n12,int n23,int n31,
int n14,int n24,int n34, int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n12,smIdType n23,smIdType n31,
smIdType n14,smIdType n24,smIdType n34, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -305,7 +305,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -318,10 +318,10 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n34);
// 2d order pyramid of 13 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n15,smIdType n25,smIdType n35,smIdType n45,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -335,7 +335,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -351,12 +351,12 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n45);
// 2d order Pentahedron with 15 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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 ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n4, smIdType n5, smIdType n6,
smIdType n12,smIdType n23,smIdType n31,
smIdType n45,smIdType n56,smIdType n64,
smIdType n14,smIdType n25,smIdType n36,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -372,7 +372,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -390,13 +390,13 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n36);
// 2d order Pentahedron with 18 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
smIdType n4, smIdType n5, smIdType n6,
smIdType n12,smIdType n23,smIdType n31,
smIdType n45,smIdType n56,smIdType n64,
smIdType n14,smIdType n25,smIdType n36,
smIdType n1245, smIdType n2356, smIdType n1346,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -415,7 +415,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -436,12 +436,12 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n1346);
// 2d order Hexahedrons with 20 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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 ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n56,smIdType n67,smIdType n78,smIdType n85,
smIdType n15,smIdType n26,smIdType n37,smIdType n48,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -462,7 +462,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -485,14 +485,14 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n48);
// 2d order Hexahedrons with 27 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(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,
int ID);
virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
smIdType n5, smIdType n6, smIdType n7, smIdType n8,
smIdType n12,smIdType n23,smIdType n34,smIdType n41,
smIdType n56,smIdType n67,smIdType n78,smIdType n85,
smIdType n15,smIdType n26,smIdType n37,smIdType n48,
smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
smIdType n1458,smIdType n5678,smIdType nCenter,
smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -520,7 +520,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n1458,
const SMDS_MeshNode * n5678,
const SMDS_MeshNode * nCenter,
int ID);
smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
@ -549,31 +549,31 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n5678,
const SMDS_MeshNode * nCenter);
virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
const int ID);
virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
const smIdType ID);
virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
const int ID);
const smIdType ID);
virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes);
virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<int> & nodes_ids,
const int ID);
virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<smIdType> & nodes_ids,
const smIdType ID);
virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes,
const int ID);
const smIdType ID);
virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes);
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<int>& nodes_ids,
const std::vector<int>& quantities,
const int ID);
(const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities,
const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<const SMDS_MeshNode*>& nodes,
const std::vector<int>& quantities,
const int ID);
const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolume
(const std::vector<const SMDS_MeshNode*>& nodes,
@ -600,8 +600,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
bool ChangePolyhedronNodes(const SMDS_MeshElement * elem,
const std::vector<const SMDS_MeshNode*>& nodes,
const std::vector<int>& quantities);
bool ModifyCellNodes(int smdsVolId, std::map<int,int> localClonedNodeIds);
void Renumber (const bool isNodes, const int startID=1, const int deltaID=1);
bool ModifyCellNodes(vtkIdType smdsVolId, std::map<int,int> localClonedNodeIds);
void Renumber (const bool isNodes, const smIdType startID=1, const smIdType deltaID=1);
void SetNodeInVolume(const SMDS_MeshNode * aNode, const TopoDS_Shell & S);
void SetNodeInVolume(const SMDS_MeshNode * aNode, const TopoDS_Solid & S);
@ -641,7 +641,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
// Groups. SMESHDS_Mesh is not an owner of groups
void AddGroup (SMESHDS_GroupBase* theGroup) { myGroups.insert(theGroup); }
void RemoveGroup (SMESHDS_GroupBase* theGroup) { myGroups.erase(theGroup); }
int GetNbGroups() const { return myGroups.size(); }
size_t GetNbGroups() const { return myGroups.size(); }
const std::set<SMESHDS_GroupBase*>& GetGroups() const { return myGroups; }
bool IsGroupOfSubShapes (const TopoDS_Shape& aSubShape) const;

144
src/SMESHDS/SMESHDS_Script.cxx
View File

@ -89,7 +89,7 @@ SMESHDS_Command* SMESHDS_Script::getCommand(const SMESHDS_CommandType aType)
//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;
@ -102,7 +102,7 @@ void SMESHDS_Script::AddNode(int NewNodeID, double x, double y, double z)
//function :
//purpose :
//=======================================================================
void SMESHDS_Script::Add0DElement (int New0DElementID, int idnode)
void SMESHDS_Script::Add0DElement (smIdType New0DElementID, smIdType idnode)
{
if (myIsEmbeddedMode) {
myIsModified = true;
@ -115,7 +115,7 @@ void SMESHDS_Script::Add0DElement (int New0DElementID, int idnode)
//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;
@ -128,8 +128,8 @@ void SMESHDS_Script::AddEdge(int NewEdgeID, int idnode1, int idnode2)
//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;
@ -143,9 +143,9 @@ void SMESHDS_Script::AddFace(int NewFaceID,
//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;
@ -160,9 +160,9 @@ void SMESHDS_Script::AddFace(int NewFaceID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Script::AddVolume(int NewID,
int idnode1, int idnode2,
int idnode3, int idnode4)
void SMESHDS_Script::AddVolume(smIdType NewID,
smIdType idnode1, smIdType idnode2,
smIdType idnode3, smIdType idnode4)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -177,9 +177,9 @@ void SMESHDS_Script::AddVolume(int NewID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Script::AddVolume(int NewID,
int idnode1, int idnode2,
int idnode3, int idnode4, int idnode5)
void SMESHDS_Script::AddVolume(smIdType NewID,
smIdType idnode1, smIdType idnode2,
smIdType idnode3, smIdType idnode4, smIdType idnode5)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -194,9 +194,9 @@ void SMESHDS_Script::AddVolume(int NewID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Script::AddVolume(int NewID,
int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5, int idnode6)
void SMESHDS_Script::AddVolume(smIdType NewID,
smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4, smIdType idnode5, smIdType idnode6)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -211,9 +211,9 @@ void SMESHDS_Script::AddVolume(int NewID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Script::AddVolume(int NewID,
int idnode1, int idnode2, int idnode3, int idnode4,
int idnode5, int idnode6, int idnode7, int idnode8)
void SMESHDS_Script::AddVolume(smIdType NewID,
smIdType idnode1, smIdType idnode2, smIdType idnode3, smIdType idnode4,
smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -228,9 +228,9 @@ void SMESHDS_Script::AddVolume(int NewID,
//function :
//purpose :
//=======================================================================
void SMESHDS_Script::AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5, int idnode6, int idnode7, int idnode8,
int idnode9, int idnode10, int idnode11, int idnode12)
void SMESHDS_Script::AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8,
smIdType idnode9, smIdType idnode10, smIdType idnode11, smIdType idnode12)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -246,7 +246,7 @@ void SMESHDS_Script::AddVolume(int NewVolID, int idnode1, int idnode2, int idnod
//function : AddPolygonalFace
//purpose :
//=======================================================================
void SMESHDS_Script::AddPolygonalFace (int NewFaceID, const std::vector<int>& nodes_ids)
void SMESHDS_Script::AddPolygonalFace (smIdType NewFaceID, const std::vector<smIdType>& nodes_ids)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -259,7 +259,7 @@ void SMESHDS_Script::AddPolygonalFace (int NewFaceID, const std::vector<int>& no
//function : AddQuadPolygonalFace
//purpose :
//=======================================================================
void SMESHDS_Script::AddQuadPolygonalFace(int NewFaceID, const std::vector<int>& nodes_ids)
void SMESHDS_Script::AddQuadPolygonalFace(smIdType NewFaceID, const std::vector<smIdType>& nodes_ids)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -272,9 +272,9 @@ void SMESHDS_Script::AddQuadPolygonalFace(int NewFaceID, const std::vector<int>&
//function : AddPolyhedralVolume
//purpose :
//=======================================================================
void SMESHDS_Script::AddPolyhedralVolume (int NewID,
const std::vector<int>& nodes_ids,
const std::vector<int>& quantities)
void SMESHDS_Script::AddPolyhedralVolume (smIdType NewID,
const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -289,7 +289,7 @@ void SMESHDS_Script::AddPolyhedralVolume (int NewID,
//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;
@ -301,7 +301,7 @@ void SMESHDS_Script::AddBall(int NewBallID, int node, double diameter)
//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;
@ -314,7 +314,7 @@ void SMESHDS_Script::MoveNode(int NewNodeID, double x, double y, double z)
//function :
//purpose :
//=======================================================================
void SMESHDS_Script::RemoveNode(int ID)
void SMESHDS_Script::RemoveNode(smIdType ID)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -327,7 +327,7 @@ void SMESHDS_Script::RemoveNode(int ID)
//function :
//purpose :
//=======================================================================
void SMESHDS_Script::RemoveElement(int ElementID)
void SMESHDS_Script::RemoveElement(smIdType ElementID)
{
if(myIsEmbeddedMode){
myIsModified = true;
@ -341,7 +341,7 @@ void SMESHDS_Script::RemoveElement(int ElementID)
//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;
@ -354,8 +354,8 @@ void SMESHDS_Script::ChangeElementNodes(int ElementID, int nodes[], int nbnodes)
//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){
@ -370,7 +370,7 @@ void SMESHDS_Script::ChangePolyhedronNodes (const int ElementID,
//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;
@ -424,7 +424,7 @@ const list<SMESHDS_Command*>& SMESHDS_Script::GetCommands()
//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;
@ -437,8 +437,8 @@ void SMESHDS_Script::AddEdge(int NewEdgeID, int n1, int n2, int n12)
//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;
@ -452,8 +452,8 @@ void SMESHDS_Script::AddFace(int NewFaceID, int n1, int n2, int n3,
//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;
@ -467,8 +467,8 @@ void SMESHDS_Script::AddFace(int NewFaceID, int n1, int n2, int n3,
//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;
@ -482,8 +482,8 @@ void SMESHDS_Script::AddFace(int NewFaceID, int n1, int n2, int n3, int n4,
//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;
@ -497,9 +497,9 @@ void SMESHDS_Script::AddFace(int NewFaceID, int n1, int n2, int n3, int n4,
//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;
@ -514,9 +514,9 @@ void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
//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;
@ -531,10 +531,10 @@ void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
//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;
@ -550,11 +550,11 @@ void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
//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;
@ -571,11 +571,11 @@ void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3, int n4,
//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;
@ -592,13 +592,13 @@ void SMESHDS_Script::AddVolume(int NewVolID, int n1, int n2, int n3,
//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;

140
src/SMESHDS/SMESHDS_Script.hxx
View File

@ -31,6 +31,8 @@
#include "SMESHDS_Command.hxx"
#include <smIdType.hxx>
#include <list>
#include <vector>
@ -44,79 +46,79 @@ class SMESHDS_EXPORT SMESHDS_Script
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 AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4);
void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5);
void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5, int idnode6);
void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5, int idnode6, int idnode7, int idnode8);
void AddVolume(int NewVolID, int idnode1, int idnode2, int idnode3,
int idnode4, int idnode5, int idnode6, int idnode7, int idnode8,
int idnode9, int idnode10, int idnode11, int idnode12);
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,
smIdType idnode4, smIdType idnode5);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4, smIdType idnode5, smIdType idnode6);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8);
void AddVolume(smIdType NewVolID, smIdType idnode1, smIdType idnode2, smIdType idnode3,
smIdType idnode4, smIdType idnode5, smIdType idnode6, smIdType idnode7, smIdType idnode8,
smIdType idnode9, smIdType idnode10, smIdType idnode11, smIdType idnode12);
void AddPolygonalFace (const int NewFaceID,
const std::vector<int>& nodes_ids);
void AddQuadPolygonalFace (const int NewFaceID,
const std::vector<int>& nodes_ids);
void AddPolyhedralVolume (const int NewVolID,
const std::vector<int>& nodes_ids,
const std::vector<int>& quantities);
void AddBall(int NewBallID, int node, double diameter);
void AddPolygonalFace (const smIdType NewFaceID,
const std::vector<smIdType>& nodes_ids);
void AddQuadPolygonalFace (const smIdType NewFaceID,
const std::vector<smIdType>& nodes_ids);
void AddPolyhedralVolume (const smIdType NewVolID,
const std::vector<smIdType>& nodes_ids,
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();

8
src/SMESHDS/SMESHDS_SubMesh.cxx
View File

@ -235,12 +235,12 @@ bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N)
//purpose :
//=======================================================================
int SMESHDS_SubMesh::NbElements() const
smIdType SMESHDS_SubMesh::NbElements() const
{
if ( !IsComplexSubmesh() )
return myNbElements;
int nbElems = 0;
smIdType nbElems = 0;
TSubMeshSet::const_iterator it = mySubMeshes.begin();
for ( ; it != mySubMeshes.end(); it++ )
nbElems += (*it)->NbElements();
@ -253,12 +253,12 @@ int SMESHDS_SubMesh::NbElements() const
//purpose :
//=======================================================================
int SMESHDS_SubMesh::NbNodes() const
smIdType SMESHDS_SubMesh::NbNodes() const
{
if ( !IsComplexSubmesh() )
return myNbNodes;
int nbElems = 0;
smIdType nbElems = 0;
TSubMeshSet::const_iterator it = mySubMeshes.begin();
for ( ; it != mySubMeshes.end(); it++ )
nbElems += (*it)->NbNodes();

11
src/SMESHDS/SMESHDS_SubMesh.hxx
View File

@ -31,6 +31,7 @@
#include "SMDS_ElementHolder.hxx"
#include "SMDS_Mesh.hxx"
#include <smIdType.hxx>
#include <vector>
#include <boost/container/flat_set.hpp>
@ -62,12 +63,12 @@ class SMESHDS_EXPORT SMESHDS_SubMesh : public SMDS_ElementHolder
bool RemoveSubMesh( const SMESHDS_SubMesh* theSubMesh );
void RemoveAllSubmeshes();
bool ContainsSubMesh( const SMESHDS_SubMesh* theSubMesh ) const;
int NbSubMeshes() const { return mySubMeshes.size(); }
size_t NbSubMeshes() const { return mySubMeshes.size(); }
SMESHDS_SubMeshIteratorPtr GetSubMeshIterator() const;
// for both types
virtual int NbElements() const;
virtual int NbNodes() const;
virtual smIdType NbElements() const;
virtual smIdType NbNodes() const;
virtual SMDS_ElemIteratorPtr GetElements() const;
virtual SMDS_NodeIteratorPtr GetNodes() const;
virtual bool Contains(const SMDS_MeshElement * ME) const; // check if elem or node is in
@ -89,8 +90,8 @@ class SMESHDS_EXPORT SMESHDS_SubMesh : public SMDS_ElementHolder
private:
int myIndex;
int myNbElements;
int myNbNodes;
smIdType myNbElements;
smIdType myNbNodes;
const SMDS_MeshElement* my1stElemNode[2]; // elem and node with least ID, to optimize iteration
const SMESHDS_Mesh * myParent;
TSubMeshSet mySubMeshes;

66
src/SMESHGUI/SMESHGUI.cxx
View File

@ -608,7 +608,7 @@ namespace
}
if ( ! notSupportedElemTypes.empty() )
{
SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
SMESH::smIdType_array_var nbElems = aMeshOrGroup->GetMeshInfo();
for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
@ -994,11 +994,19 @@ namespace
aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
}
}
catch (const SALOME::SALOME_Exception& S_ex){
catch (const SALOME::SALOME_Exception& S_ex)
{
wc.suspend();
SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
if ( S_ex.details.type == SALOME::COMM && // communicate about too large mesh
strncmp( "format=", S_ex.details.sourceFile.in(), 7 ) == 0 )
SUIT_MessageBox::critical(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr(S_ex.details.text.in() ));
else
SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
wc.resume();
}
}
@ -1218,14 +1226,14 @@ namespace
SMESH::Controls::NumericalFunctor* aNumFun =
dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
if ( aNumFun ) {
std::vector<int> elements;
std::vector<SMESH::smIdType> elements;
SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
if ( mesh->_is_nil() ) {
SMESH::SMESH_IDSource_var idSource =
SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
if ( !idSource->_is_nil() )
{
SMESH::long_array_var ids = idSource->GetIDs();
SMESH::smIdType_array_var ids = idSource->GetIDs();
elements.resize( ids->length() );
for ( unsigned i = 0; i < elements.size(); ++i )
elements[i] = ids[i];
@ -1853,7 +1861,7 @@ namespace
if ( anActor->GetControlMode() != aControl )
anActor->SetControlMode( aControl );
QString functorName = functorToString( anActor->GetFunctor() );
int anEntitiesCount = anActor->GetNumberControlEntities();
smIdType anEntitiesCount = anActor->GetNumberControlEntities();
if (anEntitiesCount >= 0)
functorName = functorName + ": " + QString::number(anEntitiesCount);
anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
@ -2261,7 +2269,7 @@ bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
SMESH::long_array_var info = theMesh->GetMeshInfo();
SMESH::smIdType_array_var info = theMesh->GetMeshInfo();
long nbOdElems = info[SMDSEntity_0D];
long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
@ -3128,10 +3136,10 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
try {
SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
// get submesh elements list by types
SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
SMESH::smIdType_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
SMESH::smIdType_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
SMESH::smIdType_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
SMESH::smIdType_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
// create group for each type o elements
QString aName = IObject->getName();
QStringList anEntryList;
@ -3639,7 +3647,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
try {
SUIT_OverrideCursor wc;
SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
int removed = aMeshEditor->RemoveOrphanNodes();
smIdType removed = aMeshEditor->RemoveOrphanNodes();
SUIT_MessageBox::information(SMESHGUI::desktop(),
tr("SMESH_INFORMATION"),
tr("NB_NODES_REMOVED").arg(removed));
@ -5628,23 +5636,23 @@ void SMESHGUI::createPreferences()
int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
/* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "element_width");
int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "outline_width");
int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
int ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
int ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "element_width");
int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "outline_width");
int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
setPreferenceProperty( size0d, "min", 1 );
setPreferenceProperty( size0d, "max", 10 );
// setPreferenceProperty( ballSize, "min", 1 );
// setPreferenceProperty( ballSize, "max", 10 );
// setPreferenceProperty( ballSize, "min", 1 );
// setPreferenceProperty( ballSize, "max", 10 );
setPreferenceProperty( ballDiameter, "min", 1e-7 );
setPreferenceProperty( ballDiameter, "max", 1e9 );
@ -5822,8 +5830,8 @@ void SMESHGUI::createPreferences()
void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
{
if ( sect=="SMESH" ) {
float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
float aTol = 1.00000009999999;
double sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
double aTol = 1.00000009999999;
std::string aWarning;
SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);

7
src/SMESHGUI/SMESHGUI_Add0DElemsOnAllNodesDlg.cxx
View File

@ -40,6 +40,7 @@
#include <SUIT_MessageBox.h>
#include <SVTK_Selector.h>
#include <SalomeApp_Tools.h>
#include <smIdType.hxx>
// Qt includes
#include <QButtonGroup>
@ -426,7 +427,7 @@ bool SMESHGUI_Add0DElemsOnAllNodesOp::onApply()
SUIT_MessageBox::warning( myDlg, tr( "SMESH_WRN_WARNING" ), tr( "SMESH_BAD_SELECTION" ) );
return false;
}
SMESH::long_array_var idArray = new SMESH::long_array;
SMESH::smIdType_array_var idArray = new SMESH::smIdType_array;
idArray->length( idList.count() );
QStringList::iterator idIt = idList.begin();
for ( int i = 0; idIt != idList.end(); ++idIt, ++i )
@ -438,14 +439,14 @@ bool SMESHGUI_Add0DElemsOnAllNodesOp::onApply()
// Create 0D elements
int prevNb0D = mesh->Nb0DElements();
smIdType prevNb0D = mesh->Nb0DElements();
QString groupName = myDlg->myGroupListCmBox->currentText();
SMESH::SMESH_IDSource_var newObj =
editor->Create0DElementsOnAllNodes( meshObject, groupName.toUtf8().data(),
myDlg->myDuplicateElemsChkBox->isChecked() );
int newNb0D = mesh->Nb0DElements() - prevNb0D;
smIdType newNb0D = mesh->Nb0DElements() - prevNb0D;
SUIT_MessageBox::information( myDlg, tr( "SMESH_INFORMATION" ),
tr( "NB_NEW_0D" ).arg( newNb0D ),
SUIT_MessageBox::Ok, SUIT_MessageBox::Ok);

10
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
View File

@ -553,7 +553,7 @@ void SMESHGUI_AddMeshElementDlg::ClickOnApply()
if (myNbOkNodes && !SMESHGUI::isStudyLocked()) {
myBusy = true;
QStringList aListId = myEditCurrentArgument->text().split(" ", QString::SkipEmptyParts);
SMESH::long_array_var anArrayOfIndices = new SMESH::long_array;
SMESH::smIdType_array_var anArrayOfIndices = new SMESH::smIdType_array;
anArrayOfIndices->length(aListId.count());
const std::vector<int>& revIndex = SMDS_MeshCell::reverseSmdsOrder( myGeomType );
if ( ReverseOrDulicate && ReverseOrDulicate->isChecked() && (int)revIndex.size() == aListId.count() )
@ -598,10 +598,10 @@ void SMESHGUI_AddMeshElementDlg::ClickOnApply()
}
SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();
SMESH::long_array_var anIdList = new SMESH::long_array;
SMESH::smIdType_array_var anIdList = new SMESH::smIdType_array;
anIdList->length( 1 );
anIdList[0] = -1;
int nbElemsBefore = 0;
smIdType nbElemsBefore = 0;
switch (myElementType) {
case SMDSAbs_0DElement: {
@ -611,7 +611,7 @@ void SMESHGUI_AddMeshElementDlg::ClickOnApply()
for ( size_t i = 0; i < anArrayOfIndices->length(); ++i )
anIdList[i] = aMeshEditor->Add0DElement(anArrayOfIndices[i], duplicateElements);
CORBA::ULong nbAdded = myMesh->Nb0DElements() - nbElemsBefore;
SMESH::smIdType nbAdded = myMesh->Nb0DElements() - nbElemsBefore;
if ( !duplicateElements && nbAdded < anArrayOfIndices->length() )
SUIT_MessageBox::information(SMESHGUI::desktop(),
tr("SMESH_INFORMATION"),
@ -784,7 +784,7 @@ void SMESHGUI_AddMeshElementDlg::onTextChange (const QString& theNewText)
aMesh = myActor->GetObject()->GetMesh();
if (aMesh) {
TColStd_MapOfInteger newIndices;
SVTK_TVtkIDsMap newIndices;
QStringList aListId = theNewText.split(" ", QString::SkipEmptyParts);
bool allOk = true;

6
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -741,7 +741,7 @@ bool SMESHGUI_AddQuadraticElementDlg::ClickOnApply()
ReverseConnectivity( anIds, myGeomType, /*toReverse=*/true, /*toVtkOrder=*/false );
int aNumberOfIds = anIds.size();
SMESH::long_array_var anArrayOfIdeces = new SMESH::long_array;
SMESH::smIdType_array_var anArrayOfIdeces = new SMESH::smIdType_array;
anArrayOfIdeces->length( aNumberOfIds );
for (int i = 0; i < aNumberOfIds; i++)
@ -841,7 +841,7 @@ bool SMESHGUI_AddQuadraticElementDlg::ClickOnApply()
}
if ( !aGroupUsed->_is_nil() ) {
SMESH::long_array_var anIdList = new SMESH::long_array;
SMESH::smIdType_array_var anIdList = new SMESH::smIdType_array;
anIdList->length( 1 );
anIdList[0] = anElemId;
aGroupUsed->Add( anIdList.inout() );
@ -989,7 +989,7 @@ void SMESHGUI_AddQuadraticElementDlg::onTextChange (const QString& theNewText)
myCurrentLineEdit = send;
if (aMesh) {
TColStd_MapOfInteger newIndices;
SVTK_TVtkIDsMap newIndices;
QStringList aListId = theNewText.split(" ", QString::SkipEmptyParts);
bool allOk = true;

Some files were not shown because too many files have changed in this diff Show More