"Re" Introducing GoGCM

I've created the github repository for GoGCM. The "model" is currently just a place holder. It is a mean (configurable but set to 17.5 by default) that has a random value added to it (standard deviation of 1 and mean of 0). The point is more about the process of installing it and running it in order to get information from it. In order to install and run this, follow these instructions.

1. Install and build the go repository by following the instructions on the go website. For those using windows, you will likely need to install it from here.


2. I believe you need a github account for the next step. Go to the website and create an account.


3. Go has a very handy tool called goinstall. Open a console and enter the following commands:
goinstall github.com/Arrow/GoGCM
cd go/src/pkg/github.com/Arrow/GoGCM
gomake


4. These commands will download the code from the github repository and build the GoGCM code. You can now run the code with
./gcm


5. This will output a list from 0 to 100 with the model output in a csv format (to stdout). You can do the usual piping and send it to a text file like so
./gcm > model.csv



That is the basics of installing the (currently very simple) GoGCM. If you run into any problems just let me know or check the go website and the go-nuts group to see if others have had the same issues.

Evaluating Success

As I had stated in my last post, I intend to fill in the blanks for how this project will proceed.


The first issue to settle, is how the design will be decided. This blog will serve as the point of discussion for all the technical issues. My intent is to evaluate each design decision point by point in this forum (I'm hopeful other's will join me in leading these discussions).


Once each decision is made, the code will be updated in the project. I will be setting up a github repository for the code later this week, along with an initial simple model to demonstrate how the code will be set-up.


The next issue to settle is how the project will be evaluated. I considered trying to implement a direct copy of another GCM (for example GISS's Model E). It would be a much easier undertaking and the project would likely create a running GCM much quicker. I decided against this path for the reason that less would be learnt by doing this, as all the decisions would be to follow a give model. As such, these decisions will consider how other models do this but will not necessarily follow a given model (for the moment, I'll be especially focusing on the GISS Model E and NCAR CESM). 


As an example of the types of decisions to be taken, consider the grid selection of the surface. GISS uses a Cartesian grid (4deg X 5deg and 2deg X2.5deg). While this is a more straightforward grid, it also leads to a bunching of the grid boxes at the poles. There are other grids that could be used and it is one of the issues that I intend to bring up on this blog.


Since GoGCM will not be based off a given model, it does beg the question as to how the model will be evaluated. I want to select a model that will provide a reference for comparison for the work being done on GoGCM. The reference will be GISS's models. Starting with trying to replicate GISS Model II (or EdGCM), this will allow GoGCM to evaluate it's performance and what it's design decisions are achieving. I want to know what others think of this suggestion. Please comment on what you think of this decision.


Finally, you may ask what I hope to achieve with this project? My hope is that this project will demystify GCM's. I want to understand how they function and what type of information they can give us. By understanding this, we can also help to evaluate their results. As I have seen Gavin comment at realclimate, there is a lot of data that is output from GCM's. By better understanding GCM's, maybe this output can be more thoroughly analysed.


Finally, it is my hope that this project will lead to better GCM's. I think there is a long way to go from this point, however having more minds looking at these issues is bound to generate a host of ideas about how to improve current GCM's. I would feel extremely proud if even one of these ideas leads to an improvement in any of the current GCM's or the analysis of their results.

Introducing GoGCM

I have been interested by two subjects recently. Climate Change and the Go Programming Language. This blog is a combination of these two interests. I want to start a project to create an open source General Circulation Model (GCM) in Go. The obvious questions are, why a GCM and why Go?

Why a GCM?

There has been much interest in "citizen science" of late in the climate change blogosphere. There have been many global temperature reconstructions over the past several months. I think efforts like this are extremely valuable and that more should be done, especially in order to improve our understanding of (or increase our confidence in) an important issue such as climate change.

In this light, I want to start a project in order to create an open source GCM. This blog will have a series of posts that discuss various aspects of GCM's and how to implement it in GoGCM. I think GCM's are often misunderstood and these posts (while trying to design this GCM) will shed some light on how GCM's work, and what they can/can't do.

While the main audience of this blog will be "citizen scientists" (eg. Engineers, Programmers and other technical persons interested in Climate Change), I am hoping that some of the Climate Experts will contribute in some form (commenting or guest posts) from time to time.

Why Go?

Since it was released in November 2009, I have been following the development of the Go Programming Language. My first reaction was, if you take a few interesting languages and strip the interesting parts out, you get Go. Since then, I've been looking more and more at this language, and I have been extremely impressed. While the feature set seems basic on first inspection, it is quite expressive. Andrew Gerrand had two posts (part 1 and part 2) that demonstrates this nicely.

I think the Go Programming Language represents an important innovation in programming. In particular, it's ability to reduce bookkeeping and focus on the important parts of code are remarkable. While many in the "citizen science" climate community have been relying on R for the analysis of the temperature reconstructions, I believe a project like this requires something more substantial.

The other option would be using directly the source code provided by current GCM's (GISS and NCAR for example). While this option likely has a better chance of success (a GCM that actually runs), developing GoGCM will force all aspects of the GCM to be investigated. This means that the GCM's will be understood more by the community that I hope this blog fosters.

The final reason I chose Go, is that I am optimistic about the Go Programming Language. I believe it could be an important general programming language in the future. By trying to create GoGCM (especially with a vocal "citizen science" community), I'm hoping to attract dozens of new Go programmers, particularly those who are interested in scientific programming like I am.

Going Forward

I'll be laying out some of basics rules for how this site will work and try to start some technical threads for the basic design decisions. As well, I'll be setting up project page (likely github) in which I will post the code. I look forward to any feedback.