| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The nine following examples introduce new features gradually, starting with `t1.geo'. The files corresponding to these examples are available in the `tutorial' directory of the Gmsh distribution.
This tutorial does not explain the mesh and post-processing file formats: see 9. File formats, for this.
To learn how to run Gmsh on your computer, see 8. Running Gmsh.
7.1 `t1.geo' 7.2 `t2.geo' 7.3 `t3.geo' 7.4 `t4.geo' 7.5 `t5.geo' 7.6 `t6.geo' 7.7 `t7.geo' 7.8 `t8.geo' 7.9 `t9.geo'
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
/*********************************************************************
*
* Gmsh tutorial 1
*
* Variables, elementary entities (points, lines, surfaces), physical
* entities (points, lines, surfaces), background mesh
*
*********************************************************************/
// The simplest construction of Gmsh's scripting language is the
// `affectation'. The following command defines a new variable `lc':
lc = 0.009;
// This variable can then for example be used in the definition of
// Gmsh's simplest `elementary entity', a `Point'. A Point is defined
// by a list of four numbers: its three coordinates (X, Y and Z), and
// a characteristic length which sets the target element size at the
// point:
Point(1) = {0, 0, 0, 9.e-1 * lc};
// The actual distribution of the mesh element sizes is then obtained
// by interpolation of these characteristic lengths throughout the
// geometry. There are also other possibilities to specify
// characteristic lengths: attractors (see `t7.geo') and background
// meshes (see `bgmesh.pos').
// As can be seen in the previous definition, more complex expressions
// can be constructed from variables and floating point
// constants. Here, the product of the variable `lc' by the constant
// 9.e-1 is given as the fourth argument of the list defining the
// point.
// We can then define some additional points as well as our first
// curve. Curves are Gmsh's second type of elementery entities, and,
// amongst curves, straight lines are the simplest. A straight line is
// defined by a list of point numbers. In the commands below, for
// example, the line 1 starts at point 1 and ends at point 2:
Point(2) = {.1, 0, 0, lc} ;
Point(3) = {.1, .3, 0, lc} ;
Point(4) = {0, .3, 0, lc} ;
Line(1) = {1,2} ;
Line(2) = {3,2} ;
Line(3) = {3,4} ;
Line(4) = {4,1} ;
// The third elementary entity is the surface. In order to define a
// simple rectangular surface from the four lines defined above, a
// line loop has first to be defined. A line loop is a list of
// connected lines, a sign being associated with each line (depending
// on the orientation of the line):
Line Loop(5) = {4,1,-2,3} ;
// We can then define the surface as a list of line loops (only one
// here, since there are no holes--see `t4.geo'):
Plane Surface(6) = {5} ;
// At this level, Gmsh knows everything to display the rectangular
// surface 6 and to mesh it. An optional step is needed if we want to
// associate specific region numbers to the various elements in the
// mesh (e.g. to the line segments discretizing lines 1 to 4 or to the
// triangles discretizing surface 6). This is achieved by the
// definition of `physical entities'. Physical entities will group
// elements belonging to several elementary entities by giving them a
// common number (a region number), and specifying their orientation.
// We can for example group the points 1 and 2 into the physical
// entity 1:
Physical Point(1) = {1,2} ;
// Consequently, two punctual elements will be saved in the output
// files, both with the region number 1. The mechanism is identical
// for line or surface elements:
Physical Line(10) = {1,2,4} ;
MySurface = 100;
Physical Surface(MySurface) = {6} ;
// All the line elements created during the meshing of lines 1, 2 and
// 4 will be saved in the output file with the region number 10; and
// all the triangular elements resulting from the discretization of
// surface 6 will be given the region number 100.
// Note that, if no physical entities are defined, all the elements in
// the mesh will be directly saved with their default orientation and
// with a region number equal to the number of the elementary entity
// they discretize.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
/*********************************************************************
*
* Gmsh tutorial 2
*
* Includes, geometrical transformations, extruded geometries,
* elementary entities (volumes), physical entities (volumes)
*
*********************************************************************/
// We first include the previous tutorial file, in order to use it as
// a basis for this one:
Include "t1.geo";
// We can then add new points and lines in the same way as we did in
// `t1.geo':
Point(5) = {0, .4, 0, lc};
Line(5) = {4, 5};
// But Gmsh also provides tools to tranform (translate, rotate, etc.)
// elementary entities or copies of elementary entities. For example,
// the point 3 can be moved by 0.05 units to the left with:
Translate {-0.05, 0, 0} { Point{3}; }
// The resulting point can also be duplicated and translated by 0.1
// along the y axis:
tmp[] = Translate {0, 0.1, 0} { Duplicata{ Point{3}; } } ;
// In this case, we assigned the result of the Translate command to a
// list, so that we can retrieve the number of the newly created point
// and use it to create new lines and a new surface:
Line(7) = {3,tmp[0]};
Line(8) = {tmp[0],5};
Line Loop(10) = {5,-8,-7,3};
Plane Surface(11) = {10};
// Of course, these transformation commands not only apply to points,
// but also to lines and surfaces. We can for example translate a copy
// of surface 6 by 0.12 units along the z axis and define some
// additional lines and surfaces with:
h = 0.12;
Translate {0, 0, h} { Duplicata{ Surface{6}; } }
Line(106) = {1,8};
Line(107) = {2,12};
Line(108) = {3,16};
Line(109) = {4,7};
Line Loop(110) = {1,107,-103,-106}; Plane Surface(111) = {110};
Line Loop(112) = {2,107,104,-108}; Plane Surface(113) = {112};
Line Loop(114) = {3,109,-105,-108}; Plane Surface(115) = {114};
Line Loop(116) = {4,106,-102,-109}; Plane Surface(117) = {116};
// Volumes are the fourth type of elementary entities in Gmsh. In the
// same way one defines line loops to build surfaces, one has to
// define surface loops (i.e. `shells') to build volumes. The
// following volume does not have holes and thus consists of a single
// surface loop:
Surface Loop(118) = {117,-6,111,-113,101,115};
Volume(119) = {118};
// Another way to define a volume is by extruding a surface. The
// following command extrudes the surface 11 along the z axis and
// automatically creates a new volume:
Extrude Surface { 11, {0, 0, h} };
// All these geometrical transformations automatically generate new
// elementary entities. The following command permits to manually
// specify a characteristic length for some of the new points:
Characteristic Length {tmp[0], 2, 12, 3, 16, 6, 22} = lc * 4;
// Note that, if the transformation tools are handy to create complex
// geometries, it is also sometimes useful to generate the `flat'
// geometry, with an explicit list of all elementary entities. This
// can be achieved by selecting the `File->Save as->Gmsh unrolled
// geometry' menu or by typing
//
// > gmsh t2.geo -0
//
// on the command line.
// To save all the tetrahedra discretizing the volumes 119 and 120
// with a common region number, we finally define a physical
// volume:
Physical Volume (1) = {119,120};
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
/*********************************************************************
*
* Gmsh tutorial 3
*
* Extruded meshes, options
*
*********************************************************************/
// Again, we start by including the first tutorial:
Include "t1.geo";
// As in `t2.geo', we plan to perform an extrusion along the z axis.
// But here, instead of only extruding the geometry, we also want to
// extrude the 2D mesh. This is done with the same `Extrude' command,
// but by specifying the number of layers (4 in this case, with 8, 4,
// 2 and 1 subdivisions, respectively), with volume numbers 9000 to
// 9003 and respective heights equal to h/4:
h = 0.1;
Extrude Surface { 6, {0,0,h} } {
Layers { {8,4,2,1}, {9000:9003}, {0.25,0.5,0.75,1} };
};
// The extrusion can also be performed with a rotation instead of a
// translation, and the resulting mesh can be recombined into prisms
// (wedges). All rotations are specified by an axis direction
// ({0,1,0}), an axis point ({-0.1,0,0.1}) and a rotation angle
// (-Pi/2):
Extrude Surface { 122, {0,1,0} , {-0.1,0,0.1} , -Pi/2 } {
Recombine; Layers { 7, 9004, 1 };
};
// Note that a translation ({-2*h,0,0}) and a rotation ({1,0,0},
// {0,0.15,0.25}, Pi/2) can also be combined:
aa[] = Extrude Surface {news-1, {-2*h,0,0}, {1,0,0} , {0,0.15,0.25} , Pi/2}{
Layers { 10, 1 }; Recombine;
}; ;
// In this last extrusion command we didn't specify an explicit
// volume number (which is equivalent to setting it to "0"),
// which means that the elements will simply belong the automatically
// created volume (whose number we get from the aa[] list).
// We finally define a new physical volume to save all the tetrahedra
// with a common region number (101):
Physical Volume(101) = {9000:9004, aa[1]};
// Let us now change some options... Since all interactive options are
// accessible in Gmsh's scripting language, we can for example define
// a global characteristic length factor, redefine some background
// colors, disable the display of the axes, and select an initial
// viewpoint in XYZ mode (disabling the interactive trackball-like
// rotation mode) directly in the input file:
Mesh.CharacteristicLengthFactor = 4;
General.Color.Background = {120,120,120};
General.Color.Foreground = {255,255,255};
General.Color.Text = White;
Geometry.Color.Points = Orange;
General.Axes = 0;
General.Trackball = 0;
General.RotationCenterGravity = 0;
General.RotationCenterX = 0;
General.RotationCenterY = 0;
General.RotationCenterZ = 0;
General.RotationX = 10;
General.RotationY = 70;
General.TranslationX = -0.2;
// Note that all colors can be defined literally or numerically, i.e.
// `General.Color.Background = Red' is equivalent to
// `General.Color.Background = {255,0,0}'; and also note that, as with
// user-defined variables, the options can be used either as right or
// left hand sides, so that the following command will set the surface
// color to the same color as the points:
Geometry.Color.Surfaces = Geometry.Color.Points;
// You can click on the `?' button in the status bar of the graphic
// window to see the current values of all options. To save all the
// options in a file, you can use the `File->Save as->Gmsh options'
// menu. To save the current options as the default options for all
// future Gmsh sessions, you should use the `Tools->Options->Save'
// button.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
/*********************************************************************
*
* Gmsh tutorial 4
*
* Built-in functions, holes, strings, mesh color
*
*********************************************************************/
// As usual, we start by defining some variables, some points and some
// lines:
cm = 1e-02;
e1 = 4.5*cm; e2 = 6*cm / 2; e3 = 5*cm / 2;
h1 = 5*cm; h2 = 10*cm; h3 = 5*cm; h4 = 2*cm; h5 = 4.5*cm;
R1 = 1*cm; R2 = 1.5*cm; r = 1*cm;
ccos = ( -h5*R1 + e2 * Hypot(h5,Hypot(e2,R1)) ) / (h5^2 + e2^2);
ssin = Sqrt(1-ccos^2);
Lc1 = 0.01;
Lc2 = 0.003;
Point(1) = { -e1-e2, 0.0 , 0.0 , Lc1};
Point(2) = { -e1-e2, h1 , 0.0 , Lc1};
Point(3) = { -e3-r , h1 , 0.0 , Lc2};
Point(4) = { -e3-r , h1+r , 0.0 , Lc2};
Point(5) = { -e3 , h1+r , 0.0 , Lc2};
Point(6) = { -e3 , h1+h2, 0.0 , Lc1};
Point(7) = { e3 , h1+h2, 0.0 , Lc1};
Point(8) = { e3 , h1+r , 0.0 , Lc2};
Point(9) = { e3+r , h1+r , 0.0 , Lc2};
Point(10)= { e3+r , h1 , 0.0 , Lc2};
Point(11)= { e1+e2, h1 , 0.0 , Lc1};
Point(12)= { e1+e2, 0.0 , 0.0 , Lc1};
Point(13)= { e2 , 0.0 , 0.0 , Lc1};
Point(14)= { R1 / ssin , h5+R1*ccos, 0.0 , Lc2};
Point(15)= { 0.0 , h5 , 0.0 , Lc2};
Point(16)= { -R1 / ssin , h5+R1*ccos, 0.0 , Lc2};
Point(17)= { -e2 , 0.0 , 0.0 , Lc1};
Point(18)= { -R2 , h1+h3 , 0.0 , Lc2};
Point(19)= { -R2 , h1+h3+h4, 0.0 , Lc2};
Point(20)= { 0.0 , h1+h3+h4, 0.0 , Lc2};
Point(21)= { R2 , h1+h3+h4, 0.0 , Lc2};
Point(22)= { R2 , h1+h3 , 0.0 , Lc2};
Point(23)= { 0.0 , h1+h3 , 0.0 , Lc2};
Point(24)= { 0 , h1+h3+h4+R2, 0.0 , Lc2};
Point(25)= { 0 , h1+h3-R2, 0.0 , Lc2};
Line(1) = {1 ,17};
Line(2) = {17,16};
// Since not all curves are straight lines, Gmsh provides many other
// curve primitives: splines, B-splines, circle arcs, ellipse arcs,
// etc. Here we define a new circle arc, starting at point 14 and
// ending at point 16, with the circle's center being the point 15:
Circle(3) = {14,15,16};
// Note that, in Gmsh, circle arcs should always be stricly smaller
// than Pi. We can then define additional lines and circles, as well
// as a new surface:
Line(4) = {14,13};
Line(5) = {13,12};
Line(6) = {12,11};
Line(7) = {11,10};
Circle(8) = { 8, 9,10};
Line(9) = { 8, 7};
Line(10) = { 7, 6};
Line(11) = { 6, 5};
Circle(12) = { 3, 4, 5};
Line(13) = { 3, 2};
Line(14) = { 2, 1};
Line(15) = {18,19};
Circle(16) = {21,20,24};
Circle(17) = {24,20,19};
Circle(18) = {18,23,25};
Circle(19) = {25,23,22};
Line(20) = {21,22};
Line Loop(21) = {17,-15,18,19,-20,16};
Plane Surface(22) = {21};
// But we still need to define the exterior surface. Since it has a
// hole, its definition now requires two lines loops:
Line Loop(23) = {11,-12,13,14,1,2,-3,4,5,6,7,-8,9,10};
Plane Surface(24) = {23,21};
// Finally, we can add some comments by embedding a post-processing
// view containing some strings, and change the color of some mesh
// entities:
View "comments" {
// 10 pixels from the left and 15 pixels from the top of the graphic
// window:
T2(10,15,0){StrCat("File created on ", Today)};
// 10 pixels from the left and 10 pixels from the bottom of the
// graphic window:
T2(10,-10,0){"Copyright (C) My Company"};
// in the model, at (X,Y,Z) = (0.0,0.11,0.0):
T3(0,0.11,0,0){"Hole"};
};
Color Grey70{ Surface{ 22 }; }
Color Purple{ Surface{ 24 }; }
Color Red{ Line{ 1:14 }; }
Color Yellow{ Line{ 15:20 }; }
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
/*********************************************************************
*
* Gmsh tutorial 5
*
* Characteristic lengths, arrays of variables, functions, loops
*
*********************************************************************/
// Again, we start be defining some characteristic lengths:
lcar1 = .1;
lcar2 = .0005;
lcar3 = .055;
// If we wanted to change these lengths globally (without changing the
// above definitions), we could give a global scaling factor for all
// characteristic lengths on the command line with the `-clscale'
// option (or with `Mesh.CharacteristicLengthFactor' in an option
// file). For example, with:
//
// > gmsh t5 -clscale 1
//
// this input file produces a mesh of approximately 2,500 nodes and
// 13,000 tetrahedra (in 4 seconds on a 1.2GHz PC). With
//
// > gmsh t5 -clscale 0.2
//
// (i.e. with all characteristic lengths divided by 5), the mesh
// counts approximately 260,000 nodes and 1.6 million tetrahedra (and
// the computation takes 16 minutes on the same machine).
// Let us proceed by defining some elementary entities describing a
// truncated cube:
Point(1) = {0.5,0.5,0.5,lcar2}; Point(2) = {0.5,0.5,0,lcar1};
Point(3) = {0,0.5,0.5,lcar1}; Point(4) = {0,0,0.5,lcar1};
Point(5) = {0.5,0,0.5,lcar1}; Point(6) = {0.5,0,0,lcar1};
Point(7) = {0,0.5,0,lcar1}; Point(8) = {0,1,0,lcar1};
Point(9) = {1,1,0,lcar1}; Point(10) = {0,0,1,lcar1};
Point(11) = {0,1,1,lcar1}; Point(12) = {1,1,1,lcar1};
Point(13) = {1,0,1,lcar1}; Point(14) = {1,0,0,lcar1};
Line(1) = {8,9}; Line(2) = {9,12}; Line(3) = {12,11};
Line(4) = {11,8}; Line(5) = {9,14}; Line(6) = {14,13};
Line(7) = {13,12}; Line(8) = {11,10}; Line(9) = {10,13};
Line(10) = {10,4}; Line(11) = {4,5}; Line(12) = {5,6};
Line(13) = {6,2}; Line(14) = {2,1}; Line(15) = {1,3};
Line(16) = {3,7}; Line(17) = {7,2}; Line(18) = {3,4};
Line(19) = {5,1}; Line(20) = {7,8}; Line(21) = {6,14};
Line Loop(22) = {-11,-19,-15,-18}; Plane Surface(23) = {22};
Line Loop(24) = {16,17,14,15}; Plane Surface(25) = {24};
Line Loop(26) = {-17,20,1,5,-21,13}; Plane Surface(27) = {26};
Line Loop(28) = {-4,-1,-2,-3}; Plane Surface(29) = {28};
Line Loop(30) = {-7,2,-5,-6}; Plane Surface(31) = {30};
Line Loop(32) = {6,-9,10,11,12,21}; Plane Surface(33) = {32};
Line Loop(34) = {7,3,8,9}; Plane Surface(35) = {34};
Line Loop(36) = {-10,18,-16,-20,4,-8}; Plane Surface(37) = {36};
Line Loop(38) = {-14,-13,-12,19}; Plane Surface(39) = {38};
// Instead of using included files, let us now use a user-defined
// function in order to carve some holes in the cube:
Function CheeseHole
// In the following commands we use the reserved variable name
// `newp', which automatically selects a new point number. This
// number is chosen as the highest current point number, plus
// one. (Note that, analogously to `newp', the variables `newc',
// `news', `newv' and `newreg' select the highest number amongst
// currently defined curves, surfaces, volumes and `any entities
// other than points', respectively.)
p1 = newp; Point(p1) = {x, y, z, lcar3} ;
p2 = newp; Point(p2) = {x+r,y, z, lcar3} ;
p3 = newp; Point(p3) = {x, y+r,z, lcar3} ;
p4 = newp; Point(p4) = {x, y, z+r,lcar3} ;
p5 = newp; Point(p5) = {x-r,y, z, lcar3} ;
p6 = newp; Point(p6) = {x, y-r,z, lcar3} ;
p7 = newp; Point(p7) = {x, y, z-r,lcar3} ;
c1 = newreg; Circle(c1) = {p2,p1,p7};
c2 = newreg; Circle(c2) = {p7,p1,p5};
c3 = newreg; Circle(c3) = {p5,p1,p4};
c4 = newreg; Circle(c4) = {p4,p1,p2};
c5 = newreg; Circle(c5) = {p2,p1,p3};
c6 = newreg; Circle(c6) = {p3,p1,p5};
c7 = newreg; Circle(c7) = {p5,p1,p6};
c8 = newreg; Circle(c8) = {p6,p1,p2};
c9 = newreg; Circle(c9) = {p7,p1,p3};
c10 = newreg; Circle(c10) = {p3,p1,p4};
c11 = newreg; Circle(c11) = {p4,p1,p6};
c12 = newreg; Circle(c12) = {p6,p1,p7};
// We need non-plane surfaces to define the spherical cheese
// holes. Here we use ruled surfaces, which can have 3 or 4
// sides:
l1 = newreg; Line Loop(l1) = {c5,c10,c4}; Ruled Surface(newreg) = {l1};
l2 = newreg; Line Loop(l2) = {c9,-c5,c1}; Ruled Surface(newreg) = {l2};
l3 = newreg; Line Loop(l3) = {c12,-c8,-c1}; Ruled Surface(newreg) = {l3};
l4 = newreg; Line Loop(l4) = {c8,-c4,c11}; Ruled Surface(newreg) = {l4};
l5 = newreg; Line Loop(l5) = {-c10,c6,c3}; Ruled Surface(newreg) = {l5};
l6 = newreg; Line Loop(l6) = {-c11,-c3,c7}; Ruled Surface(newreg) = {l6};
l7 = newreg; Line Loop(l7) = {-c2,-c7,-c12};Ruled Surface(newreg) = {l7};
l8 = newreg; Line Loop(l8) = {-c6,-c9,c2}; Ruled Surface(newreg) = {l8};
// Please note that all surface meshes are generated by projecting a
// 2D planar mesh onto the surface, and that this method gives nice
// results only if the surface's curvature is small enough. If not,
// you will have to cut the surface in pieces.
// We then use an array of variables to store the surface loops
// identification numbers for later reference (we will need these to
// define the final volume):
theloops[t] = newreg ;
Surface Loop(theloops[t]) = {l8+1,l5+1,l1+1,l2+1,l3+1,l7+1,l6+1,l4+1};
thehole = newreg ;
Volume(thehole) = theloops[t] ;
Return
// We can use a `For' loop to generate five holes in the cube:
x = 0 ; y = 0.75 ; z = 0 ; r = 0.09 ;
For t In {1:5}
x += 0.166 ;
z += 0.166 ;
Call CheeseHole ;
// We define a physical volume for each hole:
Physical Volume (t) = thehole ;
// We also print some variables on the terminal (note that, since
// all variables are treated internally as floating point numbers,
// the format string should only contain valid floating point format
// specifiers):
Printf("Hole %g (center = {%g,%g,%g}, radius = %g) has number %g!",
t, x, y, z, r, thehole) ;
EndFor
// We can then define the surface loop for the exterior surface of the
// cube:
theloops[0] = newreg ;
Surface Loop(theloops[0]) = {35,31,29,37,33,23,39,25,27} ;
// The volume of the cube, without the 5 cheese holes, is now defined
// by 6 surface loops (the exterior surface and the five interior
// loops). To reference an array of variables, its identifier is
// followed by '[]':
Volume(186) = {theloops[]} ;
// We finally define a physical volume for the elements discretizing
// the cube, without the holes (whose elements were already tagged
// with numbers 1 to 5 in the `For' loop):
Physical Volume (10) = 186 ;
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
/*********************************************************************
*
* Gmsh tutorial 6
*
* Transfinite meshes
*
*********************************************************************/
// We start by defining a more complex geometry, using the same
// commands as in the previous examples:
r_int = 0.05 ;
r_ext = 0.051 ;
r_far = 0.125 ;
r_inf = 0.4 ;
phi1 = 30. * (Pi/180.) ;
angl = 45. * (Pi/180.) ;
nbpt_phi = 5 ; nbpt_int = 20 ;
nbpt_arc1 = 10 ; nbpt_arc2 = 10 ;
nbpt_shell = 10 ; nbpt_far = 25 ; nbpt_inf = 15 ;
lc0 = 0.1 ; lc1 = 0.1 ; lc2 = 0.3 ;
Point(1) = {0, 0, 0, lc0} ;
Point(2) = {r_int, 0, 0, lc0} ;
Point(3) = {r_ext, 0, 0, lc1} ;
Point(4) = {r_far, 0, 0, lc2} ;
Point(5) = {r_inf, 0, 0, lc2} ;
Point(6) = {0, 0, r_int, lc0} ;
Point(7) = {0, 0, r_ext, lc1} ;
Point(8) = {0, 0, r_far, lc2} ;
Point(9) = {0, 0, r_inf, lc2} ;
Point(10) = {r_int*Cos(phi1), r_int*Sin(phi1), 0, lc0} ;
Point(11) = {r_ext*Cos(phi1), r_ext*Sin(phi1), 0, lc1} ;
Point(12) = {r_far*Cos(phi1), r_far*Sin(phi1), 0, lc2} ;
Point(13) = {r_inf*Cos(phi1), r_inf*Sin(phi1), 0, lc2} ;
Point(14) = {r_int/2, 0, 0, lc2} ;
Point(15) = {r_int/2*Cos(phi1), r_int/2*Sin(phi1), 0, lc2} ;
Point(16) = {r_int/2, 0, r_int/2, lc2} ;
Point(17) = {r_int/2*Cos(phi1), r_int/2*Sin(phi1), r_int/2, lc2} ;
Point(18) = {0, 0, r_int/2, lc2} ;
Point(19) = {r_int*Cos(angl), 0, r_int*Sin(angl), lc2} ;
Point(20) = {r_int*Cos(angl)*Cos(phi1), r_int*Cos(angl)*Sin(phi1),
r_int*Sin(angl), lc2} ;
Point(21) = {r_ext*Cos(angl), 0, r_ext*Sin(angl), lc2} ;
Point(22) = {r_ext*Cos(angl)*Cos(phi1), r_ext*Cos(angl)*Sin(phi1),
r_ext*Sin(angl), lc2} ;
Point(23) = {r_far*Cos(angl), 0, r_far*Sin(angl), lc2} ;
Point(24) = {r_far*Cos(angl)*Cos(phi1), r_far*Cos(angl)*Sin(phi1),
r_far*Sin(angl), lc2} ;
Point(25) = {r_inf, 0, r_inf, lc2} ;
Point(26) = {r_inf*Cos(phi1), r_inf*Sin(phi1), r_inf, lc2} ;
Circle(1) = {2,1,19}; Circle(2) = {19,1,6}; Circle(3) = {3,1,21};
Circle(4) = {21,1,7}; Circle(5) = {4,1,23}; Circle(6) = {23,1,8};
Line(7) = {5,25}; Line(8) = {25,9};
Circle(9) = {10,1,20}; Circle(10)= {20,1,6}; Circle(11) = {11,1,22};
Circle(12)= {22,1,7}; Circle(13)= {12,1,24}; Circle(14) = {24,1,8};
Line(15) = {13,26}; Line(16) = {26,9};
Circle(17)= {19,1,20}; Circle(18)= {21,1,22}; Circle(19) = {23,1,24};
Circle(20)= {25,1,26}; Circle(21)= {2,1,10}; Circle(22) = {3,1,11};
Circle(23)= {4,1,12}; Circle(24)= {5,1,13};
Line(25) = {1,14}; Line(26) = {14,2}; Line(27) = {2,3};
Line(28) = {3,4}; Line(29) = {4,5}; Line(30) = {1,15};
Line(31) = {15,10}; Line(32) = {10,11}; Line(33) = {11,12};
Line(34) = {12,13}; Line(35) = {14,15}; Line(36) = {14,16};
Line(37) = {15,17}; Line(38) = {16,17}; Line(39) = {18,16};
Line(40) = {18,17}; Line(41) = {1,18}; Line(42) = {18,6};
Line(43) = {6,7}; Line(44) = {16,19}; Line(45) = {19,21};
Line(46) = {21,23}; Line(47) = {23,25}; Line(48) = {17,20};
Line(49) = {20,22}; Line(50) = {22,24}; Line(51) = {24,26};
Line(52) = {7,8}; Line(53) = {8,9};
Line Loop(54) = {39,-36,-25,41}; Ruled Surface(55) = {54};
Line Loop(56) = {44,-1,-26,36}; Ruled Surface(57) = {56};
Line Loop(58) = {3,-45,-1,27}; Ruled Surface(59) = {58};
Line Loop(60) = {5,-46,-3,28}; Ruled Surface(61) = {60};
Line Loop(62) = {7,-47,-5,29}; Ruled Surface(63) = {62};
Line Loop(64) = {-2,-44,-39,42}; Ruled Surface(65) = {64};
Line Loop(66) = {-4,-45,2,43}; Ruled Surface(67) = {66};
Line Loop(68) = {-6,-46,4,52}; Ruled Surface(69) = {68};
Line Loop(70) = {-8,-47,6,53}; Ruled Surface(71) = {70};
Line Loop(72) = {-40,-41,30,37}; Ruled Surface(73) = {72};
Line Loop(74) = {48,-9,-31,37}; Ruled Surface(75) = {74};
Line Loop(76) = {49,-11,-32,9}; Ruled Surface(77) = {76};
Line Loop(78) = {-50,-11,33,13}; Ruled Surface(79) = {78};
Line Loop(80) = {-51,-13,34,15}; Ruled Surface(81) = {80};
Line Loop(82) = {10,-42,40,48}; Ruled Surface(83) = {82};
Line Loop(84) = {12,-43,-10,49}; Ruled Surface(85) = {84};
Line Loop(86) = {14,-52,-12,50}; Ruled Surface(87) = {86};
Line Loop(88) = {16,-53,-14,51}; Ruled Surface(89) = {88};
Line Loop(90) = {-30,25,35}; Ruled Surface(91) = {90};
Line Loop(92) = {-40,39,38}; Ruled Surface(93) = {92};
Line Loop(94) = {37,-38,-36,35}; Ruled Surface(95) = {94};
Line Loop(96) = {-48,-38,44,17}; Ruled Surface(97) = {96};
Line Loop(98) = {18,-49,-17,45}; Ruled Surface(99) = {98};
Line Loop(100) = {19,-50,-18,46}; Ruled Surface(101) = {100};
Line Loop(102) = {20,-51,-19,47}; Ruled Surface(103) = {102};
Line Loop(104) = {-2,17,10}; Ruled Surface(105) = {104};
Line Loop(106) = {-9,-21,1,17}; Ruled Surface(107) = {106};
Line Loop(108) = {-4,18,12}; Ruled Surface(109) = {108};
Line Loop(110) = {-11,-22,3,18}; Ruled Surface(111) = {110};
Line Loop(112) = {-13,-23,5,19}; Ruled Surface(113) = {112};
Line Loop(114) = {-6,19,14}; Ruled Surface(115) = {114};
Line Loop(116) = {-15,-24,7,20}; Ruled Surface(117) = {116};
Line Loop(118) = {-8,20,16}; Ruled Surface(119) = {118};
Line Loop(120) = {-31,-35,26,21}; Ruled Surface(121) = {120};
Line Loop(122) = {32,-22,-27,21}; Ruled Surface(123) = {122};
Line Loop(124) = {33,-23,-28,22}; Ruled Surface(125) = {124};
Line Loop(126) = {34,-24,-29,23}; Ruled Surface(127) = {126};
Surface Loop(128) = {93,-73,-55,95,-91};
Volume(129) = {128}; // int
Surface Loop(130) = {107,-75,-97,95,57,121};
Volume(131) = {130}; // int b
Surface Loop(132) = {105,-65,-97,-83,-93};
Volume(133) = {132}; // int h
Surface Loop(134) = {99,-111,77,123,59,107};
Volume(135) = {134}; // shell b
Surface Loop(136) = {99,-109,67,105,85};
Volume(137) = {136}; // shell h
Surface Loop(138) = {113,79,-101,-111,-125,-61};
Volume(139) = {138}; // ext b
Surface Loop(140) = {115,-69,-101,-87,-109};
Volume(141) = {140}; // ext h
Surface Loop(142) = {103,-117,-81,113,127,63};
Volume(143) = {142}; // inf b
Surface Loop(144) = {89,-119,71,103,115};
Volume(145) = {144}; // inf h
// Once the geometry is defined, we then add transfinite mesh commands
// in order to explicitly define a structured mesh.
// 1. Transfinite line commands specify the number of points on the
// curves and their distribution (`Progression 2' means that each line
// element in the series will be twice as long as the preceding one):
Transfinite Line{35,21,22,23,24,38,17,18,19,20} = nbpt_phi ;
Transfinite Line{31,26,48,44,42} = nbpt_int Using Progression 0.88;
Transfinite Line{41,37,36,9,11,1,3,13,5,15,7} = nbpt_arc1 ;
Transfinite Line{30,25,40,39,10,2,12,4,14,6,16,8} = nbpt_arc2 ;
Transfinite Line{32,27,49,45,43} = nbpt_shell ;
Transfinite Line{33,28,46,50,52} = nbpt_far Using Progression 1.2 ;
Transfinite Line{34,29,51,47,53} = nbpt_inf Using Progression 1.05;
// 2. Transfinite surfaces are defined by an ordered list of the
// points on their boundary (the ordering of these points defines the
// ordering of the mesh elements). Note that a transfinite surface can
// only have 3 or 4 sides:
Transfinite Surface{55} = {1,14,16,18};
Transfinite Surface{57} = {14,2,19,16};
Transfinite Surface{59} = {2,3,21,19};
Transfinite Surface{61} = {3,4,23,21};
Transfinite Surface{63} = {4,5,25,23};
Transfinite Surface{73} = {1,15,17,18};
Transfinite Surface{75} = {15,10,20,17};
Transfinite Surface{77} = {10,11,22,20};
Transfinite Surface{79} = {11,12,24,22};
Transfinite Surface{81} = {12,13,26,24};
Transfinite Surface{65} = {18,16,19,6};
Transfinite Surface{67} = {6,19,21,7};
Transfinite Surface{69} = {7,21,23,8};
Transfinite Surface{71} = {8,23,25,9};
Transfinite Surface{83} = {17,18,6,20};
Transfinite Surface{85} = {20,6,7,22};
Transfinite Surface{87} = {22,7,8,24};
Transfinite Surface{89} = {24,8,9,26};
Transfinite Surface{91} = {1,14,15};
Transfinite Surface{95} = {15,14,16,17};
Transfinite Surface{93} = {18,16,17};
Transfinite Surface{121} = {15,14,2,10};
Transfinite Surface{97} = {17,16,19,20};
Transfinite Surface{123} = {10,2,3,11};
Transfinite Surface{99} = {20,19,21,22};
Transfinite Surface{107} = {10,2,19,20};
Transfinite Surface{105} = {6,20,19};
Transfinite Surface{109} = {7,22,21};
Transfinite Surface{111} = {11,3,21,22};
Transfinite Surface{101} = {22,21,23,24};
Transfinite Surface{125} = {11,3,4,12};
Transfinite Surface{115} = {8,24,23};
Transfinite Surface{113} = {24,12,4,23};
Transfinite Surface{127} = {12,13,5,4};
Transfinite Surface{103} = {24,23,25,26};
Transfinite Surface{119} = {9,26,25};
Transfinite Surface{117} = {13,5,25,26};
// 3. Transfinite volumes are also defined by an ordered list of the
// points on their boundary (the ordering defines the ordering of the
// mesh elements). A transfinite volume can only have 6 or 8 faces:
Transfinite Volume{129} = {1,14,15,18,16,17};
Transfinite Volume{131} = {17,16,14,15,20,19,2,10};
Transfinite Volume{133} = {18,17,16,6,20,19};
Transfinite Volume{135} = {10,2,19,20,11,3,21,22};
Transfinite Volume{137} = {6,20,19,7,22,21};
Transfinite Volume{139} = {11,3,4,12,22,21,23,24};
Transfinite Volume{141} = {7,22,21,8,24,23};
Transfinite Volume{143} = {12,4,5,13,24,23,25,26};
Transfinite Volume{145} = {8,24,23,9,26,25};
// As with Extruded meshes, the `Recombine' command tells Gmsh to
// recombine the simplices into quadrangles, prisms or hexahedra when
// possible:
Recombine Surface {55:127};
// We finish by defing some physical entities:
VolInt = 1000 ;
SurfIntPhi0 = 1001 ; SurfIntPhi1 = 1002 ;
SurfIntZ0 = 1003 ;
VolShell = 2000 ;
SurfShellInt = 2001 ; SurfShellExt = 2002 ;
SurfShellPhi0 = 2003 ; SurfShellPhi1 = 2004 ;
SurfShellZ0 = 2005 ;
LineShellIntPhi0 = 2006 ;
LineShellIntPhi1 = 2007 ; LineShellIntZ0 = 2008 ;
PointShellInt = 2009 ;
VolExt = 3000 ;
VolInf = 3001 ;
SurfInf = 3002 ;
SurfExtInfPhi0 = 3003 ; SurfExtInfPhi1 = 3004 ;
SurfExtInfZ0 = 3005 ;
SurfInfRight = 3006 ;
SurfInfTop = 3007 ;
Physical Volume (VolInt) = {129,131,133} ;
Physical Surface (SurfIntPhi0) = {55,57,65} ;
Physical Surface (SurfIntPhi1) = {73,75,83} ;
Physical Surface (SurfIntZ0) = {91,121} ;
Physical Volume (VolShell) = {135,137} ;
Physical Surface (SurfShellInt) = {105,107} ;
Physical Surface (SurfShellExt) = {109,111} ;
Physical Surface (SurfShellPhi0) = {59,67} ;
Physical Surface (SurfShellPhi1) = {77,85} ;
Physical Surface (SurfShellZ0) = {123} ;
Physical Line (LineShellIntPhi0) = {1,2} ;
Physical Line (LineShellIntPhi1) = {9,10} ;
Physical Line (LineShellIntZ0) = 21 ;
//Physical Point (PointShellInt) = 6 ;
Physical Volume (VolExt) = {139,141} ;
Physical Volume (VolInf) = {143,145} ;
Physical Surface (SurfExtInfPhi0) = {61,63,69,71} ;
Physical Surface (SurfExtInfPhi1) = {79,87,81,89} ;
Physical Surface (SurfExtInfZ0) = {125,127} ;
Physical Surface (SurfInfRight) = {117} ;
Physical Surface (SurfInfTop) = {119} ;
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
/*********************************************************************
*
* Gmsh tutorial 7
*
* Anisotropic meshes, attractors
*
*********************************************************************/
// The anisotropic 2D mesh generator can be selected with:
Mesh.Algorithm = 2 ;
// One can force a 4 step Laplacian smoothing of the mesh with:
Mesh.Smoothing = 4 ;
lc = .1;
Point(1) = {0.0,0.0,0,lc};
Point(2) = {1.2,-0.2,0,lc};
Point(3) = {1,1,0,lc};
Point(4) = {0,1,0,lc};
Line(1) = {3,2};
Line(2) = {2,1};
Line(3) = {1,4};
Line(4) = {4,3};
Line Loop(5) = {1,2,3,4};
Plane Surface(6) = {5};
Point(5) = {0.1,0.2,0,lc};
Point(11) = {0.4,0.7,-1,lc};
Point(12) = {0.5,0.5,0,lc};
Point(22) = {0.9,0.9,1,lc};
Line(5) = {11,22};
Spline(7) = {4,5,12,2};
// Isotropic and anisotropic attractors can be defined on points and
// lines (this is still experimental and known to be unstable: use at
// your own risk!):
Attractor Point{1} = {0.01, 0.01, 2};
Attractor Line{5} = {0.3, 0.01, 2};
Attractor Line{7} = {0.1, 0.02, 8};
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
/*********************************************************************
*
* Gmsh tutorial 8
*
* Post-processing, scripting, animations, options
*
*********************************************************************/
// We first include `t1.geo' as well as some post-processing views:
Include "t1.geo" ;
Include "view1.pos" ;
Include "view1.pos" ;
Include "view4.pos" ;
// We then set some general options:
General.Trackball = 0 ;
General.RotationX = 0 ;
General.RotationY = 0 ;
General.RotationZ = 0 ;
General.Color.Background = White ;
General.Color.Foreground = Black ;
General.Color.Text = Black ;
General.Orthographic = 0 ;
General.Axes = 0 ;
General.SmallAxes = 0 ;
// We also set some options for each post-processing view:
v0 = PostProcessing.NbViews-4;
v1 = v0+1;
v2 = v0+2;
v3 = v0+3;
View[v0].IntervalsType = 2 ;
View[v0].OffsetZ = 0.05 ;
View[v0].RaiseZ = 0 ;
View[v0].Light = 1 ;
View[v0].ShowScale = 0;
View[v0].SmoothNormals = 1;
View[v1].IntervalsType = 1 ;
View[v1].ColorTable = { Green, Blue } ;
View[v1].NbIso = 10 ;
View[v1].ShowScale = 0;
View[v2].Name = "Test..." ;
View[v2].IntervalsType = 2 ;
View[v2].Type = 2;
View[v2].IntervalsType = 2 ;
View[v2].AutoPosition = 0;
View[v2].PositionX = 85;
View[v2].PositionY = 50;
View[v2].Width = 200;
View[v2].Height = 130;
View[v3].Type = 3;
View[v3].RangeType = 2;
View[v3].IntervalsType = 4 ;
View[v3].ShowScale = 0;
View[v3].Axes = 0;
View[v3].CustomMin = View[v2].CustomMin;
View[v3].CustomMax = View[v2].CustomMax;
View[v3].AutoPosition = 0;
View[v3].PositionX = View[v2].PositionX;
View[v3].PositionY = View[v2].PositionY;
View[v3].Width = View[v2].Width;
View[v3].Height = View[v2].Height;
// We then loop from 1 to 255 with a step of 1. (To use a different
// step, just add a third argument in the list. For example, `For num
// In {0.5:1.5:0.1}' would increment num from 0.5 to 1.5 with a step
// of 0.1.)
t = 0 ;
For num In {1:255}
View[v0].TimeStep = t ;
View[v1].TimeStep = t ;
View[v2].TimeStep = t ;
View[v3].TimeStep = t ;
t = (View[v0].TimeStep < View[v0].NbTimeStep-1) ? t+1 : 0 ;
View[v0].RaiseZ += 0.01/View[v0].Max * t ;
If (num == 3)
// We want to create 320x240 frames when num == 3:
General.GraphicsWidth = 320 ;
General.GraphicsHeight = 240 ;
EndIf
// It is possible to nest loops:
For num2 In {1:50}
General.RotationX += 10 ;
General.RotationY = General.RotationX / 3 ;
General.RotationZ += 0.1 ;
Sleep 0.01; // sleep for 0.01 second
Draw; // draw the scene
If (num == 3)
// The `Print' command saves the graphical window; the `Sprintf'
// function permits to create the file names on the fly:
Print Sprintf("t8-%02g.gif", num2);
Print Sprintf("t8-%02g.jpg", num2);
EndIf
EndFor
If(num == 3)
// Here we could make a system call to generate a movie. For example,
// with whirlgif:
//
// System "whirlgif -minimize -loop -o t8.gif t8-*.gif";
// with mpeg_encode:
//
// System "mpeg_encode t8.par";
// with mencoder:
//
// System "mencoder 'mf://*.jpg' -mf fps=5 -o t8.mpg -ovc lavc
// -lavcopts vcodec=mpeg1video:vhq";
// System "mencoder 'mf://*.jpg' -mf fps=5 -o t8.mpg -ovc lavc
// -lavcopts vcodec=mpeg4:vhq";
// with ffmpeg:
//
// System "ffmpeg -hq -r 5 -b 800 -vcodec mpeg1video
// -i t8-%02d.jpg t8.mpg"
// System "ffmpeg -hq -r 5 -b 800 -i t8-%02d.jpg t8.asf"
EndIf
EndFor
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
/********************************************************************* * * Gmsh tutorial 9 * * Post-processing, plugins * *********************************************************************/ // Plugins can be added to Gmsh in order to extend its // capabilities. For example, post-processing plugins can modify a // view, or create a new view based on previously loaded // views. Several default plugins are statically linked with Gmsh, // e.g. CutMap, CutPlane, CutSphere, Skin, Transform or Smooth. // Plugins can be controlled in the same way as other options: either // from the graphical interface (right click on the view button, then // `Plugins'), or from the command file. // Let us for example include a three-dimensional scalar view: Include "view3.pos" ; // We then set some options for the `CutMap' plugin (which extracts an // isovalue surface from a 3D scalar view), and run it: Plugin(CutMap).A = 0.67 ; // iso-value level Plugin(CutMap).iView = 0 ; // source view is View[0] Plugin(CutMap).Run ; // We also set some options for the `CutPlane' plugin (which computes // a section of a 3D view), and then run it: Plugin(CutPlane).A = 0 ; Plugin(CutPlane).B = 0.2 ; Plugin(CutPlane).C = 1 ; Plugin(CutPlane).D = 0 ; Plugin(CutPlane).Run ; // Add a title Plugin(Annotate).Text = "A nice title" ; // By convention, a value greater than 99999 represents the center (we // could also use `General.GraphicsWidth/2', but that would only center // the string for the current window size): Plugin(Annotate).X = 1.e5; Plugin(Annotate).Y = 50 ; Plugin(Annotate).Font = "Times-BoldItalic" ; Plugin(Annotate).FontSize = 28 ; Plugin(Annotate).Align = "Center" ; Plugin(Annotate).Run ; Plugin(Annotate).Text = "(and a small subtitle)" ; Plugin(Annotate).Y = 70 ; Plugin(Annotate).Font = "Times-Roman" ; Plugin(Annotate).FontSize = 12 ; Plugin(Annotate).Run ; // We finish by setting some view options and redrawing the scene: View[0].Light = 1; View[0].IntervalsType = 2; View[0].NbIso = 6; View[0].SmoothNormals = 1; View[1].IntervalsType = 2; View[2].IntervalsType = 2; Draw;
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |