Salome HOME
Merge from BR_plugins_pbyacs 03/04/2013
authorvsr <vsr@opencascade.com>
Thu, 4 Apr 2013 07:08:19 +0000 (07:08 +0000)
committervsr <vsr@opencascade.com>
Thu, 4 Apr 2013 07:08:19 +0000 (07:08 +0000)
211 files changed:
adm_local/unix/config_files/check_SMESH.m4
doc/salome/examples/3dmesh.py
doc/salome/examples/cartesian_algo.py
doc/salome/examples/creating_meshes_ex01.py
doc/salome/examples/creating_meshes_ex02.py
doc/salome/examples/creating_meshes_ex03.py
doc/salome/examples/creating_meshes_ex04.py
doc/salome/examples/creating_meshes_ex05.py
doc/salome/examples/creating_meshes_ex06.py
doc/salome/examples/creating_meshes_ex07.py
doc/salome/examples/creating_meshes_ex08.py
doc/salome/examples/defining_hypotheses_ex01.py
doc/salome/examples/defining_hypotheses_ex02.py
doc/salome/examples/defining_hypotheses_ex03.py
doc/salome/examples/defining_hypotheses_ex04.py
doc/salome/examples/defining_hypotheses_ex05.py
doc/salome/examples/defining_hypotheses_ex06.py
doc/salome/examples/defining_hypotheses_ex07.py
doc/salome/examples/defining_hypotheses_ex08.py
doc/salome/examples/defining_hypotheses_ex09.py
doc/salome/examples/defining_hypotheses_ex10.py
doc/salome/examples/defining_hypotheses_ex11.py
doc/salome/examples/defining_hypotheses_ex12.py
doc/salome/examples/defining_hypotheses_ex13.py
doc/salome/examples/defining_hypotheses_ex14.py
doc/salome/examples/defining_hypotheses_ex15.py
doc/salome/examples/defining_hypotheses_ex16.py
doc/salome/examples/defining_hypotheses_ex17.py
doc/salome/examples/filters_ex01.py
doc/salome/examples/filters_ex02.py
doc/salome/examples/filters_ex03.py
doc/salome/examples/filters_ex04.py
doc/salome/examples/filters_ex05.py
doc/salome/examples/filters_ex06.py
doc/salome/examples/filters_ex07.py
doc/salome/examples/filters_ex08.py
doc/salome/examples/filters_ex09.py
doc/salome/examples/filters_ex10.py
doc/salome/examples/filters_ex11.py
doc/salome/examples/filters_ex12.py
doc/salome/examples/filters_ex13.py
doc/salome/examples/filters_ex14.py
doc/salome/examples/filters_ex15.py
doc/salome/examples/filters_ex16.py
doc/salome/examples/filters_ex17.py
doc/salome/examples/filters_ex18.py
doc/salome/examples/filters_ex19.py
doc/salome/examples/filters_ex20.py
doc/salome/examples/filters_ex21.py
doc/salome/examples/filters_ex22.py
doc/salome/examples/filters_ex23.py
doc/salome/examples/filters_ex24.py
doc/salome/examples/filters_ex25.py
doc/salome/examples/filters_ex26.py
doc/salome/examples/filters_ex27.py
doc/salome/examples/filters_ex28.py
doc/salome/examples/filters_ex29.py
doc/salome/examples/filters_ex30.py
doc/salome/examples/filters_ex31.py
doc/salome/examples/filters_ex32.py
doc/salome/examples/filters_ex33.py
doc/salome/examples/filters_ex34.py
doc/salome/examples/filters_ex35.py
doc/salome/examples/filters_ex36.py
doc/salome/examples/generate_flat_elements.py
doc/salome/examples/grouping_elements_ex01.py
doc/salome/examples/grouping_elements_ex02.py
doc/salome/examples/grouping_elements_ex03.py
doc/salome/examples/grouping_elements_ex04.py
doc/salome/examples/grouping_elements_ex05.py
doc/salome/examples/grouping_elements_ex06.py
doc/salome/examples/grouping_elements_ex07.py
doc/salome/examples/grouping_elements_ex08.py
doc/salome/examples/measurements_ex01.py
doc/salome/examples/measurements_ex02.py
doc/salome/examples/modifying_meshes_ex01.py
doc/salome/examples/modifying_meshes_ex02.py
doc/salome/examples/modifying_meshes_ex03.py
doc/salome/examples/modifying_meshes_ex09.py
doc/salome/examples/modifying_meshes_ex10.py
doc/salome/examples/modifying_meshes_ex15.py
doc/salome/examples/modifying_meshes_ex16.py
doc/salome/examples/modifying_meshes_ex17.py
doc/salome/examples/modifying_meshes_ex18.py
doc/salome/examples/modifying_meshes_ex19.py
doc/salome/examples/modifying_meshes_ex20.py
doc/salome/examples/modifying_meshes_ex21.py
doc/salome/examples/modifying_meshes_ex22.py
doc/salome/examples/modifying_meshes_ex23.py
doc/salome/examples/modifying_meshes_ex25.py
doc/salome/examples/modifying_meshes_ex26.py
doc/salome/examples/notebook_smesh.py
doc/salome/examples/quality_controls_ex01.py
doc/salome/examples/quality_controls_ex02.py
doc/salome/examples/quality_controls_ex03.py
doc/salome/examples/quality_controls_ex04.py
doc/salome/examples/quality_controls_ex05.py
doc/salome/examples/quality_controls_ex06.py
doc/salome/examples/quality_controls_ex07.py
doc/salome/examples/quality_controls_ex08.py
doc/salome/examples/quality_controls_ex09.py
doc/salome/examples/quality_controls_ex10.py
doc/salome/examples/quality_controls_ex11.py
doc/salome/examples/quality_controls_ex12.py
doc/salome/examples/quality_controls_ex13.py
doc/salome/examples/quality_controls_ex14.py
doc/salome/examples/quality_controls_ex15.py
doc/salome/examples/quality_controls_ex16.py
doc/salome/examples/quality_controls_ex17.py
doc/salome/examples/quality_controls_ex18.py
doc/salome/examples/quality_controls_ex19.py
doc/salome/examples/quality_controls_ex20.py
doc/salome/examples/quality_controls_ex21.py
doc/salome/examples/quality_controls_ex22.py
doc/salome/examples/transforming_meshes_ex01.py
doc/salome/examples/transforming_meshes_ex02.py
doc/salome/examples/transforming_meshes_ex03.py
doc/salome/examples/transforming_meshes_ex04.py
doc/salome/examples/transforming_meshes_ex06.py
doc/salome/examples/transforming_meshes_ex07.py
doc/salome/examples/transforming_meshes_ex08.py
doc/salome/examples/transforming_meshes_ex09.py
doc/salome/examples/transforming_meshes_ex10.py
doc/salome/examples/transforming_meshes_ex11.py
doc/salome/examples/transforming_meshes_ex12.py
doc/salome/examples/transforming_meshes_ex13.py
doc/salome/examples/use_existing_faces.py
doc/salome/examples/viewing_meshes_ex01.py
doc/salome/examples/viewing_meshes_ex02.py
doc/salome/gui/SMESH/Makefile.am
doc/salome/gui/SMESH/doxyfile_py.in
doc/salome/gui/SMESH/input/smeshpy_interface.doc
doc/salome/gui/SMESH/input/tui_filters.doc
resources/StdMeshers.xml
src/OBJECT/SMESH_Object.h
src/OBJECT/SMESH_ObjectDef.h
src/SMESH_I/SMESH_2smeshpy.cxx
src/SMESH_I/SMESH_2smeshpy.hxx
src/SMESH_I/SMESH_DumpPython.cxx
src/SMESH_I/SMESH_PythonDump.hxx
src/SMESH_SWIG/Makefile.am
src/SMESH_SWIG/PAL_MESH_041_mesh.py
src/SMESH_SWIG/PAL_MESH_043_2D.py
src/SMESH_SWIG/PAL_MESH_043_3D.py
src/SMESH_SWIG/SMESH_AdvancedEditor.py
src/SMESH_SWIG/SMESH_BelongToGeom.py
src/SMESH_SWIG/SMESH_BuildCompound.py
src/SMESH_SWIG/SMESH_GroupFromGeom.py
src/SMESH_SWIG/SMESH_GroupFromGeom2.py
src/SMESH_SWIG/SMESH_GroupLyingOnGeom.py
src/SMESH_SWIG/SMESH_Nut.py
src/SMESH_SWIG/SMESH_Partition1_tetra.py
src/SMESH_SWIG/SMESH_Sphere.py
src/SMESH_SWIG/SMESH_blocks.py
src/SMESH_SWIG/SMESH_box.py
src/SMESH_SWIG/SMESH_box2_tetra.py
src/SMESH_SWIG/SMESH_box3_tetra.py
src/SMESH_SWIG/SMESH_box_tetra.py
src/SMESH_SWIG/SMESH_controls.py
src/SMESH_SWIG/SMESH_demo_hexa2_upd.py
src/SMESH_SWIG/SMESH_fixation.py
src/SMESH_SWIG/SMESH_fixation_hexa.py
src/SMESH_SWIG/SMESH_fixation_netgen.py
src/SMESH_SWIG/SMESH_fixation_tetra.py
src/SMESH_SWIG/SMESH_flight_skin.py
src/SMESH_SWIG/SMESH_freebord.py
src/SMESH_SWIG/SMESH_hexaedre.py
src/SMESH_SWIG/SMESH_mechanic.py
src/SMESH_SWIG/SMESH_mechanic_editor.py
src/SMESH_SWIG/SMESH_mechanic_netgen.py
src/SMESH_SWIG/SMESH_mechanic_tetra.py
src/SMESH_SWIG/SMESH_reg.py
src/SMESH_SWIG/SMESH_test.py
src/SMESH_SWIG/SMESH_test0.py
src/SMESH_SWIG/SMESH_test1.py
src/SMESH_SWIG/SMESH_test1_AndDisplay.py
src/SMESH_SWIG/SMESH_test3.py
src/SMESH_SWIG/SMESH_test4.py
src/SMESH_SWIG/SMESH_test5.py
src/SMESH_SWIG/StdMeshersBuilder.py [new file with mode: 0644]
src/SMESH_SWIG/StdMeshersDC.py [deleted file]
src/SMESH_SWIG/__init__.py [new file with mode: 0644]
src/SMESH_SWIG/ex01_cube2build.py
src/SMESH_SWIG/ex02_cube2primitive.py
src/SMESH_SWIG/ex03_cube2partition.py
src/SMESH_SWIG/ex04_cube5tetraHexa.py
src/SMESH_SWIG/ex05_hole1build.py
src/SMESH_SWIG/ex06_hole1boolean.py
src/SMESH_SWIG/ex07_hole1partition.py
src/SMESH_SWIG/ex08_hole2build.py
src/SMESH_SWIG/ex09_grid4build.py
src/SMESH_SWIG/ex10_grid4geometry.py
src/SMESH_SWIG/ex11_grid3partition.py
src/SMESH_SWIG/ex12_grid17partition.py
src/SMESH_SWIG/ex13_hole1partial.py
src/SMESH_SWIG/ex14_cyl1holed.py
src/SMESH_SWIG/ex15_cyl2geometry.py
src/SMESH_SWIG/ex16_cyl2complementary.py
src/SMESH_SWIG/ex17_dome1.py
src/SMESH_SWIG/ex18_dome2.py
src/SMESH_SWIG/ex19_sphereINcube.py
src/SMESH_SWIG/ex21_lamp.py
src/SMESH_SWIG/ex24_cylinder.py
src/SMESH_SWIG/ex29_refine.py
src/SMESH_SWIG/ex30_groupsOp.py
src/SMESH_SWIG/ex30_tepal.py
src/SMESH_SWIG/ex31_dimGroup.py
src/SMESH_SWIG/smesh.py
src/SMESH_SWIG/smeshBuilder.py [new file with mode: 0644]
src/SMESH_SWIG/smeshDC.py [deleted file]
src/SMESH_SWIG/smesh_algorithm.py

index b8290a2..3877591 100644 (file)
@@ -64,7 +64,7 @@ fi
 
 #CCRTif test -f ${SMESH_DIR}/bin/salome/libSMESH_Swig.py ; then
 #if test -f ${SMESH_DIR}/bin/salome/MED_Test ; then
-if test -f ${SMESH_DIR}/bin/salome/smesh.py ; then
+if test -f ${SMESH_DIR}/bin/salome/SMESH_test.py ; then
    SMesh_ok=yes
    AC_MSG_RESULT(Using SMesh module distribution in ${SMESH_DIR})
 
index bd6d3b4..67a7075 100644 (file)
@@ -1,7 +1,14 @@
 # 3d mesh generation
 
-from geompy import * 
-import smesh 
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 ###
 # Geometry: an assembly of a box, a cylinder and a truncated cone
@@ -18,33 +25,33 @@ radius_2 = 40
 height = 100 
 
 # Build a box
-box = MakeBox(-cote, -cote, -cote, +cote, +cote, +cote) 
+box = geompy.MakeBox(-cote, -cote, -cote, +cote, +cote, +cote) 
 
 # Build a cylinder
-pt1 = MakeVertex(0, 0, cote/3) 
-di1 = MakeVectorDXDYDZ(0, 0, 1) 
-cyl = MakeCylinder(pt1, di1, section, size) 
+pt1 = geompy.MakeVertex(0, 0, cote/3) 
+di1 = geompy.MakeVectorDXDYDZ(0, 0, 1) 
+cyl = geompy.MakeCylinder(pt1, di1, section, size) 
 
 # Build a truncated cone
-pt2 = MakeVertex(0, 0, size) 
-cone = MakeCone(pt2, di1, radius_1, radius_2, height) 
+pt2 = geompy.MakeVertex(0, 0, size) 
+cone = geompy.MakeCone(pt2, di1, radius_1, radius_2, height) 
 
 # Fuse
-box_cyl = MakeFuse(box, cyl) 
-piece = MakeFuse(box_cyl, cone) 
+box_cyl = geompy.MakeFuse(box, cyl) 
+piece = geompy.MakeFuse(box_cyl, cone) 
 
 # Add to the study
-addToStudy(piece, name) 
+geompy.addToStudy(piece, name) 
 
 # Create a group of faces
-group = CreateGroup(piece, ShapeType["FACE"]) 
+group = geompy.CreateGroup(piece, geompy.ShapeType["FACE"]) 
 group_name = name + "_grp" 
-addToStudy(group, group_name) 
+geompy.addToStudy(group, group_name) 
 group.SetName(group_name) 
 
 # Add faces to the group
-faces = SubShapeAllIDs(piece, ShapeType["FACE"]) 
-UnionIDs(group, faces) 
+faces = geompy.SubShapeAllIDs(piece, geompy.ShapeType["FACE"]) 
+geompy.UnionIDs(group, faces) 
 
 ###
 # Create a mesh
index b15455f..dc0dc23 100644 (file)
@@ -1,14 +1,24 @@
 # Usage of Body Fitting algorithm
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 # create a sphere
 sphere = geompy.MakeSphereR( 50 )
 geompy.addToStudy( sphere, "sphere" )
 
 # create a mesh and assign a "Body Fitting" algo
-mesh = Mesh( sphere )
+mesh = smesh.Mesh( sphere )
 cartAlgo = mesh.BodyFitted()
 
 # define a cartesian grid using Coordinates
index 0b93356..f328d05 100644 (file)
@@ -1,7 +1,14 @@
 # Construction of a Mesh
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
 box = geompy.MakeBox(0., 0., 0., 100., 200., 300.)
index c541b4a..fe9f72f 100644 (file)
@@ -1,16 +1,23 @@
 # Construction of a Submesh
 
-from geompy import *
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
-box = MakeBoxDXDYDZ(10., 10., 10.)
-addToStudy(box, "Box")
+box = geompy.MakeBoxDXDYDZ(10., 10., 10.)
+geompy.addToStudy(box, "Box")
 
 # select one edge of the box for definition of a local hypothesis
-p5 = MakeVertex(5., 0., 0.)
-EdgeX = GetEdgeNearPoint(box, p5)
-addToStudyInFather(box, EdgeX, "Edge [0,0,0 - 10,0,0]")
+p5 = geompy.MakeVertex(5., 0., 0.)
+EdgeX = geompy.GetEdgeNearPoint(box, p5)
+geompy.addToStudyInFather(box, EdgeX, "Edge [0,0,0 - 10,0,0]")
 
 # create a hexahedral mesh on the box
 quadra = smesh.Mesh(box, "Box : quadrangle 2D mesh")
index 7b219f3..7cf85b7 100644 (file)
@@ -1,9 +1,14 @@
 # Change priority of submeshes in Mesh
 
 import salome
-import geompy
-import smesh
-import SMESH
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 Box_1 = geompy.MakeBoxDXDYDZ(200, 200, 200)
 [Face_1,Face_2,Face_3,Face_4,Face_5,Face_6] = geompy.SubShapeAllSorted(Box_1, geompy.ShapeType["FACE"])
@@ -24,7 +29,7 @@ Max_Element_Volume_1 = Tetrahedron.MaxElementVolume(40000)
 Regular_1D_1 = Mesh_1.Segment(geom=Face_1)
 Nb_Segments_2 = Regular_1D_1.NumberOfSegments(4)
 Nb_Segments_2.SetDistrType( 0 )
-MEFISTO_2D_1 = Mesh_1.Triangle(algo=smesh.MEFISTO,geom=Face_1)
+MEFISTO_2D_1 = Mesh_1.Triangle(algo=smeshBuilder.MEFISTO,geom=Face_1)
 Length_From_Edges_2D = MEFISTO_2D_1.LengthFromEdges()
 SubMesh_1 = MEFISTO_2D_1.GetSubMesh()
 
@@ -32,7 +37,7 @@ SubMesh_1 = MEFISTO_2D_1.GetSubMesh()
 Regular_1D_2 = Mesh_1.Segment(geom=Face_2)
 Nb_Segments_3 = Regular_1D_2.NumberOfSegments(8)
 Nb_Segments_3.SetDistrType( 0 )
-MEFISTO_2D_2 = Mesh_1.Triangle(algo=smesh.MEFISTO,geom=Face_2)
+MEFISTO_2D_2 = Mesh_1.Triangle(algo=smeshBuilder.MEFISTO,geom=Face_2)
 Length_From_Edges_2D_1 = MEFISTO_2D_2.LengthFromEdges()
 SubMesh_2 = MEFISTO_2D_2.GetSubMesh()
 
@@ -40,7 +45,7 @@ SubMesh_2 = MEFISTO_2D_2.GetSubMesh()
 Regular_1D_3 = Mesh_1.Segment(geom=Face_3)
 Nb_Segments_4 = Regular_1D_3.NumberOfSegments(12)
 Nb_Segments_4.SetDistrType( 0 )
-MEFISTO_2D_3 = Mesh_1.Triangle(algo=smesh.MEFISTO,geom=Face_3)
+MEFISTO_2D_3 = Mesh_1.Triangle(algo=smeshBuilder.MEFISTO,geom=Face_3)
 Length_From_Edges_2D_2 = MEFISTO_2D_3.LengthFromEdges()
 SubMesh_3 = MEFISTO_2D_3.GetSubMesh()
 
index 33106c7..f2cdfdb 100644 (file)
@@ -1,7 +1,14 @@
 # Editing of a mesh
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 def PrintMeshInfo(theMesh):
     aMesh = theMesh.GetMesh()
index 6ba4103..98e921a 100644 (file)
@@ -1,7 +1,14 @@
 # Export of a Mesh
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
 box = geompy.MakeBox(0., 0., 0., 100., 200., 300.)
index 96b2a29..d16e067 100644 (file)
@@ -1,12 +1,17 @@
 # Creating a hexahedral mesh on a cylinder.
 # Note: it is a copy of 'ex24_cylinder.py' from SMESH_SWIG
 
-import math
-
-import geompy
-import smesh
 import salome
-geo = geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
+import math
 
 # Parameters
 # ----------
@@ -17,62 +22,62 @@ height = 200
 # Build a cylinder
 # ----------------
 
-base = geo.MakeVertex(0, 0, 0)
-direction = geo.MakeVectorDXDYDZ(0, 0, 1)
+base = geompy.MakeVertex(0, 0, 0)
+direction = geompy.MakeVectorDXDYDZ(0, 0, 1)
 
-cylinder = geo.MakeCylinder(base, direction, radius, height)
+cylinder = geompy.MakeCylinder(base, direction, radius, height)
 
-geo.addToStudy(cylinder, "cylinder")
+geompy.addToStudy(cylinder, "cylinder")
 
 # Build blocks
 # ------------
 
 size = radius/2.0
 
-box_rot = geo.MakeBox(-size, -size, 0,  +size, +size, height)
-box_axis = geo.MakeLine(base, direction)
-box = geo.MakeRotation(box_rot, box_axis, math.pi/4)
+box_rot = geompy.MakeBox(-size, -size, 0,  +size, +size, height)
+box_axis = geompy.MakeLine(base, direction)
+box = geompy.MakeRotation(box_rot, box_axis, math.pi/4)
 
-hole = geo.MakeCut(cylinder, box)
+hole = geompy.MakeCut(cylinder, box)
 
 plane_trim = 2000
 
-plane_a = geo.MakePlane(base, geo.MakeVectorDXDYDZ(1, 0, 0), plane_trim)
-plane_b = geo.MakePlane(base, geo.MakeVectorDXDYDZ(0, 1, 0), plane_trim)
+plane_a = geompy.MakePlane(base, geompy.MakeVectorDXDYDZ(1, 0, 0), plane_trim)
+plane_b = geompy.MakePlane(base, geompy.MakeVectorDXDYDZ(0, 1, 0), plane_trim)
 
-blocks_part = geo.MakePartition([hole], [plane_a, plane_b], [], [], geo.ShapeType["SOLID"])
-blocks_list = [box] + geo.SubShapeAll(blocks_part, geo.ShapeType["SOLID"])
-blocks_all = geo.MakeCompound(blocks_list)
-blocks = geo.MakeGlueFaces(blocks_all, 0.0001)
+blocks_part = geompy.MakePartition([hole], [plane_a, plane_b], [], [], geompy.ShapeType["SOLID"])
+blocks_list = [box] + geompy.SubShapeAll(blocks_part, geompy.ShapeType["SOLID"])
+blocks_all = geompy.MakeCompound(blocks_list)
+blocks = geompy.MakeGlueFaces(blocks_all, 0.0001)
 
