+# Public class: Mesh_RadialQuadrangle1D2D
+# -------------------------------
+
+## Defines a Radial Quadrangle 1D2D algorithm
+# @ingroup l2_algos_radialq
+#
+class Mesh_RadialQuadrangle1D2D(Mesh_Algorithm):
+
+ ## Private constructor.
+ def __init__(self, mesh, geom=0):
+ Mesh_Algorithm.__init__(self)
+ self.Create(mesh, geom, "RadialQuadrangle_1D2D")
+
+ self.distribHyp = None #self.Hypothesis("LayerDistribution2D", UseExisting=0)
+ self.nbLayers = None
+
+ ## Return 2D hypothesis holding the 1D one
+ def Get2DHypothesis(self):
+ return self.distribHyp
+
+ ## Private method creating a 1D hypothesis and storing it in the LayerDistribution
+ # hypothesis. Returns the created hypothesis
+ def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
+ #print "OwnHypothesis",hypType
+ if self.nbLayers:
+ self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
+ if self.distribHyp is None:
+ self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
+ else:
+ self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp )
+ study = self.mesh.smeshpyD.GetCurrentStudy() # prevents publishing own 1D hypothesis
+ self.mesh.smeshpyD.SetCurrentStudy( None )
+ hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
+ self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing
+ self.distribHyp.SetLayerDistribution( hyp )
+ return hyp
+
+ ## Defines "NumberOfLayers" hypothesis, specifying the number of layers
+ # @param n number of layers
+ # @param UseExisting if ==true - searches for the existing hypothesis created with
+ # the same parameters, else (default) - creates a new one
+ def NumberOfLayers(self, n, UseExisting=0):
+ if self.distribHyp:
+ self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
+ self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
+ CompareMethod=self.CompareNumberOfLayers)
+ self.nbLayers.SetNumberOfLayers( n )
+ return self.nbLayers
+
+ ## Checks if the given "NumberOfLayers" hypothesis has the same parameters as the given arguments
+ def CompareNumberOfLayers(self, hyp, args):
+ return IsEqual(hyp.GetNumberOfLayers(), args[0])
+
+ ## Defines "LocalLength" hypothesis, specifying the segment length
+ # @param l the length of segments
+ # @param p the precision of rounding
+ def LocalLength(self, l, p=1e-07):
+ hyp = self.OwnHypothesis("LocalLength", [l,p])
+ hyp.SetLength(l)
+ hyp.SetPrecision(p)
+ return hyp
+
+ ## Defines "NumberOfSegments" hypothesis, specifying the number of layers
+ # @param n the number of layers
+ # @param s the scale factor (optional)
+ def NumberOfSegments(self, n, s=[]):
+ if s == []:
+ hyp = self.OwnHypothesis("NumberOfSegments", [n])
+ else:
+ hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
+ hyp.SetDistrType( 1 )
+ hyp.SetScaleFactor(s)
+ hyp.SetNumberOfSegments(n)
+ return hyp
+
+ ## Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
+ # with a length that changes in arithmetic progression
+ # @param start the length of the first segment
+ # @param end the length of the last segment
+ def Arithmetic1D(self, start, end ):
+ hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
+ hyp.SetLength(start, 1)
+ hyp.SetLength(end , 0)
+ return hyp
+
+ ## Defines "StartEndLength" hypothesis, specifying distribution of segments
+ # as geometric length increasing
+ # @param start for the length of the first segment
+ # @param end for the length of the last segment
+ def StartEndLength(self, start, end):
+ hyp = self.OwnHypothesis("StartEndLength", [start, end])
+ hyp.SetLength(start, 1)
+ hyp.SetLength(end , 0)
+ return hyp
+
+ ## Defines "AutomaticLength" hypothesis, specifying the number of segments
+ # @param fineness defines the quality of the mesh within the range [0-1]
+ def AutomaticLength(self, fineness=0):
+ hyp = self.OwnHypothesis("AutomaticLength")
+ hyp.SetFineness( fineness )
+ return hyp
+
+
+# Public class: Mesh_UseExistingElements
+# --------------------------------------
+## Defines a Radial Quadrangle 1D2D algorithm
+# @ingroup l3_algos_basic
+#
+class Mesh_UseExistingElements(Mesh_Algorithm):
+
+ def __init__(self, dim, mesh, geom=0):
+ if dim == 1:
+ self.Create(mesh, geom, "Import_1D")
+ else:
+ self.Create(mesh, geom, "Import_1D2D")
+ return
+
+ ## Defines "Source edges" hypothesis, specifying groups of edges to import
+ # @param groups list of groups of edges
+ # @param toCopyMesh if True, the whole mesh \a groups belong to is imported
+ # @param toCopyGroups if True, all groups of the mesh \a groups belong to are imported
+ # @param UseExisting if ==true - searches for the existing hypothesis created with
+ # the same parameters, else (default) - creates a new one
+ def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
+ if self.algo.GetName() == "Import_2D":
+ raise ValueError, "algoritm dimension mismatch"
+ hyp = self.Hypothesis("ImportSource1D", [groups, toCopyMesh, toCopyGroups],
+ UseExisting=UseExisting, CompareMethod=self._compareHyp)
+ hyp.SetSourceEdges(groups)
+ hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
+ return hyp
+
+ ## Defines "Source faces" hypothesis, specifying groups of faces to import
+ # @param groups list of groups of faces
+ # @param toCopyMesh if True, the whole mesh \a groups belong to is imported
+ # @param toCopyGroups if True, all groups of the mesh \a groups belong to are imported
+ # @param UseExisting if ==true - searches for the existing hypothesis created with
+ # the same parameters, else (default) - creates a new one
+ def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
+ if self.algo.GetName() == "Import_1D":
+ raise ValueError, "algoritm dimension mismatch"
+ hyp = self.Hypothesis("ImportSource2D", [groups, toCopyMesh, toCopyGroups],
+ UseExisting=UseExisting, CompareMethod=self._compareHyp)
+ hyp.SetSourceFaces(groups)
+ hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups)
+ return hyp
+
+ def _compareHyp(self,hyp,args):
+ if hasattr( hyp, "GetSourceEdges"):
+ entries = hyp.GetSourceEdges()
+ else:
+ entries = hyp.GetSourceFaces()
+ groups = args[0]
+ toCopyMesh,toCopyGroups = hyp.GetCopySourceMesh()
+ if len(entries)==len(groups) and toCopyMesh==args[1] and toCopyGroups==args[2]:
+ entries2 = []
+ study = self.mesh.smeshpyD.GetCurrentStudy()
+ if study:
+ for g in groups:
+ ior = salome.orb.object_to_string(g)
+ sobj = study.FindObjectIOR(ior)
+ if sobj: entries2.append( sobj.GetID() )
+ pass
+ pass
+ entries.sort()
+ entries2.sort()
+ return entries == entries2
+ return False
+
+