Making Money Using Google Page 1

��

��

��

��

�� !�� " �#��$��"%�� $

&��

&��

cgx -b cylinder3.fbd

��#��'��$(��)�� *��+$��,��-��-�� .�� *��+��"��$/��01-1-2345 ��

swep all top tra 0 0 18

2

��

��6�� $/�� 6��#�� -��

�

��

��"� �� $�� "��5� ��#��

plot ld all

7��5�#��8��9�� :�� :&��*;#+��

'

��

7��

qdiv

&�� *��+�

a

��

r

r

9

��

�<�� ,�� <��=&��>?"��"��:.�

99

@��

q

7�� <�� #��

elty all he8

&��

mesh all

��<��

please wait for 'ready'

A

�� !

�� !

��

numFaces:456192 numElems:76032 size:32845824

ready

B��5��<��

plot e all

��*>��> ��+�

C

��

&��5��5��<��

plot f all

7��-�� $�� "��<�� -��-��-��$$��"�� <�� "�� ,�.$(��)�"��"�� <,*��+.�

qadd in

a

r

r

f

q

D

��

��6�� ,��.�

plot f all

plus f in g

3

��

E��<��

qrem in

a

r

r

f

q

��,*��+.�� ,*��+.��<$B��5��8*��+��-*��+�� *��+��"��

plot f all

plus f in g

plus f out r

plus f wall b

F

��

��6��#��

prnt se

��<��

1 all stat:o n:80100 e:76032 f:7872 p:1602 l:3937 s:3104 b:768 L:0 S:0

se:0

2 top stat:c n:801 e:0 f:768 p:801 l:1568 s:768 b:0 L:0 S:0 se:0

3 in stat:c n:0 e:0 f:768 p:0 l:0 s:0 b:0 L:0 S:0 se:0

4 -NJBY stat:c n:0 e:0 f:0 p:0 l:0 s:0 b:0 L:0 S:0 se:0

5 out stat:c n:0 e:0 f:768 p:0 l:0 s:0 b:0 L:0 S:0 se:0

6 wall stat:c n:0 e:0 f:6336 p:0 l:0 s:0 b:0 L:0 S:0 se:0

>#��#��,*��+8��<��-*��+8��<�� *��+8��<��.�

send all foam patch in patch out wall wall

E��<�

please wait for 'ready'

use boundary: type:patch set:in

use boundary: type:patch set:out

use boundary: type:wall set:wall

21

��

wrote foam mesh

ready

�� <��"�� :G��H��

quit

22

Combined Use of Blender with OpenFOAM

G. Douglas Baldwin

Abstract

Blender from blender.org contains a powerful, widely accepted, open source, surface mesh generation

tool that was developed for the digital arts community. Furthermore, Blender includes a robust and

well documented Python application programming interface (API) which facilitates the development of

user tools for mesh manipulation, layered manifolds, and import/export.

The author developed a Python script and technique for manipulating and exporting Blender objects

into CalculiX for hexagonal grid generation, which are then exported into OpenFOAM format. The

benefit of this approach is that manifolds allow absolute control of maximum cell growth rates from the

boundary layer out to the edge of the computational domain, while also directing the path of stacked

hexagonal cells to avoid skew. This technique was used to streamline an aircraft fuselage using a pure

hexagonal grid with OpenFOAM, and then import the grid into Scientific Simulations NSU3D for

authoritative drag analysis.

The technique is ripe with possibilities for developing meshes for many classes of simulations.

Highlights of the hexahedral grids used in the aircraft streamlining effort will be shown and discussed

below, followed by an illustrative grid that combines hexahedral cells at the boundary layer with

tetrahedral cells in the bulk flow. This paper will conclude with a copy of the Python script and a

discussion of how it may be further developed. The author has no intention at this time of leading

further development of this script due to other demands on his time. It is hoped that others too will find

value in this approach and perhaps carry it forward.

Fuselage Streamlining

In general, Blender meshes are comprised of both triangles and quadrilaterals. For the fuselage

streamlining project, it was decided to use exclusively quadrilaterals for the surface. Illustrations of the

final surface are provided below. Notice the pink vertices. The only verticies defined by the user are

those shown in pink. All of the other verticies are automatically generated by Blender when the subsurf

modifier is applied to the object. The strength of the lines connecting any two pink verticies is

controlled by the crease feature. It is not the purpose of this paper to provide a tutorial on Blender,

subsurf, and crease. Many excellent Blender tutorials are readily available on the internet. Notice

however the technique of having evenly space pink verticies to maintain a relatively consistent grid size.

The close-up illustration below reveals better the individual quadrilateral elements automatically

generated by the Blender subsurf modifier. Also note the two different colored Blender materials used

on the object. These Blender materials eventually translate to OpenFOAM patches. The decision to

have two patches for this fuselage model is unrelated to the present topic and will not be discussed

further to avoid a confusing digression.

Presented at the 3rd OpenFOAM Workshop, Milan, Italy, 10-11 July 2008.

Manifolds surrounding this fuselage object were created by using the Python script that will be

provided towards the end of this paper. The procedure for creating manifolds is that a copy of the base

object is created by the user, and then an automatic algorithm moves each pink vertex along its normal

by a user specified amount, making automatic adjustments until all computer generated verticies have

also moved approximately along their normals by approximately the same distance. As a byproduct of

this algorithm, color coded representations of cell height, aspect ratio, and skew are generated as a

visual aid for manual tweaking of the manifold verticies. The first manifold surrounds the

fuselage/base object as shown in the illustration below.

The following illustrations show the color-coded representations of cell height, aspect ratio, and skew,

in that order. The color codes for these illustrations have the following meanings. For the height and

aspect ratio illustrations, blue represents the minimum within the range of values and red represents the

maximum within the range of values. For skew, blue through red represent the range of zero to ninety

degrees in 12.5 degree increments.

The design goal for this fuselage grid was to have a cell height at the fuselage with y+ in the range of 1

to 10, and a cell growth factor of 1.15 extending to the edge of the computational domain, which was

approximately 10 times the reference length away from the fuselage in all directions. A series of four

manifolds were needed to avoid high skew angles. As can be seen in the following two illustrations, the

manifolds further away from the fuselage become become more sphere-like. The first three manifolds

are shown in the cutaway illustration below, followed by an illustration of the fourth manifold enclosing

the third manifold. Notice that the fourth and largest manifold has two materials assigned, shown as

blue and red, which represent the inlet patch and the outlet patch.

The user interface for the Python script is shown below. So far, we have only discussed the manifold

generation capabilities of this script which are controlled by the Displacement Slider and the Apply

button. The units of the Displacement Slider are equivalent to the average edge length of the manifold

quads. The procedure for creating a manifold is as follows: 1) duplicate the the Blender Object; 2)

while in Edit Mode select the vertices that will be displaced; and 3) click on the Apply button. Only

the selected vertices will be displaced. The standard Blender Undo command can be used to move the