-geo.addToStudy(blocks, "cylinder:blocks")
+geompy.addToStudy(blocks, "cylinder:blocks")
 
 # Build geometric groups
 # ----------------------
 
 def group(name, shape, type, base=None, direction=None):
-    t = geo.ShapeType[type]
-    g = geo.CreateGroup(shape, t)
+    t = geompy.ShapeType[type]
+    g = geompy.CreateGroup(shape, t)
 
-    geo.addToStudy(g, name)
+    geompy.addToStudy(g, name)
     g.SetName(name)
 
     if base!=None:
-        l = geo.GetShapesOnPlaneWithLocationIDs(shape, t, direction, base, geo.GEOM.ST_ON)
-        geo.UnionIDs(g, l)
+        l = geompy.GetShapesOnPlaneWithLocationIDs(shape, t, direction, base, GEOM.ST_ON)
+        geompy.UnionIDs(g, l)
 
     return g
 
 group_a = group("baseA", blocks, "FACE", base, direction)
 
-base_b  = geo.MakeVertex(0, 0, height)
+base_b  = geompy.MakeVertex(0, 0, height)
 group_b = group("baseB", blocks, "FACE", base_b, direction)
 
 group_1 = group("limit", blocks, "SOLID")
-group_1_all = geo.SubShapeAllIDs(blocks, geo.ShapeType["SOLID"])
-geo.UnionIDs(group_1, group_1_all)
-group_1_box = geo.GetBlockNearPoint(blocks, base)
-geo.DifferenceList(group_1, [group_1_box])
+group_1_all = geompy.SubShapeAllIDs(blocks, geompy.ShapeType["SOLID"])
+geompy.UnionIDs(group_1, group_1_all)
+group_1_box = geompy.GetBlockNearPoint(blocks, base)
+geompy.DifferenceList(group_1, [group_1_box])
 
 # Mesh the blocks with hexahedral
 # -------------------------------
@@ -80,8 +85,8 @@ geo.DifferenceList(group_1, [group_1_box])
 smesh.SetCurrentStudy(salome.myStudy)
 
 def discretize(x, y, z,  n, s=blocks):
-    p = geo.MakeVertex(x, y, z)
-    e = geo.GetEdgeNearPoint(s, p)
+    p = geompy.MakeVertex(x, y, z)
+    e = geompy.GetEdgeNearPoint(s, p)
     a = hexa.Segment(e)
     a.NumberOfSegments(n)
     a.Propagation()
index 3140ace..65a4f74 100644 (file)
@@ -2,8 +2,14 @@
 # Note: it is a copy of 'SMESH_BuildCompound.py' from SMESH_SWIG
 
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 ## create a bottom box
 Box_inf = geompy.MakeBox(0., 0., 0., 200., 200., 50.)
@@ -65,9 +71,9 @@ Ginf2=Mesh_sup.Group(Finf2, "Inf")
 ## create compounds
 # create a compound of two meshes with renaming groups with the same names and
 # merging of elements with the given tolerance
-Compound1 = smesh.smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 0, 1, 1e-05)
+Compound1 = smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 0, 1, 1e-05)
 smesh.SetName(Compound1, 'Compound_with_RenamedGrps_and_MergeElems')
 # create a compound of two meshes with uniting groups with the same names and
 # creating groups of all elements
-Compound2 = smesh.smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 1, 0, 1e-05, True)
+Compound2 = smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 1, 0, 1e-05, True)
 smesh.SetName(Compound2, 'Compound_with_UniteGrps_and_GrpsOfAllElems')
index a76e8d1..18f9dad 100644 (file)
@@ -1,40 +1,47 @@
 # Mesh Copying
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # make geometry of a box
 box = geompy.MakeBoxDXDYDZ(100,100,100)
 face = geompy.SubShapeAllSorted(box, geompy.ShapeType["FACE"])[0]
 
 # generate 3D mesh
-mesh = Mesh(box)
+mesh = smesh.Mesh(box)
 localAlgo = mesh.Triangle(face)
 mesh.AutomaticHexahedralization()
 
 # objects to copy
 fGroup = mesh.GroupOnGeom( face, "2D on face")
-nGroup = mesh.GroupOnGeom( face, "nodes on face", NODE)
+nGroup = mesh.GroupOnGeom( face, "nodes on face", SMESH.NODE)
 subMesh = localAlgo.GetSubMesh()
 
 # make a new mesh by copying different parts of the mesh
 
 # 1. copy the whole mesh
-newMesh = CopyMesh( mesh, "whole mesh copy")
+newMesh = smesh.CopyMesh( mesh, "whole mesh copy")
 
 # 2. copy a group of 2D elements along with groups
-newMesh = CopyMesh( fGroup,  "face group copy with groups",toCopyGroups=True)
+newMesh = smesh.CopyMesh( fGroup,  "face group copy with groups",toCopyGroups=True)
 
 # 3. copy a group of nodes with preseving their ids
-newMesh = CopyMesh( nGroup, "node group copy", toKeepIDs=True)
+newMesh = smesh.CopyMesh( nGroup, "node group copy", toKeepIDs=True)
 
 # 4. copy some faces
 faceIds = fGroup.GetIDs()[-10:]
-newMesh = CopyMesh( mesh.GetIDSource( faceIds, FACE ), "some faces copy")
+newMesh = smesh.CopyMesh( mesh.GetIDSource( faceIds, SMESH.FACE ), "some faces copy")
 
 # 5. copy some nodes
 nodeIds = nGroup.GetIDs()[-10:]
-newMesh = CopyMesh( mesh.GetIDSource( nodeIds, NODE), "some nodes copy")
+newMesh = smesh.CopyMesh( mesh.GetIDSource( nodeIds, SMESH.NODE), "some nodes copy")
 
 # 6. copy a sub-mesh
-newMesh = CopyMesh( subMesh, "submesh copy" )
+newMesh = smesh.CopyMesh( subMesh, "submesh copy" )
index 6efb1cf..4bb75c5 100644 (file)
@@ -1,7 +1,14 @@
 # Arithmetic 1D
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
 box = geompy.MakeBoxDXDYDZ(10., 10., 10.)
index b0726a1..3662d56 100644 (file)
@@ -1,7 +1,14 @@
 # Deflection 1D and Number of Segments
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a face from arc and straight segment
 px = geompy.MakeVertex(100., 0.  , 0.  )
index cfb1ca8..05a984b 100644 (file)
@@ -1,16 +1,23 @@
 # Start and End Length
 
-from geompy import *
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
-box = MakeBoxDXDYDZ(10., 10., 10.)
-addToStudy(box, "Box")
+box = geompy.MakeBoxDXDYDZ(10., 10., 10.)
+geompy.addToStudy(box, "Box")
 
 # get one edge of the box to put local hypothesis on
-p5 = MakeVertex(5., 0., 0.)
-EdgeX = GetEdgeNearPoint(box, p5)
-addToStudyInFather(box, EdgeX, "Edge [0,0,0 - 10,0,0]")
+p5 = geompy.MakeVertex(5., 0., 0.)
+EdgeX = geompy.GetEdgeNearPoint(box, p5)
+geompy.addToStudyInFather(box, EdgeX, "Edge [0,0,0 - 10,0,0]")
 
 # create a hexahedral mesh on the box
 hexa = smesh.Mesh(box, "Box : hexahedrical mesh")
index 0a17f5c..8ebddfc 100644 (file)
@@ -1,16 +1,23 @@
 # Local Length
 
-from geompy import *
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
-box = MakeBoxDXDYDZ(10., 10., 10.)
-addToStudy(box, "Box")
+box = geompy.MakeBoxDXDYDZ(10., 10., 10.)
+geompy.addToStudy(box, "Box")
 
 # get one edge of the box to put local hypothesis on
-p5 = MakeVertex(5., 0., 0.)
-EdgeX = GetEdgeNearPoint(box, p5)
-addToStudyInFather(box, EdgeX, "Edge [0,0,0 - 10,0,0]")
+p5 = geompy.MakeVertex(5., 0., 0.)
+EdgeX = geompy.GetEdgeNearPoint(box, p5)
+geompy.addToStudyInFather(box, EdgeX, "Edge [0,0,0 - 10,0,0]")
 
 # create a hexahedral mesh on the box
 hexa = smesh.Mesh(box, "Box : hexahedrical mesh")
index fcf03d0..d2b98f1 100644 (file)
@@ -1,8 +1,14 @@
 # Maximum Element Area
 
-import geompy
-import smesh
-import salome 
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a face
 px   = geompy.MakeVertex(100., 0.  , 0.  )
index 24bc4da..d6978df 100644 (file)
@@ -1,7 +1,14 @@
 # Maximum Element Volume
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a cylinder
 cyl = geompy.MakeCylinderRH(30., 50.)
index 59d7521..c2dc2cf 100644 (file)
@@ -1,7 +1,14 @@
 # Length from Edges
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create sketchers
 sketcher1 = geompy.MakeSketcher("Sketcher:F 0 0:TT 70 0:TT 70 70:TT 0 70:WW")
index 4387734..34fcbc3 100644 (file)
@@ -1,16 +1,23 @@
 # Propagation
 
-from geompy import *
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
-box = MakeBoxDXDYDZ(10., 10., 10.)
-addToStudy(box, "Box")
+box = geompy.MakeBoxDXDYDZ(10., 10., 10.)
+geompy.addToStudy(box, "Box")
 
 # get one edge of the box to put local hypothesis on
-p5 = MakeVertex(5., 0., 0.)
-EdgeX = GetEdgeNearPoint(box, p5)
-addToStudyInFather(box, EdgeX, "Edge [0,0,0 - 10,0,0]")
+p5 = geompy.MakeVertex(5., 0., 0.)
+EdgeX = geompy.GetEdgeNearPoint(box, p5)
+geompy.addToStudyInFather(box, EdgeX, "Edge [0,0,0 - 10,0,0]")
 
 # create a hexahedral mesh on the box
 hexa = smesh.Mesh(box, "Box : hexahedrical mesh")
index 9956e4b..1ad07c6 100644 (file)
@@ -1,7 +1,14 @@
 # Defining Meshing Algorithms
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
 box = geompy.MakeBoxDXDYDZ(10., 10., 10.)
index 644908b..1ebd7d8 100644 (file)
@@ -2,7 +2,15 @@
 
 # Project prisms from one meshed box to another mesh on the same box
 
-from smesh import *
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # Prepare geometry
 
@@ -36,7 +44,7 @@ geompy.addToStudyInFather( box, edgesF2, "edgesF2" )
 
 
 # Make the source mesh with prisms
-src_mesh = Mesh(box, "Source mesh")
+src_mesh = smesh.Mesh(box, "Source mesh")
 src_mesh.Segment().NumberOfSegments(9,10)
 src_mesh.Quadrangle()
 src_mesh.Hexahedron()
@@ -47,7 +55,7 @@ src_mesh.Compute()
 # Mesh the box using projection algoritms
 
 # Define the same global 1D and 2D hypotheses
-tgt_mesh = Mesh(box, "Target mesh")
+tgt_mesh = smesh.Mesh(box, "Target mesh")
 tgt_mesh.Segment().NumberOfSegments(9,10,UseExisting=True)
 tgt_mesh.Quadrangle()
 
@@ -73,4 +81,4 @@ proj3D.SourceShape3D( box, src_mesh, v1F1, v1F2, v2F1, v2F2 )
 tgt_mesh.Compute()
 
 # Move the source mesh to visualy compare the two meshes
-src_mesh.TranslateObject( src_mesh, MakeDirStruct( 210, 0, 0 ), Copy=False)
+src_mesh.TranslateObject( src_mesh, smesh.MakeDirStruct( 210, 0, 0 ), Copy=False)
index be55047..961a56d 100644 (file)
@@ -2,7 +2,15 @@
 
 # Project triangles from one meshed face to another mesh on the same box
 
-from smesh import *
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # Prepare geometry
 
@@ -20,7 +28,7 @@ geompy.addToStudyInFather( box, Face_1, 'Face_1' )
 geompy.addToStudyInFather( box, Face_2, 'Face_2' )
 
 # Make the source mesh with Netgem2D
-src_mesh = Mesh(Face_1, "Source mesh")
+src_mesh = smesh.Mesh(Face_1, "Source mesh")
 src_mesh.Segment().NumberOfSegments(15)
 src_mesh.Triangle()
 src_mesh.Compute()
index dd891a7..5b6842f 100644 (file)
@@ -1,8 +1,14 @@
 # 1D Mesh with Fixed Points example
 
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 import StdMeshers
 
 # Create face and explode it on edges
index 2839849..32fbef4 100644 (file)
@@ -1,8 +1,14 @@
 # Radial Quadrangle 1D2D example
 
-from smesh import *
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-SetCurrentStudy(salome.myStudy)
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # Create face from the wire and add to study
 Face = geompy.MakeSketcher("Sketcher:F 0 0:TT 20 0:R 90:C 20 90:WF", [0, 0, 0, 1, 0, 0, 0, 0, 1])
@@ -16,7 +22,7 @@ geompy.addToStudyInFather(Face, circle,"circle")
 
 # Define geometry for mesh, and Radial Quadrange algorithm
 mesh = smesh.Mesh(Face)
-radial_Quad_algo = mesh.Quadrangle(algo=RADIAL_QUAD)
+radial_Quad_algo = mesh.Quadrangle(algo=smeshBuilder.RADIAL_QUAD)
 
 # The Radial Quadrange algorithm can work without any hypothesis
 # In this case it uses "Default Nb of Segments" preferences parameter to discretize edges
index 6c93e3d..3f55844 100644 (file)
@@ -1,7 +1,14 @@
 # Quadrangle Parameters example 1 (meshing a face with 3 edges)
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # Get 1/4 part from the disk face.
 Box_1 = geompy.MakeBoxDXDYDZ(100, 100, 100)
index a08dfbf..6e077d8 100644 (file)
@@ -1,7 +1,14 @@
 # Quadrangle Parameters example 2 (using different types)
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 import StdMeshers
 
 # Make quadrangle face and explode it on edges.
index 4930340..9125787 100644 (file)
@@ -1,7 +1,14 @@
 # "Use Existing Elements" example
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # Make a patritioned box
 
@@ -23,15 +30,15 @@ geompy.addToStudyInFather( boxes[1], midFace1, "middle Face")
 
 # Mesh one of boxes with quadrangles. It is a source mesh
 
-srcMesh = Mesh(boxes[0], "source mesh") # box coloser to CS origin
+srcMesh = smesh.Mesh(boxes[0], "source mesh") # box coloser to CS origin
 nSeg1 = srcMesh.Segment().NumberOfSegments(4)
 srcMesh.Quadrangle()
 srcMesh.Compute()
-srcFaceGroup = srcMesh.GroupOnGeom( midFace0, "src faces", FACE )
+srcFaceGroup = srcMesh.GroupOnGeom( midFace0, "src faces", SMESH.FACE )
 
 # Import faces from midFace0 to the target mesh
 
-tgtMesh = Mesh(boxes[1], "target mesh")
+tgtMesh = smesh.Mesh(boxes[1], "target mesh")
 importAlgo = tgtMesh.UseExisting2DElements(midFace1)
 import2hyp = importAlgo.SourceFaces( [srcFaceGroup] )
 tgtMesh.Segment().NumberOfSegments(3)
index dc3ee9b..d21638f 100644 (file)
@@ -1,7 +1,14 @@
 # Viscous layers construction
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 X = geompy.MakeVectorDXDYDZ( 1,0,0 )
 O = geompy.MakeVertex( 100,50,50 )
@@ -19,7 +26,7 @@ geompy.addToStudy( shape, "shape" )
 geompy.addToStudyInFather( shape, face1, "face1")
 
 
-mesh = Mesh(shape, "CFD")
+mesh = smesh.Mesh(shape, "CFD")
 
 mesh.Segment().NumberOfSegments( 4 )
 
@@ -35,6 +42,6 @@ layersHyp = algo3D.ViscousLayers(thickness,numberOfLayers,stretchFactor,ignoreFa
 
 mesh.Compute()
 
-mesh.MakeGroup("Tetras",VOLUME,FT_ElemGeomType,"=",Geom_TETRA)
-mesh.MakeGroup("Pyras",VOLUME,FT_ElemGeomType,"=",Geom_PYRAMID)
-mesh.MakeGroup("Prims",VOLUME,FT_ElemGeomType,"=",Geom_PENTA)
+mesh.MakeGroup("Tetras",SMESH.VOLUME,SMESH.FT_ElemGeomType,"=",SMESH.Geom_TETRA)
+mesh.MakeGroup("Pyras",SMESH.VOLUME,SMESH.FT_ElemGeomType,"=",SMESH.Geom_PYRAMID)
+mesh.MakeGroup("Prims",SMESH.VOLUME,SMESH.FT_ElemGeomType,"=",SMESH.Geom_PENTA)
index 9869047..86be381 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get faces with aspect ratio > 6.5
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_AspectRatio, smesh.FT_MoreThan, 6.5)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_AspectRatio, SMESH.FT_MoreThan, 6.5)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces with aspect ratio > 6.5:", len(ids)
index f692173..5709ef4 100644 (file)
@@ -5,6 +5,6 @@ from SMESH_mechanic import *
 mesh.Tetrahedron()
 mesh.Compute()
 # get volumes with aspect ratio < 2.0
-filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_AspectRatio3D, smesh.FT_LessThan, 2.0)
+filter = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_AspectRatio3D, SMESH.FT_LessThan, 2.0)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of volumes with aspect ratio < 2.0:", len(ids)
index 5afe3a4..c9313bc 100644 (file)
@@ -3,7 +3,7 @@
 # create mesh
 from SMESH_mechanic import *
 # get faces with warping angle = 2.0e-13 with tolerance 5.0e-14
-criterion = smesh.GetCriterion(smesh.FACE, smesh.FT_Warping, smesh.FT_EqualTo, 2.0e-13)
+criterion = smesh.GetCriterion(SMESH.FACE, SMESH.FT_Warping, SMESH.FT_EqualTo, 2.0e-13)
 criterion.Tolerance = 5.0e-14
 filter = smesh.CreateFilterManager().CreateFilter()
 filter.SetCriteria([criterion])
index d4d31a7..fef619c 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get faces with minimum angle > 75
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_MinimumAngle,">", 75)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_MinimumAngle,">", 75)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces with minimum angle > 75:", len(ids)
index b152251..c1c1852 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get faces with taper < 1.e-15
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_Taper, smesh.FT_LessThan, 1.e-15)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Taper, SMESH.FT_LessThan, 1.e-15)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces with taper < 1.e-15:", len(ids)
index 0f609a5..610a9a9 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get faces with skew > 50
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_Skew, smesh.FT_MoreThan, 50)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Skew, SMESH.FT_MoreThan, 50)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces with skew > 50:", len(ids)
index 723d8d2..6c42d52 100644 (file)
@@ -3,9 +3,9 @@
 # create mesh
 from SMESH_mechanic import *
 # get faces with area > 60 and < 90
-criterion1 = smesh.GetCriterion(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 60,\
-                                smesh.FT_Undefined, smesh.FT_LogicalAND)
-criterion2 = smesh.GetCriterion(smesh.FACE, smesh.FT_Area, smesh.FT_LessThan, 90)
+criterion1 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 60,\
+                                SMESH.FT_Undefined, SMESH.FT_LogicalAND)
+criterion2 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_Area, SMESH.FT_LessThan, 90)
 filter = smesh.CreateFilterManager().CreateFilter()
 filter.SetCriteria([criterion1,criterion2])
 ids = mesh.GetIdsFromFilter(filter)
index 2bc96b6..d87f974 100644 (file)
@@ -5,6 +5,6 @@ from SMESH_mechanic import *
 mesh.Tetrahedron()
 mesh.Compute()
 # get volumes faces with volume > 100
-filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_Volume3D, smesh.FT_MoreThan, 100)
+filter = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_Volume3D, SMESH.FT_MoreThan, 100)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of volumes with volume > 100:", len(ids)
index 0d045b7..9efa008 100644 (file)
@@ -1,7 +1,17 @@
 # Free borders
 
 # create mesh
-import geompy, smesh, StdMeshers
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
 face = geompy.MakeFaceHW(100, 100, 1)
 geompy.addToStudy( face, "quadrangle" )
 mesh = smesh.Mesh(face)
@@ -9,6 +19,6 @@ mesh.Segment().NumberOfSegments(10)
 mesh.Triangle().MaxElementArea(25)
 mesh.Compute()
 # get all free borders
-filter = smesh.GetFilter(smesh.EDGE, smesh.FT_FreeBorders)
+filter = smesh.GetFilter(SMESH.EDGE, SMESH.FT_FreeBorders)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of edges on free borders:", len(ids)
index bbbdd98..423b910 100644 (file)
@@ -1,7 +1,17 @@
 # Free edges
 
 # create mesh
-import geompy, smesh, StdMeshers
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
 face = geompy.MakeFaceHW(100, 100, 1)
 geompy.addToStudy( face, "quadrangle" )
 mesh = smesh.Mesh(face)
@@ -9,6 +19,6 @@ mesh.Segment().NumberOfSegments(10)
 mesh.Triangle().MaxElementArea(25)
 mesh.Compute()
 # get all faces with free edges
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_FreeEdges)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_FreeEdges)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces with free edges:", len(ids)
index 4d754bc..5f1bf4c 100644 (file)
@@ -5,6 +5,6 @@ from SMESH_mechanic import *
 # add node
 mesh.AddNode(0,0,0)
 # get all free nodes
-filter = smesh.GetFilter(smesh.NODE, smesh.FT_FreeNodes)
+filter = smesh.GetFilter(SMESH.NODE, SMESH.FT_FreeNodes)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of free nodes:", len(ids)
index dfb0f40..a1f20dc 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get all free faces
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_FreeFaces)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_FreeFaces)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of free faces:", len(ids)
index e20937d..f56d39f 100644 (file)
@@ -3,8 +3,8 @@
 # create mesh
 from SMESH_mechanic import *
 # remove some faces to have faces with bare borders
-mesh.RemoveElements( mesh.GetElementsByType(smesh.FACE)[0:5] )
+mesh.RemoveElements( mesh.GetElementsByType(SMESH.FACE)[0:5] )
 # get all faces bare borders
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_BareBorderFace)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_BareBorderFace)
 ids = mesh.GetIdsFromFilter(filter)
 print "Faces with bare borders:", ids
