building VTK on (intel) Mac OS 10.5

Based on [directions found here](https://svn.enthought.com/enthought/wiki/IntelMacPython25), I created a working build of VTK with Python bindings.

First, download the source from CVS, [here](http://www.vtk.org/get-software.php). You will need to make sure you have a recent version of [CMake](http://www.cmake.org/) installed as well. Then, go into the VTK directory and type:

mkdir build; cd build
ccmake ..

Press c to do the initial configuration. Set:

BUILD_SHARED_LIBS=ON
VTK_WRAP_PYTHON=ON

Press c again. Press t to look at the advanced options. This is where my directions diverge slightly from the enthought directions. I used the system python, which ccmake seems to recognize right away, so I only changed:

PYTHON_LIBRARY=-framework Python

Press c, then press g to generate the files. Then

make
make install

The make can take *forever*, so be patient.

One final thing to get vtk working with python is to go into the Build/Wrapping/Python directory and do a python build and install:

cd Wrapping/Python
python setup.py build
sudo python setup.py install

Done. Now you should be able to import vtk in python.

Google earth animations of various tidal constituents.

For my intro to Oceanography class, I made animations of the barotropic tide sea surface height. You can find them [here](http://pong.tamu.edu/~rob/google_earth_tides). Trust me, they are _very_ slick.

Removing non-english localizations on mac os x

I found this command on macupdate:

sudo find / -not -name English.lproj -name "*.lproj" -exec rm -r {} \;

and ran it. It seems to have saved about 3 Gb from the Application directory, and about 5 GB total.

Spaces and Terminal on Mac OS X Leopard 10.5.3

In a [recent post](http://daringfireball.net/2008/05/spaces) on [Daring Fireball](http://daringfireball.net/), John Gruber describes how some new small changes in Spaces in Mac OS 10.5.3 have made it usable.

I use the terminal quite a bit, and I have noticed this small tip. If you use ⌘-` you will cycle through the windows within one space/screen (i.e., you won't switch virtual screens). ⌘-→ or ⌘-← will cycle through _all_ of the terminal windows, even on other spaces screens.

Delayed login for ssh

I was suffering delays logging in between the head node and cluster nodes. I tried all the usual tricks -- mainly editing /etc/hosts. I tracked the problem down with

ssh -vvv c0-0

which showed that the delay was in xauth. Fine. What I needed to do was turn on ForwardX11Trusted, it was the *Trusted* part that was missing. This can be done with ssh -Y, or by editing /etc/ssh/ssh_config and adding a line

ForwardX11Trusted yes

This is needed to get tools like cluster-fork to work with the Trusted forwarding.

Interview with Donald Knuth

I've seen [this interview with Donald Knuth](http://www.informit.com/articles/article.aspx?p=1193856) linked a few times, and I also found it very interesting. In particular, I found it interesting that he:

- uses EMACS/TeX -- after writing everything by hand.
- does not particularly care for unit tests
- is a big fan of (i.e., invented) [Literate programming](http://www.literateprogramming.com/)
- is not a big fan of multicore processing (he does note, however, that physics and biology as exceptions where multicore programming makes sense..)

I have to admit, that I am on his side in terms of the unit testing and literate programming issues. I find that my biggest chalange in programming is not getting the code right (i.e., unit tests), but rather designing the way the function/class will behave for the user. Writing down what you expect the program to do in different cases (i.e., the API documentation) seems to be the best way to write a good, solid program.

NetCDF build notes for Mac OS 10.5 with ifort and gfortran

I have recently written down the steps I needed to build netcdf3, hdf5, and netcdf4 on my Mac using both ifort and [gfortran](http://r.research.att.com/tools/). Details follow

Python build script for roms

I wrote a build script for ROMS in python based on some of the other build scripts (in bash and Cshell) I have seen. The usage is as follows:

Create a directory with a header file called case_name.h in it. This should have the CPP defs for your particular case. Then run the build script like this:

build-roms.py case_name

Options, as seen from the help are:

-h, --help Print this message

--fort=[ifort] Specify fortran compiler
--netcdf=[4, 3] Version of NetCDF to use [default is NetCDF4]
-j=n Parallel make [n = number of procs, default is 4]

--mpi Compile using mpi
--clean Delete Build scratch directory before build
--debug Compile in debug mode
--root Specify ROMS_ROOT_DIR

This script creates a Build directory in the local directory, where the actual compilation happens. Analytical things can be defined in an optional Functionals directory, just like with the other build scripts. To see the script, continue...

using kd-trees for interpolation.

I have been looking for ways to interpolate big model results to other big mode results.. again. This seems to be an unsolved problem in ocean modeling. However, I have stumbled on a new method for finding nearest neighbors that seems quite promising.

As long as you are interpolating from something that has a relatively uniform grid with a relatively smooth field, you don't need to bring out the big guns, like optimal interpolation. In other words, you may often ignore data error in your interpolation - especially going from one model to another to generate initial or boundary conditions.

[Kd-trees](http://en.wikipedia.org/wiki/Kd-tree) (k-dimensional trees) are a method for organizing a set of k-dimensional points. In particular, I would like to find the nearest neighbors in three-dimensions. Many interpolation tools (such as [csa](http://www.marine.csiro.au/~sak007/) or [delaunay](http://scipy.org/scipy/scikits/browser/trunk/delaunay/) only work with 2D data.

The advantage of using kd-trees is twofold: First storing the tree is not very memory intensive, approximately the same size as the original point field itself, and building the tree scales roughly as the number of points (n log(n)). Second, searching for the closest points to a query point is quite fast (log(n)). The [ann library](http://www.cs.umd.edu/~mount/ANN/) can be used to return indicies of and distances to the M closest points to a query point. An example of how to use the ann library for interpolation is below the fold.

ROMS project movie back online

The ROMS project movie (the only thing people seemed to miss during the black months when pong was down) is now back online. See it [here](http://pong.tamu.edu/~rob/movies/roms_project.mov).

Making images and animations of model output in google earth

I have been working on creating images and animations from google earth. I started out [here](http://www.barnabu.co.uk/animations/) for inspiration. Here are some samples of an [image](http://pong.tamu.edu/~rob/files/bsh.kmz) and an [animation](http://pong.tamu.edu/~rob/files/bsh_anim.kmz). The code is actually quite simple:

Woot! Back up

Finally, after a massive hard drive failure, my web log is back up. To make a long story short, I promise to make better backups and buy Steve a beer.. I feel a pent up pile of posts -- so after waiting for so long, be sure to check often now.