Defines a segment 1D algorithm for discretization. More...

Inheritance diagram for smeshDC.Mesh_CompositeSegment:

Public Member Functions
def	__init__
	Private constructor.
def	LocalLength
	Defines "LocalLength" hypothesis to cut an edge in several segments with the same length.
def	CompareLocalLength
	Private method Checks if the given "LocalLength" hypothesis has the same parameters as the given arguments.
def	MaxSize
	Defines "MaxSize" hypothesis to cut an edge into segments not longer than given value.
def	NumberOfSegments
	Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments.
def	CompareNumberOfSegments
	Private method Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments.
def	Arithmetic1D
	Defines "Arithmetic1D" hypothesis to cut an edge in several segments with increasing arithmetic length.
def	CompareArithmetic1D
	Private method Check if the given "Arithmetic1D" hypothesis has the same parameters as the given arguments.
def	FixedPoints1D
	Defines "FixedPoints1D" hypothesis to cut an edge using parameter on curve from 0 to 1 (additionally it is neecessary to check orientation of edges and create list of reversed edges if it is needed) and sets numbers of segments between given points (default values are equals 1.
def	CompareFixedPoints1D
	Private method Check if the given "FixedPoints1D" hypothesis has the same parameters as the given arguments.
def	StartEndLength
	Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length.
def	CompareStartEndLength
	Check if the given "StartEndLength" hypothesis has the same parameters as the given arguments.
def	Deflection1D
	Defines "Deflection1D" hypothesis.
def	CompareDeflection1D
	Check if the given "Deflection1D" hypothesis has the same parameters as the given arguments.
def	Propagation
	Defines "Propagation" hypothesis that propagates all other hypotheses on all other edges that are at the opposite side in case of quadrangular faces.
def	AutomaticLength
	Defines "AutomaticLength" hypothesis.
def	CompareAutomaticLength
	Checks if the given "AutomaticLength" hypothesis has the same parameters as the given arguments.
def	LengthNearVertex
	Defines "SegmentLengthAroundVertex" hypothesis.
def	CompareLengthNearVertex
	Checks if the given "LengthNearVertex" hypothesis has the same parameters as the given arguments.
def	QuadraticMesh
	Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
def	FindHypothesis
	Finds a hypothesis in the study by its type name and parameters.
def	FindAlgorithm
	Finds the algorithm in the study by its type name.
def	GetSubMesh
	If the algorithm is global, returns 0; else returns the submesh associated to this algorithm.
def	GetAlgorithm
	Returns the wrapped mesher.
def	GetCompatibleHypothesis
	Gets the list of hypothesis that can be used with this algorithm.
def	GetName
	Gets the name of the algorithm.
def	SetName
	Sets the name to the algorithm.
def	GetId
	Gets the id of the algorithm.
def	Create
	Private method.
def	Assign
	Private method.
def	CompareHyp
def	CompareEqualHyp
def	Hypothesis
	Private method.
def	MainShapeEntry
	Returns entry of the shape to mesh in the study.
def	ViscousLayers
	Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build near mesh boundary.
Data Fields
	geom
	mesh
	subm
	algo

Detailed Description

Defines a segment 1D algorithm for discretization.

Definition at line 4812 of file smeshDC.py.

Constructor & Destructor Documentation

def smeshDC.Mesh_CompositeSegment.__init__	(	self,
		mesh,
		geom = `0`
	)

Private constructor.

Reimplemented from smeshDC.Mesh_Segment.

Definition at line 4815 of file smeshDC.py.

04816                                     :
04817         self.Create(mesh, geom, "CompositeSegment_1D")
04818 
04819 
04820 # Public class: Mesh_Segment_Python
04821 # ---------------------------------

Member Function Documentation

def smeshDC.Mesh_Algorithm.Assign	(	self,
		algo,
		mesh,
		geom
	)	`[inherited]`

Private method.

Definition at line 4403 of file smeshDC.py.

04404                                       :
04405         if geom is None:
04406             raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape"
04407         self.mesh = mesh
04408         name = ""
04409         if not geom:
04410             self.geom = mesh.geom
04411         else:
04412             self.geom = geom
04413             AssureGeomPublished( mesh, geom )
04414             try:
04415                 name = GetName(geom)
04416                 pass
04417             except:
04418                 pass
04419             self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName())
04420         self.algo = algo
04421         status = mesh.mesh.AddHypothesis(self.geom, self.algo)
04422         TreatHypoStatus( status, algo.GetName(), name, True )
04423         return