index 01ea27a..a9021f9 100644 (file)
@@ -2,8 +2,8 @@
 
 # create mesh
 from SMESH_mechanic import *
-faceID = mesh.GetElementsByType(smesh.FACE)[0]
+faceID = mesh.GetElementsByType(SMESH.FACE)[0]
 # get all faces co-planar to the first face with tolerance 5 degrees
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_CoplanarFaces,faceID,Tolerance=5.0)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_CoplanarFaces,faceID,Tolerance=5.0)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces coplanar with the first one:", len(ids)
index 2044c60..3f13447 100644 (file)
@@ -2,6 +2,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get all over-constrained faces
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_OverConstrainedFace)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_OverConstrainedFace)
 ids = mesh.GetIdsFromFilter(filter)
 print "Over-constrained faces:", ids
index 3c7159d..bdca2d8 100644 (file)
@@ -1,20 +1,31 @@
 # Double edges, Double faces, Double volumes
 
-from smesh import *
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 # make a mesh on a box
 box = geompy.MakeBoxDXDYDZ(100,100,100)
-mesh = Mesh( box, "Box" )
+mesh = smesh.Mesh( box, "Box" )
 mesh.Segment().NumberOfSegments(10)
 mesh.Quadrangle()
 mesh.Hexahedron()
 mesh.Compute()
 # copy all elements with translation and Merge nodes
-mesh.TranslateObject( mesh, MakeDirStruct( 10,0,0), Copy=True )
+mesh.TranslateObject( mesh, smesh.MakeDirStruct( 10,0,0), Copy=True )
 mesh.MergeNodes( mesh.FindCoincidentNodes(1e-7) )
 # create filters to find equal elements
-equalEdgesFilter   = GetFilter(SMESH.EDGE, FT_EqualEdges)
-equalFacesFilter   = GetFilter(SMESH.FACE, FT_EqualFaces)
-equalVolumesFilter = GetFilter(SMESH.VOLUME, FT_EqualVolumes)
+equalEdgesFilter   = smesh.GetFilter(SMESH.EDGE, SMESH.FT_EqualEdges)
+equalFacesFilter   = smesh.GetFilter(SMESH.FACE, SMESH.FT_EqualFaces)
+equalVolumesFilter = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_EqualVolumes)
 # get equal elements
 print "Number of equal edges:",   len( mesh.GetIdsFromFilter( equalEdgesFilter ))
 print "Number of equal faces:",   len( mesh.GetIdsFromFilter( equalFacesFilter ))
index b79f4a7..c3f80d6 100644 (file)
@@ -1,16 +1,27 @@
 # Double nodes
 
-from smesh import *
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 # make a mesh on a box
 box = geompy.MakeBoxDXDYDZ(100,100,100)
-mesh = Mesh( box, "Box" )
+mesh = smesh.Mesh( box, "Box" )
 mesh.Segment().NumberOfSegments(10)
 mesh.Quadrangle()
 mesh.Hexahedron()
 mesh.Compute()
 # copy all elements with translation
-mesh.TranslateObject( mesh, MakeDirStruct( 10,0,0), Copy=True )
+mesh.TranslateObject( mesh, smesh.MakeDirStruct( 10,0,0), Copy=True )
 # create filters to find nodes equal within tolerance of 1e-5
-filter = GetFilter(SMESH.NODE, FT_EqualNodes, Tolerance=1e-5)
+filter = smesh.GetFilter(SMESH.NODE, SMESH.FT_EqualNodes, Tolerance=1e-5)
 # get equal nodes
 print "Number of equal nodes:", len( mesh.GetIdsFromFilter( filter ))
index 30158e2..805f54e 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get border edges with number of connected faces = 5
-filter = smesh.GetFilter(smesh.EDGE, smesh.FT_MultiConnection, 5)
+filter = smesh.GetFilter(SMESH.EDGE, SMESH.FT_MultiConnection, 5)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of border edges with 5 faces connected:", len(ids)
index 41b7cc7..3ac7879 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get faces which consist of edges belonging to 2 mesh elements
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_MultiConnection2D, 2)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_MultiConnection2D, 2)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces consisting of edges belonging to 2 faces:", len(ids)
index 37227c4..1bdc00b 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get edges with length > 14
-filter = smesh.GetFilter(smesh.EDGE, smesh.FT_Length, smesh.FT_MoreThan, 14)
+filter = smesh.GetFilter(SMESH.EDGE, SMESH.FT_Length, SMESH.FT_MoreThan, 14)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of edges with length > 14:", len(ids)
index 0882fe2..79c8843 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get all faces that have edges with length > 14
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_Length2D, smesh.FT_MoreThan, 14)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Length2D, SMESH.FT_MoreThan, 14)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces with maximum edge length > 14:", len(ids)
index f654217..0271110 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get all faces that have elements with length > 10
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_MaxElementLength2D, smesh.FT_MoreThan, 10)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_MaxElementLength2D, SMESH.FT_MoreThan, 10)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces with maximum element length > 10:", len(ids)
index 848f8d9..49569df 100644 (file)
@@ -5,6 +5,6 @@ from SMESH_mechanic import *
 mesh.Tetrahedron()
 mesh.Compute()
 # get all volumes that have elements with length > 10
-filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_MaxElementLength3D, smesh.FT_MoreThan, 10)
+filter = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_MaxElementLength3D, SMESH.FT_MoreThan, 10)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of volumes with maximum element length > 10:", len(ids)
index 036ba03..bab47e2 100644 (file)
@@ -7,6 +7,6 @@ mesh.Compute()
 # remove some volumes to have volumes with bare borders
 mesh.RemoveElements( mesh.GetElementsByType(VOLUME)[0:5] )
 # get all volumes with bare borders
-filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_BareBorderVolume)
+filter = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_BareBorderVolume)
 ids = mesh.GetIdsFromFilter(filter)
 print "Volumes with bare borders:", ids
index 7e44898..06862c7 100644 (file)
@@ -5,6 +5,6 @@ from SMESH_mechanic import *
 mesh.Tetrahedron()
 mesh.Compute()
 # get all over-constrained volumes
-filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_OverConstrainedVolume)
+filter = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_OverConstrainedVolume)
 ids = mesh.GetIdsFromFilter(filter)
 print "Over-constrained volumes:", ids
index 3c5ce29..d544466 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get all faces which nodes lie on the face sub_face3
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_BelongToGeom, sub_face3)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_BelongToGeom, sub_face3)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces which nodes lie on sub_face3:", len(ids)
index 10067ea..4c38bd9 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get all faces at least one node of each lies on the face sub_face3
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_LyingOnGeom, sub_face3)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_LyingOnGeom, sub_face3)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces at least one node of each lies on sub_face3:", len(ids)
index 032b966..12da64c 100644 (file)
@@ -3,10 +3,9 @@
 # create mesh
 from SMESH_mechanic import *
 # create plane
-import geompy
 plane_1 = geompy.MakePlane(p3,seg1,2000)
 geompy.addToStudy(plane_1, "plane_1")
 # get all nodes which lie on the plane \a plane_1
-filter = smesh.GetFilter(smesh.NODE, smesh.FT_BelongToPlane, plane_1)
+filter = smesh.GetFilter(SMESH.NODE, SMESH.FT_BelongToPlane, plane_1)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of nodes which lie on the plane plane_1:", len(ids)
index c256724..b4a454a 100644 (file)
@@ -3,6 +3,6 @@
 # create mesh
 from SMESH_mechanic import *
 # get all faces which lie on the cylindrical face \a sub_face1
-filter = smesh.GetFilter(smesh.FACE, smesh.FT_BelongToCylinder, sub_face1)
+filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_BelongToCylinder, sub_face1)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of faces which lie on the cylindrical surface sub_face1:", len(ids)
index 19c2138..9d161a7 100644 (file)
@@ -7,6 +7,6 @@ spline_1 = geompy.MakeInterpol([p4,p6,p3,p1])
 surface_1 = geompy.MakePrismVecH( spline_1, vz, 70.0 )
 geompy.addToStudy(surface_1, "surface_1")
 # get all nodes which lie on the surface \a surface_1
-filter = smesh.GetFilter(smesh.NODE, smesh.FT_BelongToGenSurface, surface_1)
+filter = smesh.GetFilter(SMESH.NODE, SMESH.FT_BelongToGenSurface, surface_1)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of nodes which lie on the surface surface_1:", len(ids)
index 4a2acbf..ea9b99e 100644 (file)
@@ -3,9 +3,9 @@
 # create mesh
 from SMESH_mechanic import *
 # get nodes with identifiers [5-10] and [15-30]
-criterion1 = smesh.GetCriterion(smesh.NODE, smesh.FT_RangeOfIds, Threshold="5-10",\
-                                BinaryOp=smesh.FT_LogicalOR)
-criterion2 = smesh.GetCriterion(smesh.NODE, smesh.FT_RangeOfIds, Threshold="15-30")
+criterion1 = smesh.GetCriterion(SMESH.NODE, SMESH.FT_RangeOfIds, Threshold="5-10",\
+                                BinaryOp=SMESH.FT_LogicalOR)
+criterion2 = smesh.GetCriterion(SMESH.NODE, SMESH.FT_RangeOfIds, Threshold="15-30")
 filter = smesh.CreateFilterManager().CreateFilter()
 filter.SetCriteria([criterion1,criterion2])
 ids = mesh.GetIdsFromFilter(filter)
index 726ca15..5ce64d6 100644 (file)
@@ -5,6 +5,6 @@ from SMESH_mechanic import *
 mesh.Tetrahedron()
 mesh.Compute()
 # get all badly oriented volumes
-filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_BadOrientedVolume)
+filter = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_BadOrientedVolume)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of badly oriented volumes:", len(ids)
index 2fbaab0..c844e90 100644 (file)
@@ -3,8 +3,8 @@
 # create mesh
 from SMESH_mechanic import *
 # get number of linear and quadratic edges
-filter_linear = smesh.GetFilter(smesh.EDGE, smesh.FT_LinearOrQuadratic)
-filter_quadratic = smesh.GetFilter(smesh.EDGE, smesh.FT_LinearOrQuadratic, smesh.FT_LogicalNOT)
+filter_linear = smesh.GetFilter(SMESH.EDGE, SMESH.FT_LinearOrQuadratic)
+filter_quadratic = smesh.GetFilter(SMESH.EDGE, SMESH.FT_LinearOrQuadratic, SMESH.FT_LogicalNOT)
 ids_linear = mesh.GetIdsFromFilter(filter_linear)
 ids_quadratic = mesh.GetIdsFromFilter(filter_quadratic)
 print "Number of linear edges:", len(ids_linear), "; number of quadratic edges:", len(ids_quadratic)
index 8e63056..980509d 100644 (file)
@@ -3,12 +3,12 @@
 # create mesh
 from SMESH_mechanic import *
 # create group of edges
-all_edges = mesh.GetElementsByType(smesh.EDGE)
-grp = mesh.MakeGroupByIds("edges group", smesh.EDGE, all_edges[:len(all_edges)/4])
+all_edges = mesh.GetElementsByType(SMESH.EDGE)
+grp = mesh.MakeGroupByIds("edges group", SMESH.EDGE, all_edges[:len(all_edges)/4])
 import SALOMEDS
 c = SALOMEDS.Color(0.1, 0.5, 1.0)
 grp.SetColor(c)
 # get number of the edges not belonging to the group with the given color
-filter = smesh.GetFilter(smesh.EDGE, smesh.FT_GroupColor, c, smesh.FT_LogicalNOT)
+filter = smesh.GetFilter(SMESH.EDGE, SMESH.FT_GroupColor, c, SMESH.FT_LogicalNOT)
 ids = mesh.GetIdsFromFilter(filter)
 print "Number of edges not beloging to the group with color (0.1, 0.5, 1.0):", len(ids)
index 369d732..4a3c2bd 100644 (file)
@@ -5,10 +5,10 @@ from SMESH_mechanic import *
 mesh.Tetrahedron()
 mesh.Compute()
 # get all triangles, quadrangles, tetrahedrons, pyramids
-filter_tri = smesh.GetFilter(smesh.FACE, smesh.FT_ElemGeomType, smesh.Geom_TRIANGLE)
-filter_qua = smesh.GetFilter(smesh.FACE, smesh.FT_ElemGeomType, smesh.Geom_QUADRANGLE)
-filter_tet = smesh.GetFilter(smesh.VOLUME, smesh.FT_ElemGeomType, smesh.Geom_TETRA)
-filter_pyr = smesh.GetFilter(smesh.VOLUME, smesh.FT_ElemGeomType, smesh.Geom_PYRAMID)
+filter_tri = smesh.GetFilter(SMESH.FACE, SMESH.FT_ElemGeomType, smesh.Geom_TRIANGLE)
+filter_qua = smesh.GetFilter(SMESH.FACE, SMESH.FT_ElemGeomType, smesh.Geom_QUADRANGLE)
+filter_tet = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_ElemGeomType, smesh.Geom_TETRA)
+filter_pyr = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_ElemGeomType, smesh.Geom_PYRAMID)
 ids_tri = mesh.GetIdsFromFilter(filter_tri)
 ids_qua = mesh.GetIdsFromFilter(filter_qua)
 ids_tet = mesh.GetIdsFromFilter(filter_tet)
index 7675bc9..3dc8e4f 100644 (file)
@@ -3,11 +3,11 @@
 # create mesh
 from SMESH_mechanic import *
 # get all the quadrangle faces ...
-criterion1 = smesh.GetCriterion(smesh.FACE, smesh.FT_ElemGeomType, smesh.Geom_QUADRANGLE, smesh.FT_LogicalAND)
+criterion1 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_ElemGeomType, SMESH.Geom_QUADRANGLE, SMESH.FT_LogicalAND)
 # ... AND do NOT get those from sub_face3
-criterion2 = smesh.GetCriterion(smesh.FACE, smesh.FT_BelongToGeom, sub_face3, smesh.FT_LogicalNOT)
+criterion2 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_BelongToGeom, sub_face3, SMESH.FT_LogicalNOT)
 filter = smesh.CreateFilterManager().CreateFilter()
 filter.SetCriteria([criterion1,criterion2])
 ids = mesh.GetIdsFromFilter(filter)
 
-myGroup = mesh.MakeGroupByIds("Quads_on_cylindrical_faces",smesh.FACE,ids)
+myGroup = mesh.MakeGroupByIds("Quads_on_cylindrical_faces",SMESH.FACE,ids)
index a23c200..df18718 100644 (file)
@@ -3,9 +3,17 @@
 # This example represents an iron cable (a thin cylinder) in a concrete bloc (a big cylinder).
 # The big cylinder is defined by two geometric volumes.
 
-import geompy
-import smesh
-import SMESH
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
 
 # geometry 
 
@@ -21,22 +29,22 @@ Vertex_3 = geompy.MakeVertex(250, 200, 200)
 Box_1 = geompy.MakeBoxTwoPnt(Vertex_2, Vertex_3)
 Fuse_1 = geompy.MakeFuse(Cylinder_1, Cylinder_2)
 Partition_1 = geompy.MakePartition([Fuse_1], [Cylinder_1, Box_1], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
-[Solid_1,Solid_2] = geompy.GetShapesOnShape(Cylinder_1, Partition_1, geompy.ShapeType["SOLID"], geompy.GEOM.ST_IN)
-[Solid_3,Solid_4] = geompy.GetShapesOnShape(Cylinder_2, Partition_1, geompy.ShapeType["SOLID"], geompy.GEOM.ST_IN)
+[Solid_1,Solid_2] = geompy.GetShapesOnShape(Cylinder_1, Partition_1, geompy.ShapeType["SOLID"], GEOM.ST_IN)
+[Solid_3,Solid_4] = geompy.GetShapesOnShape(Cylinder_2, Partition_1, geompy.ShapeType["SOLID"], GEOM.ST_IN)
 Vertex_4 = geompy.MakeVertex(450, 0, 0)
 Vertex_5 = geompy.MakeVertex(500, 0, 0)
 Vertex_6 = geompy.MakeVertex(550, 0, 0)
 vec1 = geompy.MakeVector(Vertex_4, Vertex_5)
 vec2 = geompy.MakeVector(Vertex_5, Vertex_6)
-[Face_1] = geompy.GetShapesOnPlane(Partition_1, geompy.ShapeType["FACE"], vec1, geompy.GEOM.ST_ON)
-[Face_2] = geompy.GetShapesOnPlane(Partition_1, geompy.ShapeType["FACE"], vec2, geompy.GEOM.ST_ON)
+[Face_1] = geompy.GetShapesOnPlane(Partition_1, geompy.ShapeType["FACE"], vec1, GEOM.ST_ON)
+[Face_2] = geompy.GetShapesOnPlane(Partition_1, geompy.ShapeType["FACE"], vec2, GEOM.ST_ON)
 
 # meshing (we have linear tetrahedrons here, but other elements are OK)
 
 Mesh_1 = smesh.Mesh(Partition_1)
 Regular_1D = Mesh_1.Segment()
 Nb_Segments_1 = Regular_1D.NumberOfSegments(15)
-MEFISTO_2D = Mesh_1.Triangle(algo=smesh.MEFISTO)
+MEFISTO_2D = Mesh_1.Triangle(algo=smeshBuilder.MEFISTO)
 Length_From_Edges_2D = MEFISTO_2D.LengthFromEdges()
 ALGO3D = Mesh_1.Tetrahedron()
 isDone = Mesh_1.Compute()
index d0971d6..0133327 100644 (file)
@@ -1,21 +1,22 @@
 # Create a Standalone Group
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
 salome = SMESH_mechanic.salome
 
 # Get ids of all faces with area > 100 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 100.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 100.)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
 # create a group consisting of faces with area > 100
-aGroup1 = mesh.MakeGroupByIds("Area > 100", smesh.FACE, anIds)
+aGroup1 = mesh.MakeGroupByIds("Area > 100", SMESH.FACE, anIds)
 
 # create a group that contains all nodes from the mesh
-aGroup2 = mesh.CreateEmptyGroup(smesh.NODE, "all nodes")
+aGroup2 = mesh.CreateEmptyGroup(SMESH.NODE, "all nodes")
 aGroup2.AddFrom(mesh.mesh)
 
 salome.sg.updateObjBrowser(1)
index 228248d..909a9b4 100644 (file)
@@ -1,8 +1,15 @@
 # Create a Group on Geometry
 
+
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
 box = geompy.MakeBox(0., 0., 0., 100., 100., 100.)
index 05fb69d..375749c 100644 (file)
@@ -1,23 +1,33 @@
 # Create a Group on Filter
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 box = geompy.MakeBoxDXDYDZ(10,10,10)
 
 # make a mesh with quadrangles of different area in range [1,16]
-mesh = Mesh(box,"Quad mesh")
+mesh = smesh.Mesh(box,"Quad mesh")
 hyp1D = mesh.Segment().StartEndLength( 1, 4 )
 mesh.Quadrangle()
 mesh.Compute()
 
 # create a group on filter selecting faces of medium size
 critaria = [ \
-    GetCriterion(FACE, FT_Area, ">", 1.1, BinaryOp=FT_LogicalAND ),
-    GetCriterion(FACE, FT_Area, "<", 15.0 )
+    smesh.GetCriterion(SMESH.FACE, SMESH.FT_Area, ">", 1.1, BinaryOp=SMESH.FT_LogicalAND ),
+    smesh.GetCriterion(SMESH.FACE, SMESH.FT_Area, "<", 15.0 )
     ]
-filt = GetFilterFromCriteria( critaria )
-filtGroup = mesh.GroupOnFilter( FACE, "group on filter", filt )
+filt = smesh.GetFilterFromCriteria( critaria )
+filtGroup = mesh.GroupOnFilter( SMESH.FACE, "group on filter", filt )
 print "Group on filter contains %s elemens" % filtGroup.Size()
 
 # group on filter is updated if the mesh is modified
@@ -27,12 +37,12 @@ mesh.Compute()
 print "After mesh change, group on filter contains %s elemens" % filtGroup.Size()
 
 # set a new filter defining the group
-filt2 = GetFilter( FACE, FT_RangeOfIds, "1-50" )
+filt2 = smesh.GetFilter( SMESH.FACE, SMESH.FT_RangeOfIds, "1-50" )
 filtGroup.SetFilter( filt2 )
 print "With a new filter, group on filter contains %s elemens" % filtGroup.Size()
 
 # group is updated at modification of the filter
-filt2.SetCriteria( [ GetCriterion( FACE, FT_RangeOfIds, "1-70" )])
+filt2.SetCriteria( [ smesh.GetCriterion( SMESH.FACE, SMESH.FT_RangeOfIds, "1-70" )])
 filtIDs3 = filtGroup.GetIDs()
 print "After filter modification, group on filter contains %s elemens" % filtGroup.Size()
 
index 730a2ca..ebd59e7 100644 (file)
@@ -1,24 +1,25 @@
 # Edit a Group
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
 salome = SMESH_mechanic.salome
 
 # Get ids of all faces with area > 35
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 35.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 35.)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
 print "Criterion: Area > 35, Nb = ", len(anIds)
 
 # create a group by adding elements with area > 35
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Area > 35")
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Area > 35")
 aGroup.Add(anIds) 
 
 # Get ids of all faces with area > 40
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 40.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 40.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
index 90453fe..9883ebd 100644 (file)
@@ -1,31 +1,32 @@
 # Union of groups
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
 salome = SMESH_mechanic.salome
 
 # Criterion : AREA > 20
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 20.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 20.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 print "Criterion: Area > 20, Nb = ", len( anIds ) 
 
 # create a group by adding elements with area > 20
-aGroup1 = mesh.CreateEmptyGroup(smesh.FACE, "Area > 20")
+aGroup1 = mesh.CreateEmptyGroup(SMESH.FACE, "Area > 20")
 aGroup1.Add(anIds)
 
 # Criterion : AREA = 20
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_EqualTo, 20.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_EqualTo, 20.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 print "Criterion: Area = 20, Nb = ", len( anIds ) 
 
 # create a group by adding elements with area = 20
-aGroup2 = mesh.CreateEmptyGroup( smesh.FACE, "Area = 20" )
+aGroup2 = mesh.CreateEmptyGroup( SMESH.FACE, "Area = 20" )
 
 aGroup2.Add(anIds)
 
