/[escript]/trunk/doc/user/pycad.tex
ViewVC logotype

Contents of /trunk/doc/user/pycad.tex

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2683 - (show annotations)
Tue Sep 29 02:20:22 2009 UTC (11 years, 5 months ago) by gross
File MIME type: application/x-tex
File size: 28410 byte(s)
documentation for pycad added.
1
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 %
4 % Copyright (c) 2003-2009 by University of Queensland
5 % Earth Systems Science Computational Center (ESSCC)
6 % http://www.uq.edu.au/esscc
7 %
8 % Primary Business: Queensland, Australia
9 % Licensed under the Open Software License version 3.0
10 % http://www.opensource.org/licenses/osl-3.0.php
11 %
12 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13
14
15
16 \chapter{The Module \pycad} \label{PYCAD CHAP}
17
18
19 \section{Introduction}
20
21 \pycad provides a simple way to build a mesh for your finite element
22 simulation. You begin by building what we call a \class{Design} using
23 primitive geometric objects, and then to go on to build a mesh from
24 this. The final step of generating the mesh from a \class{Design}
25 uses freely available mesh generation software, such as \gmshextern.
26
27 A \class{Design} is built by defining points, which are used to specify
28 the corners of geometric objects and the vertices of curves. Using
29 points you construct more interesting objects such as lines,
30 rectangles, and arcs. By adding many of these objects into what we
31 call a \class{Design}, you can build meshes for arbitrarily complex 2-D
32 and 3-D structures.
33
34 \section{The Unit Square}
35 So the simplest geometry is the unit square. First we generate the
36 corner points
37 \begin{python}
38 from esys.pycad import *
39 p0=Point(0.,0.,0.)
40 p1=Point(1.,0.,0.)
41 p2=Point(1.,1.,0.)
42 p3=Point(0.,1.,0.)
43 \end{python}
44 which are then linked to define the edges of the square
45 \begin{python}
46 l01=Line(p0,p1)
47 l12=Line(p1,p2)
48 l23=Line(p2,p3)
49 l30=Line(p3,p0)
50 \end{python}
51 The lines are put together to form a loop
52 \begin{python}
53 c=CurveLoop(l01,l12,l23,l30)
54 \end{python}
55 The orientation of the line defining the \class{CurveLoop} is important. It is assumed that the surrounded
56 area is to the left when moving along the lines from their starting points towards the end points. Moreover,
57 the line need to form a closed loop.
58
59 We use the \class{CurveLoop} to define a surface
60 \begin{python}
61 s=PlaneSurface(c)
62 \end{python}
63 Notice there is difference between the \class{CurveLoop} defining the boundary
64 of the surface and the actually surface \class{PlaneSurface}. This difference becomes clearer in the next example with a hole. The direction of the lines is important.
65 New we are ready to define the geometry which described by an instance of \class{Design} class:
66 \begin{python}
67 d=Design(dim=2,element_size=0.05)
68 \end{python}
69 Here we use the two dimensional domain with a local element size in the finite element mesh of $0.05$.
70 We then add the surface \code{s} to the geometry
71 \begin{python}
72 d.addItems(s)
73 \end{python}
74 This will automatically import all items used to construct \code{s} into the \class{Design} \code{d}.
75 Now we are ready to construct a \finley FEM mesh and then write it to the file \file{quad.fly}:
76 \begin{python}
77 from esys.finley import MakeDomain
78 dom=MakeDomain(d)
79 dom.write("quad.fly")
80 \end{python}
81 In some cases it is useful to access the script used to generate the geometry. You can specify a specific name
82 for the script file. In our case we use
83 \begin{python}
84 d.setScriptFileName("quad.geo")
85 \end{python}
86 If we put everything together we get the script
87 \begin{python}
88 from esys.pycad import *
89 from esys.pycad.gmsh import Design
90 from esys.finley import MakeDomain
91 p0=Point(0.,0.,0.)
92 p1=Point(1.,0.,0.)
93 p2=Point(1.,1.,0.)
94 p3=Point(0.,1.,0.)
95 l01=Line(p0,p1)
96 l12=Line(p1,p2)
97 l23=Line(p2,p3)
98 l30=Line(p3,p0)
99 c=CurveLoop(l01,l12,l23,l30)
100 s=PlaneSurface(c)
101 d=Design(dim=2,element_size=0.05)
102 d.setScriptFileName("quad.geo")
103 d.setMeshFileName("quad.msh")
104 d.addItems(s)
105 pl1=PropertySet("sides",l01,l23)
106 pl2=PropertySet("top_and_bottom",l12,l30)
107 d.addItems(pl1, pl2)
108 dom=MakeDomain(d)
109 dom.write("quad.fly")
110 \end{python}
111 This example is included with the software in
112 \file{quad.py} in the \ExampleDirectory.
113
114 There are three extra statements which we have not discussed yet: By default the mesh used to subdivide
115 the boundary are not written into the mesh file mainly to reduce the size of the data file. One need to explicitly add the lines to the \Design which should be present in the mesh data. Here we additionally labeled the
116 lines on the top and the bottom with the name ``top_and_bottom`` and the lines on the left and right hand side
117 with the name ``sides`` using \class{PropertySet} objects. The labeling is convenient
118 when using tagging \index{tagging}, see Chapter~\ref{ESCRIPT CHAP}.
119
120 \begin{figure}
121 \centerline{\includegraphics[width=\figwidth]{figures/quad.eps}}
122 \caption{Trapozid with triangle Hole.}
123 \label{fig:PYCAD 0}
124 \end{figure}
125
126 If you have \gmshextern installed you can run the example and view the geometry and mesh with:
127 \begin{python}
128 escript quad.py
129 gmsh quad.geo
130 gmsh quad.msh
131 \end{python}
132 See Figure~\ref{fig:PYCAD 0} for a result.
133
134 In most cases it is best practice to generate the mesh and to solve the mathematical
135 model in to different scripts. In our example you can read the \finley mesh into your simulation
136 code using
137 \begin{python}
138 from finley import ReadMesh
139 mesh=ReadMesh("quad.fly")
140 \end{python}
141
142 Note that the underlying mesh generation software will not accept all
143 the geometries you can create with \pycad. For example, \pycad
144 will happily allow you to create a 2-D \class{Design} that is a
145 closed loop with some additional points or lines lying outside of the
146 enclosed area, but \gmshextern will fail to create a mesh for it.
147
148 \begin{figure}
149 \centerline{\includegraphics[width=\figwidth]{figures/trap.eps}}
150 \caption{Trapozid with triangle Hole.}
151 \label{fig:PYCAD 1}
152 \end{figure}
153
154
155 \section{Holes}
156 The example included below shows how to use \pycad to create a 2-D mesh
157 in the shape of a trapezoid with a cut-out area, see Figure~\ref{fig:PYCAD 1}:
158 \begin{python}
159 from esys.pycad import *
160 from esys.pycad.gmsh import Design
161 from esys.finley import MakeDomain
162
163 # A trapezoid
164 p0=Point(0.0, 0.0, 0.0)
165 p1=Point(1.0, 0.0, 0.0)
166 p2=Point(1.0, 0.5, 0.0)
167 p3=Point(0.0, 1.0, 0.0)
168 l01=Line(p0, p1)
169 l12=Line(p1, p2)
170 l23=Line(p2, p3)
171 l30=Line(p3, p0)
172 c=CurveLoop(l01, l12, l23, l30)
173
174 # A small triangular cutout
175 x0=Point(0.1, 0.1, 0.0)
176 x1=Point(0.5, 0.1, 0.0)
177 x2=Point(0.5, 0.2, 0.0)
178 x01=Line(x0, x1)
179 x12=Line(x1, x2)
180 x20=Line(x2, x0)
181 cutout=CurveLoop(x01, x12, x20)
182
183 # Create the surface with cutout
184 s=PlaneSurface(c, holes=[cutout])
185
186 # Create a Design which can make the mesh
187 d=Design(dim=2, element_size=0.05)
188
189 # Add the trapezoid with cutout
190 d.addItems(s)
191
192 # Create the geometry, mesh and Escript domain
193 d.setScriptFileName("trapezoid.geo")
194 d.setMeshFileName("trapezoid.msh")
195 domain=MakeDomain(d)
196 # write mesh to a finley file:
197 domain.write("trapezoid.fly")
198 \end{python}
199 This example is included with the software in
200 \file{trapezoid.py} in the \ExampleDirectory.
201
202 A \code{CurveLoop} is used to connect several lines into a single curve.
203 It is used in the example above to create the trapezoidal outline for the grid
204 and also for the triangular cutout area.
205 You can use any number of lines when creating a \class{CurveLoop}, but
206 the end of one line must be identical to the start of the next.
207
208
209 \begin{figure}
210 \centerline{\includegraphics[width=\figwidth]{figures/brick.eps}}
211 \caption{Three dimensional Block.}
212 \label{fig:PYCAD 2}
213 \end{figure}
214
215 \section{A 3D example}
216 In this section we discuss the definition of 3D geometries. The example is the unit cube, see Figure~\ref{fig:PYCAD 2}. First we generate the vertices of the cube:
217 \begin{python}
218 from esys.pycad import *
219 p0=Point(0.,0.,0.)
220 p1=Point(1.,0.,0.)
221 p2=Point(0.,1.,0.)
222 p3=Point(1.,1.,0.)
223 p4=Point(0.,0.,1.)
224 p5=Point(1.,0.,1.)
225 p6=Point(0.,1.,1.)
226 p7=Point(1.,1.,1.)
227 \end{python}
228 We connect the points to form the bottom and top surfaces of the cube:
229 \begin{python}
230 l01=Line(p0,p1)
231 l13=Line(p1,p3)
232 l32=Line(p3,p2)
233 l20=Line(p2,p0)
234 bottom=PlaneSurface(CurveLoop(l01,l13,l32,l20))
235 \end{python}
236 and
237 \begin{python}
238 l45=Line(p4,p5)
239 l57=Line(p5,p7)
240 l76=Line(p7,p6)
241 l64=Line(p6,p4)
242 top=PlaneSurface(CurveLoop(l45,l57,l76,l64))
243 \end{python}
244 To form the front face we introduce the two additional lines connecting the left and right front
245 points of the the \code{top} and \code{bottom} face:
246 \begin{python}
247 l15=Line(p1,p5)
248 l40=Line(p4,p0)
249 \end{python}
250 To form the front face we encounter the problem as the line \code{l45} used to define the
251 \code{top} face is pointing the wrong direction. In \pycad you can reversing direction of an
252 object by changing its sign. So we write \code{-l45} to indicate that the direction is to be reversed. With this notation we can write
253 \begin{python}
254 front=PlaneSurface(CurveLoop(l01,l15,-l45,l40))
255 \end{python}
256 Keep in mind that if you use \code{Line(p4,p5)} instead \code{-l45} both objects are treated as different although the connecting the same points with a straight line in the same direction. The resulting geometry would include an opening along the \code{p4}--\code{p5} connection. This will lead to an inconsistent mesh and may result in a failure of the volumetric mesh generator. Similarly we can define the other sides of the cube:
257 \begin{python}
258 l37=Line(p3,p7)
259 l62=Line(p6,p2)
260 back=PlaneSurface(CurveLoop(l32,-l62,-l76,-l37))
261 left=PlaneSurface(CurveLoop(-l40,-l64,l62,l20))
262 right=PlaneSurface(CurveLoop(-l15,l13,l37,-l57))
263 \end{python}
264 We can now put the six surfaces together to form a \class{SurfaceLoop} defining the
265 boundary of the volume of the cube:
266 \begin{python}
267 sl=SurfaceLoop(top,-bottom,front,back,left,right)
268 v=Volume(sl)
269 \end{python}
270 Similar to the definition of a \code{CurvedLoop} the orientation of the surfaces \code{SurfaceLoop} is relevant. In fact the surface normal direction defined by the the right hand rule needs to point outwards as indicated by the surface normals in
271 Figure~\ref{fig:PYCAD 2}. As the \code{bottom} face is directed upwards it is inserted with the minus sign
272 into the \code{SurfaceLoop} in order to adjust the orientation of the surface.
273
274 As in the 2D case, the \class{Design} class is used to define the geometry:
275 \begin{python}
276 from esys.pycad.gmsh import Design
277 from esys.finley import MakeDomain
278
279 des=Design(dim=3, element_size = 0.1, keep_files=True)
280 des.setScriptFileName("brick.geo")
281 des.addItems(v, top, bottom, back, front, left , right)
282
283 dom=MakeDomain(des)
284 dom.write("brick.fly")
285 \end{python}
286 Note that the \finley mesh file \file{brick.fly} will contain the
287 triangles used to define the surfaces as they are added to the \class{Design}.
288 The example script of the cube is included with the software in
289 \file{brick.py} in the \ExampleDirectory.
290
291 \begin{figure}
292 \centerline{\includegraphics[width=\figwidth]{figures/refine1.eps}}
293 \caption{Local refinement at the origin by \code{local_scale=0.01} with \code{element_size=0.3} and number of elements on the top set to 10.}
294 \label{fig:PYCAD 5}
295 \end{figure}
296
297 \section{Element Sizes}
298 The element size used globally is defined by the
299 \code{element_size} argument of the \class{Design}. The mesh generator
300 will try to use this mesh size everywhere in the geometry. In some cases it can be
301 desirable to use locally a finer mesh. A local refinement can be defined at each
302 \class{Point}:
303 \begin{python}
304 p0=Point(0.,0.,0.,local_scale=0.01)
305 \end{python}
306 Here the mesh generator will create a mesh with an element size which is by the factor \code{0.01}
307 times smaller than the global mesh size \code{element_size=0.3}, see Figure~\ref{fig:PYCAD 5}. The point where a refinement is defined must be a point of curve used to define the geometry.
308
309 Alternatively, one can define a mesh size along a curve by defining the number of elements to be used to subdivide the curve. For instance, to use $20$ element on line \code{l23} on uses:
310 \begin{python}
311 l23=Line(p2, p3)
312 l23.setElementDistribution(20)
313 \end{python}
314 Setting the number of elements on a curve overwrites the global mesh size \code{element_size}. The result is shown in Figure~\ref{fig:PYCAD 5}.
315
316
317
318 \section{\pycad Classes}
319 \declaremodule{extension}{esys.pycad}
320 \modulesynopsis{Python geometry description and meshing interface}
321
322 \subsection{Primitives}
323
324 Some of the most commonly-used objects in \pycad are listed here. For a more complete
325 list see the full API documentation.
326
327 \begin{classdesc}{Point}{x=0.,y=0.,z=0.\optional{,local_scale=1.}}
328 Create a point with from coordinates with local characteristic length \var{local_scale}
329 \end{classdesc}
330
331 \begin{classdesc}{Line}{point1, point2}
332 Create a line with between starting and ending points.
333 \end{classdesc}
334 \begin{methoddesc}[Line]{setElementDistribution}{n\optional{,progression=1\optional{,createBump=\False}}}
335 Defines the number of elements on the line. If set it overwrites the local length setting which would be applied. The progression factor \var{progression} defines the change of element size between neighboured elements. If \var{createBump} is set
336 progression is applied towards the centre of the line.
337 \end{methoddesc}
338 \begin{methoddesc}[Line]{resetElementDistribution}{}
339 removes a previously set element distribution from the line.
340 \end{methoddesc}
341 \begin{methoddesc}[Line]{getElemenofDistribution}{}
342 Returns the element distribution as tuple of
343 number of elements, progression factor and bump flag. If
344 no element distribution is set None is returned.
345 \end{methoddesc}
346
347
348 \begin{classdesc}{Spline}{point0, point1, ...}
349 A spline curve defined by a list of points \var{point0}, \var{point1},....
350 \end{classdesc}
351 \begin{methoddesc}[Spline]{setElementDistribution}{n\optional{,progression=1\optional{,createBump=\False}}}
352 Defines the number of elements on the line. If set it overwrites the local length setting which would be applied. The progression factor \var{progression} defines the change of element size between neighboured elements. If \var{createBump} is set
353 progression is applied towards the centre of the line.
354 \end{methoddesc}
355 \begin{methoddesc}[Spline]{resetElementDistribution}{}
356 removes a previously set element distribution from the line.
357 \end{methoddesc}
358 \begin{methoddesc}[Spline]{getElemenofDistribution}{}
359 Returns the element distribution as tuple of
360 number of elements, progression factor and bump flag. If
361 no element distribution is set None is returned.
362 \end{methoddesc}
363
364 \begin{classdesc}{BSpline}{point0, point1, ...}
365 A B-spline curve defined by a list of points \var{point0}, \var{point1},....
366 \end{classdesc}
367 \begin{methoddesc}[BSpline]{setElementDistribution}{n\optional{,progression=1\optional{,createBump=\False}}}
368 Defines the number of elements on the line. If set it overwrites the local length setting which would be applied. The progression factor \var{progression} defines the change of element size between neighboured elements. If \var{createBump} is set
369 progression is applied towards the centre of the line.
370 \end{methoddesc}
371 \begin{methoddesc}[BSpline]{resetElementDistribution}{}
372 removes a previously set element distribution from the line.
373 \end{methoddesc}
374 \begin{methoddesc}[BSpline]{getElemenofDistribution}{}
375 Returns the element distribution as tuple of
376 number of elements, progression factor and bump flag. If
377 no element distribution is set None is returned.
378 \end{methoddesc}
379
380 \begin{classdesc}{BezierCurve}{point0, point1, ...}
381 A Brezier spline curve defined by a list of points \var{point0}, \var{point1},....
382 \end{classdesc}
383 \begin{methoddesc}[BezierCurve]{setElementDistribution}{n\optional{,progression=1\optional{,createBump=\False}}}
384 Defines the number of elements on the line. If set it overwrites the local length setting which would be applied. The progression factor \var{progression} defines the change of element size between neighboured elements. If \var{createBump} is set
385 progression is applied towards the centre of the line.
386 \end{methoddesc}
387 \begin{methoddesc}[BezierCurve]{resetElementDistribution}{}
388 removes a previously set element distribution from the line.
389 \end{methoddesc}
390 \begin{methoddesc}[BezierCurve]{getElemenofDistribution}{}
391 Returns the element distribution as tuple of
392 number of elements, progression factor and bump flag. If
393 no element distribution is set None is returned.
394 \end{methoddesc}
395
396 \begin{classdesc}{Arc}{centre_point, start_point, end_point}
397 Create an arc by specifying a centre for a circle and start and end points. An arc may subtend an angle of at most $\pi$ radians.
398 \end{classdesc}
399 \begin{methoddesc}[Arc]{setElementDistribution}{n\optional{,progression=1\optional{,createBump=\False}}}
400 Defines the number of elements on the line. If set it overwrites the local length setting which would be applied. The progression factor \var{progression} defines the change of element size between neighboured elements. If \var{createBump} is set
401 progression is applied towards the centre of the line.
402 \end{methoddesc}
403 \begin{methoddesc}[Arc]{resetElementDistribution}{}
404 removes a previously set element distribution from the line.
405 \end{methoddesc}
406 \begin{methoddesc}[Arc]{getElemenofDistribution}{}
407 Returns the element distribution as tuple of
408 number of elements, progression factor and bump flag. If
409 no element distribution is set None is returned.
410 \end{methoddesc}
411
412 \begin{classdesc}{CurveLoop}{list}
413 Create a closed curve from the \code{list}. of
414 \class{Line}, \class{Arc}, \class{Spline}, \class{BSpline},
415 \class{BrezierSpline}.
416 \end{classdesc}
417
418 \begin{classdesc}{PlaneSurface}{loop, \optional{holes=[list]}}
419 Create a plane surface from a \class{CurveLoop}, which may have one or more holes
420 described by \var{list} of \class{CurveLoop}.
421 \end{classdesc}
422 \begin{methoddesc}[PlaneSurface]{setRecombination}{max_deviation}
423 the mesh generator will try to recombine triangular elements
424 into quadrilateral elements. \var{max_deviation} (in radians) defines the
425 maximum deviation of any angle in the quadrilaterals from the right angle.
426 Set \var{max_deviation}=\var{None} to remove recombination.
427 \end{methoddesc}
428 \begin{methoddesc}[PlaneSurface]{setTransfiniteMeshing}{\optional{orientation="Left"}}
429 applies 2D transfinite meshing to the surface.
430 \var{orientation} defines the orientation of triangles. Allowed values
431 are \var{``Left''}, \var{``Right''} or \var{``Alternate''}. The
432 boundary of the surface must be defined by three or four lines where an
433 element distribution must be defined on all faces where opposite
434 faces uses the same element distribution. No holes must be present.
435 \end{methoddesc}
436
437
438
439 \begin{classdesc}{RuledSurface}{list}
440 Create a surface that can be interpolated using transfinite interpolation.
441 \var{list} gives a list of three or four lines defining the boundary of the
442 surface.
443 \end{classdesc}
444 \begin{methoddesc}[RuledSurface]{setRecombination}{max_deviation}
445 the mesh generator will try to recombine triangular elements
446 into quadrilateral elements. \var{max_deviation} (in radians) defines the
447 maximum deviation of any angle in the quadrilaterals from the right angle.
448 Set \var{max_deviation}=\var{None} to remove recombination.
449 \end{methoddesc}
450 \begin{methoddesc}[RuledSurface]{setTransfiniteMeshing}{\optional{orientation="Left"}}
451 applies 2D transfinite meshing to the surface.
452 \var{orientation} defines the orientation of triangles. Allowed values
453 are \var{``Left''}, \var{``Right''} or \var{``Alternate''}. The
454 boundary of the surface must be defined by three or four lines where an
455 element distribution must be defined on all faces where opposite
456 faces uses the same element distribution. No holes must be present.
457 \end{methoddesc}
458
459
460 \begin{classdesc}{SurfaceLoop}{list}
461 Create a loop of \class{PlaneSurface} or \class{RuledSurface}, which defines the shell of a volume.
462 \end{classdesc}
463
464 \begin{classdesc}{Volume}{loop, \optional{holes=[list]}}
465 Create a volume given a \class{SurfaceLoop}, which may have one or more holes
466 define by the list of \class{SurfaceLoop}.
467 \end{classdesc}
468
469 \begin{classdesc}{PropertySet}{list}
470 Create a PropertySet given a list of 1-D, 2-D or 3-D items. See the section on Properties below for more information.
471 \end{classdesc}
472
473 %============================================================================================================
474 \subsection{Transformations}
475
476 Sometimes it's convenient to create an object and then make copies at
477 different orientations and in different sizes. Transformations are
478 used to move geometrical objects in the 3-dimensional space and to
479 resize them.
480
481 \begin{classdesc}{Translation}{\optional{b=[0,0,0]}}
482 defines a translation $x \to x+b$. \var{b} can be any object that can be converted
483 into a \numpy object of shape $(3,)$.
484 \end{classdesc}
485
486 \begin{classdesc}{Rotatation}{\optional{axis=[1,1,1], \optional{ point = [0,0,0], \optional{angle=0*RAD} } } }
487 defines a rotation by \var{angle} around axis through point \var{point} and direction \var{axis}.
488 \var{axis} and \var{point} can be any object that can be converted
489 into a \numpy object of shape $(3,)$.
490 \var{axis} does not have to be normalised but must have positive length. The right hand rule~\cite{RIGHTHANDRULE}
491 applies.
492 \end{classdesc}
493
494
495 \begin{classdesc}{Dilation}{\optional{factor=1., \optional{centre=[0,0,0]}}}
496 defines a dilation by the expansion/contraction \var{factor} with
497 \var{centre} as the dilation centre.
498 \var{centre} can be any object that can be converted
499 into a \numpy object of shape $(3,)$.
500 \end{classdesc}
501
502 \begin{classdesc}{Reflection}{\optional{normal=[1,1,1], \optional{offset=0}}}
503 defines a reflection on a plane defined in normal form $n^t x = d$
504 where $n$ is the surface normal \var{normal} and $d$ is the plane \var{offset}.
505 \var{normal} can be any object that can be converted
506 into a \numpy object of shape $(3,)$.
507 \var{normal} does not have to be normalised but must have positive length.
508 \end{classdesc}
509
510 \begin{datadesc}{DEG}
511 A constant to convert from degrees to an internal angle representation in radians. For instance use \code{90*DEG} for $90$ degrees.
512 \end{datadesc}
513
514 \subsection{Properties}
515
516 If you are building a larger geometry you may find it convenient to
517 create it in smaller pieces and then assemble them into the whole.
518 Property sets make this easy, and they allow you to name the smaller
519 pieces for convenience.
520
521 Property sets are used to bundle a set of geometrical objects in a
522 group. The group is identified by a name. Typically a property set
523 is used to mark subregions with share the same material properties or
524 to mark portions of the boundary. For efficiency, the \Design class
525 object assigns a integer to each of its property sets, a so-called tag
526 \index{tag}. The appropriate tag is attached to the elements at
527 generation time.
528
529 See the file \code{pycad/examples/quad.py} for an example using a {\it PropertySet}.
530
531
532 \begin{classdesc}{PropertySet}{name,*items}
533 defines a group geometrical objects which can be accessed through a \var{name}
534 The objects in the tuple \var{items} mast all be \ManifoldOneD, \ManifoldTwoD or \ManifoldThreeD objects.
535 \end{classdesc}
536
537
538 \begin{methoddesc}[PropertySet]{getManifoldClass}{}
539 returns the manifold class \ManifoldOneD, \ManifoldTwoD or \ManifoldThreeD expected from the items
540 in the property set.
541 \end{methoddesc}
542
543 \begin{methoddesc}[PropertySet]{getDim}{}
544 returns the spatial dimension of the items
545 in the property set.
546 \end{methoddesc}
547
548 \begin{methoddesc}[PropertySet]{getName}{}
549 returns the name of the set
550 \end{methoddesc}
551
552 \begin{methoddesc}[PropertySet]{setName}{name}
553 sets the name. This name should be unique within a \Design.
554 \end{methoddesc}
555
556 \begin{methoddesc}[PropertySet]{addItem}{*items}
557 adds a tuple of items. They need to be objects of class \ManifoldOneD, \ManifoldTwoD or \ManifoldThreeD.
558 \end{methoddesc}
559
560 \begin{methoddesc}[PropertySet]{getItems}{}
561 returns the list of items
562 \end{methoddesc}
563
564 \begin{methoddesc}[PropertySet]{clearItems}{}
565 clears the list of items
566 \end{methoddesc}
567
568 \begin{methoddesc}[PropertySet]{getTag}{}
569 returns the tag used for this property set
570 \end{methoddesc}
571
572 \section{Interface to the mesh generation software}
573 \declaremodule{extension}{esys.pycad.gmsh}
574 \modulesynopsis{Python geometry description and meshing interface}
575
576 The class and methods described here provide an interface to the mesh
577 generation software, which is currently \gmshextern. This interface could be
578 adopted to triangle or another mesh generation package if this is
579 deemed to be desirable in the future.
580
581 \begin{classdesc}{Design}{
582 \optional{dim=3, \optional{element_size=1., \optional{order=1, \optional{keep_files=False}}}}}
583 The \class{Design} describes the geometry defined by primitives to be meshed.
584 The \var{dim} specifies the spatial dimension. The argument \var{element_size} defines the global
585 element size which is multiplied by the local scale to set the element size at each \Point.
586 The argument \var{order} defines the element order to be used. If \var{keep_files} is set to
587 \True temporary files a kept otherwise they are removed when the instance of the class is deleted.
588 \end{classdesc}
589
590
591 \begin{methoddesc}[Design]{setDim}{\optional{dim=3}}
592 sets the spatial dimension which needs to be $1$, $2$ or $3$.
593 \end{methoddesc}
594
595 \begin{methoddesc}[Design]{getDim}{}
596 returns the spatial dimension.
597 \end{methoddesc}
598
599 \begin{methoddesc}[Design]{setElementOrder}{\optional{order=1}}
600 sets the element order which needs to be $1$ or $2$.
601 \end{methoddesc}
602
603 \begin{methoddesc}[Design]{getElementOrder}{}
604 returns the element order.
605 \end{methoddesc}
606
607
608 \begin{methoddesc}[Design]{setElementSize}{\optional{element_size=1}}
609 set the global element size. The local element size at a point is defined as
610 the global element size multiplied by the local scale. The element size must be positive.
611 \end{methoddesc}
612
613
614 \begin{methoddesc}[Design]{getElementSize}{}
615 returns the global element size.
616 \end{methoddesc}
617
618 \begin{memberdesc}[Design]{DELAUNAY}
619 the gmsh Delauny triangulator.
620 \end{memberdesc}
621
622 \begin{memberdesc}[Design]{TETGEN}
623 the TetGen~\cite{TETGEN} triangulator.
624 \end{memberdesc}
625
626 \begin{memberdesc}[Design]{NETGEN}
627 the NETGEN~\cite{NETGEN} triangulator.
628 \end{memberdesc}
629
630 \begin{methoddesc}[Design]{setKeepFilesOn}{}
631 work files are kept at the end of the generation.
632 \end{methoddesc}
633
634 \begin{methoddesc}[Design]{setKeepFilesOff}{}
635 work files are deleted at the end of the generation.
636 \end{methoddesc}
637
638 \begin{methoddesc}[Design]{keepFiles}{}
639 returns \True if work files are kept. Otherwise \False is returned.
640 \end{methoddesc}
641
642 \begin{methoddesc}[Design]{setScriptFileName}{\optional{name=None}}
643 set the file name for the gmsh input script. if no name is given a name with extension "geo" is generated.
644 \end{methoddesc}
645
646 \begin{methoddesc}[Design]{getScriptFileName}{}
647 returns the name of the file for the gmsh script.
648 \end{methoddesc}
649
650
651 \begin{methoddesc}[Design]{setMeshFileName}{\optional{name=None}}
652 sets the name for the gmsh mesh file. if no name is given a name with extension "msh" is generated.
653 \end{methoddesc}
654
655 \begin{methoddesc}[Design]{getMeshFileName}{}
656 returns the name of the file for the gmsh msh
657 \end{methoddesc}
658
659
660 \begin{methoddesc}[Design]{addItems}{*items}
661 adds the tuple of var{items}. An item can be any primitive or a \class{PropertySet}.
662 \warning{If a \PropertySet is added as an item added object that are not
663 part of a \PropertySet are not considered in the messing.
664 }
665
666 \end{methoddesc}
667
668 \begin{methoddesc}[Design]{getItems}{}
669 returns a list of the items
670 \end{methoddesc}
671
672 \begin{methoddesc}[Design]{clearItems}{}
673 resets the items in design
674 \end{methoddesc}
675
676 \begin{methoddesc}[Design]{getMeshHandler}{}
677 returns a handle to the mesh. The call of this method generates the mesh from the geometry and
678 returns a mechanism to access the mesh data. In the current implementation this
679 method returns a file name for a gmsh file containing the mesh data.
680 \end{methoddesc}
681
682 \begin{methoddesc}[Design]{getScriptString}{}
683 returns the gmsh script to generate the mesh as a string.
684 \end{methoddesc}
685
686 \begin{methoddesc}[Design]{getCommandString}{}
687 returns the gmsh command used to generate the mesh as string.
688 \end{methoddesc}
689
690 \begin{methoddesc}[Design]{setOptions}{\optional{algorithm=None, \optional{ optimize_quality=True,\optional{ smoothing=1}}}}
691 sets options for the mesh generator. \var{algorithm} sets the algorithm to be used.
692 The algorithm needs to be \var{Design.DELAUNAY}
693 \var{Design.TETGEN}
694 or \var{Design.NETGEN}. By default \var{Design.DELAUNAY} is used. \var{optimize_quality}=\True invokes an optimization of the mesh quality. \var{smoothing} sets the number of smoothing steps to be applied to the mesh.
695 \end{methoddesc}
696
697 \begin{methoddesc}[Design]{getTagMap}{}
698 returns a \class{TagMap} to map the name \class{PropertySet} in the class to tag numbers generated by gmsh.
699 \end{methoddesc}

  ViewVC Help
Powered by ViewVC 1.1.26