def smeshDC.Mesh_Segment.CompareArithmetic1D	(	self,
		hyp,
		args
	)	`[inherited]`

Private method Check if the given "Arithmetic1D" hypothesis has the same parameters as the given arguments.

Definition at line 4633 of file smeshDC.py.

04634                                             :
04635         if IsEqual(hyp.GetLength(1), args[0]):
04636             if IsEqual(hyp.GetLength(0), args[1]):
04637                 if hyp.GetReversedEdges() == args[2]:
04638                     if not args[2] or hyp.GetObjectEntry() == args[3]:
04639                         return True
04640         return False
04641

def smeshDC.Mesh_Segment.CompareAutomaticLength	(	self,
		hyp,
		args
	)	`[inherited]`

Checks if the given "AutomaticLength" hypothesis has the same parameters as the given arguments.

Definition at line 4747 of file smeshDC.py.

04748                                                :
04749         return IsEqual(hyp.GetFineness(), args[0])

def smeshDC.Mesh_Segment.CompareDeflection1D	(	self,
		hyp,
		args
	)	`[inherited]`

Check if the given "Deflection1D" hypothesis has the same parameters as the given arguments.

Definition at line 4726 of file smeshDC.py.

04727                                             :
04728         return IsEqual(hyp.GetDeflection(), args[0])

def smeshDC.Mesh_Algorithm.CompareEqualHyp	(	self,
		hyp,
		args
	)	`[inherited]`

Definition at line 4428 of file smeshDC.py.

04429                                          :
04430         return True

def smeshDC.Mesh_Segment.CompareFixedPoints1D	(	self,
		hyp,
		args
	)	`[inherited]`

Private method Check if the given "FixedPoints1D" hypothesis has the same parameters as the given arguments.

Definition at line 4672 of file smeshDC.py.

04673                                              :
04674         if hyp.GetPoints() == args[0]:
04675             if hyp.GetNbSegments() == args[1]:
04676                 if hyp.GetReversedEdges() == args[2]:
04677                     if not args[2] or hyp.GetObjectEntry() == args[3]:
04678                         return True
04679         return False
04680 
04681

def smeshDC.Mesh_Algorithm.CompareHyp	(	self,
		hyp,
		args
	)	`[inherited]`

Definition at line 4424 of file smeshDC.py.

04425                                     :
04426         print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName()
04427         return False

def smeshDC.Mesh_Segment.CompareLocalLength	(	self,
		hyp,
		args
	)	`[inherited]`

Private method Checks if the given "LocalLength" hypothesis has the same parameters as the given arguments.

Definition at line 4532 of file smeshDC.py.

04533                                            :
04534         if IsEqual(hyp.GetLength(), args[0]):
04535             return IsEqual(hyp.GetPrecision(), args[1])
04536         return False

def smeshDC.Mesh_Segment.CompareNumberOfSegments	(	self,
		hyp,
		args
	)	`[inherited]`

Private method Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments.

Definition at line 4594 of file smeshDC.py.

04595                                                 :
04596         if hyp.GetNumberOfSegments() == args[0]:
04597             if len(args) == 3:
04598                 if hyp.GetReversedEdges() == args[1]:
04599                     if not args[1] or hyp.GetObjectEntry() == args[2]:
04600                         return True
04601             else:
04602                 if hyp.GetReversedEdges() == args[2]:
04603                     if not args[2] or hyp.GetObjectEntry() == args[3]:
04604                         if hyp.GetDistrType() == 1:
04605                             if IsEqual(hyp.GetScaleFactor(), args[1]):
04606                                 return True
04607         return False

def smeshDC.Mesh_Segment.CompareStartEndLength	(	self,
		hyp,
		args
	)	`[inherited]`

Check if the given "StartEndLength" hypothesis has the same parameters as the given arguments.

Definition at line 4706 of file smeshDC.py.

04707                                               :
04708         if IsEqual(hyp.GetLength(1), args[0]):
04709             if IsEqual(hyp.GetLength(0), args[1]):
04710                 if hyp.GetReversedEdges() == args[2]:
04711                     if not args[2] or hyp.GetObjectEntry() == args[3]:
04712                         return True
04713         return False

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

