# smesh.Mesh_Segment Class Reference

Class to define a segment 1D algorithm for discretization. More...

Inheritance diagram for smesh.Mesh_Segment:

## Public Member Functions
def | __init__
| Private constructor.
def | LocalLength
| Define "LocalLength" hypothesis to cut an edge in several segments with the same length.
def | NumberOfSegments
| Define "NumberOfSegments" hypothesis to cut an edge in several fixed number of segments.
def | Arithmetic1D
| Define "Arithmetic1D" hypothesis to cut an edge in several segments with arithmetic length increasing.
def | StartEndLength
| Define "StartEndLength" hypothesis to cut an edge in several segments with geometric length increasing.
def | Deflection1D
| Define "Deflection1D" hypothesis.
def | Propagation
| Define "Propagation" hypothesis that propagate all other hypothesis on all others edges that are in the opposite side in the case of quadrangular faces.
def | AutomaticLength
| Define "AutomaticLength" hypothesis.
def | QuadraticMesh
| Define "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
def | GetSubMesh
def | GetAlgorithm
| Return the wrapped mesher.
def | TreatHypoStatus
| Private method.
def | Create
| Private method.
def | Hypothesis
| Private method.
## Data Fields
| mesh
| geom
| subm
| algo
## Static Public Attributes
int | mesh = 0
int | geom = 0
int | subm = 0
int | algo = 0

## Detailed Description

More details.

## Member Function Documentation

def smesh.Mesh_Segment.__init__ | ( |  | self,
|  |  | mesh,
|  |  | geom = `0`
| ) |

| Reimplemented in smesh.Mesh_Segment_Python.

def smesh.Mesh_Segment.LocalLength | ( |  | self,
|  |  | l
| ) |

  | Parameters:
  | l | for the length of segments that cut an edge

def smesh.Mesh_Segment.NumberOfSegments | ( |  | self,
|  |  | n,
|  |  | s = `[]`
| ) |

  | Parameters:
  | n | for the number of segments that cut an edge
  | s | for the scale factor (optional)

def smesh.Mesh_Segment.Arithmetic1D | ( |  | self,
|  |  | start,
|  |  | end
| ) |

  | Parameters:
  | start | for the length of the first segment
  | end | for the length of the last segment

def smesh.Mesh_Segment.StartEndLength | ( |  | self,
|  |  | start,
|  |  | end
| ) |

  | Parameters:
  | start | for the length of the first segment
  | end | for the length of the last segment

def smesh.Mesh_Segment.Deflection1D | ( |  | self,
|  |  | d
| ) |

  | Parameters:
  | d | for the deflection

def smesh.Mesh_Segment.Propagation | ( |  | self | ) |

def smesh.Mesh_Segment.AutomaticLength | ( |  | self,
|  |  | fineness = `0`
| ) |

  | Parameters:
  | fineness | for the fineness [0-1]

def smesh.Mesh_Segment.QuadraticMesh | ( |  | self | ) |

| If the 2D mesher sees that all boundary edges are quadratic ones, it generates quadratic faces, else it generates linear faces using medium nodes as if they were vertex ones. The 3D mesher generates quadratic volumes only if all boundary faces are quadratic ones, else it fails.

def smesh.Mesh_Algorithm.GetSubMesh | ( |  | self | ) | `[inherited]`

def smesh.Mesh_Algorithm.GetAlgorithm | ( |  | self | ) | `[inherited]`

def smesh.Mesh_Algorithm.TreatHypoStatus | ( |  | self,
|  |  | status,
|  |  | hypName,
|  |  | geomName,
|  |  | isAlgo
| ) | `[inherited]`

| Print error message if a hypothesis was not assigned.

def smesh.Mesh_Algorithm.Create | ( |  | self,
|  |  | mesh,
|  |  | geom,
|  |  | hypo,
|  |  | so = `"libStdMeshersEngine.so"`
| ) | `[inherited]`

def smesh.Mesh_Algorithm.Hypothesis | ( |  | self,
|  |  | hyp,
|  |  | args = `[]`,
|  |  | so = `"libStdMeshersEngine.so"`
| ) | `[inherited]`

## Field Documentation

int smesh.Mesh_Algorithm.mesh = 0`[static, inherited]`

smesh.Mesh_Algorithm.mesh`[inherited]`

int smesh.Mesh_Algorithm.geom = 0`[static, inherited]`

smesh.Mesh_Algorithm.geom`[inherited]`

int smesh.Mesh_Algorithm.subm = 0`[static, inherited]`

smesh.Mesh_Algorithm.subm`[inherited]`

int smesh.Mesh_Algorithm.algo = 0`[static, inherited]`

smesh.Mesh_Algorithm.algo`[inherited]`