@@ -35,14 +36,14 @@ print "Criterion: Area >= 20, Nb = ", len(aGroup3.GetListOfID())
 # Please note that also there is UnionGroups() method which works with two groups only
 
 # Criterion : AREA < 20
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_LessThan, 20.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_LessThan, 20.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 print "Criterion: Area < 20, Nb = ", len(anIds)
 
 # create a group by adding elements with area < 20
-aGroup4 = mesh.CreateEmptyGroup(smesh.FACE, "Area < 20")
+aGroup4 = mesh.CreateEmptyGroup(SMESH.FACE, "Area < 20")
 aGroup4.Add(anIds)
 
 # create union group : area >= 20 and area < 20
index cc8146f..060a22d 100644 (file)
@@ -1,31 +1,32 @@
 # Intersection of groups
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
 salome = SMESH_mechanic.salome
 
 # Criterion : AREA > 20
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 20.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 20.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 print "Criterion: Area > 20, Nb = ", len(anIds) 
 
 # create a group by adding elements with area > 20
-aGroup1 = mesh.CreateEmptyGroup(smesh.FACE, "Area > 20")
+aGroup1 = mesh.CreateEmptyGroup(SMESH.FACE, "Area > 20")
 aGroup1.Add(anIds)
 
 # Criterion : AREA < 60
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_LessThan, 60.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_LessThan, 60.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 print "Criterion: Area < 60, Nb = ", len(anIds) 
 
 # create a group by adding elements with area < 60
-aGroup2 = mesh.CreateEmptyGroup(smesh.FACE, "Area < 60")
+aGroup2 = mesh.CreateEmptyGroup(SMESH.FACE, "Area < 60")
 aGroup2.Add(anIds)
 
 # create an intersection of groups : 20 < area < 60
index 5bcccd0..891ed88 100644 (file)
@@ -1,30 +1,31 @@
 # Cut of groups
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
 salome = SMESH_mechanic.salome
 
 # Criterion : AREA > 20
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 20.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 20.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 print "Criterion: Area > 20, Nb = ", len(anIds) 
 
 # create a group by adding elements with area > 20
-aGroupMain = mesh.MakeGroupByIds("Area > 20", smesh.FACE, anIds)
+aGroupMain = mesh.MakeGroupByIds("Area > 20", SMESH.FACE, anIds)
 
 # Criterion : AREA < 60
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_LessThan, 60.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_LessThan, 60.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 print "Criterion: Area < 60, Nb = ", len(anIds) 
 
 # create a group by adding elements with area < 60
-aGroupTool = mesh.MakeGroupByIds("Area < 60", smesh.FACE, anIds)
+aGroupTool = mesh.MakeGroupByIds("Area < 60", SMESH.FACE, anIds)
  
 # create a cut of groups : area >= 60
 aGroupRes = mesh.CutGroups(aGroupMain, aGroupTool, "Area >= 60")
index a86ec63..fa78d72 100644 (file)
@@ -1,35 +1,36 @@
 # Creating groups of entities from existing groups of superior dimensions
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
 salome = SMESH_mechanic.salome
 
 # Criterion : AREA > 100
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 100.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 100.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 print "Criterion: Area > 100, Nb = ", len(anIds) 
 
 # create a group by adding elements with area > 100
-aSrcGroup1 = mesh.MakeGroupByIds("Area > 100", smesh.FACE, anIds)
+aSrcGroup1 = mesh.MakeGroupByIds("Area > 100", SMESH.FACE, anIds)
 
 # Criterion : AREA < 30
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_LessThan, 30.)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_LessThan, 30.)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 print "Criterion: Area < 30, Nb = ", len(anIds) 
 
 # create a group by adding elements with area < 30
-aSrcGroup2 = mesh.MakeGroupByIds("Area < 30", smesh.FACE, anIds)
+aSrcGroup2 = mesh.MakeGroupByIds("Area < 30", SMESH.FACE, anIds)
 
 # Create group of edges using source groups of faces
-aGrp = mesh.CreateDimGroup( [aSrcGroup1, aSrcGroup2], smesh.EDGE, "Edges" )
+aGrp = mesh.CreateDimGroup( [aSrcGroup1, aSrcGroup2], SMESH.EDGE, "Edges" )
 
 # Create group of nodes using source groups of faces
-aGrp = mesh.CreateDimGroup( [aSrcGroup1, aSrcGroup2], smesh.NODE, "Nodes" )
+aGrp = mesh.CreateDimGroup( [aSrcGroup1, aSrcGroup2], SMESH.NODE, "Nodes" )
 
 salome.sg.updateObjBrowser(1)
index 9677547..d8a5bd7 100644 (file)
@@ -1,6 +1,16 @@
 # Minimum Distance
 
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 from SMESH_mechanic import mesh as mesh1
 from SMESH_test1 import mesh as mesh2
 
index 3333bc0..b5fbf8b 100644 (file)
@@ -1,6 +1,17 @@
 # Bounding Box
 
-import smesh
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 from SMESH_mechanic import mesh as mesh1
 from SMESH_test1 import mesh as mesh2
 
index ee183d7..434cc1a 100644 (file)
@@ -1,6 +1,17 @@
 # Add Node
 
-import smesh
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 mesh = smesh.Mesh()
 
index c99bf2a..563295c 100644 (file)
@@ -1,6 +1,17 @@
 # Add 0D Element
 
-import smesh
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 mesh = smesh.Mesh()
 
index 19b423e..beefe20 100644 (file)
@@ -1,6 +1,17 @@
 # Add 0D Element on Element Nodes
 
-import smesh, SMESH, geompy
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 # create a geometry
 box = geompy.MakeBoxDXDYDZ( 10, 10, 10 )
index 2fd9111..476ebbb 100644 (file)
@@ -1,9 +1,18 @@
 # Add Polygon
 
 import math
+
 import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
 
-import smesh
 
 # create an empty mesh structure
 mesh = smesh.Mesh() 
index 1d1af19..894fe9d 100644 (file)
@@ -1,7 +1,17 @@
 # Add Polyhedron
 
+
 import salome
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 import math
 
 # create an empty mesh structure
index 49676d0..ae6d5ea 100644 (file)
@@ -1,18 +1,28 @@
 # Moving Nodes
 
-from geompy import *
-from smesh import *
 
-box = MakeBoxDXDYDZ(200, 200, 200)
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-mesh = Mesh( box )
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
+
+box = geompy.MakeBoxDXDYDZ(200, 200, 200)
+
+mesh = smesh.Mesh( box )
 mesh.Segment().AutomaticLength(0.1)
 mesh.Quadrangle()
 mesh.Compute()
 
 # find node at (0,0,0)
 node000 = None
-for vId in SubShapeAllIDs( box, ShapeType["VERTEX"]):
+for vId in geompy.SubShapeAllIDs( box, geompy.ShapeType["VERTEX"]):
     if node000: break
     nodeIds = mesh.GetSubMeshNodesId( vId, True )
     for node in nodeIds:
index 6567dff..076cebf 100644 (file)
@@ -1,7 +1,17 @@
 # Diagonal Inversion
 
+
 import salome
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 # create an empty mesh structure
 mesh = smesh.Mesh() 
index 732953a..c45fd28 100644 (file)
@@ -1,7 +1,17 @@
 # Uniting two Triangles
 
+
 import salome
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 # create an empty mesh structure
 mesh = smesh.Mesh() 
index 9f73930..60b395a 100644 (file)
@@ -1,7 +1,17 @@
 # Uniting a Set of Triangles
 
+
 import salome
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 # create an empty mesh structure
 mesh = smesh.Mesh() 
@@ -37,7 +47,7 @@ ff[5] = mesh.AddFace([bb[2], tt[3], tt[2]])
 
 # unite a set of triangles
 print "\nUnite a set of triangles ... ",
-res = mesh.TriToQuad([ff[2], ff[3], ff[4], ff[5]], smesh.FT_MinimumAngle, 60.)
+res = mesh.TriToQuad([ff[2], ff[3], ff[4], ff[5]], SMESH.FT_MinimumAngle, 60.)
 if not res: print "failed!"
 else:       print "done."
 
index c3eaf49..7223fb0 100644 (file)
@@ -1,7 +1,17 @@
 # Orientation
 
+
 import salome
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 # create an empty mesh structure
 mesh = smesh.Mesh() 
index aa52da7..ffbff36 100644 (file)
@@ -1,9 +1,10 @@
 # Cutting Quadrangles
 
 import SMESH_mechanic
+import SMESH
 
 smesh = SMESH_mechanic.smesh
 mesh  = SMESH_mechanic.mesh
 
 # cut two quadrangles: 405 and 406
-mesh.QuadToTri([405, 406], smesh.FT_MinimumAngle)
+mesh.QuadToTri([405, 406], SMESH.FT_MinimumAngle)
index ece705c..50355fd 100644 (file)
@@ -1,11 +1,19 @@
 # Smoothing
 
+
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 import SMESH_mechanic
 
-smesh = SMESH_mechanic.smesh
+#smesh = SMESH_mechanic.smesh
 mesh = SMESH_mechanic.mesh
 
 # select the top face
@@ -14,7 +22,7 @@ face = faces[3]
 geompy.addToStudyInFather(SMESH_mechanic.shape_mesh, face, "face planar with hole")
 
 # create a group of faces to be smoothed
-GroupSmooth = mesh.GroupOnGeom(face, "Group of faces (smooth)", smesh.FACE)
+GroupSmooth = mesh.GroupOnGeom(face, "Group of faces (smooth)", SMESH.FACE)
 
 # perform smoothing
 
index e9dcb3c..e6d5fd6 100644 (file)
@@ -1,11 +1,19 @@
 # Extrusion
 
+
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 import SMESH_mechanic
 
-smesh = SMESH_mechanic.smesh
+#smesh = SMESH_mechanic.smesh
 mesh = SMESH_mechanic.mesh 
 
 # select the top face
@@ -14,11 +22,11 @@ face = faces[7]
 geompy.addToStudyInFather(SMESH_mechanic.shape_mesh, face, "face circular top")
 
 # create a vector for extrusion
-point = smesh.PointStruct(0., 0., 5.)
-vector = smesh.DirStruct(point)
+point = SMESH.PointStruct(0., 0., 5.)
+vector = SMESH.DirStruct(point)
 
 # create a group to be extruded
-GroupTri = mesh.GroupOnGeom(face, "Group of faces (extrusion)", smesh.FACE)
+GroupTri = mesh.GroupOnGeom(face, "Group of faces (extrusion)", SMESH.FACE)
 
 # perform extrusion of the group
 mesh.ExtrusionSweepObject(GroupTri, vector, 5)
index a789b76..bad439d 100644 (file)
@@ -1,10 +1,16 @@
 # Extrusion along a Path
 
 import math
+
 import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-# Geometry
-import geompy
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # 1. Create points
 points = [[0, 0], [50, 30], [50, 110], [0, 150], [-80, 150], [-130, 70], [-130, -20]]
@@ -36,7 +42,6 @@ for ii in range(len(Wire_polyline_edges)):
     pass
 
 # Mesh
-import smesh
 
 # Mesh the given shape with the given 1d hypothesis
 def Mesh1D(shape1d, nbSeg, name):
@@ -91,7 +96,7 @@ Edge_Circle_mesh   = Mesh1D(Edge_Circle  , 8, "Edge_Circle")
 # ExtrusionAlongPath
 # IDsOfElements, PathMesh, PathShape, NodeStart,
 # HasAngles, Angles, HasRefPoint, RefPoint
-refPoint = smesh.PointStruct(0, 0, 0)
+refPoint = SMESH.PointStruct(0, 0, 0)
 a10 = 10.0*math.pi/180.0
 a45 = 45.0*math.pi/180.0
 
index e8801e0..4072560 100644 (file)
@@ -1,7 +1,15 @@
 # Pattern Mapping
 
-import geompy
-import smesh
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # define the geometry
 Box_1 = geompy.MakeBoxDXDYDZ(200., 200., 200.)
@@ -41,7 +49,7 @@ isDone = pattern.LoadFromFace(Mesh_2.GetMesh(), Face_2, 0)
 if (isDone != 1): print 'LoadFromFace :', pattern.GetErrorCode()
 
 # apply the pattern to a face of the first mesh
-facesToSplit = Mesh_1.GetElementsByType(smesh.SMESH.FACE)
+facesToSplit = Mesh_1.GetElementsByType(SMESH.FACE)
 print "Splitting %d rectangular face(s) to %d triangles..."%(len(facesToSplit), 2*len(facesToSplit))
 pattern.ApplyToMeshFaces(Mesh_1.GetMesh(), facesToSplit, 0, 0)
 isDone = pattern.MakeMesh(Mesh_1.GetMesh(), 0, 0)
@@ -84,7 +92,7 @@ smp_hexa = """!!! Nb of points:
 pattern_hexa.LoadFromFile(smp_hexa)
 
 # apply the pattern to a mesh
-volsToSplit = Mesh_3.GetElementsByType(smesh.SMESH.VOLUME)
+volsToSplit = Mesh_3.GetElementsByType(SMESH.VOLUME)
 print "Splitting %d hexa volume(s) to %d hexas..."%(len(volsToSplit), 4*len(volsToSplit))
 pattern_hexa.ApplyToHexahedrons(Mesh_3.GetMesh(), volsToSplit,0,3)
 isDone = pattern_hexa.MakeMesh(Mesh_3.GetMesh(), True, True)
@@ -123,7 +131,7 @@ smp_pyra = """!!! Nb of points:
 pattern_pyra.LoadFromFile(smp_pyra)
 
 # apply the pattern to a face mesh
-volsToSplit = Mesh_4.GetElementsByType(smesh.SMESH.VOLUME)
+volsToSplit = Mesh_4.GetElementsByType(SMESH.VOLUME)
 print "Splitting %d hexa volume(s) to %d hexas..."%(len(volsToSplit), 6*len(volsToSplit))
 pattern_pyra.ApplyToHexahedrons(Mesh_4.GetMesh(), volsToSplit,1,0)
 isDone = pattern_pyra.MakeMesh(Mesh_4.GetMesh(), True, True)
index aa8cb43..4a8eba7 100644 (file)
@@ -1,7 +1,15 @@
 # Convert mesh to/from quadratic
 
-import geompy
-import smesh
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create sphere of radius 100
 
index 9cccc7b..e52ef1b 100644 (file)
@@ -1,7 +1,15 @@
 # Using SALOME NoteBook
 
-import geompy
-import smesh
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 import salome_notebook
 
 # set variables
@@ -34,6 +42,6 @@ algo3D.MaxElementVolume("MaxElementVolume")
 ret = tetra.Compute()
 
 # translate the mesh
-point = smesh.PointStruct("Offset", 0., 0.)
-vector = smesh.DirStruct(point) 
+point = SMESH.PointStruct("Offset", 0., 0.)
+vector = SMESH.DirStruct(point)
 tetra.TranslateObject(tetra, vector, 0)
index f411d2e..0f73a56 100644 (file)
@@ -1,9 +1,15 @@
 # Free Borders
 
+
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-import smesh
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create open shell: a box without one plane
 box = geompy.MakeBox(0., 0., 0., 20., 20., 15.)
@@ -21,7 +27,7 @@ algo.MaxElementArea(20.)
 mesh.Compute() 
 
 # criterion : free borders
-aFilter = smesh.GetFilter(smesh.EDGE, smesh.FT_FreeBorders) 
+aFilter = smesh.GetFilter(SMESH.EDGE, SMESH.FT_FreeBorders)
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 # print the result
@@ -35,7 +41,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.GetMesh().CreateGroup(smesh.EDGE, "Free borders")
+aGroup = mesh.GetMesh().CreateGroup(SMESH.EDGE, "Free borders")
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index 5373c4d..491c81e 100644 (file)
@@ -1,10 +1,15 @@
 # Borders at Multiconnection
 
+
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-import smesh
-import SMESH
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create open shell: a box without one plane
 box = geompy.MakeBox(0., 0., 0., 20., 20., 15.)
@@ -24,7 +29,7 @@ mesh.Compute()
 # Criterion : Borders at multi-connection
 nb_conn = 2
 
-aFilter = smesh.GetFilter(smesh.EDGE, smesh.FT_MultiConnection, smesh.FT_EqualTo, nb_conn)
+aFilter = smesh.GetFilter(SMESH.EDGE, SMESH.FT_MultiConnection, SMESH.FT_EqualTo, nb_conn)
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 # print the result
@@ -38,7 +43,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.GetMesh().CreateGroup(smesh.EDGE, "Borders at multi-connections")
+aGroup = mesh.GetMesh().CreateGroup(SMESH.EDGE, "Borders at multi-connections")
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index eaa607b..b1da190 100644 (file)
@@ -1,9 +1,15 @@
 # Length 1D
 
+
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-import smesh
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create open shell: a box without one plane
 box = geompy.MakeBox(0., 0., 0., 20., 20., 15.)
@@ -23,7 +29,7 @@ mesh.Compute()
 # Criterion : Length > 3.
 length_margin = 3.
 
-aFilter = smesh.GetFilter(smesh.EDGE, smesh.FT_Length, smesh.FT_MoreThan, length_margin)
+aFilter = smesh.GetFilter(SMESH.EDGE, SMESH.FT_Length, SMESH.FT_MoreThan, length_margin)
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
 # print the result
@@ -37,7 +43,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.GetMesh().CreateGroup(smesh.EDGE, "Edges with length > " + `length_margin`)
+aGroup = mesh.GetMesh().CreateGroup(SMESH.EDGE, "Edges with length > " + `length_margin`)
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index d26eb4d..c687d92 100644 (file)
@@ -1,6 +1,7 @@
 # Free Edges
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
@@ -12,7 +13,7 @@ aFilterMgr = smesh.CreateFilterManager()
 # Criterion : AREA > 95.
 area_margin = 95.
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, area_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, area_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
@@ -22,8 +23,8 @@ mesh.RemoveElements(anIds)
 aBorders = mesh.GetFreeBorders() 
 
 # create groups
-aGroupF = mesh.CreateEmptyGroup(smesh.FACE, "Faces with free edges")
-aGroupN = mesh.CreateEmptyGroup(smesh.NODE, "Nodes on free edges")
+aGroupF = mesh.CreateEmptyGroup(SMESH.FACE, "Faces with free edges")
+aGroupN = mesh.CreateEmptyGroup(SMESH.NODE, "Nodes on free edges")
 
 # fill groups with elements, corresponding to the criterion
 print ""
index 90c7c04..f034565 100644 (file)
@@ -1,9 +1,15 @@
 # Free Nodes
 
+
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-import smesh
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create box
 box = geompy.MakeBox(0., 0., 0., 100., 200., 300.)
@@ -13,7 +19,7 @@ idbox = geompy.addToStudy(box, "box")
 mesh = smesh.Mesh(box, "Mesh_free_nodes")
 algo = mesh.Segment()
 algo.NumberOfSegments(10)
-algo = mesh.Triangle(smesh.MEFISTO)
+algo = mesh.Triangle(smeshBuilder.MEFISTO)
 algo.MaxElementArea(150.)
 mesh.Compute() 
 
@@ -21,18 +27,18 @@ mesh.Compute()
 # Criterion : AREA < 80.
 area_margin = 80.
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_LessThan, area_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_LessThan, area_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
 mesh.RemoveElements(anIds)
 
 # criterion : free nodes
-aFilter = smesh.GetFilter(smesh.NODE, smesh.FT_FreeNodes) 
+aFilter = smesh.GetFilter(SMESH.NODE, SMESH.FT_FreeNodes)
 anNodeIds = mesh.GetIdsFromFilter(aFilter)
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.NODE, "Free_nodes")
+aGroup = mesh.CreateEmptyGroup(SMESH.NODE, "Free_nodes")
 aGroup.Add(anNodeIds)
 
 # print the result
index 2fe67ab..861206b 100644 (file)
@@ -1,7 +1,15 @@
 # Free Faces
 
+
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 ####### GEOM part ########
 
@@ -30,9 +38,6 @@ geompy.addToStudyInFather( Box_1, Box_1_vertex_21, "Box_1:vertex_21" )
 geompy.addToStudy( Plane_2, "Plane_2" )
 
 ###### SMESH part ######
-import smesh
-
-import StdMeshers
 
 Mesh_1 = smesh.Mesh(Partition_1)
 Regular_1D = Mesh_1.Segment()
@@ -42,10 +47,10 @@ Tetrahedronn = Mesh_1.Tetrahedron()
 isDone = Mesh_1.Compute()
 
 # create a group of free faces
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_FreeFaces )
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_FreeFaces )
 aFaceIds = Mesh_1.GetIdsFromFilter(aFilter)
 
-aGroup = Mesh_1.CreateEmptyGroup(smesh.FACE, "Free_faces")
+aGroup = Mesh_1.CreateEmptyGroup(SMESH.FACE, "Free_faces")
 aGroup.Add(aFaceIds)
 
 # print the result
@@ -59,15 +64,15 @@ for i in range(len(aFaceIds)):
 print ""
 
 #filter faces from plane 2
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_BelongToPlane, Plane_2)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_BelongToPlane, Plane_2)
 aFaceIds = Mesh_1.GetIdsFromFilter(aFilter)
 aGroup.Remove(aFaceIds)
 
 # create a group of shared faces (located on partition boundary inside box)
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_BelongToPlane, Plane_1)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_BelongToPlane, Plane_1)
 aFaceIds = Mesh_1.GetIdsFromFilter(aFilter)
 
-aGroup = Mesh_1.CreateEmptyGroup(smesh.FACE, "Shared_faces")
+aGroup = Mesh_1.CreateEmptyGroup(SMESH.FACE, "Shared_faces")
 aGroup.Add(aFaceIds)
 
 salome.sg.updateObjBrowser(1)
index a2be029..5e84f2b 100644 (file)
@@ -1,7 +1,17 @@
 # Bare border faces
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 box = geompy.MakeBoxDXDYDZ(100, 100, 100)
 geompy.addToStudy( box, "box" )
@@ -12,8 +22,8 @@ mesh.Quadrangle()
 mesh.Compute()
 
 # remove 2 faces
-allFaces = mesh.GetElementsByType(FACE)
+allFaces = mesh.GetElementsByType(SMESH.FACE)
 mesh.RemoveElements( allFaces[0:2])
 