Private method.

Definition at line 4392 of file smeshDC.py.

04393                                                                    :
04394         if geom is None:
04395             raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape"
04396         algo = self.FindAlgorithm(hypo, mesh.smeshpyD)
04397         if algo is None:
04398             algo = mesh.smeshpyD.CreateHypothesis(hypo, so)
04399             pass
04400         self.Assign(algo, mesh, geom)
04401         return self.algo

def smeshDC.Mesh_Algorithm.FindAlgorithm	(	self,
		algoname,
		smeshpyD
	)	`[inherited]`

Finds the algorithm in the study by its type name.

Finds only the algorithms, which have been created in smeshpyD engine.

Returns:: SMESH.SMESH_Algo

Definition at line 4327 of file smeshDC.py.

04328                                                 :
04329         study = smeshpyD.GetCurrentStudy()
04330         #to do: find component by smeshpyD object, not by its data type
04331         scomp = study.FindComponent(smeshpyD.ComponentDataType())
04332         if scomp is not None:
04333             res,hypRoot = scomp.FindSubObject(SMESH.Tag_AlgorithmsRoot)
04334             # Check if the root label of the algorithms exists
04335             if res and hypRoot is not None:
04336                 iter = study.NewChildIterator(hypRoot)
04337                 # Check all published algorithms
04338                 while iter.More():
04339                     algo_so_i = iter.Value()
04340                     attr = algo_so_i.FindAttribute("AttributeIOR")[1]
04341                     if attr is not None:
04342                         anIOR = attr.Value()
04343                         algo_o_i = salome.orb.string_to_object(anIOR)
04344                         if algo_o_i is not None:
04345                             # Check if this is an algorithm
04346                             algo_i = algo_o_i._narrow(SMESH.SMESH_Algo)
04347                             if algo_i is not None:
04348                                 # Checks if the algorithm belongs to the current engine
04349                                 if smeshpyD.GetObjectId(algo_i) > 0:
04350                                     # Check if this is the required algorithm
04351                                     if algo_i.GetName() == algoname:
04352                                         # found!!!
04353                                         return algo_i
04354                                     pass
04355                                 pass
04356                             pass
04357                         pass
04358                     iter.Next()
04359                     pass
04360                 pass
04361             pass
04362         return None

def smeshDC.Mesh_Algorithm.FindHypothesis	(	self,
		hypname,
		args,
		CompareMethod,
		smeshpyD
	)	`[inherited]`

Finds a hypothesis in the study by its type name and parameters.

Finds only the hypotheses created in smeshpyD engine.

Returns:: SMESH.SMESH_Hypothesis

Definition at line 4285 of file smeshDC.py.

04286                                                                      :
04287         study = smeshpyD.GetCurrentStudy()
04288         #to do: find component by smeshpyD object, not by its data type
04289         scomp = study.FindComponent(smeshpyD.ComponentDataType())
04290         if scomp is not None:
04291             res,hypRoot = scomp.FindSubObject(SMESH.Tag_HypothesisRoot)
04292             # Check if the root label of the hypotheses exists
04293             if res and hypRoot is not None:
04294                 iter = study.NewChildIterator(hypRoot)
04295                 # Check all published hypotheses
04296                 while iter.More():
04297                     hypo_so_i = iter.Value()
04298                     attr = hypo_so_i.FindAttribute("AttributeIOR")[1]
04299                     if attr is not None:
04300                         anIOR = attr.Value()
04301                         hypo_o_i = salome.orb.string_to_object(anIOR)
04302                         if hypo_o_i is not None:
04303                             # Check if this is a hypothesis
04304                             hypo_i = hypo_o_i._narrow(SMESH.SMESH_Hypothesis)
04305                             if hypo_i is not None:
04306                                 # Check if the hypothesis belongs to current engine
04307                                 if smeshpyD.GetObjectId(hypo_i) > 0:
04308                                     # Check if this is the required hypothesis
04309                                     if hypo_i.GetName() == hypname:
04310                                         # Check arguments
04311                                         if CompareMethod(hypo_i, args):
04312                                             # found!!!
04313                                             return hypo_i
04314                                         pass
04315                                     pass
04316                                 pass
04317                             pass
04318                         pass
04319                     iter.Next()
04320                     pass
04321                 pass
04322             pass
04323         return None

