/[escript]/trunk/pycad/py_src/elementries.py
ViewVC logotype

Contents of /trunk/pycad/py_src/elementries.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 898 - (show annotations)
Sun Nov 12 23:56:26 2006 UTC (13 years, 7 months ago) by gross
File MIME type: text/x-python
File size: 9329 byte(s)
first checkin of pycad (gmsh pythoin wrapper)
1 # $Id:$
2
3 """
4 Geometrical Elementries
5
6 the concept is inspired by gmsh and very much focused on the fact that
7 the classes are used to wrk with gmsh.
8
9 @var __author__: name of author
10 @var __copyright__: copyrights
11 @var __license__: licence agreement
12 @var __url__: url entry point on documentation
13 @var __version__: version
14 @var __date__: date of the version
15 """
16
17
18 __author__="Lutz Gross, l.gross@uq.edu.au"
19 __copyright__=""" Copyright (c) 2006 by ACcESS MNRF
20 http://www.access.edu.au
21 Primary Business: Queensland, Australia"""
22 __license__="""Licensed under the Open Software License version 3.0
23 http://www.opensource.org/licenses/osl-3.0.php"""
24 __url__="http://www.iservo.edu.au/esys/escript"
25 __version__="$Revision:$"
26 __date__="$Date:$"
27
28 class Elementary(object):
29 """
30 template for elementary geometrical object
31 """
32 def __init__(self):
33 """
34 """
35 pass
36
37 class Point(Elementary):
38 """
39 a three dimensional point
40 """
41 def __init__(self,x=0.,y=0.,z=0.,local_scale=1.):
42 """
43 creates a point with coorinates x,y,z with a relative refinement factor
44 """
45 super(Point, self).__init__()
46 if not local_scale > 0.:
47 raise ValueError("local_scale needs to be positive.")
48 self._x=numarray.array([x,y,z],numarray.Float64)
49 self.setLocalScale(0.,local_scale)
50 def __str__(self):
51 return str(self._x)
52 def setLocalScale(self,factor=1.):
53 self.__local_scale=factor
54
55
56 class Curve(Elementary):
57 """
58 a curve
59 """
60 def __init__(self,*args):
61 """
62 defines a curve form a set of control points
63 """
64 super(Curve, self).__init__()
65 l=len(args)
66 for i in range(l):
67 if not isinstance(args[i],Point):
68 raise TypeError("%s-th argument is not a Point object.")
69 super(Curve, self).__init__(args[0],args[l-1])
70 self.__nodes=list(args)
71 def __len__(self):
72 return len(self.__nodes)
73
74 def getStart(self):
75 """
76 returns start point
77 """
78 return self.__nodes[0]
79
80 def getEnd(self):
81 """
82 returns end point
83 """
84 return self.__nodes[-1]
85
86 def getNodes(self):
87 """
88 returns a list of the nodes
89 """
90 return self.__nodes
91
92 def __neg__(self):
93 """
94 returns the line segment with swapped start and end points
95 """
96 return Curve(self.__nodes[::-1])
97
98 class BezierCurve(Curve):
99 """
100 a Bezier curve
101 """
102 def __neg__(self):
103 """
104 returns the line segment with swapped start and end points
105 """
106 return BezierCurve(self.getNodesInReversedOrder())
107
108 class BSplineCurve(Curve):
109 """
110 a BSpline curve. Control points may be repeated.
111 """
112 def __neg__(self):
113 """
114 returns the line segment with swapped start and end points
115 """
116 return BSplineCurve(self.getNodesInReversedOrder())
117
118
119 class Line(Curve):
120 """
121 a line is defined by two L{Point}s
122 """
123 def __neg__(self):
124 """
125 returns the line segment with swapped start and end points
126 """
127 return Line(self.getEnd(),self.getStart())
128
129 class Arc(Curve):
130 """
131 defines an arc
132 """
133 def __init__(self,center,start,end):
134 """
135 creates an arc by the start point, end point and center
136 """
137 if not isinstance(center,Point):
138 raise TypeError("center needs to be a Point object.")
139 super(Arc, self).__init__(start,end)
140 self.__center=center
141
142 def getCenter(self):
143 """
144 returns center
145 """
146 return self.__center
147 def __neg__(self):
148 """
149 returns the line segment with swapped start and end points
150 """
151 return Arc(self.getCenter(),self.getEnd(),self.getStart())
152
153 class CurveLoop(Elementary):
154 """
155 An oriented loop of curves.
156
157 The loop must be closed and the L{Curves}s should be oriented consistently.
158 """
159 def __init__(self,*curves):
160 """
161 creates a polygon from a list of line curves. The curves must form a closed loop.
162 """
163 super(CurveLoop, self).__init__()
164 for i in curves:
165 if not isinstance(curves[i],Curve):
166 raise TypeError("%s-th argument is not a Curve object.")
167 if length(curves)>0:
168 for i in range(len(curves)-1):
169 if not curves[i].getEnd() == curves[i+1].getStart():
170 raise ValueError("start point of %s-th curve does not match end point of %s-th curve."%(i,i+1))
171 if curves[0].getStart() == curves[len(curves)-1].getEnd():
172 raise ValueError("loop is not closed.")
173 self.__curves=curves
174
175 def getCurves(self):
176 return self.__curves
177
178 def __neg__(self):
179 return CurveLoop([-c for c in self.__curves[::-1]])
180
181 def __len__(self):
182 return len(self.__curves)
183
184 class Surface(Elementary):
185 """
186 a surface
187 """
188 def __init__(self,loop):
189 """
190 creates a surface with boundary loop
191
192 @param loop: L{CurveLoop} defining the boundary of the surface
193 """
194 super(Surface, self).__init__()
195 if not isinstance(loop,CurveLoop):
196 raise TypeError("argument loop needs to be a CurveLoop object.")
197 self.__loop=loop
198 def getBoundaryLoop(self):
199 return self.__loop
200 def __neg__(self):
201 return Surface(-self.getBoundaryLoop())
202
203 class PlaneSurface(Surface):
204 """
205 a plane surface with holes
206 """
207 def __init__(self,loop,holes=[]):
208 """
209 creates a plane surface.
210
211 @param loop: L{CurveLoop} defining the boundary of the surface
212 @param holes: list of L{CurveLoop} defining holes in the surface.
213 @note: A CurveLoop defining a hole should not have any lines in common with the exterior CurveLoop.
214 A CurveLoop defining a hole should not have any lines in common with another CurveLoop defining a hole in the same surface.
215 """
216 super(PlaneSurface, self).__init__(loop)
217 for i in range(len(holes)):
218 if not isinstance(holes[i],CurveLoop):
219 raise TypeError("%i th hole needs to be a CurveLoop object.")
220 self.__holes=holes
221 def getHoles(self):
222 return self.__holes
223 def __neg__(self):
224 return PlaneSurface(-self.getBoundaryLoop(),holes=[-h for h in self.getHoles()] )
225
226 class RuledSurface(Surface):
227 """
228 A ruled surface, i.e., a surface that can be interpolated using transfinite interpolation
229 """
230 def __init__(self,loop):
231 """
232 creates a ruled surface from a
233
234 @param loop: L{CurveLoop} defining the boundary of the surface. There is a restriction of composed of either three or four L{Curve} objects.
235 """
236 if not isinstance(loop,CurveLoop):
237 raise TypeError("argument loop needs to be a CurveLoop object.")
238 if len(loop)<3:
239 raise TypeError("the loop must contain at least three Curves.")
240 super(RuledSurface, self).__init__(loop)
241 def __neg__(self):
242 return RuledSurface(-self.getBoundaryLoop())
243
244 class SurfaceLoop(Elementary):
245 """
246 a surface loop. It defines the shell of a volume.
247
248 The loop must represent a closed shell, and the L{Surface}s should be oriented consistently.
249 """
250 def __init__(self,*surfaces):
251 """
252 creates a surface loop
253 """
254 super(SurfaceLoop, self).__init__()
255 for i in surfaces:
256 if not isinstance(surfaces[i],Curve):
257 raise TypeError("%s-th argument is not a Curve object.")
258 self.__surfaces=surfaces
259
260 def getSurfaces(self):
261 return self.__surfaces
262
263 def __neg__(self):
264 return SurfaceLoop(-c for c in self.__surfaces[::-1])
265
266 def __len__(self):
267 return len(self.__surfaces)
268
269 class Volume(Elementary):
270 """
271 a volume with holes.
272 """
273 def __init__(self,loop,holes=[]):
274 """
275 creates a volume
276
277 @param loop: L{SurfaceLoop} defining the boundary of the surface
278 @param holes: list of L{SurfaceLoop} defining holes in the surface.
279 @note: A SurfaceLoop defining a hole should not have any surfaces in common with the exterior SurfaceLoop.
280 A SurfaceLoop defining a hole should not have any surfaces in common with another SurfaceLoop defining a hole in the same volume.
281 """
282 super(Volume, self).__init__()
283 if not isinstance(loop,SurfaceLoop):
284 raise TypeError("argument loop needs to be a SurfaceLoop object.")
285 for i in range(len(holes)):
286 if not isinstance(holes[i],SurfaceLoop):
287 raise TypeError("%i th hole needs to be a SurfaceLoop object.")
288 self.__loop=loop
289 self.__holes=holes
290 def getHoles(self):
291 return self.__holes
292 def getSurfaceLoop(self):
293 return self.__loop
294 def __neg__(self):
295 return PlaneSurface(-self.getSurfaceLoop(),holes=[-h for h in self.getHoles()] )
296
297 class PropertySet(Elementary):
298 """
299 defines a group L{Elementary} objects.
300 """
301 def __init__(self,tag=None,*items):
302 super(PropertySet, self).__init__()
303 self.__items=items
304 self.__tag=tag

  ViewVC Help
Powered by ViewVC 1.1.26