-bareGroup = mesh.MakeGroup("bare faces", FACE, FT_BareBorderFace)
+bareGroup = mesh.MakeGroup("bare faces", SMESH.FACE, SMESH.FT_BareBorderFace)
 assert(bareGroup.Size() == 3)
index 77e7e4c..541af64 100644 (file)
@@ -1,7 +1,17 @@
 # Bare border volumes
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 box = geompy.MakeBoxDXDYDZ(100, 30, 10)
 # the smallest face of the box
@@ -10,7 +20,7 @@ face = geompy.SubShapeAllSorted( box, geompy.ShapeType["FACE"])[0]
 geompy.addToStudy( box, "box" )
 geompy.addToStudyInFather( box, face, "face" )
 
-mesh = Mesh(box)
+mesh = smesh.Mesh(box)
 mesh.AutomaticHexahedralization();
 
 # remove half of mesh faces from the smallest face
@@ -19,5 +29,5 @@ faceToRemove = faceFaces[: len(faceFaces)/2]
 mesh.RemoveElements( faceToRemove )
 
 # make a group of volumes missing the removed faces
-bareGroup = mesh.MakeGroup("bare volumes", VOLUME, FT_BareBorderVolume)
+bareGroup = mesh.MakeGroup("bare volumes", SMESH.VOLUME, SMESH.FT_BareBorderVolume)
 assert(bareGroup.Size() == len( faceToRemove))
index c4ca44e..aca903a 100644 (file)
@@ -1,10 +1,20 @@
 # Over-constrained faces
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
 
-mesh = Mesh()
-faceFilter = GetFilter(FACE,FT_OverConstrainedFace)
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
+
+mesh = smesh.Mesh()
+faceFilter = smesh.GetFilter(SMESH.FACE,SMESH.FT_OverConstrainedFace)
 
 #make an edge
 n1 = mesh.AddNode(0,0,0)
@@ -13,5 +23,5 @@ edge = mesh.AddEdge([n1,n2])
 assert( not mesh.GetIdsFromFilter( faceFilter ))
 
 # make faces 
-mesh.ExtrusionSweep([edge], MakeDirStruct(0,7,0), 5)
+mesh.ExtrusionSweep([edge], smesh.MakeDirStruct(0,7,0), 5)
 assert( 2 == len( mesh.GetIdsFromFilter( faceFilter )))
index 49ef2e7..0411832 100644 (file)
@@ -1,15 +1,25 @@
 # Over-constrained volumes
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
 
-mesh = Mesh()
-volumeFilter = GetFilter(VOLUME,FT_OverConstrainedVolume)
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
+
+mesh = smesh.Mesh()
+volumeFilter = smesh.GetFilter(SMESH.VOLUME,SMESH.FT_OverConstrainedVolume)
 
 # make volumes by extrusion of one face
 n1 = mesh.AddNode(0,0,0)
 n2 = mesh.AddNode(10,0,0)
 edge = mesh.AddEdge([n1,n2])
-mesh.ExtrusionSweep([edge], MakeDirStruct(0,7,0), 1)
-mesh.ExtrusionSweep( mesh.GetElementsByType(FACE), MakeDirStruct(0,0,5), 7)
+mesh.ExtrusionSweep([edge], smesh.MakeDirStruct(0,7,0), 1)
+mesh.ExtrusionSweep( mesh.GetElementsByType(SMESH.FACE), smesh.MakeDirStruct(0,0,5), 7)
 assert( 2 == len( mesh.GetIdsFromFilter( volumeFilter )))
index ca955b6..69352be 100644 (file)
@@ -1,9 +1,15 @@
 # Length 2D
 
+
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-import smesh
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create open shell: a box without one plane
 box = geompy.MakeBox(0., 0., 0., 20., 20., 15.)
@@ -23,7 +29,7 @@ mesh.Compute()
 # Criterion : Length 2D > 5.7
 length_margin = 5.7
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Length2D, smesh.FT_MoreThan, length_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Length2D, SMESH.FT_MoreThan, length_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
@@ -38,7 +44,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Faces with length 2D > " + `length_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Faces with length 2D > " + `length_margin`)
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index 28a0192..4ddcc38 100644 (file)
@@ -1,9 +1,15 @@
 # Borders at Multiconnection 2D
 
+
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-import smesh
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a compound of two glued boxes
 box1 = geompy.MakeBox(0., 0., 0., 20., 20., 15.)
@@ -23,7 +29,7 @@ mesh.Compute()
 # Criterion : MULTI-CONNECTION 2D = 3
 nb_conn = 3
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_MultiConnection2D, smesh.FT_EqualTo, nb_conn)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_MultiConnection2D, SMESH.FT_EqualTo, nb_conn)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -38,7 +44,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Borders at multi-connection 2D = " + `nb_conn`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Borders at multi-connection 2D = " + `nb_conn`)
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index 1673fc7..10810c8 100644 (file)
@@ -1,6 +1,7 @@
 # Area
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic.salome
 # Criterion : AREA > 100.
 area_margin = 100.
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, area_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, area_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -24,7 +25,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Area > " + `area_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Area > " + `area_margin`)
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)  
index 379affd..50f87fb 100644 (file)
@@ -1,6 +1,7 @@
 # Taper
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic.salome
 # Criterion : Taper > 3e-20
 taper_margin = 3e-20
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Taper, smesh.FT_MoreThan, taper_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Taper, SMESH.FT_MoreThan, taper_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -24,7 +25,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Taper > " + `taper_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Taper > " + `taper_margin`)
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index 5ca56db..2c8fe7c 100644 (file)
@@ -1,6 +1,7 @@
 # Aspect Ratio
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic.salome
 # Criterion : ASPECT RATIO > 1.8
 ar_margin = 1.8
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_AspectRatio, smesh.FT_MoreThan, ar_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_AspectRatio, SMESH.FT_MoreThan, ar_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -24,7 +25,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Aspect Ratio > " + `ar_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Aspect Ratio > " + `ar_margin`)
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index a20f38f..5d8bade 100644 (file)
@@ -1,6 +1,7 @@
 # Minimum Angle
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic.salome
 # Criterion : MINIMUM ANGLE < 35.
 min_angle = 35.
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_MinimumAngle, smesh.FT_LessThan, min_angle)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_MinimumAngle, SMESH.FT_LessThan, min_angle)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -24,7 +25,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Minimum Angle < " + `min_angle`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Minimum Angle < " + `min_angle`)
 
 aGroup.Add(anIds)
 
index fcc596c..bd87eae 100644 (file)
@@ -1,6 +1,7 @@
 # Warping
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic.salome
 # Criterion : WARP ANGLE > 1e-15
 wa_margin = 1e-15
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Warping, smesh.FT_MoreThan, wa_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Warping, SMESH.FT_MoreThan, wa_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -24,7 +25,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Warp > " + `wa_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Warp > " + `wa_margin`)
 
 aGroup.Add(anIds)
 
index 42e4b30..972652c 100644 (file)
@@ -1,6 +1,7 @@
 # Skew
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic.salome
 # Criterion : Skew > 38.
 skew_margin = 38.
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_Skew, smesh.FT_MoreThan, skew_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Skew, SMESH.FT_MoreThan, skew_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter)
 
@@ -24,7 +25,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Skew > " + `skew_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Skew > " + `skew_margin`)
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index abe1952..8b7e89a 100644 (file)
@@ -1,6 +1,7 @@
 # Element Diameter 2D
 
 import SMESH_mechanic
+import SMESH
 
 smesh  = SMESH_mechanic.smesh
 mesh   = SMESH_mechanic.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic.salome
 # Criterion : ELEMENT DIAMETER 2D > 10
 mel_2d_margin = 10
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_MaxElementLength2D, smesh.FT_MoreThan, mel_2d_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_MaxElementLength2D, SMESH.FT_MoreThan, mel_2d_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -24,7 +25,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Element Diameter 2D > " + `mel_2d_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Element Diameter 2D > " + `mel_2d_margin`)
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index 9e332e0..40a7bf1 100644 (file)
@@ -1,6 +1,7 @@
 # Aspect Ratio 3D
 
 import SMESH_mechanic_tetra 
+import SMESH
 
 smesh  = SMESH_mechanic_tetra.smesh
 mesh   = SMESH_mechanic_tetra.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic_tetra.salome
 # Criterion : ASPECT RATIO 3D > 4.5
 ar_margin = 4.5
 
-aFilter = smesh.GetFilter(smesh.VOLUME, smesh.FT_AspectRatio3D, smesh.FT_MoreThan, ar_margin)
+aFilter = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_AspectRatio3D, SMESH.FT_MoreThan, ar_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -24,7 +25,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.VOLUME, "Aspect Ratio 3D > " + `ar_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.VOLUME, "Aspect Ratio 3D > " + `ar_margin`)
 
 aGroup.Add(anIds)
 
index 833ffff..29e3843 100644 (file)
@@ -1,6 +1,7 @@
 # Volume
 
 import SMESH_mechanic_tetra
+import SMESH
 
 smesh  = SMESH_mechanic_tetra.smesh
 mesh   = SMESH_mechanic_tetra.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic_tetra.salome
 # Criterion : VOLUME < 7.
 volume_margin = 7.
 
-aFilter = smesh.GetFilter(smesh.VOLUME, smesh.FT_Volume3D, smesh.FT_LessThan, volume_margin)
+aFilter = smesh.GetFilter(SMESH.VOLUME, SMESH.FT_Volume3D, SMESH.FT_LessThan, volume_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -25,7 +26,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.VOLUME, "Volume < " + `volume_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.VOLUME, "Volume < " + `volume_margin`)
 
 aGroup.Add(anIds)
 
index 5264b1a..7cd5823 100644 (file)
@@ -1,6 +1,7 @@
 # Element Diameter 3D
 
 import SMESH_mechanic_tetra
+import SMESH
 
 smesh  = SMESH_mechanic_tetra.smesh
 mesh   = SMESH_mechanic_tetra.mesh
@@ -9,7 +10,7 @@ salome = SMESH_mechanic_tetra.salome
 # Criterion : ELEMENT DIAMETER 3D > 10
 mel_3d_margin = 10
 
-aFilter = smesh.GetFilter(smesh.FACE, smesh.FT_MaxElementLength3D, smesh.FT_MoreThan, mel_3d_margin)
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_MaxElementLength3D, SMESH.FT_MoreThan, mel_3d_margin)
 
 anIds = mesh.GetIdsFromFilter(aFilter) 
 
@@ -24,7 +25,7 @@ for i in range(len(anIds)):
 print ""
 
 # create a group
-aGroup = mesh.CreateEmptyGroup(smesh.FACE, "Element Diameter 3D > " + `mel_3d_margin`)
+aGroup = mesh.CreateEmptyGroup(SMESH.FACE, "Element Diameter 3D > " + `mel_3d_margin`)
 aGroup.Add(anIds)
 
 salome.sg.updateObjBrowser(1)
index 0ea75cc..dc61324 100644 (file)
@@ -1,13 +1,14 @@
 # Translation
 
 import SMESH_mechanic
+import SMESH
 
 smesh = SMESH_mechanic.smesh 
 mesh = SMESH_mechanic.mesh 
 
 # define translation vector
-point = smesh.PointStruct(-150., -150., 0.)
-vector =smesh.DirStruct(point) 
+point = SMESH.PointStruct(-150., -150., 0.)
+vector =SMESH.DirStruct(point)
 
 # translate a mesh
 doCopy = 1
index f96a6bb..5b3ff28 100644 (file)
@@ -3,12 +3,13 @@
 import math
 
 import SMESH_mechanic
+import SMESH
 
 smesh = SMESH_mechanic.smesh
 mesh = SMESH_mechanic.mesh 
 
 # define rotation axis and angle
-axisXYZ = smesh.AxisStruct(0., 0., 0., 5., 5., 20.)
+axisXYZ = SMESH.AxisStruct(0., 0., 0., 5., 5., 20.)
 angle270 = 1.5 * math.pi
 
 # rotate a mesh
index da8105a..a6f7701 100644 (file)
@@ -1,11 +1,18 @@
 # Scale
 
-import geompy
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
 Box = geompy.MakeBoxDXDYDZ(200, 200, 200)
 f = geompy.SubShapeAllSorted(Box, geompy.ShapeType["FACE"])
 
-import smesh,SMESH
-import StdMeshers
 Mesh1 = smesh.Mesh(f[0])
 Regular_1D = Mesh1.Segment()
 Nb_Segments_1 = Regular_1D.NumberOfSegments(3)
index 0bfea61..9100355 100644 (file)
@@ -3,11 +3,12 @@
 import math
 
 import SMESH_mechanic
+import SMESH
 
 smesh = SMESH_mechanic.smesh
 mesh = SMESH_mechanic.mesh 
 
 # create a symmetrical copy of the mesh mirrored through a point
-axis = smesh.AxisStruct(0, 0, 0, 0, 0, 0)
+axis = SMESH.AxisStruct(0, 0, 0, 0, 0, 0)
 
 mesh.Mirror([], axis, smesh.POINT, 1)
index fe8c91d..c9c8353 100644 (file)
@@ -1,8 +1,15 @@
 # Merging Elements
 
+
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a face to be meshed
 px = geompy.MakeVertex(100., 0.  , 0.  )
@@ -44,7 +51,7 @@ circlemesh.Compute()
 
 # extrusion of the mesh
 trias.ExtrusionAlongPath([], circlemesh, circle,
-                         1, 0, [], 0, smesh.PointStruct(0, 0, 0))
+                         1, 0, [], 0, SMESH.PointStruct(0, 0, 0))
 
 # merge nodes
 print "Number of nodes before MergeNodes:", 
index bb42d33..227eb63 100644 (file)
@@ -1,7 +1,15 @@
 # Sew Meshes Border to Side
 
-import geompy
-import smesh
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create two faces of a box
 box1 = geompy.MakeBox(0., 0., -10., 30., 20., 25.)
index e028735..77042de 100644 (file)
@@ -1,7 +1,17 @@
 # Sew Conform Free Borders
 
-import geompy
-import smesh
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 # create two faces of the box
 box1 = geompy.MakeBox(0., 0., -10., 20., 20., 15.)
index 5f92fd1..62fea88 100644 (file)
@@ -1,7 +1,15 @@
 # Sew Free Borders
 
-import geompy
-import smesh
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create two faces of the box
 box1 = geompy.MakeBox(0., 0., 0., 20., 20., 15.)
index c54aca6..426a011 100644 (file)
@@ -1,7 +1,14 @@
 # Sew Side Elements
 
-import geompy
-import smesh
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create two boxes
 box1 = geompy.MakeBox(0.,  0., 0., 10., 10., 10.)
index f94aafe..0c3bee8 100644 (file)
@@ -1,8 +1,15 @@
 # Duplicate nodes
 
+
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # Create a box
 
@@ -20,11 +27,11 @@ mesh.Compute()
 # Without the duplication of border elements
 
 # Nodes to duplicate
-nodes1 = mesh.CreateEmptyGroup( smesh.NODE, 'nodes1' )
+nodes1 = mesh.CreateEmptyGroup( SMESH.NODE, 'nodes1' )
 nodes1.Add( [ 119, 125, 131, 137 ] )
 
 # Group of faces to replace nodes with new ones 
-faces1 = mesh.CreateEmptyGroup( smesh.FACE, 'faces1' )
+faces1 = mesh.CreateEmptyGroup( SMESH.FACE, 'faces1' )
 faces1.Add( [ 144, 151, 158 ] )
 
 # Duplicate nodes
@@ -44,15 +51,15 @@ print "Quadrangles : ", mesh.NbQuadrangles()
 # With the duplication of border elements
 
 # Edges to duplicate
-edges = mesh.CreateEmptyGroup( smesh.EDGE, 'edges' )
+edges = mesh.CreateEmptyGroup( SMESH.EDGE, 'edges' )
 edges.Add( [ 32, 33, 34 ] )
 
 # Nodes not to duplicate
-nodes2 = mesh.CreateEmptyGroup( smesh.NODE, 'nodes2' )
+nodes2 = mesh.CreateEmptyGroup( SMESH.NODE, 'nodes2' )
 nodes2.Add( [ 35, 38 ] )
 
 # Group of faces to replace nodes with new ones 
-faces2 = mesh.CreateEmptyGroup( smesh.FACE, 'faces2' )
+faces2 = mesh.CreateEmptyGroup( SMESH.FACE, 'faces2' )
 faces2.Add( [ 141, 148, 155 ] )
 
 # Duplicate nodes
index 0380cc3..e1d850e 100644 (file)
@@ -1,7 +1,17 @@
 # Create boundary elements
 
-from smesh import *
-SetCurrentStudy(salome.myStudy)
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 box = geompy.MakeBoxDXDYDZ(100, 100, 100)
 gFaces = geompy.SubShapeAllSorted(box, geompy.ShapeType["FACE"])
@@ -19,7 +29,7 @@ twoFaces = geompy.MakeCompound([f1,f2])
 ## -----------
 dim = SMESH.BND_2DFROM3D
 
-init_mesh = Mesh(box, "box")
+init_mesh = smesh.Mesh(box, "box")
 init_mesh.AutomaticHexahedralization() # it makes 3 x 3 x 3 hexahedrons
 
 # remove some faces
@@ -29,7 +39,7 @@ rm_face = faces[ : nb_faces/2]
 init_mesh.RemoveElements( rm_face )
 
 # restore boundary in this mesh
-mesh = CopyMesh( init_mesh, "2D from 3D")
+mesh = smesh.CopyMesh( init_mesh, "2D from 3D")
 groupName = "bnd 2D"
 nb, new_mesh, new_group = mesh.MakeBoundaryElements(dim, groupName)
 
