*
* Algorithms that !NeedDescretBoundary() || !OnlyUnaryInput() are
* to set SMESH_ComputeError returned by SMESH_submesh::GetComputeError()
- * to report problematic subshapes
+ * to report problematic sub-shapes
*/
virtual bool Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape) = 0;
if ( anUpward ) // is called from below code here
{
// -----------------------------------------------
- // mesh all the subshapes starting from vertices
+ // mesh all the sub-shapes starting from vertices
// -----------------------------------------------
smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
while ( smIt->more() )
}
}
// -----------------------------------------------
- // mesh the rest subshapes starting from vertices
+ // mesh the rest sub-shapes starting from vertices
// -----------------------------------------------
ret = Compute( aMesh, aShape, /*anUpward=*/true, aDim, aShapesId );
}
if ( anUpward ) { // is called from below code here
// -----------------------------------------------
- // mesh all the subshapes starting from vertices
+ // mesh all the sub-shapes starting from vertices
// -----------------------------------------------
smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
while ( smIt->more() ) {
}
// -----------------------------------------------
- // mesh the rest subshapes starting from vertices
+ // mesh the rest sub-shapes starting from vertices
// -----------------------------------------------
ret = Evaluate( aMesh, aShape, aResMap, /*anUpward=*/true, aShapesId );
}
HYP_NOTCONFORM, // not conform mesh is produced appling a hypothesis
HYP_ALREADY_EXIST,// such hypothesis already exist
HYP_BAD_DIM, // bad dimension
- HYP_BAD_SUBSHAPE, // shape is neither the main one, nor its subshape, nor a group
+ HYP_BAD_SUBSHAPE, // shape is neither the main one, nor its sub-shape, nor a group
HYP_BAD_GEOMETRY, // shape geometry mismatches algorithm's expectation
HYP_NEED_SHAPE // algorithm can work on shape only
};
SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
- // subShapes
+ // sub-shapes
if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
anHyp->GetDim() <= SMESH_Gen::GetShapeDim(aSubShape)) // is added on father
{
subMesh->CheckConcurentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK)
ret = SMESH_Hypothesis::HYP_CONCURENT;
- // subShapes
+ // sub-shapes
if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
anHyp->GetDim() <= SMESH_Gen::GetShapeDim(aSubShape)) // is removed from father
{
}
//================================================================================
/*!
- * \brief Return submeshes of groups containing the given subshape
+ * \brief Return submeshes of groups containing the given sub-shape
*/
//================================================================================
list<SMESH_MeshEditor_PathPoint> fullList;
const TopoDS_Shape& aS = theTrack->GetSubShape();
- // Sub shape for the Pattern must be an Edge or Wire
+ // Sub-shape for the Pattern must be an Edge or Wire
if( aS.ShapeType() == TopAbs_EDGE ) {
aTrackEdge = TopoDS::Edge( aS );
// the Edge must not be degenerated
}
fullList.push_back(PP1);
- } // Sub shape for the Pattern must be an Edge or Wire
+ } // Sub-shape for the Pattern must be an Edge or Wire
else if( aS.ShapeType() == TopAbs_EDGE ) {
aTrackEdge = TopoDS::Edge( aS );
// the Edge must not be degenerated
{
SMESHDS_Mesh* meshDS = GetMeshDS();
// we can create quadratic elements only if all elements
- // created on subshapes of given shape are quadratic
+ // created on sub-shapes of given shape are quadratic
// also we have to fill myTLinkNodeMap
myCreateQuadratic = true;
mySeamShapeIds.clear();
//function : GetNodeUVneedInFaceNode
//purpose : Check if inFaceNode argument is necessary for call GetNodeUV(F,..)
// Return true if the face is periodic.
-// If F is Null, answer about subshape set through IsQuadraticSubMesh() or
+// If F is Null, answer about sub-shape set through IsQuadraticSubMesh() or
// * SetSubShape()
//=======================================================================
// coordinates computed by either of Apply...() methods
// WARNING : StdMeshers_Projection_... relies on MakeMesh() behavior: that
// it does not care of nodes and elements already existing on
-// subshapes. DO NOT MERGE them or modify also StdMeshers_Projection_..
+// sub-shapes. DO NOT MERGE them or modify also StdMeshers_Projection_..
//=======================================================================
bool SMESH_Pattern::MakeMesh(SMESH_Mesh* theMesh,
//================================================================================
/*!
- * \brief Allow algo->Compute() if a subshape of lower dim is meshed but
+ * \brief Allow algo->Compute() if a sub-shape of lower dim is meshed but
* none mesh entity is bound to it (PAL13615, 2nd part)
*/
//================================================================================
break;
case REMOVE_ALGO: { // perhaps a father algo applies ?
algo = GetAlgo();
- if (algo == NULL) // no more algo applying on subShape...
+ if (algo == NULL) // no more algo applying on sub-shape...
{
SetAlgoState(NO_ALGO);
}
}
case REMOVE_ALGO: { // perhaps a father algo applies ?
algo = GetAlgo();
- if (algo == NULL) // no more algo applying on subShape...
+ if (algo == NULL) // no more algo applying on sub-shape...
{
SetAlgoState(NO_ALGO);
}
// Show error
SMESH_Comment text;
- text << theAlgo->GetName() << " failed on subshape #" << _Id << " with error ";
+ text << theAlgo->GetName() << " failed on sub-shape #" << _Id << " with error ";
if (_computeError->IsCommon() )
text << _computeError->CommonName();
else
//================================================================================
/*!
- * \brief Find common submeshes (based on shared subshapes with other
+ * \brief Find common submeshes (based on shared sub-shapes with other
* \param theOther submesh to check
* \param theSetOfCommon set of common submesh
*/
//================================================================================
/*!
* \brief return submesh by shape
- * \param shape - the subshape
+ * \param shape - the sub-shape
* \retval SMESHDS_SubMesh* - the found submesh
*
* search of submeshes is optimized
//================================================================================
/*!
- * \brief return submesh by subshape index
- * \param Index - the subshape index
+ * \brief return submesh by sub-shape index
+ * \param Index - the sub-shape index
* \retval SMESHDS_SubMesh* - the found submesh
* search of submeshes is optimized
*/
//=======================================================================
//function : IsGroupOfSubShapes
-//purpose : return true if at least one subshape of theShape is a subshape
+//purpose : return true if at least one sub-shape of theShape is a sub-shape
// of myShape or theShape == myShape
//=======================================================================
}
// -----------------------------------------------------------------------
/*!
- * \brief Return SO of a subshape
+ * \brief Return SO of a sub-shape
*/
_PTR(SObject) getSubShapeSO( int subShapeID, GEOM::GEOM_Object_var aMainShape)
{
}
// -----------------------------------------------------------------------
/*!
- * \brief Return subshape by ID
+ * \brief Return sub-shape by ID
*/
GEOM::GEOM_Object_ptr getSubShape( int subShapeID, GEOM::GEOM_Object_var aMainShape)
{
}
// -----------------------------------------------------------------------
/*!
- * \brief Return text describing a subshape
+ * \brief Return text describing a sub-shape
*/
QString shapeText(int subShapeID, GEOM::GEOM_Object_var aMainShape )
{
//================================================================================
/*!
- * \brief publish selected subshape
+ * \brief publish selected sub-shape
*/
//================================================================================
//================================================================================
/*!
- * \brief check if selected shape is a subshape of the shape to mesh
+ * \brief check if selected shape is a sub-shape of the shape to mesh
* \retval bool - check result
*/
//================================================================================
//================================================================================
/*!
* \brief If create or edit a submesh, return a hypothesis holding parameters used
- * to mesh a subshape
+ * to mesh a sub-shape
* \param aHypType - The hypothesis type name
* \param aServerLib - Server library name
* \param hypData - The structure holding the hypothesis type etc.
}
}
- // deselect geometry: next submesh should be created on other subshape
+ // deselect geometry: next submesh should be created on other sub-shape
myDlg->clearSelection( SMESHGUI_MeshDlg::Geom );
selectObject( _PTR(SObject)() );
selectionDone();
</message>
<message>
<source>COL_SHAPE_HEADER</source>
- <translation>SubShape</translation>
+ <translation>Sub-shape</translation>
</message>
<message>
<source>COMPERR_ALGO_FAILED</source>
</message>
<message>
<source>SMESH_HYP_11</source>
- <translation>Shape is neither the main one, nor its subshape, nor a valid group</translation>
+ <translation>Shape is neither the main one, nor its sub-shape, nor a valid group</translation>
</message>
<message>
<source>SMESH_HYP_12</source>
</message>
<message>
<source>PUBLISH_SHAPE</source>
- <translation>Publish SubShape</translation>
+ <translation>Publish Sub-shape</translation>
</message>
<message>
<source>SHOW_SHAPE</source>
- <translation>Show SubShape</translation>
+ <translation>Show Sub-shape</translation>
</message>
<message>
<source>SHOW_BAD_MESH</source>
</message>
<message>
<source>INVALID_SUBSHAPE</source>
- <translation>Geometry object is not a subshape of the shape to mesh</translation>
+ <translation>Geometry object is not a sub-shape of the shape to mesh</translation>
</message>
<message>
<source>MESH_IS_NOT_DEFINED</source>
//================================================================================
/*!
* \brief Set edge data
- * \param edgeID - block subshape ID
+ * \param edgeID - block sub-shape ID
* \param curve - edge geometry
* \param isForward - is curve orientation coincides with edge orientation in the block
*/
//================================================================================
/*!
* \brief Set coordinates of nodes at edge ends to work with mesh block
- * \param edgeID - block subshape ID
+ * \param edgeID - block sub-shape ID
* \param node1 - coordinates of node with lower ID
* \param node2 - coordinates of node with upper ID
*/
//================================================================================
/*!
* \brief Set face data
- * \param faceID - block subshape ID
+ * \param faceID - block sub-shape ID
* \param S - face surface geometry
* \param c2d - 4 pcurves in the order as returned by GetFaceEdgesIDs(faceID)
* \param isForward - orientation of pcurves comparing with block edge direction
//================================================================================
/*!
* \brief Set face data to work with mesh block
- * \param faceID - block subshape ID
+ * \param faceID - block sub-shape ID
* \param edgeU0 - filled data of edge u0 = GetFaceEdgesIDs(faceID)[ 0 ]
* \param edgeU1 - filled data of edge u1 = GetFaceEdgesIDs(faceID)[ 1 ]
*/
//=======================================================================
//function : ShellPoint
//purpose : computes coordinates of a point in shell by points on sub-shapes;
-// thePointOnShape[ subShapeID ] must be a point on a subShape
+// thePointOnShape[ subShapeID ] must be a point on a sub-shape
//=======================================================================
bool SMESH_Block::ShellPoint(const gp_XYZ& theParams,
//================================================================================
/*!
* \brief Initialize block geometry with shapes from theShapeIDMap
- * \param theShapeIDMap - map of block subshapes
+ * \param theShapeIDMap - map of block sub-shapes
* \retval bool - is a success
*/
//================================================================================
* \brief Load face geometry
* \param theFace - face
* \param theFaceID - face in-block ID
- * \param theShapeIDMap - map of block subshapes
+ * \param theShapeIDMap - map of block sub-shapes
* \retval bool - is a success
*
* It is enough to compute params or coordinates on the face.
- * Face subshapes must be loaded into theShapeIDMap before
+ * Face sub-shapes must be loaded into theShapeIDMap before
*/
//================================================================================
* \brief/ Insert theShape into theShapeIDMap with theShapeID
* \param theShape - shape to insert
* \param theShapeID - shape in-block ID
- * \param theShapeIDMap - map of block subshapes
+ * \param theShapeIDMap - map of block sub-shapes
*/
//================================================================================
{
if (!myMeshDS || myShape.IsNull()) return;
- // is subshape of main shape?
+ // is sub-shape of main shape?
TopoDS_Shape aMainShape = myMeshDS->ShapeToMesh();
if (aMainShape.IsNull()) {
myIsSubshape = false;
{
if (!myMeshDS || myShape.IsNull()) return;
- // is subshape of main shape?
+ // is sub-shape of main shape?
TopoDS_Shape aMainShape = myMeshDS->ShapeToMesh();
if (aMainShape.IsNull()) {
myIsSubshape = false;
if(MYDEBUG) MESSAGE("addHypothesis");
if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh())
- THROW_SALOME_CORBA_EXCEPTION("bad subShape reference",
+ THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference",
SALOME::BAD_PARAM);
SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp);
SMESH::SMESH_Hypothesis_ptr anHyp)
{
if(MYDEBUG) MESSAGE("removeHypothesis()");
- // **** proposer liste de subShape (selection multiple)
+ // **** proposer liste de sub-shape (selection multiple)
if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh())
- THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", SALOME::BAD_PARAM);
+ THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp);
if (CORBA::is_nil(myHyp))
int hypId = myHyp->GetId();
status = _impl->RemoveHypothesis(myLocSubShape, hypId);
-// if ( !SMESH_Hypothesis::IsStatusFatal(status) ) EAP: hyp can be used on many subshapes
+// if ( !SMESH_Hypothesis::IsStatusFatal(status) ) EAP: hyp can be used on many sub-shapes
// _mapHypo.erase( hypId );
}
catch(SALOME_Exception & S_ex)
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetHypothesisList");
if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShapeObject))
- THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", SALOME::BAD_PARAM);
+ THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
SMESH::ListOfHypothesis_var aList = new SMESH::ListOfHypothesis();
Unexpect aCatch(SALOME_SalomeException);
MESSAGE("SMESH_Mesh_i::GetSubMesh");
if (CORBA::is_nil(aSubShapeObject))
- THROW_SALOME_CORBA_EXCEPTION("bad subShape reference",
+ THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference",
SALOME::BAD_PARAM);
SMESH::SMESH_subMesh_var subMesh;
}
}
- //! Check sharing of sub shapes
+ //! Check sharing of sub-shapes
static bool isShareSubShapes(const TopTools_MapOfShape& theToCheck,
const TopTools_MapOfShape& theToFind,
const TopAbs_ShapeEnum theType)
const TopoDS_Shape aSubSh = anItr.Key();
// check for case when concurrent dimensions are same
isShared = theToFind.Contains( aSubSh );
- // check for subshape with concurrent dimension
+ // check for sub-shape with concurrent dimension
TopExp_Explorer anExp( aSubSh, theType );
for ( ; !isShared && anExp.More(); anExp.Next() )
isShared = theToFind.Contains( anExp.Current() );
}
- //! Check if subshape hypotheses are concurrent
+ //! Check if sub-shape hypotheses are concurrent
bool IsConcurrent(const SMESH_DimHyp* theOther) const
{
if ( _subMesh == theOther->_subMesh )
- return false; // same subshape - should not be
+ return false; // same sub-shape - should not be
// if ( <own dim of either of submeshes> == <concurrent dim> &&
// any of the two submeshes is not on COMPOUND shape )
// hyp it-self is algo
anAlgo = (SMESH_Algo*)dynamic_cast<const SMESH_Algo*>(hyp);
else {
- // try to find algorithm with help of subshapes
+ // try to find algorithm with help of sub-shapes
TopExp_Explorer anExp( aSubMeshShape, shapeTypeByDim(hyp->GetDim()) );
for ( ; !anAlgo && anExp.More(); anExp.Next() )
anAlgo = mesh.GetGen()->GetAlgo( mesh, anExp.Current() );
subshapes = geompy.SubShapeAll(alveole, geompy.ShapeType["SHAPE"])
-## there are 9 subshapes
+## there are 9 sub-shapes
comp1 = geompy.MakeCompound( [ subshapes[0], subshapes[1] ] )
comp2 = geompy.MakeCompound( [ subshapes[2], subshapes[3] ] )
# ---- explode on faces
SubFaceL = geompy.SubShapeAllSorted(mechanic, geompy.ShapeType["FACE"])
-# ---- add a face sub shape in study to be meshed different
+# ---- add a face sub-shape in study to be meshed different
sub_face1 = SubFaceL[0]
name = geompy.SubShapeName( sub_face1, mechanic )
Id_SubFace1 = geompy.addToStudyInFather( mechanic, sub_face1, name )
-# ---- add a face sub shape in study to be meshed different
+# ---- add a face sub-shape in study to be meshed different
sub_face2 = SubFaceL[4]
name = geompy.SubShapeName( sub_face2, mechanic )
Id_SubFace2 = geompy.addToStudyInFather( mechanic, sub_face2, name )
-# ---- add a face sub shape in study to be meshed different
+# ---- add a face sub-shape in study to be meshed different
sub_face3 = SubFaceL[5]
name = geompy.SubShapeName( sub_face3, mechanic )
Id_SubFace3 = geompy.addToStudyInFather( mechanic, sub_face3, name )
-# ---- add a face sub shape in study to be meshed different
+# ---- add a face sub-shape in study to be meshed different
sub_face4 = SubFaceL[10]
name = geompy.SubShapeName( sub_face4, mechanic )
# ---- explode on faces
SubFaceL = geompy.SubShapeAllSorted(mechanic, geompy.ShapeType["FACE"])
-# ---- add a face sub shape in study to be meshed different
+# ---- add a face sub-shape in study to be meshed different
sub_face1 = SubFaceL[0]
name = geompy.SubShapeName( sub_face1, mechanic )
Id_SubFace1 = geompy.addToStudyInFather( mechanic, sub_face1, name )
-# ---- add a face sub shape in study to be meshed different
+# ---- add a face sub-shape in study to be meshed different
sub_face2 = SubFaceL[4]
name = geompy.SubShapeName( sub_face2, mechanic )
Id_SubFace2 = geompy.addToStudyInFather( mechanic, sub_face2, name )
-# ---- add a face sub shape in study to be meshed different
+# ---- add a face sub-shape in study to be meshed different
sub_face3 = SubFaceL[5]
name = geompy.SubShapeName( sub_face3, mechanic )
Id_SubFace3 = geompy.addToStudyInFather( mechanic, sub_face3, name )
-# ---- add a face sub shape in study to be meshed different
+# ---- add a face sub-shape in study to be meshed different
sub_face4 = SubFaceL[10]
name = geompy.SubShapeName( sub_face4, mechanic )
elif status == HYP_CONCURENT :
reason = "there are concurrent hypotheses on sub-shapes"
elif status == HYP_BAD_SUBSHAPE :
- reason = "the shape is neither the main one, nor its subshape, nor a valid group"
+ reason = "the shape is neither the main one, nor its sub-shape, nor a valid group"
elif status == HYP_BAD_GEOMETRY:
reason = "geometry mismatches the expectation of the algorithm"
elif status == HYP_HIDDEN_ALGO:
self.mesh = self.smeshpyD.CreateMesh(geom)
## Returns true if the hypotheses are defined well
- # @param theSubObject a subshape of a mesh shape
+ # @param theSubObject a sub-shape of a mesh shape
# @return True or False
# @ingroup l2_construct
def IsReadyToCompute(self, theSubObject):
## Returns errors of hypotheses definition.
# The list of errors is empty if everything is OK.
- # @param theSubObject a subshape of a mesh shape
+ # @param theSubObject a sub-shape of a mesh shape
# @return a list of errors
# @ingroup l2_construct
def GetAlgoState(self, theSubObject):
## Creates a segment discretization 1D algorithm.
# If the optional \a algo parameter is not set, this algorithm is REGULAR.
# \n If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo the type of the required algorithm. Possible values are:
# - smesh.REGULAR,
# - smesh.PYTHON for discretization via a python function,
# - smesh.COMPOSITE for meshing a set of edges on one face side as a whole.
- # @param geom If defined is the subshape to be meshed
+ # @param geom If defined is the sub-shape to be meshed
# @return an instance of Mesh_Segment or Mesh_Segment_Python, or Mesh_CompositeSegment class
# @ingroup l3_algos_basic
def Segment(self, algo=REGULAR, geom=0):
## Creates 1D algorithm importing segments conatined in groups of other mesh.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param geom If defined the subshape is to be meshed
# @return an instance of Mesh_UseExistingElements class
# @ingroup l3_algos_basic
## Creates 2D algorithm importing faces conatined in groups of other mesh.
# If the optional \a geom parameter is not set, this algorithm is global.
# Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined the subshape is to be meshed
+ # @param geom If defined the sub-shape is to be meshed
# @return an instance of Mesh_UseExistingElements class
# @ingroup l3_algos_basic
def UseExisting2DElements(self, geom=0):
# The added nodes and segments must be bound to edges and vertices by
# SetNodeOnVertex(), SetNodeOnEdge() and SetMeshElementOnShape()
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom the subshape to be manually meshed
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom the sub-shape to be manually meshed
# @return StdMeshers_UseExisting_1D algorithm that generates nothing
# @ingroup l3_algos_basic
def UseExistingSegments(self, geom=0):
# The added nodes and faces must be bound to geom faces by SetNodeOnFace()
# and SetMeshElementOnShape()
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom the subshape to be manually meshed
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom the sub-shape to be manually meshed
# @return StdMeshers_UseExisting_2D algorithm that generates nothing
# @ingroup l3_algos_basic
def UseExistingFaces(self, geom=0):
## Creates a triangle 2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo values are: smesh.MEFISTO || smesh.NETGEN_1D2D || smesh.NETGEN_2D || smesh.BLSURF
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @return an instance of Mesh_Triangle algorithm
# @ingroup l3_algos_basic
def Triangle(self, algo=MEFISTO, geom=0):
## Creates a quadrangle 2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @param algo values are: smesh.QUADRANGLE || smesh.RADIAL_QUAD
# @return an instance of Mesh_Quadrangle algorithm
# @ingroup l3_algos_basic
## Creates a tetrahedron 3D algorithm for solids.
# The parameter \a algo permits to choose the algorithm: NETGEN or GHS3D
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo values are: smesh.NETGEN, smesh.GHS3D, smesh.GHS3DPRL, smesh.FULL_NETGEN
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @return an instance of Mesh_Tetrahedron algorithm
# @ingroup l3_algos_basic
def Tetrahedron(self, algo=NETGEN, geom=0):
## Creates a hexahedron 3D algorithm for solids.
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo possible values are: smesh.Hexa, smesh.Hexotic
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @return an instance of Mesh_Hexahedron algorithm
# @ingroup l3_algos_basic
def Hexahedron(self, algo=Hexa, geom=0):
## Creates a projection 1D algorithm for edges.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection1D algorithm
# @ingroup l3_algos_proj
def Projection1D(self, geom=0):
## Creates a projection 1D-2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection2D algorithm
# @ingroup l3_algos_proj
def Projection1D2D(self, geom=0):
## Creates a projection 2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection2D algorithm
# @ingroup l3_algos_proj
def Projection2D(self, geom=0):
## Creates a projection 3D algorithm for solids.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection3D algorithm
# @ingroup l3_algos_proj
def Projection3D(self, geom=0):
## Creates a 3D extrusion (Prism 3D) or RadialPrism 3D algorithm for solids.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Prism3D or Mesh_RadialPrism3D algorithm
# @ingroup l3_algos_radialp l3_algos_3dextr
def Prism(self, geom=0):
# 3D structured Cartesian mesh in the internal part of a solid shape
# and polyhedral volumes near the shape boundary.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# The algorithm does not support submeshes.
# Generally usage of this algorithm as a local one is useless since
- # it does not discretize 1D and 2D subshapes in a usual way acceptable
+ # it does not discretize 1D and 2D sub-shapes in a usual way acceptable
# for other algorithms.
- # @param geom If defined, the subshape to be meshed
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Cartesian_3D algorithm
# @ingroup l3_algos_basic
def BodyFitted(self, geom=0):
## Unassigns a hypothesis
# @param hyp a hypothesis to unassign
- # @param geom a subshape of mesh geometry
+ # @param geom a sub-shape of mesh geometry
# @return SMESH.Hypothesis_Status
# @ingroup l2_hypotheses
def RemoveHypothesis(self, hyp, geom=0):
return status
## Gets the list of hypotheses added on a geometry
- # @param geom a subshape of mesh geometry
+ # @param geom a sub-shape of mesh geometry
# @return the sequence of SMESH_Hypothesis
# @ingroup l2_hypotheses
def GetHypothesisList(self, geom):
return self.mesh.GetElementGeomType(id)
## Returns the list of submesh elements IDs
- # @param Shape a geom object(subshape) IOR
- # Shape must be the subshape of a ShapeToMesh()
+ # @param Shape a geom object(sub-shape) IOR
+ # Shape must be the sub-shape of a ShapeToMesh()
# @return the list of integer values
# @ingroup l1_meshinfo
def GetSubMeshElementsId(self, Shape):
return self.mesh.GetSubMeshElementsId(ShapeID)
## Returns the list of submesh nodes IDs
- # @param Shape a geom object(subshape) IOR
- # Shape must be the subshape of a ShapeToMesh()
+ # @param Shape a geom object(sub-shape) IOR
+ # Shape must be the sub-shape of a ShapeToMesh()
# @param all If true, gives all nodes of submesh elements, otherwise gives only submesh nodes
# @return the list of integer values
# @ingroup l1_meshinfo
return self.mesh.GetSubMeshNodesId(ShapeID, all)
## Returns type of elements on given shape
- # @param Shape a geom object(subshape) IOR
- # Shape must be a subshape of a ShapeToMesh()
+ # @param Shape a geom object(sub-shape) IOR
+ # Shape must be a sub-shape of a ShapeToMesh()
# @return element type
# @ingroup l1_meshinfo
def GetSubMeshElementType(self, Shape):
// ----------------------------
// Add internal nodes of a box
// ----------------------------
- // projection points of internal nodes on box subshapes by which
+ // projection points of internal nodes on box sub-shapes by which
// coordinates of internal nodes are computed
vector<gp_XYZ> pointsOnShapes( SMESH_Block::ID_Shell );
// ----------------------------
// Add internal nodes of a box
// ----------------------------
- // projection points of internal nodes on box subshapes by which
+ // projection points of internal nodes on box sub-shapes by which
// coordinates of internal nodes are computed
vector<gp_XYZ> pointOnShape( SMESH_Block::ID_Shell );
{
// To get SMESH_subMesh corresponding to srcMeshDS we need to have a shape
// for which SMESHDS_Mesh::IsGroupOfSubShapes() returns true.
- // And this shape must be different from subshapes of the main shape.
+ // And this shape must be different from sub-shapes of the main shape.
// So we create a compound containing
// 1) some sub-shapes of SMESH_Mesh::PseudoShape() corresponding to
// srcMeshDS->GetPersistentId()
iNb=aM.Extent();
if (iNb!=iNbEx[i]){
MESSAGE("StdMeshers_Penta_3D::CheckData() ");
- myErrorStatus->myName=4; // number of subshape is not compatible
- myErrorStatus->myComment="Wrong number of subshapes of a block";
+ myErrorStatus->myName=4; // number of sub-shape is not compatible
+ myErrorStatus->myComment="Wrong number of sub-shapes of a block";
return;
}
}
case 3: text = "Internal error of StdMeshers_Penta_3D"; break;
case 4: text = "Can't compute normalized parameters of a point inside a block"; break;
case 5: text = "Can't compute coordinates by normalized parameters inside a block"; break;
- case 6: text = "Can't detect block subshapes. Not a block?"; break;
+ case 6: text = "Can't detect block sub-shapes. Not a block?"; break;
}
if (!text.empty())
err->myName = myErrorStatus;
myHelper->IsQuadraticSubMesh( theShape );
- // Analyse mesh and geomerty to find block subshapes and submeshes
+ // Analyse mesh and geomerty to find block sub-shapes and submeshes
if ( !myBlock.Init( myHelper, theShape ))
return error( myBlock.GetError());
//================================================================================
/*!
- * \brief Set projection coordinates of a node to a face and it's subshapes
+ * \brief Set projection coordinates of a node to a face and it's sub-shapes
* \param faceID - the face given by in-block ID
* \param params - node normalized parameters
* \retval bool - is a success
//================================================================================
/*!
- * \brief Fill block subshapes
+ * \brief Fill block sub-shapes
* \param shapeMap - map to fill in
- * \retval int - nb inserted subshapes
+ * \retval int - nb inserted sub-shapes
*/
//================================================================================
* \brief Tool analyzing and giving access to a prism geometry
* treating it like a block, i.e. the four side faces are
* emulated by division/uniting of missing/excess faces.
- * It also manage associations between block subshapes and a mesh.
+ * It also manage associations between block sub-shapes and a mesh.
*/
// ===============================================================
/*!
* \brief Return in-block ID of a shape
- * \param shape - block subshape
+ * \param shape - block sub-shape
* \retval int - ID or zero if the shape has no ID
*/
int ShapeID(const TopoDS_Shape& shape) const
bool projectBottomToTop();
/*!
- * \brief Set projection coordinates of a node to a face and it's subshapes
+ * \brief Set projection coordinates of a node to a face and it's sub-shapes
* \param faceID - the face given by in-block ID
* \param params - node normalized parameters
* \retval bool - is a success
//=======================================================================
/*!
- * \brief Looks for association of all subshapes of two shapes
+ * \brief Looks for association of all sub-shapes of two shapes
* \param theShape1 - shape 1
* \param theMesh1 - mesh built on shape 1
* \param theShape2 - shape 2
if ( partner ) // Same shape with different location
{
- // recursively associate all subshapes of theShape1 and theShape2
+ // recursively associate all sub-shapes of theShape1 and theShape2
typedef list< pair< TopoDS_Shape, TopoDS_Shape > > TShapePairsList;
TShapePairsList shapesQueue( 1, make_pair( theShape1, theShape2 ));
TShapePairsList::iterator s1_s2 = shapesQueue.begin();
if ( edge2.IsNull() )
RETURN_BAD_RESULT("GetEdgeByVertices() failed");
- // build map of edge to faces if shapes are not subshapes of main ones
+ // build map of edge to faces if shapes are not sub-shapes of main ones
bool isSubOfMain = false;
if ( SMESHDS_SubMesh * sm = theMesh1->GetMeshDS()->MeshElements( theShape1 ))
isSubOfMain = !sm->IsComplexSubmesh();
TopTools_MapOfShape boundEdges;
- // association of face subshapes and neighbour faces
+ // association of face sub-shapes and neighbour faces
list< pair < TopoDS_Face, TopoDS_Edge > > FE1, FE2;
list< pair < TopoDS_Face, TopoDS_Edge > >::iterator fe1, fe2;
FE1.push_back( make_pair( TopoDS::Face( F1 ), edge1 ));
* \param mesh1 - mesh containing elements on the first face
* \param face2 - the second face
* \param mesh2 - mesh containing elements on the second face
- * \param assocMap - map associating subshapes of the faces
+ * \param assocMap - map associating sub-shapes of the faces
* \param node1To2Map - map containing found matching nodes
* \retval bool - is a success
*/
TopoDS_Edge e1 = TopoDS::Edge( assocMap( e2 ));
if ( !helper1.IsSubShape( e1, face1 ))
RETURN_BAD_RESULT("Wrong association, edge " << meshDS1->ShapeToIndex( e1 ) <<
- " isn't a subshape of face " << meshDS1->ShapeToIndex( face1 ));
+ " isn't a sub-shape of face " << meshDS1->ShapeToIndex( face1 ));
// check that there are nodes on edges
SMESHDS_SubMesh * eSM1 = meshDS1->MeshElements( e1 );
SMESHDS_SubMesh * eSM2 = meshDS2->MeshElements( e2 );
//================================================================================
/*!
- * \brief Return any subshape of a face belonging to the outer wire
+ * \brief Return any sub-shape of a face belonging to the outer wire
* \param face - the face
- * \param type - type of subshape to return
- * \retval TopoDS_Shape - the found subshape
+ * \param type - type of sub-shape to return
+ * \retval TopoDS_Shape - the found sub-shape
*/
//================================================================================
//================================================================================
/*!
- * \brief Count nb of subshapes
+ * \brief Count nb of sub-shapes
* \param shape - the shape
- * \param type - the type of subshapes to count
+ * \param type - the type of sub-shapes to count
* \retval int - the calculated number
*/
//================================================================================
if ( srcShapeSM->GetSubMeshDS() &&
srcShapeSM->GetSubMeshDS()->IsComplexSubmesh() )
{ // source shape is a group
- TopExp_Explorer it(srcShapeSM->GetSubShape(), // explore the group into subshapes...
+ TopExp_Explorer it(srcShapeSM->GetSubShape(), // explore the group into sub-shapes...
subMesh->GetSubShape().ShapeType()); // ...of target shape type
for (; it.More(); it.Next())
{
typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
/*!
- * \brief Looks for association of all subshapes of two shapes
+ * \brief Looks for association of all sub-shapes of two shapes
* \param theShape1 - shape 1
* \param theMesh1 - mesh built on shape 1
* \param theShape2 - shape 2
* \param mesh1 - mesh containing elements on the first face
* \param face2 - the second face
* \param mesh2 - mesh containing elements on the second face
- * \param assocMap - map associating subshapes of the faces
+ * \param assocMap - map associating sub-shapes of the faces
* \param nodeIn2OutMap - map containing found matching nodes
* \retval bool - is a success
*/
const TShapeShapeMap & assocMap,
TNodeNodeMap & nodeIn2OutMap);
/*!
- * \brief Return any subshape of a face belonging to the outer wire
+ * \brief Return any sub-shape of a face belonging to the outer wire
* \param face - the face
- * \param type - type of subshape to return
- * \retval TopoDS_Shape - the found subshape
+ * \param type - type of sub-shape to return
+ * \retval TopoDS_Shape - the found sub-shape
*/
static TopoDS_Shape OuterShape( const TopoDS_Face& face,
TopAbs_ShapeEnum type);
static bool MakeComputed(SMESH_subMesh * sm, const int iterationNb = 0);
/*!
- * \brief Count nb of subshapes
+ * \brief Count nb of sub-shapes
* \param shape - the shape
- * \param type - the type of subshapes to count
+ * \param type - the type of sub-shapes to count
* \param ignoreSame - if true, use map not to count same shapes, esle use explorer
* \retval int - the calculated number
*/
SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();
// ---------------------------
- // Make subshapes association
+ // Make sub-shapes association
// ---------------------------
TopoDS_Edge srcEdge, tgtEdge = TopoDS::Edge( theShape.Oriented(TopAbs_FORWARD));
//SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();
// ---------------------------
- // Make subshapes association
+ // Make sub-shapes association
// ---------------------------
TopoDS_Edge srcEdge, tgtEdge = TopoDS::Edge( theShape.Oriented(TopAbs_FORWARD));
SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();
// ---------------------------
- // Make subshapes association
+ // Make sub-shapes association
// ---------------------------
TopoDS_Face tgtFace = TopoDS::Face( theShape.Oriented(TopAbs_FORWARD));
srcMesh = tgtMesh;
// ---------------------------
- // Make subshapes association
+ // Make sub-shapes association
// ---------------------------
TopoDS_Face tgtFace = TopoDS::Face( theShape.Oriented(TopAbs_FORWARD));
TopExp::Vertices( TopoDS::Edge( exp.Current() ), tgtV000, tgtV100 );
if ( !shape2ShapeMap.IsBound( tgtV000 ) || !shape2ShapeMap.IsBound( tgtV100 ))
- return error("Association of subshapes failed" );
+ return error("Association of sub-shapes failed" );
srcV000 = TopoDS::Vertex( shape2ShapeMap( tgtV000 ));
srcV100 = TopoDS::Vertex( shape2ShapeMap( tgtV100 ));
if ( !SMESH_MesherHelper::IsSubShape( srcV000, srcShell ) ||
!SMESH_MesherHelper::IsSubShape( srcV100, srcShell ))
- return error("Incorrect association of subshapes" );
+ return error("Incorrect association of sub-shapes" );
}
// Load 2 SMESH_Block's with src and tgt shells
SMESH_Block srcBlock, tgtBlock;
TopTools_IndexedMapOfOrientedShape scrShapes, tgtShapes;
if ( !tgtBlock.LoadBlockShapes( tgtShell, tgtV000, tgtV100, tgtShapes ))
- return error(COMPERR_BAD_SHAPE, "Can't detect block subshapes. Not a block?");
+ return error(COMPERR_BAD_SHAPE, "Can't detect block sub-shapes. Not a block?");
if ( !srcBlock.LoadBlockShapes( srcShell, srcV000, srcV100, scrShapes ))
- return error(COMPERR_BAD_SHAPE, "Can't detect block subshapes. Not a block?");
+ return error(COMPERR_BAD_SHAPE, "Can't detect block sub-shapes. Not a block?");
// Find matching nodes of src and tgt shells
TNodeNodeMap src2tgtNodeMap;
for ( int fId = SMESH_Block::ID_FirstF; fId < SMESH_Block::ID_Shell; ++fId )
{
- // Corresponding subshapes
+ // Corresponding sub-shapes
TopoDS_Face srcFace = TopoDS::Face( scrShapes( fId ));
TopoDS_Face tgtFace = TopoDS::Face( tgtShapes( fId ));
- if ( _sourceHypo->HasVertexAssociation() ) { // associate face subshapes
+ if ( _sourceHypo->HasVertexAssociation() ) { // associate face sub-shapes
shape2ShapeMap.Clear();
vector< int > edgeIdVec;
SMESH_Block::GetFaceEdgesIDs( fId, edgeIdVec );
return error(COMPERR_BAD_SHAPE, SMESH_Comment("Must be 2 shells but not ")<<nbShells);
// ----------------------------------
- // Associate subshapes of the shells
+ // Associate sub-shapes of the shells
// ----------------------------------
TAssocTool::TShapeShapeMap shape2ShapeMap;
for ( exp.Init( outerShell, TopAbs_FACE ); exp.More(); exp.Next() )
{
- // Corresponding subshapes
+ // Corresponding sub-shapes
TopoDS_Face outFace = TopoDS::Face( exp.Current() );
TopoDS_Face inFace;
if ( !shape2ShapeMap.IsBound( outFace )) {
return false;
}
- // Associate subshapes of the shells
+ // Associate sub-shapes of the shells
TAssocTool::TShapeShapeMap shape2ShapeMap;
if ( !TAssocTool::FindSubShapeAssociation( outerShell, &aMesh,
innerShell, &aMesh,
/*!
* \brief creates a filter for selection of shapes of given dimension
* \param dim - dimension
- * \param subShapeType - required type of subshapes, number of which must be \a nbSubShapes
- * \param nbSubShapes - number of subshapes of given type
+ * \param subShapeType - required type of sub-shapes, number of which must be \a nbSubShapes
+ * \param nbSubShapes - number of sub-shapes of given type
* \param closed - required closeness flag of a shape
* \retval SUIT_SelectionFilter* - created filter
*/
//=================================================================================
// function : GetCorrectedListOfIds
-// purpose : Called to convert the list of IDs from subshape IDs to main shape IDs
+// purpose : Called to convert the list of IDs from sub-shape IDs to main shape IDs
//=================================================================================
QList<int> StdMeshersGUI_SubShapeSelectorWdg::GetCorrectedListOfIDs( bool fromSubshapeToMainshape )
{
TopExp::MapShapes(myGeomShape, aGeomMap);
TopExp::MapShapes(myMainShape, aMainMap);
- if ( fromSubshapeToMainshape ) { // convert indexes from subshape to mainshape
+ if ( fromSubshapeToMainshape ) { // convert indexes from sub-shape to mainshape
int size = myListOfIDs.size();
for (int i = 0; i < size; i++) {
TopoDS_Shape aSubShape = aGeomMap.FindKey( myListOfIDs.at(i) );
aList.append( index );
}
myIsNotCorrected = false;
- } else { // convert indexes from main shape to subshape
+ } else { // convert indexes from main shape to sub-shape
int size = mySelectedIDs.size();
for (int i = 0; i < size; i++) {
TopoDS_Shape aSubShape = aMainMap.FindKey( mySelectedIDs.at(i) );
