1 // Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESH_MeshEditor.idl
24 #ifndef _SMESH_MESHEDITOR_IDL_
25 #define _SMESH_MESHEDITOR_IDL_
27 #include "SMESH_Mesh.idl"
28 #include "SMESH_Gen.idl"
29 #include "SMESH_smIdType.idl"
33 interface NumericalFunctor;
35 enum Bnd_Dimension { BND_2DFROM3D, BND_1DFROM3D, BND_1DFROM2D };
40 SMESH::smIdType_array nodeIDs; // all nodes defining a free border
41 // 1st and last node is same in a closed border
45 short border; // border index within a sequence<FreeBorder>
46 long node1; // node index within the border-th FreeBorder
50 typedef sequence<FreeBorder> ListOfFreeBorders;
51 typedef sequence<FreeBorderPart> FreeBordersGroup;
52 typedef sequence<FreeBordersGroup> ListOfFreeBorderGroups;
54 struct CoincidentFreeBorders
56 ListOfFreeBorders borders; // nodes of all free borders
57 ListOfFreeBorderGroups coincidentGroups; // groups of coincident parts of borders
61 // structure used in MakePolyLine() to define a cutting plane
64 // a point is defined as follows:
65 // ( node*ID1 > 0 && node*ID2 > 0 ) ==> point is in the middle of an edge defined by two nodes
66 // ( node*ID1 > 0 && node*ID2 <=0 ) ==> point is at node*ID1
67 // else ==> point is at xyz*
79 // vector on the plane; to use a default plane set vector = (0,0,0)
82 typedef sequence<PolySegment> ListOfPolySegments;
84 // face edge defined by two nodes + optional medium node
91 typedef sequence<FaceEdge> ListOfEdges;
95 * This interface makes modifications on the Mesh - removing elements and nodes etc.
96 * Also provides some analysis functions.
98 interface SMESH_MeshEditor
101 * Returns a mesh subject to edition
103 SMESH_Mesh GetMesh();
106 * Return data of mesh edition preview which is computed provided
107 * that the editor was obtained through SMESH_Mesh::GetMeshEditPreviewer()
109 MeshPreviewStruct GetPreviewData() raises (SALOME::SALOME_Exception);
112 * If during last operation of MeshEditor some nodes were
113 * created, this method returns list of their IDs, if new nodes
114 * not created - returns empty list
116 smIdType_array GetLastCreatedNodes() raises (SALOME::SALOME_Exception);
119 * If during last operation of MeshEditor some elements were
120 * created, this method returns list of their IDs, if new elements
121 * not created - returns empty list
123 smIdType_array GetLastCreatedElems() raises (SALOME::SALOME_Exception);
126 * \brief Clears sequences of last created elements and nodes
128 void ClearLastCreated() raises (SALOME::SALOME_Exception);
131 * \brief Returns description of an error/warning occurred during the last operation
133 ComputeError GetLastError() raises (SALOME::SALOME_Exception);
136 * \brief Wrap a sequence of ids in a SMESH_IDSource
137 * \param IDsOfElements list of mesh elements identifiers
138 * \return new ID source object
140 SMESH_IDSource MakeIDSource(in smIdType_array IDsOfElements, in ElementType type);
143 * \brief Remove mesh elements specified by their identifiers.
144 * \param IDsOfElements list of mesh elements identifiers
145 * \return \c true if elements are correctly removed or \c false otherwise
147 boolean RemoveElements(in smIdType_array IDsOfElements) raises (SALOME::SALOME_Exception);
150 * \brief Remove mesh nodes specified by their identifiers.
151 * \param IDsOfNodes list of mesh nodes identifiers
152 * \return \c true if nodes are correctly removed or \c false otherwise
154 boolean RemoveNodes(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
157 * \brief Remove all orphan nodes.
158 * \return number of removed nodes
160 smIdType RemoveOrphanNodes() raises (SALOME::SALOME_Exception);
163 * \brief Add a new node.
164 * \param x X coordinate of new node
165 * \param y Y coordinate of new node
166 * \param z Z coordinate of new node
167 * \return integer identifier of new node
169 smIdType AddNode(in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
172 * Create a 0D element on the given node.
173 * \param IdOfNode Node IDs for creation of element.
174 * \param DuplicateElements to add one more 0D element to a node or not
176 smIdType Add0DElement(in smIdType IDOfNode,
177 in boolean DuplicateElements) raises (SALOME::SALOME_Exception);
180 * Create a ball element on the given node.
181 * \param IdOfNode Node IDs for creation of element.
183 smIdType AddBall(in smIdType IDOfNode, in double diameter) raises (SALOME::SALOME_Exception);
186 * Create an edge, either linear and quadratic (this is determed
187 * by number of given nodes, two or three).
188 * \param IdsOfNodes List of node IDs for creation of element.
189 * Needed order of nodes in this list corresponds to description
190 * of MED. This description is located by the following link:
191 * http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
193 smIdType AddEdge(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
196 * Create face, either linear and quadratic (this is determed
197 * by number of given nodes).
198 * \param IdsOfNodes List of node IDs for creation of element.
199 * Needed order of nodes in this list corresponds to description
200 * of MED. This description is located by the following link:
201 * http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
203 smIdType AddFace(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
205 smIdType AddPolygonalFace(in smIdType_array IdsOfNodes) raises (SALOME::SALOME_Exception);
208 * Create a quadratic polygonal face
209 * \param IdsOfNodes - nodes of the polygon; corner nodes follow first
210 * \return smIdType- ID of a new polygon
212 smIdType AddQuadPolygonalFace(in smIdType_array IdsOfNodes) raises (SALOME::SALOME_Exception);
215 * Create volume, either linear and quadratic (this is determed
216 * by number of given nodes).
217 * \param IdsOfNodes List of node IDs for creation of element.
218 * Needed order of nodes in this list corresponds to description
219 * of MED. This description is located by the following link:
220 * http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
222 smIdType AddVolume(in smIdType_array IDsOfNodes) raises (SALOME::SALOME_Exception);
225 * Create volume of many faces, giving nodes for each face.
226 * \param IdsOfNodes List of node IDs for volume creation face by face.
227 * \param Quantities List of integer values, Quantities[i]
228 * gives quantity of nodes in face number i.
230 smIdType AddPolyhedralVolume (in smIdType_array IdsOfNodes,
231 in long_array Quantities) raises (SALOME::SALOME_Exception);
233 * Create volume of many faces, giving IDs of existing faces.
234 * \param IdsOfFaces List of face IDs for volume creation.
235 * \note The created volume will refer only to nodes
236 * of the given faces, not to the faces itself.
238 smIdType AddPolyhedralVolumeByFaces (in smIdType_array IdsOfFaces) raises (SALOME::SALOME_Exception);
241 * Create 0D elements on all nodes of the given object.
242 * \param theObject object on whose nodes 0D elements will be created.
243 * \param theGroupName optional name of a group to add 0D elements created
244 * and/or found on nodes of \a theObject.
245 * \param theDuplicateElements to add one more 0D element to a node or not
246 * \return an object (a new group or a temporary SMESH_IDSource) holding
247 * ids of new and/or found 0D elements.
249 SMESH_IDSource Create0DElementsOnAllNodes(in SMESH_IDSource theObject,
250 in string theGroupName,
251 in boolean theDuplicateElements)
252 raises (SALOME::SALOME_Exception);
255 * \brief Bind a node to a vertex
256 * \param NodeID - node ID
257 * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
259 void SetNodeOnVertex(in smIdType NodeID, in long VertexID)
260 raises (SALOME::SALOME_Exception);
262 * \brief Store node position on an edge
263 * \param NodeID - node ID
264 * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
265 * \param paramOnEdge - parameter on edge where the node is located
267 void SetNodeOnEdge(in smIdType NodeID, in long EdgeID, in double paramOnEdge)
268 raises (SALOME::SALOME_Exception);
270 * \brief Store node position on a face
271 * \param NodeID - node ID
272 * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
273 * \param u - U parameter on face where the node is located
274 * \param v - V parameter on face where the node is located
276 void SetNodeOnFace(in smIdType NodeID, in long FaceID, in double u, in double v)
277 raises (SALOME::SALOME_Exception);
279 * \brief Bind a node to a solid
280 * \param NodeID - node ID
281 * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
283 void SetNodeInVolume(in smIdType NodeID, in long SolidID)
284 raises (SALOME::SALOME_Exception);
286 * \brief Bind an element to a shape
287 * \param ElementID - element ID
288 * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
290 void SetMeshElementOnShape(in smIdType ElementID, in long ShapeID)
291 raises (SALOME::SALOME_Exception);
294 boolean MoveNode(in smIdType NodeID, in double x, in double y, in double z)
295 raises (SALOME::SALOME_Exception);
297 boolean InverseDiag(in smIdType NodeID1, in smIdType NodeID2)
298 raises (SALOME::SALOME_Exception);
300 boolean DeleteDiag(in smIdType NodeID1, in smIdType NodeID2)
301 raises (SALOME::SALOME_Exception);
303 boolean Reorient(in smIdType_array IDsOfElements)
304 raises (SALOME::SALOME_Exception);
306 boolean ReorientObject(in SMESH_IDSource theObject)
307 raises (SALOME::SALOME_Exception);
309 * \brief Reorient faces contained in \a the2Dgroup.
310 * \param the2Dgroup - the mesh or its part to reorient
311 * \param theDirection - desired direction of normal of \a theFace
312 * \param theFace - ID of face whose orientation is checked.
313 * It can be < 1 then \a thePoint is used to find a face.
314 * \param thePoint - is used to find a face if \a theFace < 1.
315 * \return number of reoriented faces.
317 long Reorient2D(in SMESH_IDSource the2Dgroup,
318 in DirStruct theDirection,
320 in PointStruct thePoint) raises (SALOME::SALOME_Exception);
322 * \brief Reorient faces contained in a list of \a objectFaces
323 * equally to faces contained in a list of \a referenceFaces.
324 * \param objectFaces - faces to reorient in a list including either
325 * the whole mesh or groups and/or sub-meshes.
326 * \param referenceFaces - correctly oriented faces in a list of groups and/or sub-meshes.
327 * It can be empty, then the 1st face in \a objectFaces is used as the reference.
328 * \return number of reoriented faces.
330 long Reorient2DByNeighbours(in SMESH::ListOfIDSources objectFaces,
331 in SMESH::ListOfIDSources referenceFaces)
332 raises (SALOME::SALOME_Exception);
335 * \brief Reorient faces basing on orientation of adjacent volumes.
336 * \param faces - a list of objects containing face to reorient
337 * \param volumes - an object containing volumes.
338 * \param outsideNormal - to orient faces to have their normal
339 * pointing either \a outside or \a inside the adjacent volumes.
340 * \return number of reoriented faces.
342 long Reorient2DBy3D(in ListOfIDSources faces,
343 in SMESH_IDSource volumes,
344 in boolean outsideNormal) raises (SALOME::SALOME_Exception);
347 * \brief Fuse neighbour triangles into quadrangles.
348 * \param IDsOfElements Ids of triangles to be fused.
349 * \param theCriterion Is used to choose a neighbour to fuse with.
350 * \param theMaxAngle Is a max angle between element normals at which fusion
351 * is still performed; theMaxAngle is measured in radians.
352 * \return \c true in case of success, FALSE otherwise.
355 boolean TriToQuad (in smIdType_array IDsOfElements,
356 in NumericalFunctor Criterion,
357 in double MaxAngle) raises (SALOME::SALOME_Exception);
359 * \brief Fuse neighbour triangles into quadrangles.
361 * Behaves like the above method, taking a list of elements from \a theObject
363 boolean TriToQuadObject (in SMESH_IDSource theObject,
364 in NumericalFunctor Criterion,
365 in double MaxAngle) raises (SALOME::SALOME_Exception);
368 * \brief Split quadrangles into triangles.
369 * \param IDsOfElements Ids of quadrangles to split.
370 * \param theCriterion Is used to choose a diagonal for splitting.
371 * \return TRUE in case of success, FALSE otherwise.
373 boolean QuadToTri (in smIdType_array IDsOfElements,
374 in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
376 * \brief Split quadrangles into triangles.
378 * Behaves like the above method, taking a list of elements from \a theObject
380 boolean QuadToTriObject (in SMESH_IDSource theObject,
381 in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
383 * \brief Split each of quadrangles into 4 triangles.
384 * \param theQuads Container of quadrangles to split.
386 void QuadTo4Tri (in SMESH_IDSource theQuads) raises (SALOME::SALOME_Exception);
389 * \brief Split quadrangles into triangles.
390 * \param theElems The faces to be split.
391 * \param the13Diag Is used to choose a diagonal for splitting.
392 * \return TRUE in case of success, FALSE otherwise.
394 boolean SplitQuad (in smIdType_array IDsOfElements,
395 in boolean Diag13) raises (SALOME::SALOME_Exception);
397 * \brief Split quadrangles into triangles.
399 * Behaves like the above method, taking list of elements from \a theObject
401 boolean SplitQuadObject (in SMESH_IDSource theObject,
402 in boolean Diag13) raises (SALOME::SALOME_Exception);
405 * Find better splitting of the given quadrangle.
406 * \param IDOfQuad ID of the quadrangle to be split.
407 * \param Criterion A criterion to choose a diagonal for splitting.
408 * \return 1 if 1-3 diagonal is better, 2 if 2-4
409 * diagonal is better, 0 if error occurs.
411 long BestSplit (in long IDOfQuad,
412 in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
415 * \brief Split volumic elements into tetrahedrons
416 * \param elems - elements to split
417 * \param methodFlags - flags passing splitting method:
418 * 1 - split the hexahedron into 5 tetrahedrons
419 * 2 - split the hexahedron into 6 tetrahedrons
420 * 3 - split the hexahedron into 24 tetrahedrons
422 void SplitVolumesIntoTetra(in SMESH_IDSource elems, in short methodFlags)
423 raises (SALOME::SALOME_Exception);
426 * \brief Split hexahedra into triangular prisms
427 * \param elems - elements to split
428 * \param startHexPoint - a point used to find a hexahedron for which \a facetToSplitNormal
429 * gives a normal vector defining facets to split into triangles.
430 * \param facetToSplitNormal - normal used to find a facet of hexahedron
431 * to split into triangles.
432 * \param methodFlags - flags passing splitting method:
433 * 1 - split the hexahedron into 2 prisms
434 * 2 - split the hexahedron into 4 prisms
435 * \param allDomains - if \c False, only hexahedra adjacent to one closest
436 * to \a facetToSplitNormal location are split, else \a facetToSplitNormal
437 * is used to find the facet to split in all domains present in \a elems.
439 void SplitHexahedraIntoPrisms(in SMESH_IDSource elems,
440 in SMESH::PointStruct startHexPoint,
441 in SMESH::DirStruct facetToSplitNormal,
442 in short methodFlags,
443 in boolean allDomains)
444 raises (SALOME::SALOME_Exception);
447 * \brief Split bi-quadratic elements into linear ones without creation of additional nodes.
448 * - bi-quadratic triangle will be split into 3 linear quadrangles;
449 * - bi-quadratic quadrangle will be split into 4 linear quadrangles;
450 * - tri-quadratic hexahedron will be split into 8 linear hexahedra;
451 * Quadratic elements of lower dimension adjacent to the split bi-quadratic element
452 * will be split in order to keep the mesh conformal.
453 * \param elems - elements to split
455 void SplitBiQuadraticIntoLinear(in ListOfIDSources elems)
456 raises (SALOME::SALOME_Exception);
459 enum Smooth_Method { LAPLACIAN_SMOOTH, CENTROIDAL_SMOOTH };
461 boolean Smooth(in smIdType_array IDsOfElements,
462 in smIdType_array IDsOfFixedNodes,
463 in short MaxNbOfIterations,
464 in double MaxAspectRatio,
465 in Smooth_Method Method) raises (SALOME::SALOME_Exception);
467 boolean SmoothObject(in SMESH_IDSource theObject,
468 in smIdType_array IDsOfFixedNodes,
469 in short MaxNbOfIterations,
470 in double MaxAspectRatio,
471 in Smooth_Method Method) raises (SALOME::SALOME_Exception);
473 boolean SmoothParametric(in smIdType_array IDsOfElements,
474 in smIdType_array IDsOfFixedNodes,
475 in short MaxNbOfIterations,
476 in double MaxAspectRatio,
477 in Smooth_Method Method) raises (SALOME::SALOME_Exception);
479 boolean SmoothParametricObject(in SMESH_IDSource theObject,
480 in smIdType_array IDsOfFixedNodes,
481 in short MaxNbOfIterations,
482 in double MaxAspectRatio,
483 in Smooth_Method Method) raises (SALOME::SALOME_Exception);
485 void ConvertToQuadratic(in boolean theForce3d)
486 raises (SALOME::SALOME_Exception);
487 void ConvertToQuadraticObject(in boolean theForce3d,
488 in SMESH_IDSource theObject)
489 raises (SALOME::SALOME_Exception);
491 boolean ConvertFromQuadratic()
492 raises (SALOME::SALOME_Exception);
493 void ConvertFromQuadraticObject(in SMESH_IDSource theObject)
494 raises (SALOME::SALOME_Exception);
496 void ConvertToBiQuadratic(in boolean theForce3d,
497 in SMESH_IDSource theObject)
498 raises (SALOME::SALOME_Exception);
500 void RenumberNodes() raises (SALOME::SALOME_Exception);
502 void RenumberElements() raises (SALOME::SALOME_Exception);
505 * \brief Generate dim+1 elements by rotation of the object around axis
506 * \param Nodes - nodes to revolve: a list including groups, sub-meshes or a mesh
507 * \param Edges - edges to revolve: a list including groups, sub-meshes or a mesh
508 * \param Faces - faces to revolve: a list including groups, sub-meshes or a mesh
509 * \param Axis - rotation axis
510 * \param AngleInRadians - rotation angle
511 * \param NbOfSteps - number of elements to generate from one element
512 * \param ToMakeGroups - if true, new elements will be included into new groups
513 * corresponding to groups the input elements included in.
514 * \return ListOfGroups - new groups created if \a ToMakeGroups is true
516 ListOfGroups RotationSweepObjects(in ListOfIDSources Nodes,
517 in ListOfIDSources Edges,
518 in ListOfIDSources Faces,
520 in double AngleInRadians,
523 in boolean ToMakeGroups)
524 raises (SALOME::SALOME_Exception);
527 * \brief Generate dim+1 elements by extrusion of elements along vector
528 * \param nodes - nodes to extrude: a list including groups, sub-meshes or a mesh.
529 * \param edges - edges to extrude: a list including groups, sub-meshes or a mesh.
530 * \param faces - faces to extrude: a list including groups, sub-meshes or a mesh.
531 * \param stepVector - vector giving direction and distance of an extrusion step.
532 * \param nbOfSteps - number of elements to generate from one element.
533 * \param toMakeGroups - if true, new elements will be included into new groups
534 * corresponding to groups the input elements included in.
535 * \param scaleFactors - optional scale factors to apply during extrusion; it's
536 * usage depends on \a scalesVariation parameter.
537 * \param scalesVariation - if \c True, \a scaleFactors are spread over all \a NbOfSteps,
538 otherwise \a scaleFactors[i] is applied to nodes at the i-th extrusion step.
539 * \param angles - optional rotation angles to apply during extrusion; it's
540 * usage depends on \a anglesVariation parameter.
541 * \param anglesVariation - if \c True, \a angles are spread over all \a NbOfSteps,
542 otherwise \a angle[i] is applied to nodes at the i-th extrusion step.
543 * \return ListOfGroups - new groups created if \a toMakeGroups is true
545 ListOfGroups ExtrusionSweepObjects(in ListOfIDSources nodes,
546 in ListOfIDSources edges,
547 in ListOfIDSources faces,
548 in DirStruct stepVector,
550 in boolean toMakeGroups,
551 in double_array scaleFactors,
552 in boolean scaleVariation,
553 in double_array basePoint,
554 in double_array angles,
555 in boolean angleVariation)
556 raises (SALOME::SALOME_Exception);
558 /*! Generates new elements by extrusion along the normal to a discretized surface or wire
560 ListOfGroups ExtrusionByNormal(in ListOfIDSources theObjects,
563 in boolean byAverageNormal,
564 in boolean useInputElemsOnly,
565 in boolean makeGroups,
567 raises (SALOME::SALOME_Exception);
570 * Generate new elements by extrusion of theElements
571 * by StepVector by NbOfSteps
572 * \param ExtrFlags set flags for performing extrusion
573 * \param SewTolerance - uses for comparing locations of nodes if flag
574 * EXTRUSION_FLAG_SEW is set
575 * \param ToMakeGroups - if true, new elements will be included into new groups
576 * corresponding to groups the input elements included in.
577 * \return ListOfGroups - new groups created if \a ToMakeGroups is true
579 ListOfGroups AdvancedExtrusion(in smIdType_array IDsOfElements,
580 in DirStruct StepVector,
583 in double SewTolerance,
584 in boolean ToMakeGroups)
585 raises (SALOME::SALOME_Exception);
587 enum Extrusion_Error {
592 EXTR_BAD_STARTING_NODE,
593 EXTR_BAD_ANGLES_NUMBER,
594 EXTR_CANT_GET_TANGENT
597 ListOfGroups ExtrusionAlongPathObjects(in ListOfIDSources Nodes,
598 in ListOfIDSources Edges,
599 in ListOfIDSources Faces,
600 in SMESH_IDSource Path,
601 in GEOM::GEOM_Object PathShape,
602 in smIdType NodeStart,
603 in boolean HasAngles,
604 in double_array Angles,
605 in boolean AnglesVariation,
606 in boolean HasRefPoint,
607 in PointStruct RefPoint,
608 in boolean MakeGroups,
609 in double_array ScaleFactors,
610 in boolean ScaleVariation,
611 out Extrusion_Error Error)
612 raises (SALOME::SALOME_Exception);
615 * Compute rotation angles for ExtrusionAlongPath as linear variation
616 * of given angles along path steps
617 * param PathMesh mesh containing a 1D sub-mesh on the edge, along
618 * which proceeds the extrusion
619 * param PathShape is shape(edge); as the mesh can be complex, the edge
620 * is used to define the sub-mesh for the path
622 double_array LinearAnglesVariation(in SMESH_Mesh PathMesh,
623 in GEOM::GEOM_Object PathShape,
624 in double_array Angles);
626 enum MirrorType { POINT, AXIS, PLANE };
628 void Mirror (in smIdType_array IDsOfElements,
629 in AxisStruct Mirror,
632 raises (SALOME::SALOME_Exception);
633 ListOfGroups MirrorMakeGroups (in smIdType_array IDsOfElements,
634 in AxisStruct Mirror,
636 raises (SALOME::SALOME_Exception);
637 SMESH_Mesh MirrorMakeMesh (in smIdType_array IDsOfElements,
638 in AxisStruct Mirror,
640 in boolean CopyGroups,
642 raises (SALOME::SALOME_Exception);
644 void MirrorObject (in SMESH_IDSource theObject,
645 in AxisStruct Mirror,
648 raises (SALOME::SALOME_Exception);
649 ListOfGroups MirrorObjectMakeGroups (in SMESH_IDSource theObject,
650 in AxisStruct Mirror,
652 raises (SALOME::SALOME_Exception);
653 SMESH_Mesh MirrorObjectMakeMesh (in SMESH_IDSource theObject,
654 in AxisStruct Mirror,
656 in boolean CopyGroups,
658 raises (SALOME::SALOME_Exception);
660 void Translate (in smIdType_array IDsOfElements,
663 raises (SALOME::SALOME_Exception);
664 ListOfGroups TranslateMakeGroups (in smIdType_array IDsOfElements,
666 raises (SALOME::SALOME_Exception);
667 SMESH_Mesh TranslateMakeMesh (in smIdType_array IDsOfElements,
669 in boolean CopyGroups,
671 raises (SALOME::SALOME_Exception);
673 void TranslateObject (in SMESH_IDSource theObject,
676 raises (SALOME::SALOME_Exception);
677 ListOfGroups TranslateObjectMakeGroups (in SMESH_IDSource theObject,
679 raises (SALOME::SALOME_Exception);
680 SMESH_Mesh TranslateObjectMakeMesh (in SMESH_IDSource theObject,
682 in boolean CopyGroups,
684 raises (SALOME::SALOME_Exception);
686 void Scale (in SMESH_IDSource theObject,
687 in PointStruct thePoint,
688 in double_array theScaleFact,
690 raises (SALOME::SALOME_Exception);
691 ListOfGroups ScaleMakeGroups (in SMESH_IDSource theObject,
692 in PointStruct thePoint,
693 in double_array theScaleFact)
694 raises (SALOME::SALOME_Exception);
695 SMESH_Mesh ScaleMakeMesh (in SMESH_IDSource theObject,
696 in PointStruct thePoint,
697 in double_array theScaleFact,
698 in boolean CopyGroups,
700 raises (SALOME::SALOME_Exception);
702 void Rotate (in smIdType_array IDsOfElements,
704 in double AngleInRadians,
706 raises (SALOME::SALOME_Exception);
707 ListOfGroups RotateMakeGroups (in smIdType_array IDsOfElements,
709 in double AngleInRadians)
710 raises (SALOME::SALOME_Exception);
711 SMESH_Mesh RotateMakeMesh (in smIdType_array IDsOfElements,
713 in double AngleInRadians,
714 in boolean CopyGroups,
716 raises (SALOME::SALOME_Exception);
718 void RotateObject (in SMESH_IDSource theObject,
720 in double AngleInRadians,
722 raises (SALOME::SALOME_Exception);
723 ListOfGroups RotateObjectMakeGroups (in SMESH_IDSource theObject,
725 in double AngleInRadians)
726 raises (SALOME::SALOME_Exception);
727 SMESH_Mesh RotateObjectMakeMesh (in SMESH_IDSource theObject,
729 in double AngleInRadians,
730 in boolean CopyGroups,
732 raises (SALOME::SALOME_Exception);
734 SMESH_Mesh Offset(in SMESH_IDSource theObject,
736 in boolean CopyGroups,
737 in boolean CopyElements,
739 out ListOfGroups Groups)
740 raises (SALOME::SALOME_Exception);
742 void FindCoincidentNodes (in double Tolerance,
743 out array_of_long_array GroupsOfNodes,
744 in boolean SeparateCornersAndMedium)
745 raises (SALOME::SALOME_Exception);
747 void FindCoincidentNodesOnPart (in SMESH_IDSource SubMeshOrGroup,
749 out array_of_long_array GroupsOfNodes,
750 in boolean SeparateCornersAndMedium)
751 raises (SALOME::SALOME_Exception);
753 void FindCoincidentNodesOnPartBut (in ListOfIDSources SubMeshOrGroup,
755 out array_of_long_array GroupsOfNodes,
756 in ListOfIDSources ExceptSubMeshOrGroups,
757 in boolean SeparateCornersAndMedium)
758 raises (SALOME::SALOME_Exception);
760 void MergeNodes (in array_of_long_array GroupsOfNodes,
761 in SMESH::ListOfIDSources NodesToKeep,
762 in boolean AvoidMakingHoles)
763 raises (SALOME::SALOME_Exception);
766 * \brief Find elements built on the same nodes.
767 * \param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching.
768 * \return List of groups of equal elements.
770 void FindEqualElements (in ListOfIDSources MeshOrSubMeshOrGroup,
771 in ListOfIDSources ExceptSubMeshOrGroups,
772 out array_of_long_array GroupsOfElementsID)
773 raises (SALOME::SALOME_Exception);
776 * \brief Merge elements in each given group.
777 * \param GroupsOfElementsID Groups of elements for merging.
779 void MergeElements(in array_of_long_array GroupsOfElementsID,
780 in SMESH::ListOfIDSources ElementsToKeep)
781 raises (SALOME::SALOME_Exception);
784 * \brief Merge equal elements in the whole mesh.
786 void MergeEqualElements()
787 raises (SALOME::SALOME_Exception);
790 * If the given ID is a valid node ID (nodeID > 0), just move this node, else
791 * move the node closest to the point to point's location and return ID of the node
793 smIdType MoveClosestNodeToPoint(in double x, in double y, in double z, in smIdType nodeID)
794 raises (SALOME::SALOME_Exception);
797 * Return ID of node closest to a given point
799 smIdType FindNodeClosestTo(in double x, in double y, in double z)
800 raises (SALOME::SALOME_Exception);
803 * Return elements of given type where the given point is IN or ON.
805 * 'ALL' type means elements of any type excluding nodes and 0D elements
807 smIdType_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type)
808 raises (SALOME::SALOME_Exception);
811 * Searching among the given elements, return elements of given type
812 * where the given point is IN or ON.
814 * 'ALL' type means elements of any type excluding nodes and 0D elements
816 smIdType_array FindAmongElementsByPoint(in SMESH_IDSource elements,
817 in double x, in double y, in double z,
819 raises (SALOME::SALOME_Exception);
822 * Project a point to a mesh object.
823 * Return ID of an element of given type where the given point is projected
824 * and coordinates of the projection point.
825 * In the case if nothing found, return -1 and []
827 smIdType ProjectPoint(in double x,
831 in SMESH_IDSource meshObject,
832 out double_array projecton)
833 raises (SALOME::SALOME_Exception);
836 * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
837 * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
839 short GetPointState(in double x, in double y, in double z)
840 raises (SALOME::SALOME_Exception);
843 * Check if a 2D mesh is manifold
846 raises (SALOME::SALOME_Exception);
849 * Check if orientation of 2D elements is coherent
851 boolean IsCoherentOrientation2D()
852 raises (SALOME::SALOME_Exception);
855 * Partition given 1D elements into groups of contiguous edges.
856 * A node where number of meeting edges != 2 is a group end.
857 * An optional startNode is used to orient groups it belongs to.
858 * \return a list of edge groups and a list of corresponding node groups.
859 * If a group is closed, the first and last nodes of the group are same.
861 array_of_long_array Get1DBranches( in SMESH_IDSource edges,
862 in smIdType startNode,
863 out array_of_long_array nodeGroups)
864 raises (SALOME::SALOME_Exception);
867 * Return sharp edges of faces and non-manifold ones.
868 * Optionally add existing edges. Angle is in degrees.
870 ListOfEdges FindSharpEdges(in double angle, in boolean addExistingEdges)
871 raises (SALOME::SALOME_Exception);
874 * Returns all or only closed FreeBorder's.
876 ListOfFreeBorders FindFreeBorders(in boolean closedOnly)
877 raises (SALOME::SALOME_Exception);
880 * Fill with 2D elements a hole defined by a FreeBorder.
881 * Optionally add new faces to a given group, which is returned.
883 SMESH_Group FillHole(in FreeBorder hole, in string groupName)
884 raises (SALOME::SALOME_Exception);
887 * Returns groups of FreeBorder's coincident within the given tolerance.
888 * If the tolerance <= 0.0 then one tenth of an average size of elements adjacent
889 * to free borders being compared is used.
891 CoincidentFreeBorders FindCoincidentFreeBorders(in double tolerance);
894 * Sew FreeBorder's of each group
896 short SewCoincidentFreeBorders (in CoincidentFreeBorders freeBorders,
897 in boolean createPolygons,
898 in boolean createPolyedrs)
899 raises (SALOME::SALOME_Exception);
903 SEW_BORDER1_NOT_FOUND,
904 SEW_BORDER2_NOT_FOUND,
905 SEW_BOTH_BORDERS_NOT_FOUND,
907 SEW_VOLUMES_TO_SPLIT,
908 // for SewSideElements() only:
909 SEW_DIFF_NB_OF_ELEMENTS,
910 SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
916 Sew_Error SewFreeBorders (in smIdType FirstNodeID1,
917 in smIdType SecondNodeID1,
918 in smIdType LastNodeID1,
919 in smIdType FirstNodeID2,
920 in smIdType SecondNodeID2,
921 in smIdType LastNodeID2,
922 in boolean CreatePolygons,
923 in boolean CreatePolyedrs)
924 raises (SALOME::SALOME_Exception);
926 Sew_Error SewConformFreeBorders (in smIdType FirstNodeID1,
927 in smIdType SecondNodeID1,
928 in smIdType LastNodeID1,
929 in smIdType FirstNodeID2,
930 in smIdType SecondNodeID2)
931 raises (SALOME::SALOME_Exception);
933 Sew_Error SewBorderToSide (in smIdType FirstNodeIDOnFreeBorder,
934 in smIdType SecondNodeIDOnFreeBorder,
935 in smIdType LastNodeIDOnFreeBorder,
936 in smIdType FirstNodeIDOnSide,
937 in smIdType LastNodeIDOnSide,
938 in boolean CreatePolygons,
939 in boolean CreatePolyedrs)
940 raises (SALOME::SALOME_Exception);
942 Sew_Error SewSideElements (in smIdType_array IDsOfSide1Elements,
943 in smIdType_array IDsOfSide2Elements,
944 in smIdType NodeID1OfSide1ToMerge,
945 in smIdType NodeID1OfSide2ToMerge,
946 in smIdType NodeID2OfSide1ToMerge,
947 in smIdType NodeID2OfSide2ToMerge)
948 raises (SALOME::SALOME_Exception);
951 * Set new nodes for given element.
952 * If number of nodes is not corresponded to type of
953 * element - returns false
955 boolean ChangeElemNodes(in smIdType id, in smIdType_array newIDs)
956 raises (SALOME::SALOME_Exception);
959 * \brief Duplicates given elements, i.e. creates new elements based on the
960 * same nodes as the given ones.
961 * \param theElements - container of elements to duplicate.
962 * \param theGroupName - a name of group to contain the generated elements.
963 * If a group with such a name already exists, the new elements
964 * are added to the existing group, else a new group is created.
965 * If \a theGroupName is empty, new elements are not added
967 * \return a group where the new elements are added. NULL if theGroupName == "".
970 SMESH_Group DoubleElements( in SMESH_IDSource theElements,
971 in string theGroupName )
972 raises (SALOME::SALOME_Exception);
975 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
976 * \param theNodes - identifiers of nodes to be doubled
977 * \param theModifiedElems - identifiers of elements to be updated by the new (doubled)
978 * nodes. If list of element identifiers is empty then nodes are doubled but
979 * they not assigned to elements
980 * \return TRUE if operation has been completed successfully, FALSE otherwise
981 * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
983 boolean DoubleNodes( in smIdType_array theNodes, in smIdType_array theModifiedElems )
984 raises (SALOME::SALOME_Exception);
987 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
988 * This method provided for convenience works as DoubleNodes() described above.
989 * \param theNodeId - identifier of node to be doubled.
990 * \param theModifiedElems - identifiers of elements to be updated.
991 * \return TRUE if operation has been completed successfully, FALSE otherwise
992 * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
994 boolean DoubleNode( in smIdType theNodeId, in smIdType_array theModifiedElems )
995 raises (SALOME::SALOME_Exception);
998 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
999 * This method provided for convenience works as DoubleNodes() described above.
1000 * \param theNodes - group of nodes to be doubled.
1001 * \param theModifiedElems - group of elements to be updated.
1002 * \return TRUE if operation has been completed successfully, FALSE otherwise
1003 * \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew()
1005 boolean DoubleNodeGroup( in SMESH_GroupBase theNodes,
1006 in SMESH_GroupBase theModifiedElems )
1007 raises (SALOME::SALOME_Exception);
1009 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1010 * Works as DoubleNodeGroup() described above, but returns a new group with
1011 * newly created nodes.
1012 * \param theNodes - group of nodes to be doubled.
1013 * \param theModifiedElems - group of elements to be updated.
1014 * \return a new group with newly created nodes
1015 * \sa DoubleNodeGroup()
1017 SMESH_Group DoubleNodeGroupNew( in SMESH_GroupBase theNodes,
1018 in SMESH_GroupBase theModifiedElems )
1019 raises (SALOME::SALOME_Exception);
1022 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1023 * This method provided for convenience works as DoubleNodes() described above.
1024 * \param theNodes - list of groups of nodes to be doubled
1025 * \param theModifiedElems - list of groups of elements to be updated.
1026 * \return TRUE if operation has been completed successfully, FALSE otherwise
1027 * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
1029 boolean DoubleNodeGroups( in ListOfGroups theNodes,
1030 in ListOfGroups theModifiedElems )
1031 raises (SALOME::SALOME_Exception);
1033 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1034 * Works as DoubleNodeGroups() described above, but returns a new group with
1035 * newly created nodes.
1036 * \param theNodes - list of groups of nodes to be doubled
1037 * \param theModifiedElems - list of groups of elements to be updated.
1038 * \return a new group with newly created nodes
1039 * \sa DoubleNodeGroups()
1041 SMESH_Group DoubleNodeGroupsNew( in ListOfGroups theNodes,
1042 in ListOfGroups theModifiedElems )
1043 raises (SALOME::SALOME_Exception);
1046 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1047 * \param theElems - the list of elements (edges or faces) to be replicated
1048 * The nodes for duplication could be found from these elements
1049 * \param theNodesNot - list of nodes to NOT replicate
1050 * \param theAffectedElems - the list of elements (cells and edges) to which the
1051 * replicated nodes should be associated to.
1052 * \return TRUE if operation has been completed successfully, FALSE otherwise
1053 * \sa DoubleNodeGroup(), DoubleNodeGroups()
1055 boolean DoubleNodeElem( in smIdType_array theElems,
1056 in smIdType_array theNodesNot,
1057 in smIdType_array theAffectedElems )
1058 raises (SALOME::SALOME_Exception);
1061 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1062 * \param theElems - the list of elements (edges or faces) to be replicated
1063 * The nodes for duplication could be found from these elements
1064 * \param theNodesNot - list of nodes to NOT replicate
1065 * \param theShape - shape to detect affected elements (element which geometric center
1066 * located on or inside shape).
1067 * The replicated nodes should be associated to affected elements.
1068 * \return TRUE if operation has been completed successfully, FALSE otherwise
1069 * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
1071 boolean DoubleNodeElemInRegion( in smIdType_array theElems,
1072 in smIdType_array theNodesNot,
1073 in GEOM::GEOM_Object theShape )
1074 raises (SALOME::SALOME_Exception);
1077 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1078 * This method provided for convenience works as DoubleNodes() described above.
1079 * \param theElems - group of of elements (edges or faces) to be replicated
1080 * \param theNodesNot - group of nodes not to replicated
1081 * \param theAffectedElems - group of elements to which the replicated nodes
1082 * should be associated to.
1083 * \return TRUE if operation has been completed successfully, FALSE otherwise
1084 * \sa DoubleNodes(), DoubleNodeGroups(), DoubleNodeElemGroupNew()
1086 boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems,
1087 in SMESH_GroupBase theNodesNot,
1088 in SMESH_GroupBase theAffectedElems )
1089 raises (SALOME::SALOME_Exception);
1091 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1092 * Works as DoubleNodeElemGroup() described above, but returns a new group with
1093 * newly created elements.
1094 * \param theElems - group of of elements (edges or faces) to be replicated
1095 * \param theNodesNot - group of nodes not to replicated
1096 * \param theAffectedElems - group of elements to which the replicated nodes
1097 * should be associated to.
1098 * \return a new group with newly created elements
1099 * \sa DoubleNodeElemGroup()
1101 SMESH_Group DoubleNodeElemGroupNew( in SMESH_GroupBase theElems,
1102 in SMESH_GroupBase theNodesNot,
1103 in SMESH_GroupBase theAffectedElems )
1104 raises (SALOME::SALOME_Exception);
1106 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1107 * Works as DoubleNodeElemGroup() described above, but returns two new groups:
1108 * a group of newly created elements and a group of newly created nodes
1109 * \param theElems - group of of elements (edges or faces) to be replicated
1110 * \param theNodesNot - group of nodes not to replicated
1111 * \param theAffectedElems - group of elements to which the replicated nodes
1112 * should be associated to.
1113 * \param theElemGroupNeeded - to create group of new elements or not
1114 * \param theNodeGroupNeeded - to create group of new nodes or not
1115 * \return two new groups of newly created elements (1st) and nodes (2nd)
1116 * \sa DoubleNodeElemGroup()
1118 ListOfGroups DoubleNodeElemGroup2New( in SMESH_GroupBase theElems,
1119 in SMESH_GroupBase theNodesNot,
1120 in SMESH_GroupBase theAffectedElems,
1121 in boolean theElemGroupNeeded,
1122 in boolean theNodeGroupNeeded)
1123 raises (SALOME::SALOME_Exception);
1126 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1127 * This method provided for convenience works as DoubleNodes() described above.
1128 * \param theElems - group of elements (edges or faces) to be replicated
1129 * \param theNodesNot - group of nodes not to replicated
1130 * \param theShape - shape to detect affected elements (element which geometric center
1131 * located on or inside shape).
1132 * The replicated nodes should be associated to affected elements.
1133 * \return TRUE if operation has been completed successfully, FALSE otherwise
1134 * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
1136 boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems,
1137 in SMESH_GroupBase theNodesNot,
1138 in GEOM::GEOM_Object theShape )
1139 raises (SALOME::SALOME_Exception);
1142 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1143 * This method provided for convenience works as DoubleNodes() described above.
1144 * \param theElems - list of groups of elements (edges or faces) to be replicated
1145 * \param theNodesNot - list of groups of nodes not to replicated
1146 * \param theAffectedElems - group of elements to which the replicated nodes
1147 * should be associated to.
1148 * \return TRUE if operation has been completed successfully, FALSE otherwise
1149 * \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
1151 boolean DoubleNodeElemGroups( in ListOfGroups theElems,
1152 in ListOfGroups theNodesNot,
1153 in ListOfGroups theAffectedElems )
1154 raises (SALOME::SALOME_Exception);
1156 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1157 * Works as DoubleNodeElemGroups() described above, but returns a new group with
1158 * newly created elements.
1159 * \param theElems - list of groups of elements (edges or faces) to be replicated
1160 * \param theNodesNot - list of groups of nodes not to replicated
1161 * \param theAffectedElems - group of elements to which the replicated nodes
1162 * should be associated to.
1163 * \return a new group with newly created elements
1164 * \sa DoubleNodeElemGroups()
1166 SMESH_Group DoubleNodeElemGroupsNew( in ListOfGroups theElems,
1167 in ListOfGroups theNodesNot,
1168 in ListOfGroups theAffectedElems )
1169 raises (SALOME::SALOME_Exception);
1171 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1172 * Works as DoubleNodeElemGroups() described above, but returns two new groups:
1173 * a group of newly created elements and a group of newly created nodes.
1174 * \param theElems - list of groups of elements (edges or faces) to be replicated
1175 * \param theNodesNot - list of groups of nodes not to replicated
1176 * \param theAffectedElems - group of elements to which the replicated nodes
1177 * should be associated to.
1178 * \param theElemGroupNeeded - to create group of new elements or not
1179 * \param theNodeGroupNeeded - to create group of new nodes or not
1180 * \return two new groups of newly created elements (1st) and nodes (2nd)
1181 * \sa DoubleNodeElemGroups()
1183 ListOfGroups DoubleNodeElemGroups2New( in ListOfGroups theElems,
1184 in ListOfGroups theNodesNot,
1185 in ListOfGroups theAffectedElems,
1186 in boolean theElemGroupNeeded,
1187 in boolean theNodeGroupNeeded )
1188 raises (SALOME::SALOME_Exception);
1191 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1192 * This method provided for convenience works as DoubleNodes() described above.
1193 * \param theElems - list of groups of elements (edges or faces) to be replicated
1194 * \param theNodesNot - list of groups of nodes not to replicated
1195 * \param theShape - shape to detect affected elements (element which geometric center
1196 * located on or inside shape).
1197 * The replicated nodes should be associated to affected elements.
1198 * \return TRUE if operation has been completed successfully, FALSE otherwise
1199 * \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
1201 boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
1202 in ListOfGroups theNodesNot,
1203 in GEOM::GEOM_Object theShape )
1204 raises (SALOME::SALOME_Exception);
1207 * \brief Identify the elements that will be affected by node duplication (actual duplication is not performed).
1208 * This method is the first step of DoubleNodeElemGroupsInRegion.
1209 * \param theElems - list of groups of elements (edges or faces) to be replicated
1210 * \param theNodesNot - list of groups of nodes not to replicated
1211 * \param theShape - shape to detect affected elements (element which geometric center
1212 * located on or inside shape).
1213 * The replicated nodes should be associated to affected elements.
1214 * \return groups of affected elements
1215 * \sa DoubleNodeElemGroupsInRegion()
1217 ListOfGroups AffectedElemGroupsInRegion( in ListOfGroups theElems,
1218 in ListOfGroups theNodesNot,
1219 in GEOM::GEOM_Object theShape )
1220 raises (SALOME::SALOME_Exception);
1223 * \brief Generates skin mesh (containing 2D cells) from 3D mesh
1224 * The created 2D mesh elements based on nodes of free faces of boundary volumes
1225 * \return TRUE if operation has been completed successfully, FALSE otherwise
1227 boolean Make2DMeshFrom3D() raises (SALOME::SALOME_Exception);
1230 * \brief Creates missing boundary elements
1231 * \param elements - elements whose boundary is to be checked
1232 * \param dimension - defines type of boundary elements to create
1233 * BND_1DFROM3D creates mesh edges on all borders of free facets of 3D elements.
1234 * \param groupName - a name of group to store created boundary elements in,
1235 * "" means not to create the group
1236 * \param meshName - a name of new mesh to store created boundary elements in,
1237 * "" means not to create the new mesh
1238 * \param toCopyElements - if true, the checked elements will be copied into the new mesh
1239 * else only boundary elements will be copied into the new mesh
1240 * \param toCopyExistingBondary - if true, not only new but also pre-existing
1241 * boundary elements will be copied into the new mesh
1242 * \param group - returns the create group, if any
1243 * \retval SMESH::SMESH_Mesh - the mesh where elements were added to
1245 SMESH_Mesh MakeBoundaryMesh(in SMESH_IDSource elements,
1246 in Bnd_Dimension dimension,
1247 in string groupName,
1249 in boolean toCopyElements,
1250 in boolean toCopyExistingBondary,
1251 out SMESH_Group group) raises (SALOME::SALOME_Exception);
1253 * \brief Creates missing boundary elements around either the whole mesh or
1254 * groups of 2D elements
1255 * \param dimension - defines type of boundary elements to create
1256 * \param groupName - a name of group to store all boundary elements in,
1257 * "" means not to create the group
1258 * \param meshName - a name of a new mesh, which is a copy of the initial
1259 * mesh + created boundary elements; "" means not to create the new mesh
1260 * \param toCopyAll - if true, the whole initial mesh will be copied into
1261 * the new mesh else only boundary elements will be copied into the new mesh
1262 * \param groups - optional groups of 2D elements to make boundary around
1263 * \param mesh - returns the mesh where elements were added to
1264 * \param group - returns the created group, if any
1265 * \retval long - number of added boundary elements
1267 long MakeBoundaryElements(in Bnd_Dimension dimension,
1268 in string groupName,
1270 in boolean toCopyAll,
1271 in ListOfIDSources groups,
1272 out SMESH_Mesh mesh,
1273 out SMESH_Group group) raises (SALOME::SALOME_Exception);
1276 * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
1277 * Flat elements are mainly used by some types of mechanic calculations.
1279 * The list of groups must describe a partition of the mesh volumes.
1280 * The nodes of the internal faces at the boundaries of the groups are doubled.
1281 * In option, the internal faces are replaced by flat elements.
1282 * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1283 * \param theDomains - list of groups of volumes
1284 * \param createJointElems - if TRUE, create the elements
1285 * \param onAllBoundaries - if TRUE, the nodes and elements are also created on
1286 * the boundary between \a theDomains and the rest mesh
1287 * \return TRUE if operation has been completed successfully, FALSE otherwise
1289 boolean DoubleNodesOnGroupBoundaries( in ListOfGroups theDomains,
1290 in boolean createJointElems,
1291 in boolean onAllBoundaries)
1292 raises (SALOME::SALOME_Exception);
1295 * \brief Double nodes on some external faces and create flat elements.
1296 * Flat elements are mainly used by some types of mechanic calculations.
1298 * Each group of the list must be constituted of faces.
1299 * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1300 * \param theGroupsOfFaces - list of groups of faces
1301 * \return TRUE if operation has been completed successfully, FALSE otherwise
1303 boolean CreateFlatElementsOnFacesGroups( in ListOfGroups theGroupsOfFaces )
1304 raises (SALOME::SALOME_Exception);
1307 * \brief identify all the elements around a geom shape, get the faces delimiting the hole
1308 * Build groups of volume to remove, groups of faces to replace on the skin of the object,
1309 * groups of faces to remove insidethe object, (idem edges).
1310 * Build ordered list of nodes at the border of each group of faces to replace (to be used to build a geom subshape)
1312 void CreateHoleSkin(in double radius,
1313 in GEOM::GEOM_Object theShape,
1314 in string groupName,
1315 in double_array theNodesCoords,
1316 out array_of_long_array GroupsOfNodes)
1317 raises (SALOME::SALOME_Exception);
1321 * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
1322 * the initial triangle mesh. Positions of new nodes are found by cutting the mesh by
1323 * the plane passing through pairs of points specified by each PolySegment structure.
1324 * If there are several paths connecting a pair of points, the shortest path is
1325 * selected by the module. Position of the cutting plane is defined by the two
1326 * points and an optional vector lying on the plane specified by a PolySegment.
1327 * By default the vector is defined by Mesh module as following. A middle point
1328 * of the two given points is computed. The middle point is projected to the mesh.
1329 * The vector goes from the middle point to the projection point. In case of planar
1330 * mesh, the vector is normal to the mesh.
1331 * \param [inout] segments - PolySegment's defining positions of cutting planes.
1332 * Return the used vector which goes from the middle point to its projection.
1333 * \param [in] groupName - optional name of a group where created mesh segments will
1336 void MakePolyLine(inout ListOfPolySegments segments,
1337 in string groupName)
1338 raises (SALOME::SALOME_Exception);
1341 * \brief Create a slot of given width around given 1D elements lying on a triangle mesh.
1342 * The slot is constructed by cutting faces by cylindrical surfaces made
1343 * around each segment. Segments are expected to be created by MakePolyLine().
1344 * \return Edges located at the slot boundary
1346 ListOfEdges MakeSlot( in SMESH_GroupBase segments,
1348 raises (SALOME::SALOME_Exception);