vertices back to their original position if needed.

The column of buttons and sliders on the left side of the user interface are used to specify the grid

characteristics, and then the Export button is pressed to export the selected manifolds as a solid

geometry in CalculiX format. When the button labeled “Mesh the boundary layer” has been

depressed, a boundary layer manifold will be automatically generated for the original/base object, with

a displacement distance as specified by the Displacement slider. This button is useful for relatively

simple geometries when performing multiple iterations of mesh generation and OpenFOAM analysis.

The vertices of the base object can be tweaked, and then a new boundary layer manifold is

automatically produced each time the Export button is clicked. For more complex geometries such as

the fuselage shown above, the boundary layer manifold can be manually generated and then manually

tweaked each time the fuselage vertices are tweaked.

The next two sliders specify the cell height. The slider named “Target max aspect ratio” is used to

specify the desired aspect ratio of the first cell. OpenFOAM rejects meshes having any cell aspect ratio

that is greater than 1000. This slider is useful for achieving a small y+ while staying within an aspect

ratio of 1000. Due to the nature of the meshing algorithms, the actual aspect ratio of the first cell may

be slightly larger or smaller than the specified target. The slider “Cell Growth Factor” is used to

specify the maximum cell height growth between any two stacked cells, and applies to the entire

computational domain from the first cell at the base object out to the last manifold.

The next three buttons are used to specify planes of symmetry normal to the X, Y, and Z axes,

respectively. Under most circumstances these planes of symmetry will need to pass through the origin,

but if necessary they can be offset by using the accompanying sliders. The units for these sliders are

Blender units, which for the purposes of OpenFOAM will usually be meters. As will be seen in

subsequent illustrations, a plane of symmetry normal to the Y-axis was applied when exporting the

fuselage grid.

When the Export button is clicked, the user is asked to specify the folder and file name for the CalculiX

.fbd file. File generation usually takes only a few seconds for large models, and certainly less than a

minute for the very largest of models. If Blender is initialized through a command line console

interface, then some useful statistics related to the resulting mesh are printed in this console. Also, the

height, aspect ratio, and skew illustrations as shown above are automatically generated and placed in

Blender’s layers 11, 12, and 13 respectively.

The exported file can now be loaded into Calculix by using the command: “cgx -b filename.fbd”. For

larger grids this load process can take a very long time because CalculiX automatically generates a

geometric body for each pair of quads at each pair of manifolds. After generating the geometry,

CalculiX automatically generates the mesh which also takes some time. Immediately after the file

completes loading into CalculiX, you have a mesh ready to export in OpenFOAM format. First, type in

the “save” command; this will save you the trouble of having CalculiX regenerate the geometry if you

ever need to load this file again. A simple command for exporting to OpenFOAM a test mesh is: “send

all foam patch all”. When you are satisfied with checkMesh, you will then want to specify the

individual patches in your send command. These patches were defined earlier by using Blender

materials. An example send command with patches is “send all foam patch inlet patch outlet wall

yourObject”. Also, if plane(s) of symmetry were used in Blender, then one extra step is needed in

CalculiX before sending the mesh with individual patches to OpenFOAM. Use the command “setr

symmetry se notSymmetry” to remove the non-symmetry faces from the symmetry set, and then

include the phrase “symmetryPlane symmetry” in your send command, e.g. “send all foam patch inlet

patch outlet wall yourObject symmetryPlane symmetry”. Very little proficiency with CalculiX is

necessary, though it would not hurt to learn some of the other features of this tool.

Sample paraFoam plots of the final fuselage grid are shown below.

The above four plots show: 1) the surface quads of the fuselage, 2) the symmetry plane close-in to the

fuselage, revealing the fine structure at the boundary layer, 3) the symmetry plane showing the 1st, 2nd,

and 3rd manifolds, and 4) the symmetry plane of the full computational domain, out to the 4th manifold.

After several iterations between Blender and OpenFOAM, a fuselage geometry having no flow

separation was achieved. The OpenFOAM Lift/Drag tool was used to estimate the drag coefficients.

The grid was then delivered to Scientific Simulations LLC, where an import tool was developed for

converting the OpenFOAM pure hex grid into a NSU3D grid for further CFD analysis. Using the same

operating conditions and same Spalart Allmaras wall model, the difference in predicted drag was

significant. NSU3D, which has been publicly validated for these kinds of streamlined fuselages at the

AIAA CFD Drag Workshop, predicted 30% less drag than OpenFOAM. Furthermore, NSU3D accepts

cell aspect ratios of at least 10,000, which allowed for a finer resolution of the grid at the wall without

the need to further refine the fuselage surface mesh. Together, Blender and OpenFOAM were a

powerful combination of free tools for developing this streamlined, low drag fuselage.

Combining with tetrahedrals

CalculiX can export to OpenFOAM only pure hexahedral grids, and as such is limited. Some cases

cannot be modeled with pure hex, stacked grids. For instance, an effort was made to use the above

techniques to develop a sample coarse grid of the Ahmed wind tunnel experiment. Unfortunately, the

space between the bottom of the automobile and the test section floor became crowed with many high

aspect ratio cells. A better approach is to have quadrahedrals at the boundary layer combined with

tetrahedrals filling the remainder of the computational domain. An attempt at creating such a sample

grid was undertaken, using Blender with CalculiX for the boundary layer and Netgen for the bulk flow

field. Blender images from this grid generation experiment are shown below. The first image shows

the Ahmed body and the first manifold. These two objects were exported to Calculix using the

techniques described above. The second image shows the tunnel, which was created by extruding a

copy of the first manifold and adjusting its verticies.

The tunnel object was exported from Blender in stereo-lithography (STL) format, and then read into

Netgen for tetrahedral mesh generation. Since the cavity of the tunnel object was originally a copy of

the first manifold, this provides a perfect interface for potentially using the stitchMesh tool in

OpenFOAM. Both the CalculiX generated boundary layer mesh and the Netgen bulk flow mesh were

combined in OpenFOAM using mergeMeshes. An image of the combined meshes is shown below,

which includes the tunnel inlet on the left, the symmetry plane, the surface of the Ahmed body, and the

tunnel outlet on the right. The next image shows that the Ahmed body has a quad surface with

hexahedral cells. Following this is a close-up image of the interface between the hexahedral cells and

the tetrahedral cells. Unfortunately, stitchMesh was unable to remove the interface patches. It would

appear that stitchMesh is under active development and should eventually be capable of removing this

interface.

Further uses and further developments

Blender has the ability to import STL objects, and the Python script described in this paper can be used

to create a boundary layer mesh on these STL objects. One approach is to let CalculiX convert each

trilateral into three quadrilaterals, and then use the techniques described above for creating a hexahedral

mesh. Another approach would be to modify the Python script to have it output the hexahedral grid

directly to OpenFOAM format, which would dramatically speed up the mesh generation process.