def smeshDC.Mesh_Algorithm.GetAlgorithm ( self ) [inherited]

Returns the wrapped mesher.

Definition at line 4369 of file smeshDC.py.

04370                           :
04371         return self.algo

def smeshDC.Mesh_Algorithm.GetCompatibleHypothesis ( self ) [inherited]

Gets the list of hypothesis that can be used with this algorithm.

Definition at line 4373 of file smeshDC.py.

04374                                      :
04375         mylist = []
04376         if self.algo:
04377             mylist = self.algo.GetCompatibleHypothesis()
04378         return mylist

def smeshDC.Mesh_Algorithm.GetId ( self ) [inherited]

Gets the id of the algorithm.

Definition at line 4388 of file smeshDC.py.

04389                    :
04390         return self.algo.GetId()

def smeshDC.Mesh_Algorithm.GetName ( self ) [inherited]

Gets the name of the algorithm.

Definition at line 4380 of file smeshDC.py.

04381                      :
04382         GetName(self.algo)

def smeshDC.Mesh_Algorithm.GetSubMesh ( self ) [inherited]

If the algorithm is global, returns 0;
else returns the submesh associated to this algorithm.

Definition at line 4365 of file smeshDC.py.

04366                         :
04367         return self.subm

def smeshDC.Mesh_Algorithm.Hypothesis	(	self,
		hyp,
		args = `[]`,
		so = `"libStdMeshersEngine.so"`,
		UseExisting = `0`,
		CompareMethod = `""`
	)	`[inherited]`

Private method.

Definition at line 4432 of file smeshDC.py.

04434                                                     :
04435         hypo = None
04436         if UseExisting:
04437             if CompareMethod == "": CompareMethod = self.CompareHyp
04438             hypo = self.FindHypothesis(hyp, args, CompareMethod, self.mesh.smeshpyD)
04439             pass
04440         if hypo is None:
04441             hypo = self.mesh.smeshpyD.CreateHypothesis(hyp, so)
04442             a = ""
04443             s = "="
04444             i = 0
04445             n = len(args)
04446             while i<n:
04447                 a = a + s + str(args[i])
04448                 s = ","
04449                 i = i + 1
04450                 pass
04451             self.mesh.smeshpyD.SetName(hypo, hyp + a)
04452             pass
04453         geomName=""
04454         if self.geom:
04455             geomName = GetName(self.geom)
04456         status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
04457         TreatHypoStatus( status, GetName(hypo), geomName, 0 )
04458         return hypo

def smeshDC.Mesh_Algorithm.MainShapeEntry ( self ) [inherited]

Returns entry of the shape to mesh in the study.

Definition at line 4460 of file smeshDC.py.

04461                             :
04462         entry = ""
04463         if not self.mesh or not self.mesh.GetMesh(): return entry
04464         if not self.mesh.GetMesh().HasShapeToMesh(): return entry
04465         study = self.mesh.smeshpyD.GetCurrentStudy()
04466         ior  = salome.orb.object_to_string( self.mesh.GetShape() )
04467         sobj = study.FindObjectIOR(ior)
04468         if sobj: entry = sobj.GetID()
04469         if not entry: return ""
04470         return entry

def smeshDC.Mesh_Algorithm.SetName	(	self,
		name
	)	`[inherited]`

Sets the name to the algorithm.

Definition at line 4384 of file smeshDC.py.

04385                            :
04386         self.mesh.smeshpyD.SetName(self.algo, name)

Field Documentation

smeshDC.Mesh_Algorithm.algo [inherited]

Definition at line 4276 of file smeshDC.py.

smeshDC.Mesh_Segment.geom [inherited]

Reimplemented from smeshDC.Mesh_Algorithm.

Definition at line 4758 of file smeshDC.py.

smeshDC.Mesh_Algorithm.mesh [inherited]

Definition at line 4276 of file smeshDC.py.

smeshDC.Mesh_Algorithm.subm [inherited]

Definition at line 4276 of file smeshDC.py.

smeshDC.Mesh_CompositeSegment Class ReferenceBasic meshing algorithms

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation

smeshDC.Mesh_CompositeSegment Class Reference
Basic meshing algorithms