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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2698 - (hide annotations)
Wed Sep 30 01:46:31 2009 UTC (12 years, 10 months ago) by jfenwick
File MIME type: application/x-tex
File size: 28744 byte(s)
Removing extension from some image filenames

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

  ViewVC Help
Powered by ViewVC 1.1.26