Direct export from Blender would allow generation of prism cells, which could be stacked directly onto

the STL trilaterals.

A key architectural feature of the Blender data model provides the foundation for manifold

development. Each mesh object includes a linked list of vertices. When a mesh object is copied, the

new mesh object contains the same verticies in the same linked list order. The coordinates of these

verticies may be change without changing their order within the linked list. By strategic placement of

the verticies of the new mesh relative to the original mesh, a collection of uniform, low skew

hexahedrals and/or prisms can be generated. This architectural feature was exploited to generate the

CalculiX bodies from the Blender manifolds. This same architectural feature could be exploited to

directly generate an OpenFOAM mesh comprised of hexahedrals and/or prisms with a uniform growth

factor extending from the body wall up to the first manifold, or further to a second manifold, etc. The

outer two manifolds can then be exported as an STL mesh for tetrahedral mesh generation in Netgen.

Blender has a very efficient mesh manipulation kernel, and when combined with Python scripts can

rapidly export large objects. The script provided below is both useful as is, and potentially even more

valuable with a direct export to OpenFOAM capability.

Also worth noting, modifications to CalculiX were developed to reduce memory allocation

requirements and increase precision. A modification was needed when generating the fuselage grid in

order to avoid malloc errors on a 32-bit machine. The modified source file named foamFaces.c was

posted to the CalculiX support group site on Yahoo. Also, CalculiX outputs OpenFOAM grid

coordinates in float format, and the format statement in the file write2foam.c can easily be changed to

exponential format for improved precision.

Conclusions

A combination of Blender and Calculix was used to generate pure hexahedral grids for the purpose of

streamlining an aircraft fuselage. This technique can potentially be extended to mixed

hexahedral/tetrahedral grids by employing Netgen. Furthermore, the Python script for exporting

Blender geometry in CalculiX format could through modification directly export to OpenFOAM

format, which would allow generation of a stacked prism boundary layer grid on top of an STL object.

This Python script is very useful as-is, and its value to the OpenFOAM community could be

significantly enhanced by adding these relatively minor modifications.

Python script

#!BPY

######################################################################

# Export_fbd v0.2 for Blender

# This script lets you export manifolds to Calculix format (.fbd)

# (c) 2007 G. Douglas Baldwin (doug AT baldwintechnology DOT com)

# released under Blender Artistic License

######################################################################

"""

Name: 'Calculix Export (.fbd)...'

Blender:

Group: 'Export'

Tooltip: 'Export selected objects to Calculix Format (.fbd)'

"""

__author__ = "Doug Baldwin"

__version__ = "0.2"

__bpydoc__ = """\

This script exports manifolds to Calculix Format (.fbd).

Usage:

Create a base mesh object, then make a first copy of this object.

After a copy is made vertices of any object may be repositioned, but

vertices, lines, and faces may neither be added nor deleted. Successive

copies should be stretched into ever larger manifolds. This script will create

a 3D Calculix mesh successively from the base mesh to the first copy, then from

the first copy to the second copy, etc.

The Displacement button is useful for stretching the manifolds. This function

displaces the selected vertices of the selected object in the direction

normal to the local surface.

The goal is to displace the vertices of each manifold generally normal to

its preceding mesh, while also reshaping as needed. Graphic plots of

first cell height, aspect ratio, and skew are output to layers 11, 12,

and 13.

Blender Material names of the first and last object will be exported as

Calculix sets for generating patches.

The GUI parameters Target Aspect Ratio and Growth Factor are used for

calculating the hex cell height at the base mesh object, and the ratio

of successive cell heights extending to the outermost manifold. The values

Target Aspect Ratio and Growth Factor are the maximum values for the entire

hex mesh, regardless of any undulations in the manifolds. Aspect Ratio is

calculated to be the square root of the quad surface divided by the first cell

height normal to the quad surface.

Symmetry planes may be toggled on/off and positioned along the X, Y, and

Z axes. If one or more symmetry planes are toggled on, the exported file

will include a set of external surfaces called "symmetry". Symmetry planes

are generally useful only when vertices of the base object and manifolds

lie on the symmetry plane.

Select all objects to be exported, with the outermost object active. Press

the Export button to export, then select the file location and filename.

Press the Exit button to exit the script.

"""

import Blender

from Blender import Scene, Window, Material

from math import ceil, log, sqrt, floor, acos, pi

# =================================

# === Write FBD Calculix Format ===

# =================================

from Blender.BGL import *

from Blender.Draw import *

import BPyMessages

import bpy

# Parameters

X_Plane = Create(0)

Y_Plane = Create(1)

Z_Plane = Create(0)

X_Location = Create(0.0)

Y_Location = Create(0.0)

Z_Location = Create(0.0)

growth = Create(1.15)

aspect = Create(1000)

mesh_BL = Create(0)

factor = Create(1.0)

# Events

EVENT_NOEVENT = 1

EVENT_EXPORT = 2

EVENT_EXIT = 3

EVENT_APPLY = 4

######################################################

# GUI drawing

######################################################

def draw():

global X_Plane,Y_Plane,Z_Plane,X_Location,Y_Location,Z_Location

global growth, aspect, mesh_BL, factor

global EVENT_NOEVENT,EVENT_EXPORT,EVENT_EXIT

########## Titles

glClear(GL_COLOR_BUFFER_BIT)

glRasterPos2d(8, 183)

Text("Export with optional symmetry plane(s)")


Text("Displace selected vertices normal to the subsurf")

######### Parameters GUI Buttons

X_Plane = Toggle("X: ", EVENT_NOEVENT, 10, 55, 18, 18,

X_Plane.val, "Toggle X-symmetry plane");

X_Location = Slider("Location: ", EVENT_NOEVENT, 30, 55, 200, 18,

X_Location.val, -20.000, 20.0000, 1, "X-plane location");

Y_Plane = Toggle("Y: ", EVENT_NOEVENT, 10, 75, 18, 18,

Y_Plane.val, "Toggle Y-symmetry plane");

Y_Location = Slider("Location: ", EVENT_NOEVENT, 30, 75, 200, 18,

Y_Location.val, -20.000, 20.0000, 1, "Y-plane location");

Z_Plane = Toggle("Z: ", EVENT_NOEVENT, 10, 95, 18, 18,

Z_Plane.val, "Toggle Z-symmetry plane");

Z_Location = Slider("Location: ", EVENT_NOEVENT, 30, 95, 200, 18,

Z_Location.val, -20.000, 20.0000, 1, "Z-plane location");

growth = Number("Cell Growth Factor:", EVENT_NOEVENT, 10, 115, 220, 18,

growth.val, 1.00, 2.00,

"Ratio of cell heights in direction normal to the base object")

aspect = Number("Target max aspect ratio:", EVENT_NOEVENT, 10, 135, 220, 18,

aspect.val, 100.0, 2000.0, "Target aspect ratio of first cell layer")

