# Defining Hypotheses and Algorithms

### Defining 1D Hypotheses

1D Arithmetic

import geompy

import smesh

# create a box

box = geompy.MakeBoxDXDYDZ(10., 10., 10.)

geompy.addToStudy(box, "Box")

# create a hexahedral mesh on the box

hexa = smesh.Mesh(box, "Box : hexahedrical mesh")

# create a Regular 1D algorithm for edges

algo1D = hexa.Segment()

# define "Arithmetic1D" hypothesis to cut all edges in several segments with increasing arithmetic length

algo1D.Arithmetic1D(1, 4)

# create a quadrangle 2D algorithm for faces

hexa.Quadrangle()

# create a hexahedron 3D algorithm for solids

hexa.Hexahedron()

# compute the mesh

hexa.Compute()

#### Deflection 1D and Number of Segments

import geompy

import smesh

# create a face from arc and straight segment

px = geompy.MakeVertex(100., 0. , 0. )

py = geompy.MakeVertex(0. , 100., 0. )

pz = geompy.MakeVertex(0. , 0. , 100.)

exy = geompy.MakeEdge(px, py)

arc = geompy.MakeArc(py, pz, px)

wire = geompy.MakeWire([exy, arc])

isPlanarFace = 1

face1 = geompy.MakeFace(wire, isPlanarFace)

geompy.addToStudy(face1,"Face1")

# get edges from the face

e_straight,e_arc = geompy.SubShapeAll(face1, geompy.ShapeType["EDGE"])

geompy.addToStudyInFather(face1, e_arc, "Arc Edge")

# create hexahedral mesh

hexa = smesh.Mesh(face1, "Face : triangle mesh")

# define "NumberOfSegments" hypothesis to cut a straight edge in a fixed number of segments

algo1D = hexa.Segment()

algo1D.NumberOfSegments(6)

# define "MaxElementArea" hypothesis

algo2D = hexa.Triangle()

algo2D.MaxElementArea(70.0)

# define a local "Deflection1D" hypothesis on the arc

algo_local = hexa.Segment(e_arc)

algo_local.Deflection1D(1.0)

# compute the mesh

hexa.Compute()

#### Start and End Length

from geompy import *

import smesh

# create a box

box = MakeBoxDXDYDZ(10., 10., 10.)

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]")

# create a hexahedral mesh on the box

hexa = smesh.Mesh(box, "Box : hexahedrical mesh")

# set algorithms

algo1D = hexa.Segment()

hexa.Quadrangle()

hexa.Hexahedron()

# define "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments

algo1D.NumberOfSegments(4)

# create a local hypothesis

algo_local = hexa.Segment(EdgeX)

# define "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length

algo_local.StartEndLength(1, 6)

# define "Propagation" hypothesis that propagates all other hypothesis

# on all edges on the opposite side in case of quadrangular faces

algo_local.Propagation()

# compute the mesh

hexa.Compute()

#### Average Length

from geompy import *

import smesh

# create a box

box = MakeBoxDXDYDZ(10., 10., 10.)

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]")

# create a hexahedral mesh on the box

hexa = smesh.Mesh(box, "Box : hexahedrical mesh")

# set algorithms

algo1D = hexa.Segment()

hexa.Quadrangle()

hexa.Hexahedron()

# define "NumberOfSegments" hypothesis to cut all edges in a fixed number of segments

algo1D.NumberOfSegments(4)

# create a sub-mesh

algo_local = hexa.Segment(EdgeX)

# define "LocalLength" hypothesis to cut an edge in several segments with the same length

algo_local.LocalLength(2.)

# define "Propagation" hypothesis that propagates all other hypothesis

# on all edges on the opposite side in case of quadrangular faces

algo_local.Propagation()

# compute the mesh

hexa.Compute()

### Defining 2D and 3D hypotheses

#### Maximum Element Area

import geompy

import smesh

import salome

# create a face

px = geompy.MakeVertex(100., 0. , 0. )

py = geompy.MakeVertex(0. , 100., 0. )

pz = geompy.MakeVertex(0. , 0. , 100.)

vxy = geompy.MakeVector(px, py)

arc = geompy.MakeArc(py, pz, px)

wire = geompy.MakeWire([vxy, arc])

isPlanarFace = 1

face = geompy.MakeFace(wire, isPlanarFace)

# add the face in the study

id_face = geompy.addToStudy(face, "Face to be meshed")

# create a mesh

tria_mesh = smesh.Mesh(face, "Face : triangulation")

# define 1D meshing:

algo = tria_mesh.Segment()

algo.NumberOfSegments(20)

# define 2D meshing:

