1 // Copyright (C) 2007-2019 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"
32 interface NumericalFunctor;
34 enum Bnd_Dimension { BND_2DFROM3D, BND_1DFROM3D, BND_1DFROM2D };
39 SMESH::long_array nodeIDs; // all nodes defining a free border
40 // 1st and last node is same in a closed border
44 short border; // border index within a sequence<FreeBorder>
45 long node1; // node index within the border-th FreeBorder
49 typedef sequence<FreeBorder> ListOfFreeBorders;
50 typedef sequence<FreeBorderPart> FreeBordersGroup;
51 typedef sequence<FreeBordersGroup> ListOfFreeBorderGroups;
53 struct CoincidentFreeBorders
55 ListOfFreeBorders borders; // nodes of all free borders
56 ListOfFreeBorderGroups coincidentGroups; // groups of coincident parts of borders
60 // structure used in MakePolyLine() to define a cutting plane
63 // a point is defined as follows:
64 // ( node*ID1 > 0 && node*ID2 > 0 ) ==> point is in the middle of an edge defined by two nodes
65 // ( node*ID1 > 0 && node*ID2 <=0 ) ==> point is at node*ID1
66 // else ==> point is at xyz*
78 // vector on the plane; to use a default plane set vector = (0,0,0)
81 typedef sequence<PolySegment> ListOfPolySegments;
83 // face edge defined by two nodes + optional medium node
90 typedef sequence<FaceEdge> ListOfEdges;
94 * This interface makes modifications on the Mesh - removing elements and nodes etc.
95 * Also provides some analysis functions.
97 interface SMESH_MeshEditor
100 * Returns a mesh subject to edition
102 SMESH_Mesh GetMesh();
105 * Return data of mesh edition preview which is computed provided
106 * that the editor was obtained through SMESH_Mesh::GetMeshEditPreviewer()
108 MeshPreviewStruct GetPreviewData() raises (SALOME::SALOME_Exception);
111 * If during last operation of MeshEditor some nodes were
112 * created, this method returns list of their IDs, if new nodes
113 * not created - returns empty list
115 long_array GetLastCreatedNodes() raises (SALOME::SALOME_Exception);
118 * If during last operation of MeshEditor some elements were
119 * created, this method returns list of their IDs, if new elements
120 * not created - returns empty list
122 long_array GetLastCreatedElems() raises (SALOME::SALOME_Exception);
125 * \brief Clears sequences of last created elements and nodes
127 void ClearLastCreated() raises (SALOME::SALOME_Exception);
130 * \brief Returns description of an error/warning occurred during the last operation
132 ComputeError GetLastError() raises (SALOME::SALOME_Exception);
135 * \brief Wrap a sequence of ids in a SMESH_IDSource
136 * \param IDsOfElements list of mesh elements identifiers
137 * \return new ID source object
139 SMESH_IDSource MakeIDSource(in long_array IDsOfElements, in ElementType type);
142 * \brief Remove mesh elements specified by their identifiers.
143 * \param IDsOfElements list of mesh elements identifiers
144 * \return \c true if elements are correctly removed or \c false otherwise
146 boolean RemoveElements(in long_array IDsOfElements) raises (SALOME::SALOME_Exception);
149 * \brief Remove mesh nodes specified by their identifiers.
150 * \param IDsOfNodes list of mesh nodes identifiers
151 * \return \c true if nodes are correctly removed or \c false otherwise
153 boolean RemoveNodes(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
156 * \brief Remove all orphan nodes.
157 * \return number of removed nodes
159 long RemoveOrphanNodes() raises (SALOME::SALOME_Exception);
162 * \brief Add a new node.
163 * \param x X coordinate of new node
164 * \param y Y coordinate of new node
165 * \param z Z coordinate of new node
166 * \return integer identifier of new node
168 long AddNode(in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
171 * Create a 0D element on the given node.
172 * \param IdOfNode Node IDs for creation of element.
173 * \param DuplicateElements to add one more 0D element to a node or not
175 long Add0DElement(in long IDOfNode,
176 in boolean DuplicateElements) raises (SALOME::SALOME_Exception);
179 * Create a ball element on the given node.
180 * \param IdOfNode Node IDs for creation of element.
182 long AddBall(in long IDOfNode, in double diameter) raises (SALOME::SALOME_Exception);
185 * Create an edge, either linear and quadratic (this is determed
186 * by number of given nodes, two or three).
187 * \param IdsOfNodes List of node IDs for creation of element.
188 * Needed order of nodes in this list corresponds to description
189 * of MED. This description is located by the following link:
190 * http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
192 long AddEdge(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
195 * Create face, either linear and quadratic (this is determed
196 * by number of given nodes).
197 * \param IdsOfNodes List of node IDs for creation of element.
198 * Needed order of nodes in this list corresponds to description
199 * of MED. This description is located by the following link:
200 * http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
202 long AddFace(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
204 long AddPolygonalFace(in long_array IdsOfNodes) raises (SALOME::SALOME_Exception);
207 * Create a quadratic polygonal face
208 * \param IdsOfNodes - nodes of the polygon; corner nodes follow first
209 * \return long - ID of a new polygon
211 long AddQuadPolygonalFace(in long_array IdsOfNodes) raises (SALOME::SALOME_Exception);
214 * Create volume, either linear and quadratic (this is determed
215 * by number of given nodes).
216 * \param IdsOfNodes List of node IDs for creation of element.
217 * Needed order of nodes in this list corresponds to description
218 * of MED. This description is located by the following link:
219 * http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
221 long AddVolume(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
224 * Create volume of many faces, giving nodes for each face.
225 * \param IdsOfNodes List of node IDs for volume creation face by face.
226 * \param Quantities List of integer values, Quantities[i]
227 * gives quantity of nodes in face number i.
229 long AddPolyhedralVolume (in long_array IdsOfNodes,
230 in long_array Quantities) raises (SALOME::SALOME_Exception);
232 * Create volume of many faces, giving IDs of existing faces.
233 * \param IdsOfFaces List of face IDs for volume creation.
234 * \note The created volume will refer only to nodes
235 * of the given faces, not to the faces itself.
237 long AddPolyhedralVolumeByFaces (in long_array IdsOfFaces) raises (SALOME::SALOME_Exception);
240 * Create 0D elements on all nodes of the given object.
241 * \param theObject object on whose nodes 0D elements will be created.
242 * \param theGroupName optional name of a group to add 0D elements created
243 * and/or found on nodes of \a theObject.
244 * \param theDuplicateElements to add one more 0D element to a node or not
245 * \return an object (a new group or a temporary SMESH_IDSource) holding
246 * ids of new and/or found 0D elements.
248 SMESH_IDSource Create0DElementsOnAllNodes(in SMESH_IDSource theObject,
249 in string theGroupName,
250 in boolean theDuplicateElements)
251 raises (SALOME::SALOME_Exception);
254 * \brief Bind a node to a vertex
255 * \param NodeID - node ID
256 * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
258 void SetNodeOnVertex(in long NodeID, in long VertexID)
259 raises (SALOME::SALOME_Exception);
261 * \brief Store node position on an edge
262 * \param NodeID - node ID
263 * \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
264 * \param paramOnEdge - parameter on edge where the node is located
266 void SetNodeOnEdge(in long NodeID, in long EdgeID, in double paramOnEdge)
267 raises (SALOME::SALOME_Exception);
269 * \brief Store node position on a face
270 * \param NodeID - node ID
271 * \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
272 * \param u - U parameter on face where the node is located
273 * \param v - V parameter on face where the node is located
275 void SetNodeOnFace(in long NodeID, in long FaceID, in double u, in double v)
276 raises (SALOME::SALOME_Exception);
278 * \brief Bind a node to a solid
279 * \param NodeID - node ID
280 * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
282 void SetNodeInVolume(in long NodeID, in long SolidID)
283 raises (SALOME::SALOME_Exception);
285 * \brief Bind an element to a shape
286 * \param ElementID - element ID
287 * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
289 void SetMeshElementOnShape(in long ElementID, in long ShapeID)
290 raises (SALOME::SALOME_Exception);
293 boolean MoveNode(in long NodeID, in double x, in double y, in double z)
294 raises (SALOME::SALOME_Exception);
296 boolean InverseDiag(in long NodeID1, in long NodeID2)
297 raises (SALOME::SALOME_Exception);
299 boolean DeleteDiag(in long NodeID1, in long NodeID2)
300 raises (SALOME::SALOME_Exception);
302 boolean Reorient(in long_array IDsOfElements)
303 raises (SALOME::SALOME_Exception);
305 boolean ReorientObject(in SMESH_IDSource theObject)
306 raises (SALOME::SALOME_Exception);
308 * \brief Reorient faces contained in \a the2Dgroup.
309 * \param the2Dgroup - the mesh or its part to reorient
310 * \param theDirection - desired direction of normal of \a theFace
311 * \param theFace - ID of face whose orientation is checked.
312 * It can be < 1 then \a thePoint is used to find a face.
313 * \param thePoint - is used to find a face if \a theFace < 1.
314 * \return number of reoriented faces.
316 long Reorient2D(in SMESH_IDSource the2Dgroup,
317 in DirStruct theDirection,
319 in PointStruct thePoint) raises (SALOME::SALOME_Exception);
321 * \brief Reorient faces basing on orientation of adjacent volumes.
322 * \param faces - a list of objects containing face to reorient
323 * \param volumes - an object containing volumes.
324 * \param outsideNormal - to orient faces to have their normal
325 * pointing either \a outside or \a inside the adjacent volumes.
326 * \return number of reoriented faces.
328 long Reorient2DBy3D(in ListOfIDSources faces,
329 in SMESH_IDSource volumes,
330 in boolean outsideNormal) raises (SALOME::SALOME_Exception);
333 * \brief Fuse neighbour triangles into quadrangles.
334 * \param IDsOfElements Ids of triangles to be fused.
335 * \param theCriterion Is used to choose a neighbour to fuse with.
336 * \param theMaxAngle Is a max angle between element normals at which fusion
337 * is still performed; theMaxAngle is measured in radians.
338 * \return \c true in case of success, FALSE otherwise.
340 boolean TriToQuad (in long_array IDsOfElements,
341 in NumericalFunctor Criterion,
342 in double MaxAngle) raises (SALOME::SALOME_Exception);
344 * \brief Fuse neighbour triangles into quadrangles.
346 * Behaves like the above method, taking a list of elements from \a theObject
348 boolean TriToQuadObject (in SMESH_IDSource theObject,
349 in NumericalFunctor Criterion,
350 in double MaxAngle) raises (SALOME::SALOME_Exception);
353 * \brief Split quadrangles into triangles.
354 * \param IDsOfElements Ids of quadrangles to split.
355 * \param theCriterion Is used to choose a diagonal for splitting.
356 * \return TRUE in case of success, FALSE otherwise.
358 boolean QuadToTri (in long_array IDsOfElements,
359 in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
361 * \brief Split quadrangles into triangles.
363 * Behaves like the above method, taking a list of elements from \a theObject
365 boolean QuadToTriObject (in SMESH_IDSource theObject,
366 in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
368 * \brief Split each of quadrangles into 4 triangles.
369 * \param theQuads Container of quadrangles to split.
371 void QuadTo4Tri (in SMESH_IDSource theQuads) raises (SALOME::SALOME_Exception);
374 * \brief Split quadrangles into triangles.
375 * \param theElems The faces to be split.
376 * \param the13Diag Is used to choose a diagonal for splitting.
377 * \return TRUE in case of success, FALSE otherwise.
379 boolean SplitQuad (in long_array IDsOfElements,
380 in boolean Diag13) raises (SALOME::SALOME_Exception);
382 * \brief Split quadrangles into triangles.
384 * Behaves like the above method, taking list of elements from \a theObject
386 boolean SplitQuadObject (in SMESH_IDSource theObject,
387 in boolean Diag13) raises (SALOME::SALOME_Exception);
390 * Find better splitting of the given quadrangle.
391 * \param IDOfQuad ID of the quadrangle to be split.
392 * \param Criterion A criterion to choose a diagonal for splitting.
393 * \return 1 if 1-3 diagonal is better, 2 if 2-4
394 * diagonal is better, 0 if error occurs.
396 long BestSplit (in long IDOfQuad,
397 in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
400 * \brief Split volumic elements into tetrahedrons
401 * \param elems - elements to split
402 * \param methodFlags - flags passing splitting method:
403 * 1 - split the hexahedron into 5 tetrahedrons
404 * 2 - split the hexahedron into 6 tetrahedrons
405 * 3 - split the hexahedron into 24 tetrahedrons
407 void SplitVolumesIntoTetra(in SMESH_IDSource elems, in short methodFlags)
408 raises (SALOME::SALOME_Exception);
411 * \brief Split hexahedra into triangular prisms
412 * \param elems - elements to split
413 * \param startHexPoint - a point used to find a hexahedron for which \a facetToSplitNormal
414 * gives a normal vector defining facets to split into triangles.
415 * \param facetToSplitNormal - normal used to find a facet of hexahedron
416 * to split into triangles.
417 * \param methodFlags - flags passing splitting method:
418 * 1 - split the hexahedron into 2 prisms
419 * 2 - split the hexahedron into 4 prisms
420 * \param allDomains - if \c False, only hexahedra adjacent to one closest
421 * to \a facetToSplitNormal location are split, else \a facetToSplitNormal
422 * is used to find the facet to split in all domains present in \a elems.
424 void SplitHexahedraIntoPrisms(in SMESH_IDSource elems,
425 in SMESH::PointStruct startHexPoint,
426 in SMESH::DirStruct facetToSplitNormal,
427 in short methodFlags,
428 in boolean allDomains)
429 raises (SALOME::SALOME_Exception);
432 * \brief Split bi-quadratic elements into linear ones without creation of additional nodes.
433 * - bi-quadratic triangle will be split into 3 linear quadrangles;
434 * - bi-quadratic quadrangle will be split into 4 linear quadrangles;
435 * - tri-quadratic hexahedron will be split into 8 linear hexahedra;
436 * Quadratic elements of lower dimension adjacent to the split bi-quadratic element
437 * will be split in order to keep the mesh conformal.
438 * \param elems - elements to split
440 void SplitBiQuadraticIntoLinear(in ListOfIDSources elems)
441 raises (SALOME::SALOME_Exception);
444 enum Smooth_Method { LAPLACIAN_SMOOTH, CENTROIDAL_SMOOTH };
446 boolean Smooth(in long_array IDsOfElements,
447 in long_array IDsOfFixedNodes,
448 in long MaxNbOfIterations,
449 in double MaxAspectRatio,
450 in Smooth_Method Method) raises (SALOME::SALOME_Exception);
452 boolean SmoothObject(in SMESH_IDSource theObject,
453 in long_array IDsOfFixedNodes,
454 in long MaxNbOfIterations,
455 in double MaxAspectRatio,
456 in Smooth_Method Method) raises (SALOME::SALOME_Exception);
458 boolean SmoothParametric(in long_array IDsOfElements,
459 in long_array IDsOfFixedNodes,
460 in long MaxNbOfIterations,
461 in double MaxAspectRatio,
462 in Smooth_Method Method) raises (SALOME::SALOME_Exception);
464 boolean SmoothParametricObject(in SMESH_IDSource theObject,
465 in long_array IDsOfFixedNodes,
466 in long MaxNbOfIterations,
467 in double MaxAspectRatio,
468 in Smooth_Method Method) raises (SALOME::SALOME_Exception);
470 void ConvertToQuadratic(in boolean theForce3d)
471 raises (SALOME::SALOME_Exception);
472 void ConvertToQuadraticObject(in boolean theForce3d,
473 in SMESH_IDSource theObject)
474 raises (SALOME::SALOME_Exception);
476 boolean ConvertFromQuadratic()
477 raises (SALOME::SALOME_Exception);
478 void ConvertFromQuadraticObject(in SMESH_IDSource theObject)
479 raises (SALOME::SALOME_Exception);
481 void ConvertToBiQuadratic(in boolean theForce3d,
482 in SMESH_IDSource theObject)
483 raises (SALOME::SALOME_Exception);
485 void RenumberNodes() raises (SALOME::SALOME_Exception);
487 void RenumberElements() raises (SALOME::SALOME_Exception);
490 * \brief Generate dim+1 elements by rotation of the object around axis
491 * \param Nodes - nodes to revolve: a list including groups, sub-meshes or a mesh
492 * \param Edges - edges to revolve: a list including groups, sub-meshes or a mesh
493 * \param Faces - faces to revolve: a list including groups, sub-meshes or a mesh
494 * \param Axis - rotation axis
495 * \param AngleInRadians - rotation angle
496 * \param NbOfSteps - number of elements to generate from one element
497 * \param ToMakeGroups - if true, new elements will be included into new groups
498 * corresponding to groups the input elements included in.
499 * \return ListOfGroups - new groups created if \a ToMakeGroups is true
501 ListOfGroups RotationSweepObjects(in ListOfIDSources Nodes,
502 in ListOfIDSources Edges,
503 in ListOfIDSources Faces,
505 in double AngleInRadians,
508 in boolean ToMakeGroups)
509 raises (SALOME::SALOME_Exception);
512 * \brief Generate dim+1 elements by extrusion of elements along vector
513 * \param nodes - nodes to extrude: a list including groups, sub-meshes or a mesh.
514 * \param edges - edges to extrude: a list including groups, sub-meshes or a mesh.
515 * \param faces - faces to extrude: a list including groups, sub-meshes or a mesh.
516 * \param stepVector - vector giving direction and distance of an extrusion step.
517 * \param nbOfSteps - number of elements to generate from one element.
518 * \param toMakeGroups - if true, new elements will be included into new groups
519 * corresponding to groups the input elements included in.
520 * \param scaleFactors - optional scale factors to apply during extrusion; it's
521 * usage depends on \a scalesVariation parameter.
522 * \param scalesVariation - if \c True, \a scaleFactors are spread over all \a NbOfSteps,
523 otherwise \a scaleFactors[i] is applied to nodes at the i-th extrusion step.
524 * \param angles - optional rotation angles to apply during extrusion; it's
525 * usage depends on \a anglesVariation parameter.
526 * \param anglesVariation - if \c True, \a angles are spread over all \a NbOfSteps,
527 otherwise \a angle[i] is applied to nodes at the i-th extrusion step.
528 * \return ListOfGroups - new groups created if \a toMakeGroups is true
530 ListOfGroups ExtrusionSweepObjects(in ListOfIDSources nodes,
531 in ListOfIDSources edges,
532 in ListOfIDSources faces,
533 in DirStruct stepVector,
535 in boolean toMakeGroups,
536 in double_array scaleFactors,
537 in boolean scaleVariation,
538 in double_array basePoint,
539 in double_array angles,
540 in boolean angleVariation)
541 raises (SALOME::SALOME_Exception);
543 /*! Generates new elements by extrusion along the normal to a discretized surface or wire
545 ListOfGroups ExtrusionByNormal(in ListOfIDSources theObjects,
548 in boolean byAverageNormal,
549 in boolean useInputElemsOnly,
550 in boolean makeGroups,
552 raises (SALOME::SALOME_Exception);
555 * Generate new elements by extrusion of theElements
556 * by StepVector by NbOfSteps
557 * \param ExtrFlags set flags for performing extrusion
558 * \param SewTolerance - uses for comparing locations of nodes if flag
559 * EXTRUSION_FLAG_SEW is set
560 * \param ToMakeGroups - if true, new elements will be included into new groups
561 * corresponding to groups the input elements included in.
562 * \return ListOfGroups - new groups created if \a ToMakeGroups is true
564 ListOfGroups AdvancedExtrusion(in long_array IDsOfElements,
565 in DirStruct StepVector,
568 in double SewTolerance,
569 in boolean ToMakeGroups)
570 raises (SALOME::SALOME_Exception);
572 enum Extrusion_Error {
577 EXTR_BAD_STARTING_NODE,
578 EXTR_BAD_ANGLES_NUMBER,
579 EXTR_CANT_GET_TANGENT
582 ListOfGroups ExtrusionAlongPathObjects(in ListOfIDSources Nodes,
583 in ListOfIDSources Edges,
584 in ListOfIDSources Faces,
585 in SMESH_IDSource Path,
586 in GEOM::GEOM_Object PathShape,
588 in boolean HasAngles,
589 in double_array Angles,
590 in boolean AnglesVariation,
591 in boolean HasRefPoint,
592 in PointStruct RefPoint,
593 in boolean MakeGroups,
594 in double_array ScaleFactors,
595 in boolean ScaleVariation,
596 out Extrusion_Error Error)
597 raises (SALOME::SALOME_Exception);
600 * Compute rotation angles for ExtrusionAlongPath as linear variation
601 * of given angles along path steps
602 * param PathMesh mesh containing a 1D sub-mesh on the edge, along
603 * which proceeds the extrusion
604 * param PathShape is shape(edge); as the mesh can be complex, the edge
605 * is used to define the sub-mesh for the path
607 double_array LinearAnglesVariation(in SMESH_Mesh PathMesh,
608 in GEOM::GEOM_Object PathShape,
609 in double_array Angles);
611 enum MirrorType { POINT, AXIS, PLANE };
613 void Mirror (in long_array IDsOfElements,
614 in AxisStruct Mirror,
617 raises (SALOME::SALOME_Exception);
618 ListOfGroups MirrorMakeGroups (in long_array IDsOfElements,
619 in AxisStruct Mirror,
621 raises (SALOME::SALOME_Exception);
622 SMESH_Mesh MirrorMakeMesh (in long_array IDsOfElements,
623 in AxisStruct Mirror,
625 in boolean CopyGroups,
627 raises (SALOME::SALOME_Exception);
629 void MirrorObject (in SMESH_IDSource theObject,
630 in AxisStruct Mirror,
633 raises (SALOME::SALOME_Exception);
634 ListOfGroups MirrorObjectMakeGroups (in SMESH_IDSource theObject,
635 in AxisStruct Mirror,
637 raises (SALOME::SALOME_Exception);
638 SMESH_Mesh MirrorObjectMakeMesh (in SMESH_IDSource theObject,
639 in AxisStruct Mirror,
641 in boolean CopyGroups,
643 raises (SALOME::SALOME_Exception);
645 void Translate (in long_array IDsOfElements,
648 raises (SALOME::SALOME_Exception);
649 ListOfGroups TranslateMakeGroups (in long_array IDsOfElements,
651 raises (SALOME::SALOME_Exception);
652 SMESH_Mesh TranslateMakeMesh (in long_array IDsOfElements,
654 in boolean CopyGroups,
656 raises (SALOME::SALOME_Exception);
658 void TranslateObject (in SMESH_IDSource theObject,
661 raises (SALOME::SALOME_Exception);
662 ListOfGroups TranslateObjectMakeGroups (in SMESH_IDSource theObject,
664 raises (SALOME::SALOME_Exception);
665 SMESH_Mesh TranslateObjectMakeMesh (in SMESH_IDSource theObject,
667 in boolean CopyGroups,
669 raises (SALOME::SALOME_Exception);
671 void Scale (in SMESH_IDSource theObject,
672 in PointStruct thePoint,
673 in double_array theScaleFact,
675 raises (SALOME::SALOME_Exception);
676 ListOfGroups ScaleMakeGroups (in SMESH_IDSource theObject,
677 in PointStruct thePoint,
678 in double_array theScaleFact)
679 raises (SALOME::SALOME_Exception);
680 SMESH_Mesh ScaleMakeMesh (in SMESH_IDSource theObject,
681 in PointStruct thePoint,
682 in double_array theScaleFact,
683 in boolean CopyGroups,
685 raises (SALOME::SALOME_Exception);
687 void Rotate (in long_array IDsOfElements,
689 in double AngleInRadians,
691 raises (SALOME::SALOME_Exception);
692 ListOfGroups RotateMakeGroups (in long_array IDsOfElements,
694 in double AngleInRadians)
695 raises (SALOME::SALOME_Exception);
696 SMESH_Mesh RotateMakeMesh (in long_array IDsOfElements,
698 in double AngleInRadians,
699 in boolean CopyGroups,
701 raises (SALOME::SALOME_Exception);
703 void RotateObject (in SMESH_IDSource theObject,
705 in double AngleInRadians,
707 raises (SALOME::SALOME_Exception);
708 ListOfGroups RotateObjectMakeGroups (in SMESH_IDSource theObject,
710 in double AngleInRadians)
711 raises (SALOME::SALOME_Exception);
712 SMESH_Mesh RotateObjectMakeMesh (in SMESH_IDSource theObject,
714 in double AngleInRadians,
715 in boolean CopyGroups,
717 raises (SALOME::SALOME_Exception);
719 SMESH_Mesh Offset(in SMESH_IDSource theObject,
721 in boolean CopyGroups,
722 in boolean CopyElements,
724 out ListOfGroups Groups)
725 raises (SALOME::SALOME_Exception);
727 void FindCoincidentNodes (in double Tolerance,
728 out array_of_long_array GroupsOfNodes,
729 in boolean SeparateCornersAndMedium)
730 raises (SALOME::SALOME_Exception);
732 void FindCoincidentNodesOnPart (in SMESH_IDSource SubMeshOrGroup,
734 out array_of_long_array GroupsOfNodes,
735 in boolean SeparateCornersAndMedium)
736 raises (SALOME::SALOME_Exception);
738 void FindCoincidentNodesOnPartBut (in ListOfIDSources SubMeshOrGroup,
740 out array_of_long_array GroupsOfNodes,
741 in ListOfIDSources ExceptSubMeshOrGroups,
742 in boolean SeparateCornersAndMedium)
743 raises (SALOME::SALOME_Exception);
745 void MergeNodes (in array_of_long_array GroupsOfNodes,
746 in SMESH::ListOfIDSources NodesToKeep,
747 in boolean AvoidMakingHoles)
748 raises (SALOME::SALOME_Exception);
751 * \brief Find elements built on the same nodes.
752 * \param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching.
753 * \return List of groups of equal elements.
755 void FindEqualElements (in ListOfIDSources MeshOrSubMeshOrGroup,
756 in ListOfIDSources ExceptSubMeshOrGroups,
757 out array_of_long_array GroupsOfElementsID)
758 raises (SALOME::SALOME_Exception);
761 * \brief Merge elements in each given group.
762 * \param GroupsOfElementsID Groups of elements for merging.
764 void MergeElements(in array_of_long_array GroupsOfElementsID,
765 in SMESH::ListOfIDSources ElementsToKeep)
766 raises (SALOME::SALOME_Exception);
769 * \brief Merge equal elements in the whole mesh.
771 void MergeEqualElements()
772 raises (SALOME::SALOME_Exception);
775 * If the given ID is a valid node ID (nodeID > 0), just move this node, else
776 * move the node closest to the point to point's location and return ID of the node
778 long MoveClosestNodeToPoint(in double x, in double y, in double z, in long nodeID)
779 raises (SALOME::SALOME_Exception);
782 * Return ID of node closest to a given point
784 long FindNodeClosestTo(in double x, in double y, in double z)
785 raises (SALOME::SALOME_Exception);
788 * Return elements of given type where the given point is IN or ON.
790 * 'ALL' type means elements of any type excluding nodes and 0D elements
792 long_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type)
793 raises (SALOME::SALOME_Exception);
796 * Searching among the given elements, return elements of given type
797 * where the given point is IN or ON.
799 * 'ALL' type means elements of any type excluding nodes and 0D elements
801 long_array FindAmongElementsByPoint(in SMESH_IDSource elements,
802 in double x, in double y, in double z,
804 raises (SALOME::SALOME_Exception);
807 * Project a point to a mesh object.
808 * Return ID of an element of given type where the given point is projected
809 * and coordinates of the projection point.
810 * In the case if nothing found, return -1 and []
812 long ProjectPoint(in double x,
816 in SMESH_IDSource meshObject,
817 out double_array projecton)
818 raises (SALOME::SALOME_Exception);
821 * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
822 * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
824 short GetPointState(in double x, in double y, in double z)
825 raises (SALOME::SALOME_Exception);
828 * Check if a 2D mesh is manifold
831 raises (SALOME::SALOME_Exception);
834 * Check if orientation of 2D elements is coherent
836 boolean IsCoherentOrientation2D()
837 raises (SALOME::SALOME_Exception);
840 * Partition given 1D elements into groups of contiguous edges.
841 * A node where number of meeting edges != 2 is a group end.
842 * An optional startNode is used to orient groups it belongs to.
843 * \return a list of edge groups and a list of corresponding node groups.
844 * If a group is closed, the first and last nodes of the group are same.
846 array_of_long_array Get1DBranches( in SMESH_IDSource edges,
848 out array_of_long_array nodeGroups)
849 raises (SALOME::SALOME_Exception);
852 * Return sharp edges of faces and non-manifold ones.
853 * Optionally add existing edges. Angle is in degrees.
855 ListOfEdges FindSharpEdges(in double angle, in boolean addExistingEdges)
856 raises (SALOME::SALOME_Exception);
859 * Returns all or only closed FreeBorder's.
861 ListOfFreeBorders FindFreeBorders(in boolean closedOnly)
862 raises (SALOME::SALOME_Exception);
865 * Fill with 2D elements a hole defined by a FreeBorder.
866 * Optionally add new faces to a given group, which is returned.
868 SMESH_Group FillHole(in FreeBorder hole, in string groupName)
869 raises (SALOME::SALOME_Exception);
872 * Returns groups of FreeBorder's coincident within the given tolerance.
873 * If the tolerance <= 0.0 then one tenth of an average size of elements adjacent
874 * to free borders being compared is used.
876 CoincidentFreeBorders FindCoincidentFreeBorders(in double tolerance);
879 * Sew FreeBorder's of each group
881 short SewCoincidentFreeBorders (in CoincidentFreeBorders freeBorders,
882 in boolean createPolygons,
883 in boolean createPolyedrs)
884 raises (SALOME::SALOME_Exception);
888 SEW_BORDER1_NOT_FOUND,
889 SEW_BORDER2_NOT_FOUND,
890 SEW_BOTH_BORDERS_NOT_FOUND,
892 SEW_VOLUMES_TO_SPLIT,
893 // for SewSideElements() only:
894 SEW_DIFF_NB_OF_ELEMENTS,
895 SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
901 Sew_Error SewFreeBorders (in long FirstNodeID1,
902 in long SecondNodeID1,
904 in long FirstNodeID2,
905 in long SecondNodeID2,
907 in boolean CreatePolygons,
908 in boolean CreatePolyedrs)
909 raises (SALOME::SALOME_Exception);
911 Sew_Error SewConformFreeBorders (in long FirstNodeID1,
912 in long SecondNodeID1,
914 in long FirstNodeID2,
915 in long SecondNodeID2)
916 raises (SALOME::SALOME_Exception);
918 Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder,
919 in long SecondNodeIDOnFreeBorder,
920 in long LastNodeIDOnFreeBorder,
921 in long FirstNodeIDOnSide,
922 in long LastNodeIDOnSide,
923 in boolean CreatePolygons,
924 in boolean CreatePolyedrs)
925 raises (SALOME::SALOME_Exception);
927 Sew_Error SewSideElements (in long_array IDsOfSide1Elements,
928 in long_array IDsOfSide2Elements,
929 in long NodeID1OfSide1ToMerge,
930 in long NodeID1OfSide2ToMerge,
931 in long NodeID2OfSide1ToMerge,
932 in long NodeID2OfSide2ToMerge)
933 raises (SALOME::SALOME_Exception);
936 * Set new nodes for given element.
937 * If number of nodes is not corresponded to type of
938 * element - returns false
940 boolean ChangeElemNodes(in long ide, in long_array newIDs)
941 raises (SALOME::SALOME_Exception);
944 * \brief Duplicates given elements, i.e. creates new elements based on the
945 * same nodes as the given ones.
946 * \param theElements - container of elements to duplicate.
947 * \param theGroupName - a name of group to contain the generated elements.
948 * If a group with such a name already exists, the new elements
949 * are added to the existing group, else a new group is created.
950 * If \a theGroupName is empty, new elements are not added
952 * \return a group where the new elements are added. NULL if theGroupName == "".
955 SMESH_Group DoubleElements( in SMESH_IDSource theElements,
956 in string theGroupName )
957 raises (SALOME::SALOME_Exception);
960 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
961 * \param theNodes - identifiers of nodes to be doubled
962 * \param theModifiedElems - identifiers of elements to be updated by the new (doubled)
963 * nodes. If list of element identifiers is empty then nodes are doubled but
964 * they not assigned to elements
965 * \return TRUE if operation has been completed successfully, FALSE otherwise
966 * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
968 boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems )
969 raises (SALOME::SALOME_Exception);
972 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
973 * This method provided for convenience works as DoubleNodes() described above.
974 * \param theNodeId - identifier of node to be doubled.
975 * \param theModifiedElems - identifiers of elements to be updated.
976 * \return TRUE if operation has been completed successfully, FALSE otherwise
977 * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
979 boolean DoubleNode( in long theNodeId, in long_array theModifiedElems )
980 raises (SALOME::SALOME_Exception);
983 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
984 * This method provided for convenience works as DoubleNodes() described above.
985 * \param theNodes - group of nodes to be doubled.
986 * \param theModifiedElems - group of elements to be updated.
987 * \return TRUE if operation has been completed successfully, FALSE otherwise
988 * \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew()
990 boolean DoubleNodeGroup( in SMESH_GroupBase theNodes,
991 in SMESH_GroupBase theModifiedElems )
992 raises (SALOME::SALOME_Exception);
994 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
995 * Works as DoubleNodeGroup() described above, but returns a new group with
996 * newly created nodes.
997 * \param theNodes - group of nodes to be doubled.
998 * \param theModifiedElems - group of elements to be updated.
999 * \return a new group with newly created nodes
1000 * \sa DoubleNodeGroup()
1002 SMESH_Group DoubleNodeGroupNew( in SMESH_GroupBase theNodes,
1003 in SMESH_GroupBase theModifiedElems )
1004 raises (SALOME::SALOME_Exception);
1007 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1008 * This method provided for convenience works as DoubleNodes() described above.
1009 * \param theNodes - list of groups of nodes to be doubled
1010 * \param theModifiedElems - list of groups of elements to be updated.
1011 * \return TRUE if operation has been completed successfully, FALSE otherwise
1012 * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
1014 boolean DoubleNodeGroups( in ListOfGroups theNodes,
1015 in ListOfGroups theModifiedElems )
1016 raises (SALOME::SALOME_Exception);
1018 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1019 * Works as DoubleNodeGroups() described above, but returns a new group with
1020 * newly created nodes.
1021 * \param theNodes - list of groups of nodes to be doubled
1022 * \param theModifiedElems - list of groups of elements to be updated.
1023 * \return a new group with newly created nodes
1024 * \sa DoubleNodeGroups()
1026 SMESH_Group DoubleNodeGroupsNew( in ListOfGroups theNodes,
1027 in ListOfGroups theModifiedElems )
1028 raises (SALOME::SALOME_Exception);
1031 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1032 * \param theElems - the list of elements (edges or faces) to be replicated
1033 * The nodes for duplication could be found from these elements
1034 * \param theNodesNot - list of nodes to NOT replicate
1035 * \param theAffectedElems - the list of elements (cells and edges) to which the
1036 * replicated nodes should be associated to.
1037 * \return TRUE if operation has been completed successfully, FALSE otherwise
1038 * \sa DoubleNodeGroup(), DoubleNodeGroups()
1040 boolean DoubleNodeElem( in long_array theElems,
1041 in long_array theNodesNot,
1042 in long_array theAffectedElems )
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 theShape - shape to detect affected elements (element which geometric center
1051 * located on or inside shape).
1052 * The replicated nodes should be associated to affected elements.
1053 * \return TRUE if operation has been completed successfully, FALSE otherwise
1054 * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
1056 boolean DoubleNodeElemInRegion( in long_array theElems,
1057 in long_array theNodesNot,
1058 in GEOM::GEOM_Object theShape )
1059 raises (SALOME::SALOME_Exception);
1062 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1063 * This method provided for convenience works as DoubleNodes() described above.
1064 * \param theElems - group of of elements (edges or faces) to be replicated
1065 * \param theNodesNot - group of nodes not to replicated
1066 * \param theAffectedElems - group of elements to which the replicated nodes
1067 * should be associated to.
1068 * \return TRUE if operation has been completed successfully, FALSE otherwise
1069 * \sa DoubleNodes(), DoubleNodeGroups(), DoubleNodeElemGroupNew()
1071 boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems,
1072 in SMESH_GroupBase theNodesNot,
1073 in SMESH_GroupBase theAffectedElems )
1074 raises (SALOME::SALOME_Exception);
1076 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1077 * Works as DoubleNodeElemGroup() described above, but returns a new group with
1078 * newly created elements.
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 a new group with newly created elements
1084 * \sa DoubleNodeElemGroup()
1086 SMESH_Group DoubleNodeElemGroupNew( 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 two new groups:
1093 * a group of newly created elements and a group of newly created nodes
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 * \param theElemGroupNeeded - to create group of new elements or not
1099 * \param theNodeGroupNeeded - to create group of new nodes or not
1100 * \return two new groups of newly created elements (1st) and nodes (2nd)
1101 * \sa DoubleNodeElemGroup()
1103 ListOfGroups DoubleNodeElemGroup2New( in SMESH_GroupBase theElems,
1104 in SMESH_GroupBase theNodesNot,
1105 in SMESH_GroupBase theAffectedElems,
1106 in boolean theElemGroupNeeded,
1107 in boolean theNodeGroupNeeded)
1108 raises (SALOME::SALOME_Exception);
1111 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1112 * This method provided for convenience works as DoubleNodes() described above.
1113 * \param theElems - group of elements (edges or faces) to be replicated
1114 * \param theNodesNot - group of nodes not to replicated
1115 * \param theShape - shape to detect affected elements (element which geometric center
1116 * located on or inside shape).
1117 * The replicated nodes should be associated to affected elements.
1118 * \return TRUE if operation has been completed successfully, FALSE otherwise
1119 * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
1121 boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems,
1122 in SMESH_GroupBase theNodesNot,
1123 in GEOM::GEOM_Object theShape )
1124 raises (SALOME::SALOME_Exception);
1127 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1128 * This method provided for convenience works as DoubleNodes() described above.
1129 * \param theElems - list of groups of elements (edges or faces) to be replicated
1130 * \param theNodesNot - list of groups of nodes not to replicated
1131 * \param theAffectedElems - group of elements to which the replicated nodes
1132 * should be associated to.
1133 * \return TRUE if operation has been completed successfully, FALSE otherwise
1134 * \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
1136 boolean DoubleNodeElemGroups( in ListOfGroups theElems,
1137 in ListOfGroups theNodesNot,
1138 in ListOfGroups theAffectedElems )
1139 raises (SALOME::SALOME_Exception);
1141 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
1142 * Works as DoubleNodeElemGroups() described above, but returns a new group with
1143 * newly created elements.
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 a new group with newly created elements
1149 * \sa DoubleNodeElemGroups()
1151 SMESH_Group DoubleNodeElemGroupsNew( 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 two new groups:
1158 * a group of newly created elements and a group of newly created nodes.
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 * \param theElemGroupNeeded - to create group of new elements or not
1164 * \param theNodeGroupNeeded - to create group of new nodes or not
1165 * \return two new groups of newly created elements (1st) and nodes (2nd)
1166 * \sa DoubleNodeElemGroups()
1168 ListOfGroups DoubleNodeElemGroups2New( in ListOfGroups theElems,
1169 in ListOfGroups theNodesNot,
1170 in ListOfGroups theAffectedElems,
1171 in boolean theElemGroupNeeded,
1172 in boolean theNodeGroupNeeded )
1173 raises (SALOME::SALOME_Exception);
1176 * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
1177 * This method provided for convenience works as DoubleNodes() described above.
1178 * \param theElems - list of groups of elements (edges or faces) to be replicated
1179 * \param theNodesNot - list of groups of nodes not to replicated
1180 * \param theShape - shape to detect affected elements (element which geometric center
1181 * located on or inside shape).
1182 * The replicated nodes should be associated to affected elements.
1183 * \return TRUE if operation has been completed successfully, FALSE otherwise
1184 * \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
1186 boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
1187 in ListOfGroups theNodesNot,
1188 in GEOM::GEOM_Object theShape )
1189 raises (SALOME::SALOME_Exception);
1192 * \brief Identify the elements that will be affected by node duplication (actual duplication is not performed).
1193 * This method is the first step of DoubleNodeElemGroupsInRegion.
1194 * \param theElems - list of groups of elements (edges or faces) to be replicated
1195 * \param theNodesNot - list of groups of nodes not to replicated
1196 * \param theShape - shape to detect affected elements (element which geometric center
1197 * located on or inside shape).
1198 * The replicated nodes should be associated to affected elements.
1199 * \return groups of affected elements
1200 * \sa DoubleNodeElemGroupsInRegion()
1202 ListOfGroups AffectedElemGroupsInRegion( in ListOfGroups theElems,
1203 in ListOfGroups theNodesNot,
1204 in GEOM::GEOM_Object theShape )
1205 raises (SALOME::SALOME_Exception);
1208 * \brief Generates skin mesh (containing 2D cells) from 3D mesh
1209 * The created 2D mesh elements based on nodes of free faces of boundary volumes
1210 * \return TRUE if operation has been completed successfully, FALSE otherwise
1212 boolean Make2DMeshFrom3D() raises (SALOME::SALOME_Exception);
1215 * \brief Creates missing boundary elements
1216 * \param elements - elements whose boundary is to be checked
1217 * \param dimension - defines type of boundary elements to create
1218 * BND_1DFROM3D creates mesh edges on all borders of free facets of 3D elements.
1219 * \param groupName - a name of group to store created boundary elements in,
1220 * "" means not to create the group
1221 * \param meshName - a name of new mesh to store created boundary elements in,
1222 * "" means not to create the new mesh
1223 * \param toCopyElements - if true, the checked elements will be copied into the new mesh
1224 * else only boundary elements will be copied into the new mesh
1225 * \param toCopyExistingBondary - if true, not only new but also pre-existing
1226 * boundary elements will be copied into the new mesh
1227 * \param group - returns the create group, if any
1228 * \retval SMESH::SMESH_Mesh - the mesh where elements were added to
1230 SMESH_Mesh MakeBoundaryMesh(in SMESH_IDSource elements,
1231 in Bnd_Dimension dimension,
1232 in string groupName,
1234 in boolean toCopyElements,
1235 in boolean toCopyExistingBondary,
1236 out SMESH_Group group) raises (SALOME::SALOME_Exception);
1238 * \brief Creates missing boundary elements around either the whole mesh or
1239 * groups of 2D elements
1240 * \param dimension - defines type of boundary elements to create
1241 * \param groupName - a name of group to store all boundary elements in,
1242 * "" means not to create the group
1243 * \param meshName - a name of a new mesh, which is a copy of the initial
1244 * mesh + created boundary elements; "" means not to create the new mesh
1245 * \param toCopyAll - if true, the whole initial mesh will be copied into
1246 * the new mesh else only boundary elements will be copied into the new mesh
1247 * \param groups - optional groups of 2D elements to make boundary around
1248 * \param mesh - returns the mesh where elements were added to
1249 * \param group - returns the created group, if any
1250 * \retval long - number of added boundary elements
1252 long MakeBoundaryElements(in Bnd_Dimension dimension,
1253 in string groupName,
1255 in boolean toCopyAll,
1256 in ListOfIDSources groups,
1257 out SMESH_Mesh mesh,
1258 out SMESH_Group group) raises (SALOME::SALOME_Exception);
1261 * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
1262 * Flat elements are mainly used by some types of mechanic calculations.
1264 * The list of groups must describe a partition of the mesh volumes.
1265 * The nodes of the internal faces at the boundaries of the groups are doubled.
1266 * In option, the internal faces are replaced by flat elements.
1267 * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1268 * \param theDomains - list of groups of volumes
1269 * \param createJointElems - if TRUE, create the elements
1270 * \param onAllBoundaries - if TRUE, the nodes and elements are also created on
1271 * the boundary between \a theDomains and the rest mesh
1272 * \return TRUE if operation has been completed successfully, FALSE otherwise
1274 boolean DoubleNodesOnGroupBoundaries( in ListOfGroups theDomains,
1275 in boolean createJointElems,
1276 in boolean onAllBoundaries)
1277 raises (SALOME::SALOME_Exception);
1280 * \brief Double nodes on some external faces and create flat elements.
1281 * Flat elements are mainly used by some types of mechanic calculations.
1283 * Each group of the list must be constituted of faces.
1284 * Triangles are transformed in prisms, and quadrangles in hexahedrons.
1285 * \param theGroupsOfFaces - list of groups of faces
1286 * \return TRUE if operation has been completed successfully, FALSE otherwise
1288 boolean CreateFlatElementsOnFacesGroups( in ListOfGroups theGroupsOfFaces )
1289 raises (SALOME::SALOME_Exception);
1292 * \brief identify all the elements around a geom shape, get the faces delimiting the hole
1293 * Build groups of volume to remove, groups of faces to replace on the skin of the object,
1294 * groups of faces to remove insidethe object, (idem edges).
1295 * Build ordered list of nodes at the border of each group of faces to replace (to be used to build a geom subshape)
1297 void CreateHoleSkin(in double radius,
1298 in GEOM::GEOM_Object theShape,
1299 in string groupName,
1300 in double_array theNodesCoords,
1301 out array_of_long_array GroupsOfNodes)
1302 raises (SALOME::SALOME_Exception);
1306 * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
1307 * the initial triangle mesh. Positions of new nodes are found by cutting the mesh by
1308 * the plane passing through pairs of points specified by each PolySegment structure.
1309 * If there are several paths connecting a pair of points, the shortest path is
1310 * selected by the module. Position of the cutting plane is defined by the two
1311 * points and an optional vector lying on the plane specified by a PolySegment.
1312 * By default the vector is defined by Mesh module as following. A middle point
1313 * of the two given points is computed. The middle point is projected to the mesh.
1314 * The vector goes from the middle point to the projection point. In case of planar
1315 * mesh, the vector is normal to the mesh.
1316 * \param [inout] segments - PolySegment's defining positions of cutting planes.
1317 * Return the used vector which goes from the middle point to its projection.
1318 * \param [in] groupName - optional name of a group where created mesh segments will
1321 void MakePolyLine(inout ListOfPolySegments segments,
1322 in string groupName)
1323 raises (SALOME::SALOME_Exception);
1326 * \brief Create a slot of given width around given 1D elements lying on a triangle mesh.
1327 * The slot is constructed by cutting faces by cylindrical surfaces made
1328 * around each segment. Segments are expected to be created by MakePolyLine().
1329 * \return Edges located at the slot boundary
1331 ListOfEdges MakeSlot( in SMESH_GroupBase segments,
1333 raises (SALOME::SALOME_Exception);