mesh_BL = Toggle("Mesh the boundary layer", EVENT_NOEVENT, 10, 155, 220, 18,

mesh_BL.val, "Generate a mesh extruded normal to the base object");

factor = Slider("Displacement: ", EVENT_NOEVENT, 250, 55, 260, 18,

factor.val, -1.000, 10.000, 1,

"Magnitude relative to average subsurf edge length");

######### Export and Exit Buttons


Text("Note: Select all manifolds")

Button("Export",EVENT_EXPORT , 10, 10, 80, 18, "Export to Calculix file")

Button("Apply",EVENT_APPLY , 250, 10, 80, 18,

"Apply displacement to the active object")

Button("Exit",EVENT_EXIT , 430, 10, 80, 18, "Exit script")

def event(evt, val):

if (evt == QKEY and not val):

Exit()

def bevent(evt):

# global EVENT_NOEVENT,EVENT_EXPORT,EVENT_EXIT

######### Manages GUI events

if (evt == EVENT_EXIT):

Exit()

elif (evt== EVENT_EXPORT):

if not Blender.Object.GetSelected():

BPyMessages.Error_NoActive()

return

Blender.Window.FileSelector(write_ui, 'FBD Export',

Blender.sys.makename(ext='.fbd'))

Blender.Redraw()

elif (evt == EVENT_APPLY):

manDisplace(factor.val)

Register(draw, event, bevent)

def manDisplace(factor):

sce = bpy.data.scenes.active

ob_act = sce.objects.active

if not ob_act or ob_act.type != 'Mesh':

BPyMessages.Error_NoMeshActive()

return

is_editmode = Window.EditMode()

Window.EditMode(0)

Window.WaitCursor(1)

displace(ob_act, factor)

# Restore editmode if it was enabled

if is_editmode: Window.EditMode(1)

Window.WaitCursor(0)

def write_ui(filename):

global growth, aspect, mesh_BL, factor

# open file

if not filename.lower().endswith('.fbd'):

filename += '.fbd'

file = open(filename, 'wb')

file.write('asgn s C \n') # Calculix auto-generated surfaces to begin with "C"

#initialize values

t = Blender.sys.time()

me = []

ratio = []

bl = None

scn = Scene.GetCurrent()

obs = [ob for ob in scn.objects.context]

obList = obs

if mesh_BL.val == 1:

# create boundary layer object

scn.objects.selected = [obs[len(obs)-1]]

Blender.Object.Duplicate(mesh=1)

bl = scn.objects.selected[0]

# Select vertices in base mesh

mesh = bl.getData(mesh=1)

for v in mesh.verts:

v.sel = 1

displace(bl, factor.val)

obList.insert(len(obList)-1, bl)

n = len(obList)

for i in range(n):

me.append(Blender.Mesh.New()) # create a new mesh

me[i].getFromObject(obList[i], 0, 0) # get subsurf mesh

me[i].transform(obList[i].matrix) # scale and rotate as needed

writePoints(file,me[i],i) # write mesh points

writeLines(file,me[i],i) # write mesh lines

writeSurfaces(file,me[i],i) # write mesh surfaces and patch names

if i != 0:

writeThickness(file,me[i],me[i-1],i)

writeBodies(file,me[i],me[i-1],i)

# calculate and generate div and bia

minH, maxH, ratio = heightAnalysis(me)

dH = 1.0/aspect.val

for i in reversed(range(0,n-1)):

dH = dH/ratio[i]

height = 0.0

div = 0

while height < 1.0:

height += dH

dH = dH*growth.val

div += 1

if i == n-2:

div -= 1

firstDiv = div

bia = pow(growth.val,div-1)

file.write('div %s%s %d\n' % ("thickness", i, div))

file.write('bia %s%s %f\n' % ("thickness", i, bia))

print "i, div, bia", i, div, bia

if len(obList) >= 2: surfacePlots(obList, firstDiv, growth.val)

# generate symmetry set while also generating 3-D mesh

mats = Blender.Material.get()

for mat in mats:

file.write('comp %s d\n' % mat.name)

file.write('SETA notSymmetry se %s\n' % mat.name)

file.write('comp notSymmetry d\n')

file.write('elty all he8\n')

file.write('mesh all\n')

file.write('seta symmetry se all\n')

file.write('setr symmetry se notSymmetry\n')

file.write('plot me all\n')

file.write('plus s all\n')

file.close()

if mesh_BL == 1 and n == 2:

PupMenu('Returning boundary layer object with base object')

else:

if bl != None: scn.objects.unlink(bl)

scn.objects.selected = obs

# Timing the script is a good way to be aware on any speed hits when scripting

print 'Script finished in %.2f seconds' % (Blender.sys.time()-t)

def writePoints(file,mi,i):

# write out all points in this mesh

for v in mi.verts:

file.write('PNT P%x%x ' % (i, v.index) )

file.write('%.6f %.6f %.6f\n' % tuple(v.co))

def writeLines(file,mi,i):

# write out all lines in this mesh

for e in mi.edges:

file.write('LINE L%x%x P%x%x P%x%x 1\n' % \

(i, e.index, i, e.v1.index, i, e.v2.index))

def writeThickness(file,m1,m0,i):

for j in range(len(m1.verts)):

m1vji = m1.verts[j].index

file.write('LINE M%x%x P%x%x P%x%x 2\n' % \

(i, m1vji, i, m1vji, i-1, m0.verts[j].index))

file.write('SETA %s%s l M%x%x\n' % \

("thickness", i-1, i, m1vji))

def heightAnalysis(me):

ratio = []

for i in range(len(me)-2):

ratio.append(0.0)

for f0,f1,f2 in zip(me[i].faces,me[i+1].faces,me[i+2].faces):

upperH = abs((f0.cent - f1.cent)*(f0.no + f1.no)/2)

lowerH = abs((f1.cent - f2.cent)*(f1.no + f2.no)/2)

ratio[i] = max(ratio[i], upperH/lowerH)

n = len(me)-2

f0 = me[n].faces[0]

f1 = me[n+1].faces[0]

h = abs((f0.cent - f1.cent)*(f0.no + f1.no)/2)

minH = h

maxH = h

ratio.append(h/sqrt(f1.area))

for f0, f1 in zip(me[n].faces, me[n+1].faces):

h = abs((f0.cent - f1.cent)*(f0.no + f1.no)/2)

minH = min(minH, h)

maxH = max(maxH, h)

ratio[n] = min(ratio[n],h/sqrt(f1.area))

return minH, maxH, ratio

def surfacePlots(obs, firstDiv, growth):

heights = []

aspectRatios = []

skews = []

mat = []

factor = 0

for i in range(firstDiv):

factor = factor + pow(growth,i)

factor = 1/factor


meH = Blender.Mesh.New('height') # create a new mesh

meH.getFromObject(obs[len(obs)-1], 0, 0) # get subsurf mesh