# assign triangulation algorithm

algo = tria_mesh.Triangle()

# apply "Max Element Area" hypothesis to each triangle

algo.MaxElementArea(100)

# compute the mesh

tria_mesh.Compute()

#### Maximum Element Volume

import geompy

import smesh

# create a cylinder

cyl = geompy.MakeCylinderRH(30., 50.)

geompy.addToStudy(cyl, "cyl")

# create a mesh on the cylinder

tetra = smesh.Mesh(cyl, "Cylinder : tetrahedrical mesh")

# assign algorithms

algo1D = tetra.Segment()

algo2D = tetra.Triangle()

algo3D = tetra.Tetrahedron(smesh.NETGEN)

# assign 1D and 2D hypotheses

algo1D.NumberOfSegments(7)

algo2D.MaxElementArea(150.)

# assign Max Element Volume hypothesis

algo3D.MaxElementVolume(200.)

# compute the mesh

ret = tetra.Compute()

if ret == 0:

print "probleme when computing the mesh"

else:

print "Computation succeded"

#### Length from Edges

import geompy

import smesh

# create sketchers

sketcher1 = geompy.MakeSketcher("Sketcher:F 0 0:TT 70 0:TT 70 70:TT 0 70:WW")

sketcher2 = geompy.MakeSketcher("Sketcher:F 20 20:TT 50 20:TT 50 50:TT 20 50:WW")

# create a face from two wires

isPlanarFace = 1

face1 = geompy.MakeFaces([sketcher1, sketcher2], isPlanarFace)

geompy.addToStudy(face1, "Face1")

# create a mesh

tria = smesh.Mesh(face1, "Face : triangle 2D mesh")

# Define 1D meshing

algo1D = tria.Segment()

algo1D.NumberOfSegments(2)

# create and assign the algorithm for 2D meshing with triangles

algo2D = tria.Triangle()

# create and assign "LengthFromEdges" hypothesis to build triangles based on the length of the edges taken from the wire

algo2D.LengthFromEdges()

# compute the mesh

tria.Compute()

### Defining Additional Hypotheses

#### Propagation

from geompy import *

import smesh

# create a box

box = MakeBoxDXDYDZ(10., 10., 10.)

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]")

# create a hexahedral mesh on the box

hexa = smesh.Mesh(box, "Box : hexahedrical mesh")

# set global algorithms and hypotheses

algo1D = hexa.Segment()

hexa.Quadrangle()

hexa.Hexahedron()

algo1D.NumberOfSegments(4)

# create a sub-mesh with local 1D hypothesis and propagation

algo_local = hexa.Segment(EdgeX)

# define "Arithmetic1D" hypothesis to cut an edge in several segments with increasing length

algo_local.Arithmetic1D(1, 4)

# define "Propagation" hypothesis that propagates all other 1D hypotheses

# from all edges on the opposite side of a face in case of quadrangular faces

algo_local.Propagation()

# compute the mesh

hexa.Compute()

### Defining Meshing Algorithms

import geompy

import smesh

# create a box

box = geompy.MakeBoxDXDYDZ(10., 10., 10.)

geompy.addToStudy(box, "Box")

# 1. Create a hexahedral mesh on the box

hexa = smesh.Mesh(box, "Box : hexahedrical mesh")

# create a Regular 1D algorithm for edges

algo1D = hexa.Segment()

# create a quadrangle 2D algorithm for faces

algo2D = hexa.Quadrangle()

# create a hexahedron 3D algorithm for solids

algo3D = hexa.Hexahedron()

# define hypotheses

algo1D.Arithmetic1D(1, 4)

# compute the mesh

hexa.Compute()

# 2. Create a tetrahedral mesh on the box

tetra = smesh.Mesh(box, "Box : tetrahedrical mesh")

# create a Regular 1D algorithm for edges

algo1D = tetra.Segment()

# create a Mefisto 2D algorithm for faces

algo2D = tetra.Triangle()

# create a Netgen 3D algorithm for solids

algo3D = tetra.Tetrahedron(smesh.NETGEN)

# define hypotheses

algo1D.Arithmetic1D(1, 4)

algo2D.LengthFromEdges()

# compute the mesh

tetra.Compute()

# 3. Create a tetrahedral mesh on the box with NETGEN_2D3D algorithm

tetraN = smesh.Mesh(box, "Box : tetrahedrical mesh by NETGEN_2D3D")

# create a Netgen_2D3D algorithm for solids

algo3D = tetraN.Tetrahedron(smesh.FULL_NETGEN)

# define hypotheses

n23_params = algo3D.Parameters()

# compute the mesh

tetraN.Compute()