@@ -49,7 +59,7 @@ nb, new_mesh, new_group = init_mesh.MakeBoundaryElements(dim, groupName, meshNam
 ## -----------
 dim = SMESH.BND_1DFROM2D
 
-init_mesh = Mesh(f1, "2D mesh")
+init_mesh = smesh.Mesh(f1, "2D mesh")
 init_mesh.AutomaticHexahedralization()
 
 # remove some edges
@@ -60,7 +70,7 @@ init_mesh.RemoveElements( rm_edge )
 
 
 # restore boundary edges in this mesh
-mesh = CopyMesh( init_mesh, "1D from 2D")
+mesh = smesh.CopyMesh( init_mesh, "1D from 2D")
 groupName = "bnd 1D"
 nb, new_mesh, new_group = mesh.MakeBoundaryElements(dim, groupName)
 
@@ -81,7 +91,7 @@ nb, new_mesh, new_group = init_mesh.MakeBoundaryElements(dim, groupName, meshNam
 ## ------------------
 dim = SMESH.BND_1DFROM3D
 
-init_mesh = Mesh(box, "box")
+init_mesh = smesh.Mesh(box, "box")
 init_mesh.AutomaticHexahedralization() # it makes 3 x 3 x 3 hexahedrons
 # remove all edges
 rm_edges = init_mesh.GetElementsByType( SMESH.EDGE )
@@ -92,7 +102,7 @@ fGroup1 = init_mesh.Group( f1, "f1" )
 fGroup2 = init_mesh.Group( f2, "f2" )
 
 # make 1D boundary around groups in this mesh
-mesh = CopyMesh( init_mesh, "1D from 2D groups", toCopyGroups=True)
+mesh = smesh.CopyMesh( init_mesh, "1D from 2D groups", toCopyGroups=True)
 groups = mesh.GetGroups()
 nb, new_mesh, new_group = mesh.MakeBoundaryElements(dim, groupName,groups=groups)
 
index 0126b71..fb56273 100644 (file)
@@ -1,6 +1,17 @@
 # Reorient faces by vector
 
-import smesh, geompy, SMESH
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 
 # create a geometry consisting of two faces
 box = geompy.MakeBoxDXDYDZ( 10, 10, 10 )
index 12b5a9a..6313164 100644 (file)
@@ -1,6 +1,17 @@
 # Use existing faces algorithm
 
-import smesh, geompy
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+import salome_notebook
+
 import numpy as np
 
 # define my 2D algorithm
index b2fa7df..85bc69f 100644 (file)
@@ -1,8 +1,15 @@
 # Viewing Mesh Infos
 
-import geompy
-import smesh
-import SMESH
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # create a box
 box = geompy.MakeBox(0., 0., 0., 20., 20., 20.)
index cd096ca..2ed0a21 100644 (file)
@@ -1,8 +1,15 @@
 # Find Element by Point
 
-import geompy
-import smesh
-import SMESH
+
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # Create a geometry to mesh
 box = geompy.MakeBoxDXDYDZ(100,100,100)
index 2b47b81..dcdcd89 100755 (executable)
@@ -35,16 +35,7 @@ DOC_PYTHONPATH=$(prefix)/bin/salome:$(prefix)/lib/python$(PYTHON_VERSION)/site-p
 DOC_LD_LIBRARY_PATH=$(prefix)lib/salome:${MED_ROOT_DIR}/lib/salome:${GEOM_ROOT_DIR}/lib/salome:${KERNEL_ROOT_DIR}/lib/salome
 DOC_SMESH_MeshersList=StdMeshers
 
-# to have smesh.py in the documentation instead of smeshDC.py
-# we create dummy smesh.py from the smeshDC.py
-smesh.py: ../../../../src/SMESH_SWIG/smeshDC.py
-       @awk '/^class Mesh:/ { mesh_found=1 } // { if (mesh_found) {print $$0; next} } /^ +(def|#)/ { match( $$0, /^ +/); print substr( $$0, 1+RLENGTH ); next } /^class smeshDC/ { next } //' \
-         $< > $@
-
-tmp/smesh.py: $(top_srcdir)/src/SMESH_SWIG/StdMeshersDC.py $(srcdir)/collect_mesh_methods.py
-       @mkdir -p tmp && PYTHONPATH=$(DOC_PYTHONPATH):${PYTHONPATH} LD_LIBRARY_PATH=$(DOC_LD_LIBRARY_PATH):${LD_LIBRARY_PATH} SMESH_MeshersList=$(DOC_SMESH_MeshersList) $(PYTHON) $(srcdir)/collect_mesh_methods.py -o $@ StdMeshers
-
-usr_docs: doxyfile_py doxyfile smesh.py tmp/smesh.py
+usr_docs: doxyfile_py doxyfile
        @$(DOXYGEN) doxyfile_py ;                                               \
        $(DOXYGEN) doxyfile
 
index 381ed77..e9495d4 100755 (executable)
@@ -99,10 +99,9 @@ EXAMPLE_RECURSIVE      = NO
 #---------------------------------------------------------------------------
 #Input related options
 #---------------------------------------------------------------------------
-INPUT             = smesh.py \
+INPUT             = @top_srcdir@/src/SMESH_SWIG/smeshBuilder.py \
                     @top_srcdir@/src/SMESH_SWIG/smesh_algorithm.py \
-                    @top_srcdir@/src/SMESH_SWIG/StdMeshersDC.py \
-                    tmp/smesh.py
+                    @top_srcdir@/src/SMESH_SWIG/StdMeshersBuilder.py
 FILE_PATTERNS     = 
 IMAGE_PATH        = @srcdir@/images
 RECURSIVE         = NO
index 72d4585..2542a93 100644 (file)
@@ -9,17 +9,17 @@ Documentation for SALOME %Mesh module Python API is available in two forms:
 - <a href="smeshpy_doc/modules.html">Structured documentation</a>, where all methods and
 classes are grouped by their functionality, like it is done in the GUI documentation
 - <a href="smeshpy_doc/namespaces.html">Linear documentation</a> grouped only by classes, declared
-in the \ref smesh and StdMeshersDC Python packages.
+in the \ref SMESH_SWIG.smeshBuilder "smeshBuilder" and \ref SMESH_SWIG.StdMeshersBuilder "StdMeshersBuilder" Python packages.
 
-Python package \ref smesh provides an interface to create and handle
+Class \ref SMESH_SWIG.smeshBuilder.smeshBuilder "smeshBuilder" provides an interface to create and handle
 meshes. It can be used to create an empty mesh or to import mesh from the data file.
 
 As soon as mesh is created, it is possible to manage it via its own
-methods, described in \ref smesh.Mesh "class Mesh" documentation.
+methods, described in \ref SMESH_SWIG.smeshBuilder.Mesh "class Mesh" documentation.
 
-Class \ref smesh.Mesh "Mesh" allows assigning algorithms to a mesh.
+Class \ref SMESH_SWIG.smeshBuilder.Mesh "Mesh" allows assigning algorithms to a mesh.
 Please note that some algorithms, included in the standard SALOME
-distribution are always available. Python package \ref StdMeshersDC
+distribution are always available. Python package \ref SMESH_SWIG.StdMeshersBuilder "StdMeshersBuilder"
 provides an interface for standard meshing algorithms included into
 the SALOME %Mesh module distribution, like:
 - REGULAR (1D)
index eaf5d28..9f8bff8 100755 (executable)
@@ -23,8 +23,8 @@ Python scripts.
 \section filter_aspect_ratio Aspect ratio
 
 Filter 2D mesh elements (faces) according to the aspect ratio value:
-- element type should be \a smesh.FACE
-- functor type should be \a smesh.FT_AspectRatio
+- element type should be \a SMESH.FACE
+- functor type should be \a SMESH.FT_AspectRatio
 - threshold is floating point value (aspect ratio)
 
 \tui_script{filters_ex01.py}
@@ -34,8 +34,8 @@ Filter 2D mesh elements (faces) according to the aspect ratio value:
 \section filter_aspect_ratio_3d Aspect ratio 3D
 
 Filter 3D mesh elements (volumes) according to the aspect ratio value:
-- element type is \a smesh.VOLUME
-- functor type is \a smesh.FT_AspectRatio3D
+- element type is \a SMESH.VOLUME
+- functor type is \a SMESH.FT_AspectRatio3D
 - threshold is floating point value (aspect ratio)
 
 \tui_script{filters_ex02.py}
@@ -45,8 +45,8 @@ Filter 3D mesh elements (volumes) according to the aspect ratio value:
 \section filter_warping_angle Warping angle
 
 Filter 2D mesh elements (faces) according to the warping angle value:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_Warping
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_Warping
 - threshold is floating point value (warping angle)
 
 \tui_script{filters_ex03.py}
@@ -56,8 +56,8 @@ Filter 2D mesh elements (faces) according to the warping angle value:
 \section filter_minimum_angle Minimum angle
 
 Filter 2D mesh elements (faces) according to the minimum angle value:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_MinimumAngle
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_MinimumAngle
 - threshold is floating point value (minimum angle)
 
 \tui_script{filters_ex04.py}
@@ -67,8 +67,8 @@ Filter 2D mesh elements (faces) according to the minimum angle value:
 \section filter_taper Taper
 
 Filter 2D mesh elements (faces) according to the taper value:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_Taper
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_Taper
 - threshold is floating point value (taper)
 
 \tui_script{filters_ex05.py}
@@ -78,8 +78,8 @@ Filter 2D mesh elements (faces) according to the taper value:
 \section filter_skew Skew
 
 Filter 2D mesh elements (faces) according to the skew value:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_Skew
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_Skew
 - threshold is floating point value (skew)
 
 \tui_script{filters_ex06.py}
@@ -89,8 +89,8 @@ Filter 2D mesh elements (faces) according to the skew value:
 \section filter_area Area
 
 Filter 2D mesh elements (faces) according to the area value:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_Area
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_Area
 - threshold is floating point value (area)
 
 \tui_script{filters_ex07.py}
@@ -100,8 +100,8 @@ Filter 2D mesh elements (faces) according to the area value:
 \section filter_volume Volume
 
 Filter 3D mesh elements (volumes) according to the volume value:
-- element type is \a smesh.VOLUME
-- functor type is \a smesh.FT_Volume3D
+- element type is \a SMESH.VOLUME
+- functor type is \a SMESH.FT_Volume3D
 - threshold is floating point value (volume)
 
 \tui_script{filters_ex08.py}
@@ -111,8 +111,8 @@ Filter 3D mesh elements (volumes) according to the volume value:
 \section filter_free_borders Free borders
 
 Filter 1D mesh elements (edges) which represent free borders of a mesh:
-- element type is \a smesh.EDGE
-- functor type is \a smesh.FT_FreeBorders
+- element type is \a SMESH.EDGE
+- functor type is \a SMESH.FT_FreeBorders
 - threshold value is not required
 
 \tui_script{filters_ex09.py}
@@ -123,8 +123,8 @@ Filter 1D mesh elements (edges) which represent free borders of a mesh:
 
 Filter 2D mesh elements (faces) consisting of edges belonging to one
 element of mesh only:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_FreeEdges
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_FreeEdges
 - threshold value is not required
 
 \tui_script{filters_ex10.py}
@@ -134,8 +134,8 @@ element of mesh only:
 \section filter_free_nodes Free nodes
 
 Filter free nodes:
-- element type is \a smesh.NODE
-- functor type is \a smesh.FT_FreeNodes
+- element type is \a SMESH.NODE
+- functor type is \a SMESH.FT_FreeNodes
 - threshold value is not required
 
 \tui_script{filters_ex11.py}
@@ -145,8 +145,8 @@ Filter free nodes:
 \section filter_free_faces Free faces
 
 Filter free faces:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_FreeFaces
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_FreeFaces
 - threshold value is not required
 
 \tui_script{filters_ex12.py}
@@ -156,8 +156,8 @@ Filter free faces:
 \section filter_bare_border_faces Bare border faces
 
 Filter faces with bare borders:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_BareBorderFace
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_BareBorderFace
 - threshold value is not required
 
 \tui_script{filters_ex13.py}
@@ -167,8 +167,8 @@ Filter faces with bare borders:
 \section filter_coplanar_faces Coplanar faces
 
 Filter faces with bare borders:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_CoplanarFaces
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_CoplanarFaces
 - threshold value is the face ID
 - tolerance is in degrees
 
@@ -177,8 +177,8 @@ Filter faces with bare borders:
 \section filter_over_constrained_faces Over-constrained faces
 
 Filter over-constrained faces:
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_OverConstrainedFace
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_OverConstrainedFace
 - threshold value is not required
 
 \tui_script{filters_ex15.py}
@@ -188,9 +188,9 @@ Filter over-constrained faces:
 \section filter_double_elements Double edges, Double faces, Double volumes
 
 filter mesh elements basing on the same set of nodes:
-- element type is either \a smesh.EGDE, \a smesh.FACE or \a smesh.VOLUME
-- functor type is either \a smesh.FT_EqualEdges, \a
-          smesh.FT_EqualFaces or \a smesh.FT_EqualVolumes, 
+- element type is either \a smesh.EGDE, \a SMESH.FACE or \a SMESH.VOLUME
+- functor type is either \a SMESH.FT_EqualEdges, \a
+          SMESH.FT_EqualFaces or \a SMESH.FT_EqualVolumes,
 - threshold value is not required
 
 \tui_script{filters_ex16.py}
@@ -199,8 +199,8 @@ filter mesh elements basing on the same set of nodes:
 \section tui_double_nodes_control Double nodes
 
 filters mesh nodes which are coincident with other nodes (within a given tolerance):
-- element type is \a smesh.NODE
-- functor type is \a smesh.FT_EqualNodes
+- element type is \a SMESH.NODE
+- functor type is \a SMESH.FT_EqualNodes
 - threshold value is not required
 - default tolerance is 1.0e-7
 
@@ -211,8 +211,8 @@ filters mesh nodes which are coincident with other nodes (within a given toleran
 
 Filter border 1D mesh elements (edges) according to the specified number of
 connections (faces belonging the border edges)
-- element type is \a smesh.EDGE
-- functor type is \a smesh.FT_MultiConnection
+- element type is \a SMESH.EDGE
+- functor type is \a SMESH.FT_MultiConnection
 - threshold is integer value (number of connections)
 
 \tui_script{filters_ex18.py}
@@ -223,8 +223,8 @@ connections (faces belonging the border edges)
 
 Filter 2D mesh elements (faces) which consist of edges belonging
 to the specified number of mesh elements
-- element type is \a smesh.FACE
-- functor type is \a smesh.FT_MultiConnection2D
+- element type is \a SMESH.FACE
+- functor type is \a SMESH.FT_MultiConnection2D
 - threshold is integer value (number of connections)
 
 \tui_script{filters_ex19.py}
@@ -234,8 +234,8 @@ to the specified number of mesh elements
 \section filter_length Length
 
 Filter 1D mesh elements (edges) according to the edge length value:
-- element type should be \a smesh.EDGE
-- functor type should be \a smesh.FT_Length
+- element type should be \a SMESH.EDGE
+- functor type should be \a SMESH.FT_Length
 - threshold is floating point value (length)
 
 \tui_script{filters_ex20.py}
@@ -246,8 +246,8 @@ Filter 1D mesh elements (edges) according to the edge length value:
 
 Filter 2D mesh elements (faces) corresponding to the maximum length.
 value of its edges:
-- element type should be \a smesh.FACE
-- functor type should be \a smesh.FT_Length2D
+- element type should be \a SMESH.FACE
+- functor type should be \a SMESH.FT_Length2D
 - threshold is floating point value (edge length)
 
 \tui_script{filters_ex21.py}
@@ -258,8 +258,8 @@ value of its edges:
 
 Filter 2D mesh elements (faces) corresponding to the maximum length
 value of its edges and diagonals:
-- element type should be \a smesh.FACE
-- functor type should be \a smesh.FT_MaxElementLength2D
+- element type should be \a SMESH.FACE
+- functor type should be \a SMESH.FT_MaxElementLength2D
 - threshold is floating point value (edge/diagonal length)
 
 \tui_script{filters_ex22.py}
@@ -270,8 +270,8 @@ value of its edges and diagonals:
 
 Filter 3D mesh elements (volumes) corresponding to the maximum length
 value of its edges and diagonals:
-- element type should be \a smesh.VOLUME
-- functor type should be \a smesh.FT_MaxElementLength3D
+- element type should be \a SMESH.VOLUME
+- functor type should be \a SMESH.FT_MaxElementLength3D
 - threshold is floating point value (edge/diagonal length)
 
 \tui_script{filters_ex23.py}
@@ -281,8 +281,8 @@ value of its edges and diagonals:
 \section filter_bare_border_volumes Bare border volumes
 
 Filter 3D mesh elements with bare borders:
-- element type is \a smesh.VOLUME
-- functor type is \a smesh.FT_BareBorderVolume
+- element type is \a SMESH.VOLUME
+- functor type is \a SMESH.FT_BareBorderVolume
 - threshold value is not required
 
 \tui_script{filters_ex24.py}
@@ -292,8 +292,8 @@ Filter 3D mesh elements with bare borders:
 \section filter_over_constrained_volumes Over-constrained volumes
 
 Filter over-constrained volumes:
-- element type is \a smesh.VOLUME
-- functor type is \a smesh.FT_OverConstrainedVolume
+- element type is \a SMESH.VOLUME
+- functor type is \a SMESH.FT_OverConstrainedVolume
 - threshold value is not required
 
 \tui_script{filters_ex25.py}
@@ -304,8 +304,8 @@ Filter over-constrained volumes:
 
 Filter mesh entities (nodes or elements) which all nodes lie on the
 shape defined by threshold value:
-- element type can be any entity type, from \a smesh.NODE to \a smesh.VOLUME
-- functor type should be \a smesh.FT_BelongToGeom
+- element type can be any entity type, from \a  SMESH.NODE to \a SMESH.VOLUME
+- functor type should be \a SMESH.FT_BelongToGeom
 - threshold is geometrical object
 
 \tui_script{filters_ex26.py}
@@ -314,8 +314,8 @@ shape defined by threshold value:
 
 Filter mesh entities (nodes or elements) at least one node of which lies on the
 shape defined by threshold value:
-- element type can be any entity type, from \a smesh.NODE to \a smesh.VOLUME
-- functor type should be \a smesh.FT_LyingOnGeom
+- element type can be any entity type, from \a  SMESH.NODE to \a SMESH.VOLUME
+- functor type should be \a SMESH.FT_LyingOnGeom
 - threshold is geometrical object
 
 \tui_script{filters_ex27.py}
@@ -324,8 +324,8 @@ shape defined by threshold value:
 
 Filter mesh entities (nodes or elements) which all nodes belong to the
 plane defined by threshold value with the given tolerance:
-- element type can be: \a smesh.NODE, \a smesh.EDGE, \a smesh.FACE
-- functor type should be \a smesh.FT_BelongToPlane
+- element type can be: \a  SMESH.NODE, \a SMESH.EDGE, \a SMESH.FACE
+- functor type should be \a SMESH.FT_BelongToPlane
 - threshold is geometrical object (plane)
 - default tolerance is 1.0e-7
 
@@ -335,8 +335,8 @@ plane defined by threshold value with the given tolerance:
 
 Filter mesh entities (nodes or elements) which all nodes belong to the
 cylindrical face defined by threshold value with the given tolerance:
-- element type can be: \a smesh.NODE, \a smesh.EDGE, \a smesh.FACE
-- functor type should be \a smesh.FT_BelongToCylinder
+- element type can be: \a , \a SMESH.EDGE, \a SMESH.FACE
+- functor type should be \a SMESH.FT_BelongToCylinder
 - threshold is geometrical object (cylindrical face)
 - default tolerance is 1.0e-7
 
@@ -346,8 +346,8 @@ cylindrical face defined by threshold value with the given tolerance:
 
 Filter mesh entities (nodes or elements) which all nodes belong to the
 arbitrary surface defined by threshold value with the given tolerance:
-- element type can be: \a smesh.NODE, \a smesh.EDGE, \a smesh.FACE
-- functor type should be \a smesh.FT_BelongToGenSurface
+- element type can be: \a  SMESH.NODE, \a SMESH.EDGE, \a SMESH.FACE
+- functor type should be \a SMESH.FT_BelongToGenSurface
 - threshold is geometrical object (arbitrary surface)
 - default tolerance is 1.0e-7
 
@@ -357,8 +357,8 @@ arbitrary surface defined by threshold value with the given tolerance:
 
 Filter mesh entities elements (nodes or elements) according to the
 specified identifiers range:
-- element type can be any entity type, from \a smesh.NODE to \a smesh.VOLUME
-- functor type is \a smesh.FT_RangeOfIds
+- element type can be any entity type, from \a  SMESH.NODE to \a SMESH.VOLUME
+- functor type is \a SMESH.FT_RangeOfIds
 - threshold is string listing required IDs and/or ranges of IDs, e.g."1,2,3,50-60,63,67,70-78" 
 
 \tui_script{filters_ex31.py}
@@ -367,8 +367,8 @@ specified identifiers range:
 
 Filter 3D mesh elements (volumes), which are incorrectly oriented from
 the point of view of MED convention. 
-- element type should be \a smesh.VOLUME
-- functor type is \a smesh.FT_BadOrientedVolume
+- element type should be \a SMESH.VOLUME
+- functor type is \a SMESH.FT_BadOrientedVolume
 - threshold is not required
 
 \tui_script{filters_ex32.py}
@@ -376,10 +376,10 @@ the point of view of MED convention.
 \section filter_linear_or_quadratic Linear / quadratic
 
 Filter linear / quadratic mesh elements:
-- element type should be any element type, e.g.: \a smesh.EDGE, \a smesh.FACE, \a smesh.VOLUME
-- functor type is \a smesh.FT_LinearOrQuadratic
+- element type should be any element type, e.g.: \a SMESH.EDGE, \a SMESH.FACE, \a SMESH.VOLUME
+- functor type is \a SMESH.FT_LinearOrQuadratic
 - threshold is not required
-- if unary operator is set to smesh.FT_LogicalNOT, the quadratic
+- if unary operator is set to SMESH.FT_LogicalNOT, the quadratic
 elements are selected, otherwise (by default) linear elements are selected
 
 \tui_script{filters_ex33.py}
@@ -387,8 +387,8 @@ elements are selected, otherwise (by default) linear elements are selected
 \section filter_group_color Group color
 
 Filter mesh entities, belonging to the group with the color defined by the threshold value.
-- element type can be any entity type, from \a smesh.NODE to \a smesh.VOLUME
-- functor type is \a smesh.FT_GroupColor
+- element type can be any entity type, from \a  SMESH.NODE to \a SMESH.VOLUME
+- functor type is \a SMESH.FT_GroupColor
 - threshold should be of SALOMEDS.Color type
 
 \tui_script{filters_ex34.py}
@@ -398,8 +398,8 @@ Filter mesh entities, belonging to the group with the color defined by the thres
 Filter mesh elements by the geometric type defined with the threshold
 value. The list of available geometric types depends on the element
 entity type.
-- element type should be any element type, e.g.: \a smesh.EDGE, \a smesh.FACE, \a smesh.VOLUME
-- functor type should be \a smesh.FT_ElemGeomType
+- element type should be any element type, e.g.: \a SMESH.EDGE, \a SMESH.FACE, \a SMESH.VOLUME
+- functor type should be \a SMESH.FT_ElemGeomType
 - threshold is of smesh.GeometryType value
 
 \tui_script{filters_ex35.py}
index af3dd63..81c8ba2 100644 (file)
                output   ="EDGE"
                dim      ="1">
       <python-wrap>
-        <algo>CompositeSegment_1D=Segment(algo=smesh.COMPOSITE)</algo>
+        <algo>CompositeSegment_1D=Segment(algo=smeshBuilder.COMPOSITE)</algo>
         <hypo>LocalLength=LocalLength(SetLength(), ,SetPrecision())</hypo>
         <hypo>MaxLength=MaxSize(SetLength())</hypo>
         <hypo>Arithmetic1D=Arithmetic1D(SetStartLength(),SetEndLength(),SetReversedEdges())</hypo>
                output="EDGE"
                dim="1">
       <python-wrap>
-        <algo>Python_1D=Segment(algo=smesh.PYTHON)</algo>
+        <algo>Python_1D=Segment(algo=smeshBuilder.PYTHON)</algo>
         <hypo>PythonSplit1D=PythonSplit1D(SetNumberOfSegments(),SetPythonLog10RatioFunction())</hypo>
       </python-wrap>
     </algorithm>
                output    ="TRIA"
                dim       ="2">
       <python-wrap>
-        <algo>MEFISTO_2D=Triangle(algo=smesh.MEFISTO)</algo>
+        <algo>MEFISTO_2D=Triangle(algo=smeshBuilder.MEFISTO)</algo>
         <hypo>LengthFromEdges=LengthFromEdges()</hypo>
         <hypo>MaxElementArea=MaxElementArea(SetMaxElementArea())</hypo>
         <hypo>ViscousLayers2D=ViscousLayers2D(SetTotalThickness(),SetNumberLayers(),SetStretchFactor(),SetIgnoreEdges())</hypo>
                output   ="QUAD"
                dim      ="2">
       <python-wrap>
-        <algo>Quadrangle_2D=Quadrangle(algo=smesh.QUADRANGLE)</algo>
+        <algo>Quadrangle_2D=Quadrangle(algo=smeshBuilder.QUADRANGLE)</algo>
         <hypo>QuadrangleParams=QuadrangleParameters(SetQuadType(),SetTriaVertex())</hypo>
         <hypo>ViscousLayers2D=ViscousLayers2D(SetTotalThickness(),SetNumberLayers(),SetStretchFactor(),SetIgnoreEdges())</hypo>
       </python-wrap>
                opt-hypos="ViscousLayers"
                dim      ="3">
       <python-wrap>
-        <algo>Hexa_3D=Hexahedron(algo=smesh.Hexa)</algo>
+        <algo>Hexa_3D=Hexahedron(algo=smeshBuilder.Hexa)</algo>
         <hypo>ViscousLayers=ViscousLayers(SetTotalThickness(),SetNumberLayers(),SetStretchFactor(),SetIgnoreFaces())</hypo>
       </python-wrap>
     </algorithm>
                output  ="QUAD,TRIA"
                dim     ="2">
       <python-wrap>
-        <algo>RadialQuadrangle_1D2D=Quadrangle(algo=smesh.RADIAL_QUAD)</algo>
+        <algo>RadialQuadrangle_1D2D=Quadrangle(algo=smeshBuilder.RADIAL_QUAD)</algo>
         <hypo>NumberOfLayers2D=NumberOfLayers(SetNumberOfLayers())</hypo>
       </python-wrap>
     </algorithm>
index 84d42dd..dbafd97 100644 (file)
@@ -24,7 +24,6 @@
 //  File   : SMESH_Object.h
 //  Author : Nicolas REJNERI
 //  Module : SMESH
-//  $Header$
 //
 #ifndef SMESH_OBJECT_H
 #define SMESH_OBJECT_H
index 5f37334..116ee53 100644 (file)
@@ -24,7 +24,6 @@
 //  File   : SMESH_Object.h
 //  Author : Nicolas REJNERI
 //  Module : SMESH
-//  $Header$
 //
 #ifndef SMESH_OBJECTDEF_H
 #define SMESH_OBJECTDEF_H
index b8f6840..9994f8f 100644 (file)
@@ -345,7 +345,7 @@ namespace {
 
 //================================================================================
 /*!
- * \brief Convert a python script using commands of smesh.py
+ * \brief Convert a python script using commands of smeshBuilder.py
  *  \param theScript - Input script
  *  \param theEntry2AccessorMethod - returns method names to access to
  *         objects wrapped with python class
@@ -498,7 +498,7 @@ _pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod
 
 //================================================================================
 /*!
- * \brief name of SMESH_Gen in smesh.py
+ * \brief name of SMESH_Gen in smeshBuilder.py
  */
 //================================================================================
 
@@ -916,7 +916,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
 
   // Replace name of SMESH_Gen
 
-  // names of SMESH_Gen methods fully equal to methods defined in smesh.py
+  // names of SMESH_Gen methods fully equal to methods defined in smeshBuilder.py
   static TStringSet smeshpyMethods;
   if ( smeshpyMethods.empty() ) {
     const char * names[] =
index 19a4648..f2df48d 100644 (file)
@@ -47,8 +47,8 @@
  * This file was created in order to respond to requirement of bug PAL10494:
  * SMESH python dump uses idl interface.
  *
- * The creation reason is that smesh.py commands defining hypotheses encapsulate
- * several SMESH engine method calls. As well, the dependencies between smesh.py
+ * The creation reason is that smeshBuilder.py commands defining hypotheses encapsulate
+ * several SMESH engine method calls. As well, the dependencies between smeshBuilder.py
  * classes differ from ones between corresponding SMESH IDL interfaces.
  * 
  * Everything here is for internal usage by SMESH_2smeshpy::ConvertScript()
index 15770dc..8736356 100644 (file)
@@ -869,9 +869,9 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
   aScript += helper + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()\n\t";
   aScript += helper + "aMeasurements = " + aSMESHGen + ".CreateMeasurements()\n\t";
   if ( isPublished )
-    aScript += aSMESHGen + ".SetCurrentStudy(theStudy)";
+    aScript += aSMESHGen + " = smeshBuilder.New(theStudy)";
   else
-    aScript += aSMESHGen + ".SetCurrentStudy(None)";
+    aScript += aSMESHGen + " = smeshBuilder.New(None)";
 
   // import python files corresponding to plugins
   set<string> moduleNameSet;
@@ -880,14 +880,14 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
     string moduleName = hyp_creator->second->GetModuleName();
     bool newModule = moduleNameSet.insert( moduleName ).second;
     if ( newModule )
-      aScript += helper + "\n\t" + "import " + (char*) moduleName.c_str();
+      aScript += helper + "\n\t" + "from salome." + (char*) moduleName.c_str() + " import " + (char*) moduleName.c_str() +"Builder";
   }
 
   // Dump trace of restored study
   if (theSavedTrace.Length() > 0) {
-    // For the convertion of IDL API calls -> smesh.py API, "smesh" standing for SMESH_Gen
+    // For the convertion of IDL API calls -> smeshBuilder.py API, "smesh" standing for SMESH_Gen
     // was replaces with "smeshgen" (==TPythonDump::SMESHGenName()).
-    // Change "smesh" -> "smeshgen" in the trace saved before passage to smesh.py API
+    // Change "smesh" -> "smeshgen" in the trace saved before passage to smeshBuilder.py API
     bool isNewVersion =
       theSavedTrace.Location( anOldGen + ".", 1, theSavedTrace.Length() );
     if ( !isNewVersion ) {
@@ -915,7 +915,7 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
     aScript += helper + "\n" + aNewLines;
   }
 
-  // Convert IDL API calls into smesh.py API.
+  // Convert IDL API calls into smeshBuilder.py API.
   // Some objects are wrapped with python classes and
   // Resource_DataMapOfAsciiStringAsciiString holds methods returning wrapped objects
   Resource_DataMapOfAsciiStringAsciiString anEntry2AccessorMethod;
@@ -1003,7 +1003,8 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
   TCollection_AsciiString initPart = "import ";
   if ( isMultiFile )
     initPart += helper + "salome, ";
-  initPart += aSmeshpy + ", SMESH, SALOMEDS\n";
+  initPart += " SMESH, SALOMEDS\n";
+  initPart += "from salome.smesh import smeshBuilder\n";
   if ( importGeom && isMultiFile )
   {
     initPart += ("\n## import GEOM dump file ## \n"
@@ -1026,7 +1027,7 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
     if ( aRemovedObjIDs.count( seqRemoved.Value(ir) )) continue;
     anUpdatedScript += "\n\tSO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR(";
     anUpdatedScript += seqRemoved.Value(ir);
-    // for object wrapped by class of smesh.py
+    // for object wrapped by class of smeshBuilder.py
     anEntry = theObjectNames( seqRemoved.Value(ir) );
     if ( anEntry2AccessorMethod.IsBound( anEntry ) )
       anUpdatedScript += helper + "." + anEntry2AccessorMethod( anEntry );
index d1ba4f4..598ad9f 100644 (file)
@@ -50,7 +50,7 @@ class SMESH_2smeshpy
 {
 public:
   /*!
-   * \brief Convert a python script using commands of smesh.py
+   * \brief Convert a python script using commands of smeshBuilder.py
    * \param theScript - Input script
    * \param theEntry2AccessorMethod - returns method names to access to
    *        objects wrapped with python class
index af94b18..b42bc69 100644 (file)
@@ -28,9 +28,6 @@ include $(top_srcdir)/adm_local/unix/make_common_starter.am
 # Scripts to be installed.
 dist_salomescript_PYTHON = \
        smesh.py \
-       smeshDC.py \
-       smesh_algorithm.py \
-       StdMeshersDC.py \
        batchmode_smesh.py \
        batchmode_mefisto.py \
        ex00_all.py \
@@ -99,5 +96,15 @@ dist_salomescript_PYTHON = \
        PAL_MESH_043_3D.py \
        SMESH_reg.py
 
+mypkgpythondir = $(salomepythondir)/salome/smesh
+mypkgpython_PYTHON = \
+       smeshBuilder.py \
+       smesh_algorithm.py
+       
+stdpkgpythondir = $(salomepythondir)/salome/StdMeshers
+stdpkgpython_PYTHON = \
+       __init__.py \
+       StdMeshersBuilder.py
+       
 sharedpkgpython_PYTHON =               \
        SMESH_shared_modules.py
index fe38452..12c5b88 100755 (executable)
 #
 
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 
 #-----------------------------GEOM----------------------------------------
@@ -55,7 +61,6 @@ Id_face1 = geompy.addToStudy(face1,"Face1")
 
 
 #-----------------------------SMESH-------------------------------------------
-smesh.SetCurrentStudy(salome.myStudy)
 
 # -- Init mesh --
 plane_mesh = salome.IDToObject( Id_face1)
index 15eb20e..a51bf5b 100755 (executable)
 #  Description : Create meshes to test extrusion of mesh elements along path
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 
 #----------------------------------GEOM
@@ -53,7 +59,6 @@ id_ellipse2 = geompy.addToStudy(ellipse2, "Ellips 2")
 
 
 #---------------------------------SMESH
-smesh.SetCurrentStudy(salome.myStudy)
 
 # create the path mesh
 mesh1 = smesh.Mesh(ellipse1, "Path Mesh")
index bcee8d8..b547265 100755 (executable)
 #  Description : Create meshes to test extrusion of mesh elements along path
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 
 # create points to build two circles
@@ -51,8 +57,6 @@ idcircle = geompy.addToStudy(circle, "Circle")
 idface   = geompy.addToStudy(face,   "Circular face")
 
 
-smesh.SetCurrentStudy(salome.myStudy)
-
 # init a Mesh with the circular face
 mesh1 = smesh.Mesh(face, "Mesh on circular face")
 
index 1ebeaa9..49062d3 100644 (file)
 #
 
 import salome
-import smesh
-import math
-
 salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
+import math
 
 def GetNewNodes(mesh,Elems,OldNodes):
     """
@@ -55,7 +61,6 @@ def GetNewNodes(mesh,Elems,OldNodes):
         pass
     return newnodes
             
-smesh.SetCurrentStudy(salome.myStudy)
 
 # create empty mesh
 mesh = smesh.Mesh()
@@ -67,13 +72,13 @@ tol = 0.001
 n1 = mesh.AddNode(55,-5,0)
 n2 = mesh.AddNode(55,5,0)
 e1 = mesh.AddEdge([n1,n2])
-dir1 = smesh.DirStruct(smesh.PointStruct(-10,0,0))
+dir1 = SMESH.DirStruct(SMESH.PointStruct(-10,0,0))
 mesh.ExtrusionSweep([e1],dir1,11)
 # 2. create second edge and make extrusion along 0y
 n3 = mesh.AddNode(-5,-55,0)
 n4 = mesh.AddNode(5,-55,0)
 e2 = mesh.AddEdge([n3,n4])
-dir2 = smesh.DirStruct(smesh.PointStruct(0,10,0))
+dir2 = SMESH.DirStruct(SMESH.PointStruct(0,10,0))
 mesh.ExtrusionSweep([e2],dir2,11)
 
 # since result has coincident nodes and faces
@@ -83,12 +88,12 @@ mesh.MergeNodes(nodes)
 mesh.MergeEqualElements()
 
 # make extrusion faces along 0z
-faces = mesh.GetElementsByType(smesh.FACE)
+faces = mesh.GetElementsByType(SMESH.FACE)
 nbf = len(faces)
 maxang = 2.0
 zstep = 5
 nbzsteps = 50
-dir3 = smesh.DirStruct(smesh.PointStruct(0,0,zstep))
+dir3 = SMESH.DirStruct(SMESH.PointStruct(0,0,zstep))
 newfaces = [] # list for keeping created top faces
               # during extrusion
 
@@ -121,7 +126,7 @@ for i in range(0,nbzsteps):
     pass
     
 # rotate faces from newfaces
-axisr1 = smesh.AxisStruct(0,0,0,0,0,1)
+axisr1 = SMESH.AxisStruct(0,0,0,0,0,1)
 for i in range(0,nbzsteps):
     ang = maxang*(1-math.cos((i+1)*math.pi/nbzsteps))
     mesh.Rotate(newfaces[i],axisr1,ang,0)
@@ -135,7 +140,7 @@ n6 = mesh.AddNode(67.5,0,0)
 n7 = mesh.AddNode(70,0,0)
 e56 = mesh.AddEdge([n5,n6])
 e67 = mesh.AddEdge([n6,n7])
-axisr2 = smesh.AxisStruct(65,0,0,0,1,0)
+axisr2 = SMESH.AxisStruct(65,0,0,0,1,0)
 mesh.RotationSweep([e56,e67],axisr2, math.pi/6, 12, tol)
 res = mesh.GetLastCreatedElems()
 faces1 = []
@@ -152,7 +157,7 @@ n9 = mesh.AddNode(-67.5,0,0)
 n10 = mesh.AddNode(-70,0,0)
 e8 = mesh.AddEdge([n8,n9])
 e9 = mesh.AddEdge([n9,n10])
-axisr3 = smesh.AxisStruct(-65,0,0,0,-1,0)
+axisr3 = SMESH.AxisStruct(-65,0,0,0,-1,0)
 mesh.RotationSweep([e8,e9],axisr3, math.pi/6, 12, tol)
 res = mesh.GetLastCreatedElems()
 faces2 = []
@@ -212,4 +217,4 @@ for i in range(0,nbrs):
     oldnodes = newnodes
     pass
 
-smesh.salome.sg.updateObjBrowser(1)
+salome.sg.updateObjBrowser(1)
index c87d78a..4efbc01 100644 (file)
@@ -25,7 +25,6 @@ from SMESH_test1 import *
 
 ## Old style
 def CheckBelongToGeomFilterOld(theMeshGen, theMesh, theShape, theSubShape, theElemType):
-    import geompy
     if theShape != theSubShape:
         aName = str(theSubShape)
         geompy.addToStudyInFather(theShape,theSubShape,aName)
@@ -45,25 +44,23 @@ def CheckBelongToGeomFilterOld(theMeshGen, theMesh, theShape, theSubShape, theEl
 
 ## Current style
 def CheckBelongToGeomFilter(theMesh, theShape, theSubShape, theElemType):
-    import geompy
-    import smesh
     if theShape != theSubShape:
         aName = str(theSubShape)
         geompy.addToStudyInFather(theShape,theSubShape,aName)
 
     theMesh.Compute()
-    aFilter = smesh.GetFilter(theElemType, smesh.FT_BelongToGeom, theSubShape)
+    aFilter = smesh.GetFilter(theElemType, SMESH.FT_BelongToGeom, theSubShape)
     return aFilter.GetElementsId(theMesh.GetMesh())
     
 
-anElemType = smesh.FACE;
+anElemType = SMESH.FACE;
 print "anElemType =", anElemType
 #anIds = CheckBelongToGeomFilter(mesh,box,subShapeList[1],anElemType)
 anIds = CheckBelongToGeomFilter(mesh,box,box,anElemType)
 print "Number of ids = ", len(anIds)
 print "anIds = ", anIds
 ## Check old version
-#anIds = CheckBelongToGeomFilterOld(smesh.smesh,mesh.GetMesh(),box,box,anElemType)
+#anIds = CheckBelongToGeomFilterOld(smesh,mesh.GetMesh(),box,box,anElemType)
 #print "anIds = ", anIds
 
 salome.sg.updateObjBrowser(1);
index 7f205fe..599b09d 100644 (file)
 # ! documentation generation to identify certain places of this file
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 ## create a bottom box
 Box_inf = geompy.MakeBox(0., 0., 0., 200., 200., 50.)
@@ -60,7 +66,6 @@ geompy.addToStudy(Box_sup, "Box_sup")
 geompy.addToStudyInFather(Box_sup, Fsup2, "Fsup")
 geompy.addToStudyInFather(Box_sup, Finf2, "Finf")
 
-smesh.SetCurrentStudy(salome.myStudy)
 
 ## create a bottom mesh
 Mesh_inf = smesh.Mesh(Box_inf, "Mesh_inf")
@@ -91,10 +96,10 @@ Ginf2=Mesh_sup.Group(Finf2, "Inf")
 ## create compounds
 # create a compound of two meshes with renaming groups with the same names and
 # merging of elements with the given tolerance
-Compound1 = smesh.smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 0, 1, 1e-05)
+Compound1 = smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 0, 1, 1e-05)
 smesh.SetName(Compound1, 'Compound_with_RenamedGrps_and_MergeElems')
 # create a compound of two meshes with uniting groups with the same names and
 # creating groups of all elements
-Compound2 = smesh.smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 1, 0, 1e-05, True)
+Compound2 = smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 1, 0, 1e-05, True)
 smesh.SetName(Compound2, 'Compound_with_UniteGrps_and_GrpsOfAllElems')
 #end
index a062fba..2631388 100644 (file)
@@ -44,7 +44,7 @@ geompy.AddObject(aGeomGroup2, 10)
 geompy.addToStudy(aGeomGroup1, "Group on Faces")
 geompy.addToStudy(aGeomGroup2, "Group on Edges")
 
-aSmeshGroup1 = mesh.GroupOnGeom(aGeomGroup1, "SMESHGroup1", smesh.FACE)
-aSmeshGroup2 = mesh.GroupOnGeom(aGeomGroup2, "SMESHGroup2", smesh.EDGE)
+aSmeshGroup1 = mesh.GroupOnGeom(aGeomGroup1, "SMESHGroup1", SMESH.FACE)
+aSmeshGroup2 = mesh.GroupOnGeom(aGeomGroup2, "SMESHGroup2", SMESH.EDGE)
 
 salome.sg.updateObjBrowser(1);
index 1f6274d..9b13c6f 100755 (executable)
@@ -50,11 +50,11 @@ geompy.AddObject(aGeomGroup2, 10)
 geompy.addToStudy(aGeomGroup1, "Group on Faces")
 geompy.addToStudy(aGeomGroup2, "Group on Edges")
 
-aSmeshGroup1 = mesh.GroupOnGeom(aGeomGroup1, "SMESHGroup1", smesh.FACE)
-aSmeshGroup2 = mesh.GroupOnGeom(aGeomGroup2, "SMESHGroup2", smesh.EDGE)
+aSmeshGroup1 = mesh.GroupOnGeom(aGeomGroup1, "SMESHGroup1", SMESH.FACE)
+aSmeshGroup2 = mesh.GroupOnGeom(aGeomGroup2, "SMESHGroup2", SMESH.EDGE)
 
 print "Create aGroupOnShell - a group linked to a shell"
-aGroupOnShell = mesh.GroupOnGeom(shell, "GroupOnShell", smesh.EDGE)
+aGroupOnShell = mesh.GroupOnGeom(shell, "GroupOnShell", SMESH.EDGE)
 print "aGroupOnShell type =", aGroupOnShell.GetType()
 print "aGroupOnShell size =", aGroupOnShell.Size()
 print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()
index 0d2ddea..3c55446 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
-import salome
-import smesh
-
-smesh.SetCurrentStudy(salome.myStudy)
-
 def BuildGroupLyingOn(theMesh, theElemType, theName, theShape):
-    aFilterMgr = smesh.smesh.CreateFilterManager()
+    aFilterMgr = smesh.CreateFilterManager()
     aFilter = aFilterMgr.CreateFilter()
    
     aLyingOnGeom = aFilterMgr.CreateLyingOnGeom()
@@ -47,9 +42,9 @@ from SMESH_test1 import *
 mesh.Compute()
 
 # First way
-BuildGroupLyingOn(mesh.GetMesh(), smesh.FACE, "Group of faces lying on edge #1", edge )
+BuildGroupLyingOn(mesh.GetMesh(), SMESH.FACE, "Group of faces lying on edge #1", edge )
 
 # Second way
-mesh.MakeGroup("Group of faces lying on edge #2", smesh.FACE, smesh.FT_LyingOnGeom, edge)
+mesh.MakeGroup("Group of faces lying on edge #2", SMESH.FACE, SMESH.FT_LyingOnGeom, edge)
 
 salome.sg.updateObjBrowser(1);
index a473081..fdbeb48 100755 (executable)
 #Auhtor                 :MASLOV Eugeny, KOVALTCHUK Alexey 
 #####################################################################
 #
-import geompy
 import salome
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
 import os
 import math
 
@@ -98,8 +105,6 @@ Cut_1_ID = geompy.addToStudy(Cut_1, "Cut_1")
 
 #Mesh creation
 
-smesh.SetCurrentStudy(salome.myStudy)
-
 # -- Init --
 shape_mesh = salome.IDToObject( Cut_1_ID )
 
@@ -117,7 +122,7 @@ smesh.SetName(hAvLength, "AverageLength_"+str(theAverageLength))
 
 print "-------------------------- MaxElementArea"
 theMaxElementArea = 20
-algoMef = mesh.Triangle(smesh.MEFISTO)
+algoMef = mesh.Triangle(smeshBuilder.MEFISTO)
 hArea = algoMef.MaxElementArea( theMaxElementArea )
 print hArea.GetName()
 print hArea.GetId()
@@ -126,7 +131,7 @@ smesh.SetName(hArea, "MaxElementArea_"+str(theMaxElementArea))
 
 print "-------------------------- MaxElementVolume"
 theMaxElementVolume = 150
-algoNg = mesh.Tetrahedron(smesh.NETGEN)
+algoNg = mesh.Tetrahedron(smeshBuilder.NETGEN)
 hVolume = algoNg.MaxElementVolume( theMaxElementVolume )
 print hVolume.GetName()
 print hVolume.GetId()
index ef53fd3..5a85f26 100644 (file)
 # -- Rayon de la bariere
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
 from math import sqrt
 
 
@@ -119,8 +126,6 @@ print "number of Edges  in alveole : ", len(subEdgeList)
 status = geompy.CheckShape(alveole)
 print " check status ", status
 
-# ---- launch SMESH
-smesh.SetCurrentStudy(salome.myStudy)
 
 # ---- init a Mesh with the alveole
 shape_mesh = salome.IDToObject( idalveole )
@@ -155,7 +160,7 @@ print "-------------------------- MaxElementVolume"
 
 maxElementVolume = 0.5
 
-netgen3D = mesh.Tetrahedron(smesh.NETGEN)
+netgen3D = mesh.Tetrahedron(smeshBuilder.NETGEN)
 hypVolume = netgen3D.MaxElementVolume(maxElementVolume)
 print hypVolume.GetName()
 print hypVolume.GetId()
index 36767fd..58d2aad 100644 (file)
 #  Module : GEOM
 #  $Header: 
 #
-from geompy import *
-from math import *
+import salome
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-import smesh
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
+import math
 
 # It is an example of creating a hexahedrical mesh on a sphere.
 #
@@ -42,20 +49,20 @@ import smesh
 Radius  = 100.
 Dist    = Radius / 2.
 Factor  = 2.5
-Angle90 = pi / 2.
+Angle90 = math.pi / 2.
 NbSeg   = 10
 
 PointsList = []
 ShapesList = []
 
 #Basic Elements
-P0 = MakeVertex(0., 0., 0.)
-P1 = MakeVertex(-Dist, -Dist, -Dist)
-P2 = MakeVertex(-Dist, -Dist, Dist)
-P3 = MakeVertex(-Dist, Dist, Dist)
-P4 = MakeVertex(-Dist, Dist, -Dist)
+P0 = geompy.MakeVertex(0., 0., 0.)
+P1 = geompy.MakeVertex(-Dist, -Dist, -Dist)
+P2 = geompy.MakeVertex(-Dist, -Dist, Dist)
+P3 = geompy.MakeVertex(-Dist, Dist, Dist)
+P4 = geompy.MakeVertex(-Dist, Dist, -Dist)
 
-VZ = MakeVectorDXDYDZ(0., 0., 1.)
+VZ = geompy.MakeVectorDXDYDZ(0., 0., 1.)
 
 #Construction Elements
 PointsList.append(P1)
@@ -64,47 +71,46 @@ PointsList.append(P3)
 PointsList.append(P4)
 PointsList.append(P1)
 
-PolyLine = MakePolyline(PointsList)
+PolyLine = geompy.MakePolyline(PointsList)
 
-Face1 = MakeFace(PolyLine, 1)
-Face2 = MakeScaleTransform(Face1, P0, Factor)
-Face3 = MakeScaleTransform(Face1, P0, -1.)
+Face1 = geompy.MakeFace(PolyLine, 1)
+Face2 = geompy.MakeScaleTransform(Face1, P0, Factor)
+Face3 = geompy.MakeScaleTransform(Face1, P0, -1.)
 
 #Models
-Sphere = MakeSphereR(Radius)
+Sphere = geompy.MakeSphereR(Radius)
 
-Block = MakeHexa2Faces(Face1, Face2)
-Cube  = MakeHexa2Faces(Face1, Face3)
+Block = geompy.MakeHexa2Faces(Face1, Face2)
+Cube  = geompy.MakeHexa2Faces(Face1, Face3)
 
-Common1 = MakeBoolean(Sphere, Block, 1)
-Common2 = MakeRotation(Common1, VZ, Angle90)
+Common1 = geompy.MakeBoolean(Sphere, Block, 1)
+Common2 = geompy.MakeRotation(Common1, VZ, Angle90)
 
-MultiBlock1 = MakeMultiTransformation1D(Common1, 20, -1, 3)
-MultiBlock2 = MakeMultiTransformation1D(Common2, 30, -1, 3)
+MultiBlock1 = geompy.MakeMultiTransformation1D(Common1, 20, -1, 3)
+MultiBlock2 = geompy.MakeMultiTransformation1D(Common2, 30, -1, 3)
 
 #Reconstruct sphere from several blocks
 ShapesList.append(Cube)
 ShapesList.append(MultiBlock1)
 ShapesList.append(MultiBlock2)
-Compound = MakeCompound(ShapesList)
+Compound = geompy.MakeCompound(ShapesList)
 
-Result = MakeGlueFaces(Compound, 0.1)
+Result = geompy.MakeGlueFaces(Compound, 0.1)
 
 #addToStudy
-Id_Sphere      = addToStudy(Sphere, "Sphere")
-Id_Cube        = addToStudy(Cube, "Cube")
+Id_Sphere      = geompy.addToStudy(Sphere, "Sphere")
+Id_Cube        = geompy.addToStudy(Cube, "Cube")
 
-Id_Common1     = addToStudy(Common1, "Common1")
-Id_Common2     = addToStudy(Common2, "Common2")
+Id_Common1     = geompy.addToStudy(Common1, "Common1")
+Id_Common2     = geompy.addToStudy(Common2, "Common2")
 
-Id_MultiBlock1 = addToStudy(MultiBlock1, "MultiBlock1")
-Id_MultiBlock2 = addToStudy(MultiBlock2, "MultiBlock2")
+Id_MultiBlock1 = geompy.addToStudy(MultiBlock1, "MultiBlock1")
+Id_MultiBlock2 = geompy.addToStudy(MultiBlock2, "MultiBlock2")
 
-Id_Result      = addToStudy(Result, "Result")
+Id_Result      = geompy.addToStudy(Result, "Result")
 
 #-----------------------------------------------------------------------
 #Meshing
-smesh.SetCurrentStudy(salome.myStudy)
 my_hexa = smesh.Mesh(Result, "Sphere_Mesh")
 algo = my_hexa.Segment()
 algo.NumberOfSegments(NbSeg)
index 12c68d4..c5a5e17 100644 (file)
 #  $Header$
 #
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
 import math
-import smesh
 
 import GEOM_Spanner
 
 isBlocksTest = 0 # False
 isMeshTest   = 1 # True
 
-smesh.SetCurrentStudy(salome.myStudy)
-
 GEOM_Spanner.MakeSpanner(geompy, math, isBlocksTest, isMeshTest, smesh)
 
 salome.sg.updateObjBrowser(1);
index 1ec31ed..c38c529 100755 (executable)
 # Salome geometry and meshing for a box
 #
 import salome
-from salome import sg
-import geompy
-import smesh
-
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-# ---- launch GEOM
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
-geom          = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
-
-###geom.GetCurrentStudy(salome.myStudy._get_StudyId())
+from salome import sg
 
 # Plate
 
@@ -48,7 +48,6 @@ box    = geompy.MakeBox(0.,0.,0.,1.,1.,1.)
 boxId  = geompy.addToStudy(box,"box")
 
 # ---- SMESH
-smesh.SetCurrentStudy(salome.myStudy)
 
 # ---- init a Mesh
 
index b1bc068..850df8e 100644 (file)
 # Hypothesis and algorithms for the mesh generation are global
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 
 # ---- define 2 boxes box1 and box2
@@ -74,7 +80,6 @@ print "number of Edges  in shell : ", len(subEdgeList)
 
 
 ### ---------------------------- SMESH --------------------------------------
-smesh.SetCurrentStudy(salome.myStudy)
 
 # ---- init a Mesh with the shell
 
@@ -109,7 +114,7 @@ print "-------------------------- MaxElementVolume"
 
 maxElementVolume = 500
 
-netgen3D = mesh.Tetrahedron(smesh.NETGEN)
+netgen3D = mesh.Tetrahedron(smeshBuilder.NETGEN)
 hypVolume = netgen3D.MaxElementVolume(maxElementVolume)
 print hypVolume.GetName()
 print hypVolume.GetId()
index a109658..1e4963d 100644 (file)
 # Hypothesis and algorithms for the mesh generation are global
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # ---- define 3 boxes box1, box2 and box3
 
@@ -85,7 +90,6 @@ print "number of Edges  in shell : ", len(subEdgeList)
 
 
 ### ---------------------------- SMESH --------------------------------------
-smesh.SetCurrentStudy(salome.myStudy)
 
 # ---- init a Mesh with the shell
 
@@ -120,7 +124,7 @@ print "-------------------------- MaxElementVolume"
 
 maxElementVolume = 500
 
-netgen3D = mesh.Tetrahedron(smesh.NETGEN)
+netgen3D = mesh.Tetrahedron(smeshBuilder.NETGEN)
 hypVolume = netgen3D.MaxElementVolume(maxElementVolume)
 print hypVolume.GetName()
 print hypVolume.GetId()
index 4ebd38d..f6edcf7 100644 (file)
 # the mesh generation are global
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # ---- define a boxe
 
@@ -46,7 +51,6 @@ print "number of Edges  in box : ", len(subEdgeList)
 
 
 ### ---------------------------- SMESH --------------------------------------
-smesh.SetCurrentStudy(salome.myStudy)
 
 # ---- init a Mesh with the boxe
 
@@ -79,7 +83,7 @@ print "-------------------------- MaxElementVolume"
 
 maxElementVolume = 500
 
-netgen3D = mesh.Tetrahedron(smesh.NETGEN)
+netgen3D = mesh.Tetrahedron(smeshBuilder.NETGEN)
 hypVolume = netgen3D.MaxElementVolume(maxElementVolume)
 print hypVolume.GetName()
 print hypVolume.GetId()
index dc8b4ff..e2ff1be 100644 (file)
 #  Author : Sergey LITONIN
 #  Module : SMESH
 #
-import smesh
 import SMESH_mechanic
 
-salome = smesh.salome
-mesh   = SMESH_mechanic.mesh
-
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # ---- Criterion : AREA > 100
 
 # create group
-aGroup = mesh.MakeGroup("Area > 100", smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 100)
+aGroup = mesh.MakeGroup("Area > 100", SMESH.FACE, SMESH.FT_Area, SMESH.FT_MoreThan, 100)
 
 # print result
 anIds = aGroup.GetIDs()
@@ -47,7 +46,7 @@ print "Criterion: Area > 100 Nb = ", len( anIds )
 # ----  Criterion : Taper > 3e-15
 
 # create group
-aGroup = mesh.MakeGroup("Taper > 3e-15", smesh.FACE, smesh.FT_Taper, smesh.FT_MoreThan, 3e-15)
+aGroup = mesh.MakeGroup("Taper > 3e-15", SMESH.FACE, SMESH.FT_Taper, SMESH.FT_MoreThan, 3e-15)
 
 # print result
 anIds = aGroup.GetIDs()
@@ -59,7 +58,7 @@ print "Criterion: Taper > 3e-15 Nb = ", len( anIds )
 # ----  Criterion : ASPECT RATIO > 1.3
 
 # create group
-aGroup = mesh.MakeGroup("Aspect Ratio > 1.3", smesh.FACE, smesh.FT_AspectRatio, smesh.FT_MoreThan, 1.3)
+aGroup = mesh.MakeGroup("Aspect Ratio > 1.3", SMESH.FACE, SMESH.FT_AspectRatio, SMESH.FT_MoreThan, 1.3)
 
 # print result
 anIds = aGroup.GetIDs()
@@ -71,7 +70,7 @@ print "Criterion: Aspect Ratio > 1.3 Nb = ", len( anIds )
 # ----  Criterion : MINIMUM ANGLE < 30
 
 # create group
-aGroup = mesh.MakeGroup("Minimum Angle < 30", smesh.FACE, smesh.FT_MinimumAngle, smesh.FT_LessThan, 30)
+aGroup = mesh.MakeGroup("Minimum Angle < 30", SMESH.FACE, SMESH.FT_MinimumAngle, SMESH.FT_LessThan, 30)
 
 # print result
 anIds = aGroup.GetIDs()
@@ -83,7 +82,7 @@ print "Criterion: Minimum Angle < 30 Nb = ", len( anIds )
 # ---- Criterion : Warp > 2e-13
 
 # create group
-aGroup = mesh.MakeGroup("Warp > 2e-13", smesh.FACE, smesh.FT_Warping, smesh.FT_MoreThan, 2e-13 )
+aGroup = mesh.MakeGroup("Warp > 2e-13", SMESH.FACE, SMESH.FT_Warping, SMESH.FT_MoreThan, 2e-13 )
 
 # print result
 anIds = aGroup.GetIDs()
@@ -95,7 +94,7 @@ print "Criterion: Warp > 2e-13 Nb = ", len( anIds )
 # ---- Criterion : Skew > 18
 
 # create group
-aGroup = mesh.MakeGroup("Skew > 18", smesh.FACE, smesh.FT_Skew, smesh.FT_MoreThan, 18 )
+aGroup = mesh.MakeGroup("Skew > 18", SMESH.FACE, SMESH.FT_Skew, SMESH.FT_MoreThan, 18 )
 
 # print result
 anIds = aGroup.GetIDs()
@@ -107,7 +106,7 @@ print "Criterion: Skew > 18 Nb = ", len( anIds )
 # Criterion : Length > 10
 
 # create group
-aGroup = mesh.MakeGroup("Length > 10", smesh.FACE, smesh.FT_Length, smesh.FT_MoreThan, 10 )
+aGroup = mesh.MakeGroup("Length > 10", SMESH.FACE, SMESH.FT_Length, SMESH.FT_MoreThan, 10 )
 
 # print result
 anIds = aGroup.GetIDs()
@@ -119,7 +118,7 @@ print "Criterion: Length > 10 Nb = ", len( anIds )
 # Criterion : Borders at multi-connections = 2
 
 # create group
-aGroup = mesh.MakeGroup("Borders at multi-connections = 2", smesh.EDGE, smesh.FT_MultiConnection, smesh.FT_EqualTo, 2)
+aGroup = mesh.MakeGroup("Borders at multi-connections = 2", SMESH.EDGE, SMESH.FT_MultiConnection, SMESH.FT_EqualTo, 2)
 
 # print result
 anIds = aGroup.GetIDs()
@@ -131,7 +130,7 @@ print "Criterion: Borders at multi-connections = 2 Nb = ", len( anIds )
 # Criterion : Element Diameter 2D > 10
 
 # create group
-aGroup = mesh.MakeGroup("Element Diameter 2D > 10", smesh.FACE, smesh.FT_MaxElementLength2D, smesh.FT_MoreThan, 10 )
+aGroup = mesh.MakeGroup("Element Diameter 2D > 10", SMESH.FACE, SMESH.FT_MaxElementLength2D, SMESH.FT_MoreThan, 10 )
 
 # print result
 anIds = aGroup.GetIDs()
index f99c920..6e68378 100755 (executable)
 # the mesh of some edges is thinner
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 import math
 
index 948c867..8a327de 100644 (file)
 #  $Header$
 #
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
 import math
 
 # -----------------------------------------------------------------------------
index 7bd1941..edcfef8 100644 (file)
 # Hypothesis and algorithms for the mesh generation are global
 #
 import SMESH_fixation
-import smesh
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 compshell = SMESH_fixation.compshell
 idcomp = SMESH_fixation.idcomp
index fd644d5..d6f38cb 100644 (file)
 # The new Netgen algorithm is used that discretizes baoundaries itself
 #
 import SMESH_fixation
-import smesh
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 compshell = SMESH_fixation.compshell
 idcomp = SMESH_fixation.idcomp
@@ -51,10 +54,10 @@ smesh.SetCurrentStudy(salome.myStudy)
 print "-------------------------- create Mesh, algorithm, hypothesis"
 
 mesh = smesh.Mesh(compshell, "MeshcompShel");
-netgen = mesh.Tetrahedron(smesh.FULL_NETGEN)
+netgen = mesh.Tetrahedron(smeshBuilder.FULL_NETGEN)
 netgen.SetMaxSize( 50 )
 #netgen.SetSecondOrder( 0 )
-netgen.SetFineness( smesh.Fine )
+netgen.SetFineness( smeshBuilder.Fine )
 #netgen.SetOptimize( 1 )
 
 salome.sg.updateObjBrowser(1)
index 5a4e2f3..9896da0 100644 (file)
 # SMESH_fixation.py
 # Hypothesis and algorithms for the mesh generation are global
 #
+
 import SMESH_fixation
-import smesh
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 compshell = SMESH_fixation.compshell
 idcomp = SMESH_fixation.idcomp
@@ -93,7 +97,7 @@ print "-------------------------- MaxElementVolume"
 
 maxElementVolume = 1000
 
-netgen3D = mesh.Tetrahedron(smesh.NETGEN)
+netgen3D = mesh.Tetrahedron(smeshBuilder.NETGEN)
 netgen3D.SetName("NETGEN_3D")
 hypVolume = netgen3D.MaxElementVolume(maxElementVolume)
 print hypVolume.GetName()
index 5c57e00..fce24d7 100644 (file)
 #
 import os
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 
 # ---------------------------- GEOM --------------------------------------
index 2bc4f55..809fbff 100644 (file)
 #
 
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 
 # Create box without one plane
@@ -58,7 +64,7 @@ mesh.Compute()
 
 # Criterion : Free edges. Create group.
 
-aCriterion = smesh.GetCriterion(smesh.EDGE, smesh.FT_FreeEdges)
+aCriterion = smesh.GetCriterion(SMESH.EDGE, SMESH.FT_FreeEdges)
 
 aGroup = mesh.MakeGroupByCriterion("Free edges", aCriterion)
 
index 66ba9c8..8fd527f 100755 (executable)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-# -----------------------------------------------------------------------------
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
-geom = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
+# -----------------------------------------------------------------------------
 
 p0 = geompy.MakeVertex(0., 0., 0.)
 px = geompy.MakeVertex(100., 0., 0.)
index 9f306f1..d7835f4 100644 (file)
 #-------------------------------------------------------------------------
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 import StdMeshers
 
index 4563dd4..c973d4b 100644 (file)
 #-------------------------------------------------------------------------
 #
 import salome
-import geompy
-import smesh
-
 salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
+
 # ---------------------------- GEOM --------------------------------------
 
 # ---- define contigous arcs and segment to define a closed wire
@@ -120,7 +125,6 @@ name      = geompy.SubShapeName( sub_face4, mechanic )
 Id_SubFace4 = geompy.addToStudyInFather( mechanic, sub_face4, name )
 
 # ---------------------------- SMESH --------------------------------------
-smesh.SetCurrentStudy(salome.myStudy)
 
 # -- Init --
 shape_mesh = salome.IDToObject( Id_mechanic )
@@ -194,37 +198,37 @@ mesh.SplitQuadObject(submesh2, 1)
 
 #2 cutting of triangles of the group
 FacesTriToQuad = [ 2391, 2824, 2825, 2826, 2827, 2828, 2832, 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2841, 2844, 2845, 2847, 2854, 2861, 2863, 2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 2938, 2940, 2941, 2946, 2951, 2970, 2971, 2972, 2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985 ]
-GroupTriToQuad = mesh.MakeGroupByIds("Group of faces (quad)", smesh.FACE, FacesTriToQuad)
-mesh.TriToQuadObject(GroupTriToQuad, smesh.FT_AspectRatio , 1.57)
+GroupTriToQuad = mesh.MakeGroupByIds("Group of faces (quad)", SMESH.FACE, FacesTriToQuad)
+mesh.TriToQuadObject(GroupTriToQuad, SMESH.FT_AspectRatio , 1.57)
 
 #3 extrusion of the group
-point = smesh.PointStruct(0, 0, 5)
-vector = smesh.DirStruct(point) 
+point = SMESH.PointStruct(0, 0, 5)
+vector = SMESH.DirStruct(point)
 mesh.ExtrusionSweepObject(GroupTriToQuad, vector, 5)
 
 #4 mirror object
-mesh.Mirror([], smesh.AxisStruct(0, 0, 0, 0, 0, 0), smesh.POINT, 0) 
+mesh.Mirror([], SMESH.AxisStruct(0, 0, 0, 0, 0, 0), smesh.POINT, 0)
 
 #5 mesh translation
-point = smesh.PointStruct(10, 10, 10)
-vector = smesh.DirStruct(point) 
+point = SMESH.PointStruct(10, 10, 10)
+vector = SMESH.DirStruct(point)
 mesh.Translate([], vector, 0)
 
 #6 mesh rotation
-axisXYZ = smesh.AxisStruct(0, 0, 0, 10, 10, 10)
+axisXYZ = SMESH.AxisStruct(0, 0, 0, 10, 10, 10)
 angle180 =  180*3.141/180
 mesh.Rotate([], axisXYZ, angle180, 0)
 
 #7 group smoothing
 FacesSmooth = [864, 933, 941, 950, 1005, 1013]
-GroupSmooth = mesh.MakeGroupByIds("Group of faces (smooth)", smesh.FACE, FacesSmooth)
+GroupSmooth = mesh.MakeGroupByIds("Group of faces (smooth)", SMESH.FACE, FacesSmooth)
 mesh.SmoothObject(GroupSmooth, [], 20, 2, smesh.CENTROIDAL_SMOOTH)
 
 #8 rotation sweep object
 FacesRotate = [492, 493, 502, 503]
-GroupRotate = mesh.MakeGroupByIds("Group of faces (rotate)", smesh.FACE, FacesRotate)
+GroupRotate = mesh.MakeGroupByIds("Group of faces (rotate)", SMESH.FACE, FacesRotate)
 angle45 =  45*3.141/180
-axisXYZ = smesh.AxisStruct(-38.3128, -73.3658, -133.321, -13.3402, -13.3265, 6.66632)
+axisXYZ = SMESH.AxisStruct(-38.3128, -73.3658, -133.321, -13.3402, -13.3265, 6.66632)
 mesh.RotationSweepObject(GroupRotate, axisXYZ, angle45, 4, 1e-5)
 
 #9 reorientation of the submesh1
index 653a61c..280975e 100644 (file)
 # The new Netgen algorithm is used that discretizes baoundaries itself
 #
 import salome
-import geompy
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-geom  = geompy.geom
-
-import smesh
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # ---------------------------- GEOM --------------------------------------
 
@@ -105,15 +108,14 @@ print "number of Faces in mechanic : ",len(subFaceList)
 print "number of Edges in mechanic : ",len(subEdgeList)
 
 ### ---------------------------- SMESH --------------------------------------
-smesh.SetCurrentStudy(salome.myStudy)
 
 print "-------------------------- create Mesh, algorithm, hypothesis"
 
 mesh = smesh.Mesh(mechanic, "Mesh_mechanic");
-netgen = mesh.Triangle(smesh.NETGEN)
+netgen = mesh.Triangle(smeshBuilder.NETGEN)
 netgen.SetMaxSize( 50 )
 #netgen.SetSecondOrder( 0 )
-netgen.SetFineness( smesh.Fine )
+netgen.SetFineness( smeshBuilder.Fine )
 netgen.SetQuadAllowed( 1 )
 #netgen.SetOptimize( 1 )
 
index e1893b6..68996d8 100644 (file)
 #  $Header$
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
 
-geom  = geompy.geom
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # ---------------------------- GEOM --------------------------------------
 
@@ -105,7 +109,6 @@ print "number of Faces in mechanic : ",len(subFaceList)
 print "number of Edges in mechanic : ",len(subEdgeList)
 
 ### ---------------------------- SMESH --------------------------------------
-smesh.SetCurrentStudy(salome.myStudy)
 
 shape_mesh = salome.IDToObject( Id_mechanic  )
 
@@ -125,7 +128,7 @@ smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegment))
 
 maxElementArea = 20
 
-algo2 = mesh.Triangle(smesh.MEFISTO)
+algo2 = mesh.Triangle(smeshBuilder.MEFISTO)
 hypArea = algo2.MaxElementArea(maxElementArea)
 print hypArea.GetName()
 print hypArea.GetId()
@@ -135,7 +138,7 @@ smesh.SetName(hypArea, "MaxElementArea_" + str(maxElementArea))
 
 maxElementVolume = 20
 
-algo3 = mesh.Tetrahedron(smesh.NETGEN)
+algo3 = mesh.Tetrahedron(smeshBuilder.NETGEN)
 hypVolume = algo3.MaxElementVolume(maxElementVolume)
 print hypVolume.GetName()
 print hypVolume.GetId()
index 77439c8..36fc4b8 100644 (file)
 #  Module : SMESH
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 import StdMeshers
 
index bd46756..c296df6 100644 (file)
 #  Module : SMESH
 #
 import salome
-import geompy
-import smesh
+salome.salome_init()
+import GEOM
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+smesh =  smeshBuilder.New(salome.myStudy)
 
 # ---- define a box
 
@@ -69,7 +75,7 @@ print hyp.GetName()
 print hyp.GetId()
 print hyp.GetLength()
 
-algo_2 = mesh.Triangle(smesh.MEFISTO, box)
+algo_2 = mesh.Triangle(smeshBuilder.MEFISTO, box)
 hyp = algo_2.MaxElementArea(5000)
 print hyp.GetName()
 print hyp.GetId()
diff --git