meH.transform(obs[len(obs)-1].matrix) # scale and rotate as needed

obH = scn.objects.new(meH)

obH.layers = [11]

meAR = Blender.Mesh.New('aspectRatio') # create a new mesh

meAR.getFromObject(obH, 1, 0) # copy mesh

obAR = scn.objects.new(meAR)

obAR.layers = [12]

meSkew = Blender.Mesh.New('skew') # create a new mesh

meSkew.getFromObject(obH, 1, 0) # copy mesh

obSkew = scn.objects.new(meSkew)

obSkew.layers = [13]

me1 = Blender.Mesh.New() # create a new mesh

me1.getFromObject(obs[len(obs)-2], 0, 0) # get subsurf mesh

me1.transform(obs[len(obs)-2].matrix) # scale and rotate as needed

for f0, f1 in zip(meH.faces, me1.faces):

vC = f1.cent - f0.cent

heights.append(abs(vC*(f0.no + f1.no)/2)*factor)

aspectRatios.append(sqrt(f0.area)/heights[len(heights)-1])

cosine = min(1, vC*f0.no/sqrt(vC*vC))

skews.append(acos(cosine))

minH = min(heights)

maxH = max(heights)

minAR = min(aspectRatios)

maxAR = max(aspectRatios)

print "min/max first cell height", minH, maxH

print "min/max first cell AR", minAR, maxAR

mat.append(Material.New())

mat[0].rgbCol = [0.,0.,1.]


mat[1].rgbCol = [0.,0.5,1.]


mat[2].rgbCol = [0.,1.,1.]


mat[3].rgbCol = [0.,1.,5.]


mat[4].rgbCol = [0.,1.,0.]


mat[5].rgbCol = [1.,1.,0.]


mat[6].rgbCol = [1.,0.5,0.]


mat[7].rgbCol = [1.,0.,0.]

meH.materials = mat

meAR.materials = mat

meSkew.materials = mat

obH.setMaterials(mat)

obAR.setMaterials(mat)

obSkew.setMaterials(mat)

hRange = maxH - minH

for f0, h in zip(meH.faces, heights):

f0.mat = int(floor(7.999*(h-minH)/hRange))

ARRange = maxAR - minAR

for f0, AR in zip(meAR.faces, aspectRatios):

f0.mat = int(floor(7.999*(AR-minAR)/ARRange))

for f0, s in zip(meSkew.faces, skews):

if s > pi/2.0: f0.mat = 7

else: f0.mat = int(floor(7.999*(2.0*s/pi)))

Blender.Redraw()

def writeSurfaces(file,m,i):

key_index = {}

for e in m.edges:

key_index[e.key] = e.index

for j in range(len(m.faces)):

mfi = m.faces[j].index

file.write('GSUR A%x%x + BLEND ' % (i, mfi))

for k in m.faces[j].edge_keys:

file.write(' + L%x%x' % (i, key_index[k]))

file.write('\n')

if m.materials != []:

mat = m.materials[m.faces[j].mat]

if mat != None:

file.write('SETA %s s A%x%x\n' % (mat.name, i, mfi))

def writeBodies(file,m1,m0,i):

global X_Plane,Y_Plane,Z_Plane,X_Location,Y_Location,Z_Location

for j in range(len(m1.faces)):

m1fi = m1.faces[j].index

# cut at symmetry planes as specified by GUI

if (

(X_Plane.val == 0 or m1.faces[j].cent[0] > X_Location.val) and \

(Y_Plane.val == 0 or m1.faces[j].cent[1] > Y_Location.val) and \

(Z_Plane.val == 0 or m1.faces[j].cent[2] > Z_Location.val) ):

file.write('body B%x%x A%x%x A%x%x\n' % \

(i, m1fi, i, m1fi, \

i-1, m0.faces[j].index))

file.write('SETA bods b B%x%x\n' % \

(i, m1fi))

def displace(ob, factor):

# Get subsurf mesh and calculate its normals

me0 = Blender.Mesh.New()

me0.getFromObject(ob, 0, 0)

me0.calcNormals()

# Create dictionary of subsurf vertices to faces

vert_faces = dict([(v.index, []) for v in me0.verts])

for f in me0.faces:

for v in f.verts:

vert_faces[v.index].append(f.index)

# Calculate target heights of selected subsurf vertex normals

heights = []

displacements = []

totalH = 0

nFaces = 0

for vi in me0.verts.selected():

for fi in vert_faces[vi]:

totalH += sqrt(me0.faces[fi].area)

nFaces += 1

hFace = totalH/nFaces

for vi in me0.verts.selected():

hTotal = 0

nFaces = 0

for fi in vert_faces[vi]:

hTotal += hFace/abs(me0.verts[vi].no*me0.faces[fi].no)

nFaces += 1

hNormal = hTotal/nFaces

heights.append(abs(hNormal*factor))

displacements.append(hNormal*factor)

loop = 1

count = 0

# Iterate base mesh displacements needed to achieve target heights

while loop == 1 and count <= 100:

# Copy base mesh and displace


scn.objects.selected = [ob]

Blender.Object.Duplicate(mesh=1)

obCopy = scn.objects.selected[0]

meCopy = obCopy.getData(mesh=1)

for vi, d in zip(meCopy.verts.selected(), displacements):

meCopy.verts[vi].co += meCopy.verts[vi].no*d

# Subsurf displaced mesh

meCopy0 = Blender.Mesh.New()

meCopy0.getFromObject(obCopy, 0, 0)

loop = 0

sumErrorSquare = 0

# Measure differences, correct displacements, and sum errors

for vi, i in zip(meCopy0.verts.selected(), range(len(heights))):

dv = meCopy0.verts[vi].co - me0.verts[vi].co

correction = heights[i]/sqrt(dv*dv)

displacements[i] = displacements[i]*correction

sumErrorSquare += (1-correction)*(1-correction)

if sumErrorSquare/len(heights) > 1e-8: loop=1

count += 1

scn.objects.unlink(obCopy)

print "Average Error Square=", sumErrorSquare/len(heights)

print "Loop count=", count

# Apply displacements to base mesh

me = ob.getData(mesh=1)

for vi, d in zip(me.verts.selected(), displacements):

me.verts[vi].co += me.verts[vi].no*d

scn.objects.active = ob

Local:Gmsh tutorial

From AMCGMedia

Contents

1 AMCG Gmsh tutorial

2 Online Gmsh tutorial

2.1 A two dimensional example

2.1.1 Getting started

2.1.2 Setting up the geometry

2.1.3 Physical groups: boundaries and regions

2.1.4 Editing the geometry by hand

2.1.5 Producing a mesh

2.1.6 Converting the mesh to triangle for use in fluidity

2.2 Extruding a pseudo-2D mesh

2.2.1 Editing the extrusion

2.2.2 Setting the physical groups

2.2.3 Generating the mesh

2.3 A structured mesh

2.3.1 Hexahedral mesh

2.4 A three dimensional structured example

2.4.1 Getting started

2.4.2 Setting up the geometry: Creating a radial line

2.4.3 Setting up the geometry: Forming an annulus with extrusions

2.4.4 Physical groups

2.4.5 Final customisation of the geometry

2.4.6 Producing a mesh

AMCG Gmsh tutorial

This document is a tutorial on the GMSH mesh generator. It is aimed towards complete beginners; only some basic knowledge of the

Linux terminal and a text editor is assumed. We first define what a mesh is and then introduce the reader to the basics of the GMSH

graphical user interface. A basic, two-dimensional, geometry is then constructed within GMSH and a mesh is constructed. A more

complicated three-dimesional annulus is also constructed and meshed, demonstrating some more advanced features of GMSH.

Having mastered the basic usage of the graphical user interface, users are introduced to generating simple meshes on the sphere.

Knowledge is further built to produce meshes of realistic domains of the oceans to include boundaries extracted from a high

resolution shorelines database.

Online Gmsh tutorial

A two dimensional example

This tutorial illustrates the process of meshing a square domain and specifying boundary flags on it.

Getting started

Run gmsh on the command line:

gmsh

The following windows appear:

Local:Gmsh tutorial - AMCGMedia http://amcg.ese.ic.ac.uk/index.php?title=Local:Gmsh_tutorial

1 of 13 11/03/2012 9:33 PM

Setting up the geometry

Choose "Elementary entities" then "Add", "New", "Point"

It is now possible to set points either by clicking the main window or by typing coordinates in the pop-up box. It is generally easier

and more accurate to use the latter approach. After adding the points (0,0), (1,0), (0,1) and (1,1) we have:


2 of 13 11/03/2012 9:33 PM

Now choose "Straight line" and select each pair of points in turn until the outside lines of the square are complete. This figure

illustrates the during the adding of the third side:

Finally, we need to specify the plane surface which we will mesh. Click "Plane surface" and then select any line. The whole edge of

the square will be highlighted and you press "e" to complete the selection.

Physical groups: boundaries and regions

In order to apply boundary conditions it is necessary to specify "physical groups" to which the boundaries belong. Since gmsh will

only export to the .msh file those elements which are associated with a physical entity, it is also necessary to identify the interior of

the domain with a physical group.

Click on "Geometry" to return to the first menu and then select "Physical group", "add", line. Now suppose that we want to run a

driven cavity. We'll need one boundary condition on the top and, depending on whether we use free or no slip boundary conditions

we might need one boundary for all the rest of the sides together or one for the sides and a different one for the bottom. We

therefore make one physical group for the top of the square, one for the sides together and one for the bottom.

Click on the top line and then press "e" to end the selection and form the first physical group. Next do this for the sides. The

following figure shows the selected sides immediately before pressing "e":


3 of 13 11/03/2012 9:33 PM

Finally select the bottom of the box as a physical group. Next select "Surface" and select the dashed cross in the centre of the figure

to identify the interior of the domain as a physical group.

Editing the geometry by hand

Gmsh writes all the elementary entities and physical groups to a human-editable text file with the suffix .geo. This can be useful for

cleaning up the results of using the gui, adding comments and, as we shall see later, for more complex options which are difficult or

impossible to do via the GUI.

Return to the first menu by clicking on "Geometry". Next select "Edit" and a text editor will open containing the current geometry.

In this case the file is as follows:

Point(1) = {0,0,0,0.1};

Point(2) = {0,1,0,0.1};

Point(3) = {1,1,0,0.1};

Point(4) = {1,0,0,0.1};

Line(1) = {3,4};

Line(2) = {4,1};

Line(3) = {1,2};

Line(4) = {2,3};

Line Loop(5) = {1,2,3,4};

Plane Surface(6) = {5};

Physical Line(7) = {4};

Physical Line(8) = {3,1};


Physical Surface(10) = {6};

The format is basically pretty simple. For most objects the syntax is:

New_entity(id number) = {list of component entities}

So, the fifth line above says that line 1 is composed of points 3 and 4. The exception is Point the format of which is {x, y, z, dx}

where dx is the mesh spacing at that point. gmsh determines the mesh spacing during mesh generation by interpolating between

these points.

Entity numbers are only required to be unique within that entity type - as evidenced by the reuse of the numbers 1-4 for points and

lines above. Suppose we would like different boundary markers (these are the numbers we will access boundaries by in fluidity) and

that we would like to double the resolution. We'll also add some comments for the benefit of our fellow creatures:


4 of 13 11/03/2012 9:33 PM

Point(1) = {0,0,0,0.05};

Point(2) = {0,1,0,0.05};

Point(3) = {1,1,0,0.05};

Point(4) = {1,0,0,0.05};

Line(1) = {3,4};

Line(2) = {4,1};

Line(3) = {1,2};

Line(4) = {2,3};

Line Loop(5) = {1,2,3,4};

Plane Surface(6) = {5};

// Top of the box


// Box sides

Physical Line(333) = {3,1};

// Box bottom


// This is just to ensure all the interior

// elements get written out.


Now save the file and quit the editor. Now click "Reload" to load the changes you just made into the gui.

Producing a mesh

To produce the mesh simply select "Mesh" from the dropdown menu and click "2D". The result looks something like this:

Now select "save mesh" from the "file" menu to save your masterpiece and you are done!

Converting the mesh to triangle for use in fluidity

Fluidity can directly read gmsh output if mesh/from_file/format(gmsh) is specified in the options file instead of format(triangle).

Otherwise, it is possible convert the mesh into triangle format. This is easily accomplished using the gmsh2triangle script. The

following example assumes that your mesh is in the src directory of a test case. In other cases you'll need to adjust paths

accordingly:

../../tools/gmsh2triangle --2d src/driven_cavity.msh

In case you want to convert a 3D mesh, type:

../../tools/gmsh2triangle src/driven_cavity.msh


5 of 13 11/03/2012 9:33 PM

Extruding a pseudo-2D mesh

Many fluidity users run pseudo-2D simulations in a very thin 3D domain. gmsh supports this sort of mesh using extrusion. Starting

from the geometry above we can select "Elementary entities", "Extrude", "Translate". Set the Z component to the width of the

extruded dimension (I chose 0.01) and click on the surface to extrude followed by "e".

Editing the extrusion

The extrusion commands above only extrude the domain, to cause the mesh generator to produce an extruded mesh in which the

surface triangles on the front and back of the slice line up we have to edit the .geo file a little.

The extrusion is the command:

Extrude {0,0,0.01} {

Surface{6};

}

(your surface ID may be different). You need to change this to:

Extrude {0,0,0.01} {

Surface{6}; Layers{1};

}

which specifies that there is 1 layer of elements in the Z direction (specifying a different number of layers works in the obvious

way).

Setting the physical groups

For a 3d mesh, including this pseudo-2D domain, the boundaries are obviously faces and the interior is a volume. Otherwise it's just

like the 2D case. Don't forget to specify the boundaries on the front and back of the domain!

Generating the mesh

Obviously this time you use the "3D" button on the meshing menu which results in the following mesh:


6 of 13 11/03/2012 9:33 PM

A structured mesh

One can also use extrusion to generate a structured mesh. Rather than step through the gui, which is the same process as for the

pseudo-2D mesh, we can just detail the steps:

Set up a point at the origin.1.

Extrude in the direction (1,0,0).2.



Set the physical boundaries.5.

This approach results in the following .geo file:

Point(1) = {0,0,0,0.1};

Extrude {1,0,0} {

Point{1}; Layers{5};

}

Extrude {0,1,0} {

Line{1}; Layers{5};

}

Extrude {0,0,0.1} {

Surface{5}; Layers{5};

}

Physical Surface(28) = {27,5};

Physical Surface(29) = {14,22};



and the following structured mesh:


7 of 13 11/03/2012 9:33 PM

Hexahedral mesh

To generate a hexahedral mesh the command 'Recombine' is added as a part of line and surface extrusions. Taking the structured

tetrahedral example above the line and surface extrusions are edited like so:

Extrude {0,1,0} {

Line{1}; Layers{5}; Recombine;

}

Extrude {0,0,1} {

Surface{5}; Layers{5}; Recombine;

}

A three dimensional structured example

The following tutorial explains how to generate a structured 3D annulus mesh using gmsh.

Getting started

Run gmsh on the command line:

gmsh

Create a new gmsh geometry file, by selecting "New" from the "File" menu and choosing an appropriate filename.

Setting up the geometry: Creating a radial line

We will start by adding a radial line. In thermally driven rotating annulus experiments it is often a good idea to start with resolution

concentrated towards the annulus boundaries. We will concentrate resolution towards the inner and outer walls. This can be

achieved by setting the "Characteristic lengths" of points.

From the gmsh control window, select "Geometry" (or press "G"). Select "Elementary entities", "Add", "New", "Point". Create three

points as follows (by entering the values in the relevant boxes and clicking "Add").


8 of 13 11/03/2012 9:33 PM

x = 2.5, y = 0.0, z = 0.0, Characteristic length = 0.1



The snapping grid spacing can be left at 0.1 in all directions.

Select "Geometry", "Elementary entities", "Add", "New", "Straight line", and join the three points with two lines to form an annulus

radial.


9 of 13 11/03/2012 9:33 PM

Setting up the geometry: Forming an annulus with extrusions

This radial line can now be used to form an annulus, by first extruding in the vertical to form a vertical slice, and then using a

rotational extusion.

Select "Geometry", "Elementary entities", "Extrude", "Translate", "Line". Select the two lines forming the annulus radial, and enter

the following values for the extrusion:

x = 0.0, y = 0.0, z = 14.0


10 of 13 11/03/2012 9:33 PM

Select "Geometry", "Elementary entities", "Extrude", "Rotate", "Surface". Select the two surfaces in the annulus slice, and enter the

following values for the extrusion:

Axis point x = 0.0, Axis point y = 0.0, Axis point z = 0.0 Axis direction x = 0.0, Axis direction y = 0.0, Axis direction z = 1.0 Angle

= Pi/2

Repeat this four times to form an annulus. Note that on the final extrusion a true annulus geometry is created (rather than an annulus

with two nearby radial walls).

Physical groups

As in earlier examples physical surfaces and volumes must be specified. Select "Geometry", "Physical groups", "Add", "Surface".

Select the 8 surfaces comprising the top of the annulus and press "e". Repeat for the bottom of the annulus, the inner wall, and the


11 of 13 11/03/2012 9:33 PM

outer wall (in order).

Select "Geometry", "Physical groups", "Add", "Volume", select all volumes comprising the annulus and press "e".

Final customisation of the geometry

At this point the geometry can be used to generate a mesh. However, as we are aiming to create a structed mesh, the extusions

performed earlier must be converted to layered extrusions.

From the gmsh control window select "Geometry", "Edit". This will open the gmsh geometry file in a text editor. Make the

alterations highlighted in red below and save the edited file.

// Gmsh project created on Fri Feb 08 14:43:37 2008

Point(1) = {2.5,0.0,0.0,0.1};

Point(2) = {5.25,0.0,0.0,1.0};

Point(3) = {8.0,0.0,0.0,0.1};

Line(1) = {1,2};

Line(2) = {2,3};

Extrude {0,0,14} {

Line{1,2}; Layers{25};

}

Extrude {{0,0,1}, {0,0,0}, Pi/2} {

Surface{10,6}; Layers{30};

}Extrude {{0,0,1}, {0,0,0}, Pi/2} {


}

Extrude {{0,0,1}, {0,0,0}, Pi/2} {


}

Extrude {{0,0,1}, {0,0,0}, Pi/2} {


}

// Top

Physical Surface(185) = {41,19,151,172,129,107,63,85};

// Bottom

Physical Surface(186) = {180,49,93,137,115,71,159,27};

// Inner wall

Physical Surface(187) = {53,184,141,97};

// Outer wall

Physical Surface(189) = {111,67,23,155};

Physical Volume(190) = {1,2,8,7,6,5,4,3};


12 of 13 11/03/2012 9:33 PM

This converts the vertical extrusion to a layered extrusion with 25 intervals (equivalent to a "zone" command with 25 intervals in

GEM) and the rotational extrusions to layered rotational extrusions with 30 intervals per pi/2 of arc. The comments before the

physical surface definitions are a good idea, as the physical surface numbers in brackets, (185) - (189), are the IDs that will be

entered in Diamond to assign boundary conditions.

Select "Geometry", "Reload" to apply your changes. If gmsh displays an error then there is a mistake somewhere in your gmsh

geometry file.

Producing a mesh

From the gmsh control window select "Mesh" and click "3D" to generate the mesh.

This mesh can now be exported by selecting "Save Mesh" from the "File" menu, and can then be converted to triangle format for

use with Fluidity.

Retrieved from "http://amcg.ese.ic.ac.uk/index.php?title=Local:Gmsh_tutorial"

Categories: Mesh | Fluidity


13 of 13 11/03/2012 9:33 PM

Introduction

Sometimes it's the small events that are the most exciting. Like the day I made three cents. Not three

dollars. Not thirty dollars. Just three cents. And yet it was a very exciting event because of what those three cents represented.

I made those three cents the first time someone clicked an advertisement on one of my Web pages. And it was just the beginning. Every time an ad was clicked, I'd make money. The more visitors I had, the more money I'd make. The pages that I had created purely out of interest and paid for out of my own pocket could pay for themselves, or possibly even turn a profit. That's what was so exciting about those three cents.

The great thing was that it was really easy, because Google was doing all the hard work for me, through their free AdSense program. All I had to do was give them space on my pages to display the ads. They chose the ads, tracked the clicks, and charged the advertisers. Even better, they analyzed my pages and selected ads that were relevant to the topic of each page. All I had to do was keep my

pages updated and do my best to attract a steady stream of visitors, which I was already doing. The truth was, anyone could do what I was doing!

Just as exciting was the day a few months later when the first check from Google arrived in my

mailbox. It was a small check, but it was real. I almost framed it instead of cashing it!

That's what this book is all aboutthe excitement of making money with Google without having to be a computer expert. You'll need some Web pages, but I'll show you how to build those. Don't worry, there's no programming required! All you need is a computer and a connection to the Internet.

Can It Really Be Done by Anyone?

You're skeptical. Maybe you're thinking, "This author is an experienced writer and an experienced

Web page and application developer, so of course to him it all seems very simple." While there's no denying that having a background like mine helps, it's definitely not a requirement. Making money with Google is easy to do with the right guidance. The concepts are not hard and can be mastered by anyone with the patience to learn them. Kind of like most things, really.

I think what scares most people about computers and the Web is the terminology involved, not the concepts. I'll be the first to admit that technical people use a lot of buzzwords and obscure terms when they're talking about technology. It really is a specialized vocabulary. But specialized vocabularies aren't unique to the computer industry. Look at medicine: Doctors talk to one another in

technical terms that the average person doesn't understand. This is good; specialized vocabularies are concise and more precise than general, everyday vocabularies. They can make communication quicker and more accurateas long as all parties to the communication speak the same language.

What if you don't understand the language? That's where technical people often come up short compared to medical personnel. Doctors and nurses learn to talk to their patients using terms the patients can understand. Many techies don't learn this skill, which is why technology can seem so foreign and unapproachable to nontechies. But there are people like me who can bridge the gap and write books like this one.

Please understand that there are no secrets in this book: Like many things, everything discussed here is already described somewhere on the Webyou just have to find it and understand it. Not only do I

Page 1 of 4Introduction

04/04/2012file:///C:/Users/deepak/AppData/Local/Temp/~hhCD3D.htm

save you the hassle of finding the material, I also make sure you understand it. That's the primary

value of this book.

Is This the Book for You?

If you're reading this book because you've read one of my previous works, be aware that this book is something of a departure for me. My previous books have all been programming books. This book is

different, because it's written for the average computer user, not the average computer programmerpeople like my wife or my father, not my co-workers. If you're looking for a technically oriented book, you're reading the wrong bookyou can safely put the book back on the shelf and keep browsing.

The rest of you are about to begin an interesting journey, because Make Easy Money with Google is as much about understanding the Web as it is about making money on the Web. The Web may seem mysterious to you now, but it's built on simple (yet powerful) foundations. It's a tool for finding and

sharing information, and that's exactly how you'll make your money.

The book is written as a narrative, which is not the typical format for a "computer" or "digital lifestyle" book. Though the stories are fictional, the characters you'll encounter are composites of people I've interacted with before. They all have nontechnical backgrounds, and you should relate to

them quite easily. The light, conversational style will, I hope, make the book a pleasure to read.

Please note that I didn't title this book Make Oodles and Oodles of Money with Google. I'm sure there are people who make lots of money using the techniques I describe, but I'd be lying to you if I

said this book is going to make you rich. I'm not rich. But I have made money with Google, and so can you. And you can have fun doing it!

How to Use This Book

Before we get started with our adventure, here's some important information about using this bookthe resources you'll need to gather, descriptions of each chapter, and information about the companion Web sites.

Resources You'll Need

As I've already said, this is a book for nontechnical people. If you can surf the Web, you can understand this book. The only resources you'll need are these:

� A computer. Regular access to a computer is essential. Not only do you need a place where you can sit and create your Web pages, you'll want to have a copy of the pages stored locally for safekeeping and for testing. The operating system doesn't matter, though the examples and

software discussed in this book are for Windows XP or Macintosh OS X only.

� A high-speed Internet connection. This should be a given, but it's worth mentioning. You can still build and maintain your Web site using a slow-speed dial-up connection, but a faster connection is so much more pleasurable.

� A credit card. You'll need a way to pay for some expenses. There aren't many, and they're not large expenses, but a credit card is the easiest way to pay for them.



What you don't need to do is buy high-priced software to help you build Web pages. There's enough

free software available on the Internet to make those kinds of purchases unnecessary. We'll be looking at some of this free software later in the book.

Chapter Descriptions

As a narrative, this book is meant to be read sequentially, so please follow the chapters in the order in which they're presented:

1. Making Money with Google. Introduces the four-step process for making money with Google and reviews important concepts like Web sites, Web servers, and blogs.

2. Understanding AdSense. Describes Google's AdSense program: what it is, how it works, and how to join the program. Also discusses why advertising is so important to the Web.

3. Finding Something to Say. Lists techniques for choosing page topics and building content that attracts visitors.

4. Getting Ready to Say It. Explains how to register a good name for your site and find a hosting service.

5. Designing Your Site. Discusses how to design your site: choosing a look and feel, handling site navigation issues, and making the site attractive to humans and Google.

6. Building Your Site. Shows how to build Web pages from scratch using HTML and CSSdon't

worry, it's not programmingand how to ensure that viewers see the site you want them to see.

7. Becoming an AdSense Publisher. Describes how to become an AdSense publisher, how to manage your AdSense account, and how and when you can expect to be paid.

8. Publishing Ads on Your Site. Discusses the different ad formats and how to track page performance. Also lists tips and tricks for making effective use of AdSense.

9. Making Money from Your Site. Explains how to drive traffic to your site and how to optimize your pages to get better clickthrough rates and better-paying ads.

10. Expanding Your Horizons. Wraps things up with a brief discussion of affiliate and referral

programs.

As you can see, there's a deliberate progression that takes you from learning the basic concepts to building your site to making money with the site.

Companion Web Sites

Not only have you purchased a great book, you also get access to four great Web sites, including www,MakeEasyMoneyWithGoogle.com, the official companion site for this book. On the companion site you'll find additional information that updates or enriches the material you're reading. The other sites are example sites built to complement the narrative. You can register yourself with the main site to download your own copies of the other sites for use as additional study material.

The companion site can also be accessed using the short form www.memwg.com, an unremarkable name derived from the initial letters of each word in the book's title. Within the book, links to the companion site always use this shorter form to save you finger strain and to avoid difficulties in typesetting the text.



And as a bonus, registered readers who build Web pages using this book can also apply for a link

from the companion site back to their pages, with no strings attached. This is an easy way to get some extra traffic to those pages. (See www.memwg.com/free-listing for the full details, but please note that I reserve the right not to link to inappropriate or otherwise unsuitable pages.)

Let's Get Ready

It's time to start our narrative. If you don't already have a computer and a high-speed Internet connection, now would be a great time to get yourself set up. In the meantime, let's begin the story.



Documents

Making Money Using Google Page 1