Archive for the ‘Uncategorized’ Category
NASA GISS wants to use our code
Posted by Nick.Barnes | Filed under Uncategorized
After the release of ccc-gistemp 0.3.0, I contacted Dr Reto Ruedy of NASA GISS to ask him to try out the release and have a look through it.
Dr Ruedy responded, thanking us for our effort, and saying “I hope to switch to your version of that program”. After some further discussion, he clarified this:
When GISS has the resources:
Ideally, we would like to replace our whole code
.
They are busy with other things, and won’t have the resources for quite some time. Also, we will need to do some more work, to interface our code with various GISS tools (such as the station data web page). Nonetheless this is very much to the credit of the whole ccc-gistemp team. Well done, everybody.
What do we mean when we say “Fortran”?
Posted by Nick.Barnes | Filed under Uncategorized
A visitor named “Dan” recently left this comment:
[...] I’m not sure why Python has been described in some associated project documents as easier or friendlier than Fortran. They are both pretty simple in that regard. I agree there are other reasons that Python (like some other new languages) is a better choice for a new project with many contributors and users.
Thank you for raising that point, Dan. Fortran and Python themselves are really ciphers in this discussion, standing for “obscure twisty code” and “clean clear code”.
As the old saw has it, “you can write Fortran in any language” – indeed, GISTEMP includes Fortran written in C, ksh, Fortran and even in Python. The reverse is also true: with all the features that have been added to Fortran in the last few decades, you can write any language in Fortran[*]. However, I’d invite you, or anyone, to compare:
1. padjust.f, as it is in GISTEMP. This is a tiny corner of GISTEMP, used for applying computed heat-island adjustments to urban stations, certainly nothing like as twisty as most of the code around it (e.g. PApars.f).
2. padjust.py, as it is in ccc-gistemp 0.2.0. This is a fairly routine translation of padjust.f into Python. It was a key step in the road to our 0.2 all-Python milestone, but one could, unkindly, characterize it as Fortran-in-Python.
3. apply_adjustments(), as it is today in the ccc-gistemp sources. The relevant code here is lines 690 to 791 inclusive.
There are several points to be made here. Firstly, version 3 is not exactly clear. The function adj() is not well-documented. There are a lot of slightly mysterious variables. There is some unnecessary messing-around with metadata entries, and there are substantial opportunities for using helpful little functions such as max() and min(). Code clarification is a process of gradual improvement, and is certainly not finished here.
Secondly, I expect something much like version 3 could have been written in modern Fortran. The main reason we’re not using a modern Fortran is that I set up the project. Like each team member I brought my own skills and preferences to the project, and my favourite language, at least for writing small pieces of clear, simple code, is Python. I have had very little professional experience in Fortran, and essentially none for 20 years.
Thirdly, most science Fortran, even newly written science Fortran, is like version 1: FORTRAN 77 with aspects of Fortran 90 (e.g. free-form source, long identifiers, dynamic arrays). Some is still in FORTRAN 66. Furthermore, it is big blobs of Fortran with cryptic variable and function names, very occasional comments, aliasing through COMMON blocks, a lot of unused functions and/or variables. What is the variable iy1e, and how can I find out? Why are we comparing nameo(31:32) to ‘ R’? This is what I mean when I say “Fortran”, and it is typical of GISTEMP, and other bodies of code we have seen, and friends and colleagues tell us it is true elsewhere. It is the natural consequence of the way in which science is done. Scientists are paid to do science, not to write code. As long as the code does what it ought to do, for long enough to plot the charts for the paper for publication, then it’s good enough. There is no pressure to write code which is clear, maintainable and flexible, and so scientists mostly don’t develop or retain the skills to do so. That is one of the points of this project:to show what such code might look like, how to write it, and how it can be beneficial to science.
Fourthly, in the specific case of some code such as GISTEMP, the results of the code are being used to argue important public policy questions which will affect all of us. Something that I, personally, can do to turn some of the heat of that debate into light, and to help us all reach good decisions, is to make GISTEMP accessible to the public. All-Python is simply better than Fortran-ksh-Python-C for that purpose, for various reasons but primarily that it is easier to install, browse, and run on a random PC. Consider how many people downloaded the GISTEMP sources and ran into the sand very early. That should not happen with ccc-gistemp.
So, in short, yes we are converting from “Fortran” to “Python”, but some of the “Fortran” was already Python and some of the “Python” is decidedly Fortran-like.
For more on the pros and cons of Fortran and Python, please visit the Software Carpentry project. No affiliation; I just like what they do.
[*] This isn’t quite true – as far as I know Fortran still doesn’t have the meta-object protocol or introspective facilities of some languages, and pretty much no other language has the macro facilities of Lisp – but features like that play no part in this project anyway.
GISTEMP 2009 anomaly anomaly
Posted by drj | Filed under Uncategorized
In a previous article I predicted that the 2009 GISTEMP anomaly would be +0.58. In fact when it was published it came in at +0.57. This 0.01 K difference is well within any reasonable error bounds and typical of the sort of error you get from rounding. Still, it bothered me. How unlucky was I to get agreement for all the years except the most recent one?
Today I realised that although I was using up to date land data I wasn’t using up to date ocean data. I have just fetched fresh ocean data and rerun ccc-gistemp. Of course the 2009 anomaly comes out as +0.57 K, same as GISS:
Overview of GISTEMP intermediate files
Posted by drj | Filed under Uncategorized
When ccc-gistemp runs, the data files in the input/ directory are processed in a number of steps to produce the results in the result/ directory. On the way many intermediate files are written to the work/ directory. Generally the intermediate files are written by one stage of the process and consumed by a later stage. GISS’s GISTEMP works in a broadly similar way, but the details are slightly different. One of the first things we did when working with GISTEMP was to reorganise where the intermediate files were written.
Many of the intermediate files were only written because the computers on which GISTEMP was originally intended to run were extremely resource poor and the whole data could not always be processed in working memory. Hence, data was written into several intermediate files and processed piece by piece. This is no longer necessary, and ince ccc-gistemp release 0.2.0 we have made changes that mean that far fewer intermediate files are written.
A consequence is that there are now a manageable number of file in the work/ directory, and a listing of them tells a story about how GISTEMP works:
5 Jan 20 13:27 GHCN.last_year
44716518 Jan 20 13:28 v2.mean_comb
29802728 Jan 20 13:30 Ts.txt
39696368 Jan 20 13:31 Ts.bin
20853712 Jan 20 13:31 Ts.GHCN.CL
2107900 Jan 20 13:31 ANN.dTs.GHCN.CL
354106 Jan 20 13:33 PApars.pre-flags
371742 Jan 20 13:33 PApars.list
19233584 Jan 20 13:34 Ts.GHCN.CL.PA
0 Jan 20 13:34 BX.Ts.GHCN.CL.PA.1200
50240120 Jan 20 13:50 SBBX1880.Ts.GHCN.CL.PA.1200
34001576 Jan 20 13:50 SBBX.HadR2
176152 Jan 20 13:51 ZON.Ts.ho2.GHCN.CL.PA.1200.step1
176152 Jan 20 13:51 ZON.Ts.ho2.GHCN.CL.PA.1200
15974 Jan 20 13:51 ANNZON.Ts.ho2.GHCN.CL.PA.1200
The above is a listing of my work/ directory having done a fresh run using subversion revision 199 sources. Each row lists: file size in bytes, timestamp, file name.
The first thing to note are the timestamps. The first file is written at 13:27 and the last file at 13:51. On my machine ccc-gistemp took about 25 minutes for this run.
I’ll go through the files in order and try and explain what each one is. Bear in mind that some of these files will probably disappear in future version as we reduce the number of time data is written to disk and read back in again.
GHCN.last_year
This file is used to pass the highest year that is found in the GHCN input data (input/v2.mean) from step0 (where this file is created) to step2 (where this file is read). The contents are the highest year. This is not a very elegant way to pass this information. It’s needed because in step2 a Fortran binary file is created with fixed record lengths, and the length of the record is related to the highest year that has data so that highest year needs to be known before the binary file is created.
v2.mean_comb
This large file is the output from step0. It contains all the temperature data that GISTEMP will go on to use combined into one file. The temperature data are combined from: GHCN, USHCN, SCAR, and one input file for Hohenpeissenberg. The combining process is not entirely trivial: data from USHCN do not simply replace data from GHCN, they are adjust by the mean monthly difference (see the function include_US in step0.py).
Ts.txt
This is the output of step1. Duplicate records (multiple series for the same weather station) are combined, if possible; an adjustment is made for the St Helena record (listed in the file config/combine_pieces_helena.in); records and partial records listed in the file config/Ts.strange.RSU.list.IN are removed; an adjustment is made for a discontinuity in the Lihue record (listed in the file config/Ts.discont.RS.alter.IN).
The output format of this file is different from the v2.mean format used in the previous step. Metadata from the file input/v2.inv is included in this file.
Ts.bin
At the beginning of step2 the Ts.txt file from step1 is converted to this Fortran binary file. The binary file is easier to access using a Fortran program. At one time in the past the binary file would have been significantly quicker as well, but I doubt that matters these days. Since ccc-gistemp is now entirely in Python it’s likely that we’ll remove the binary file, preserving it only as an option to match the GISTEMP intermediate files.
In the GISS code, this file is then split into 6 files so that the gridding, in step3, can proceed by using only a subset of the station data held in memory at once. Keeping all the data in one file greatly reduced the number of intermediate files created in ccc-gistemp.
The next few files are all internal to step2, the Urban adjustment.
Ts.GHCN.CL
The same data as Ts.bin but trimmed to make the file size slightly smaller. Even more pointless in this day and age.
ANN.dTs.GHCN.CL
Annual anomalies for each station, computed in step2. Each of the 12 months has an average computed, and the anomaly for a year is computed from the difference between each month in that year and that month’s average.
There is far less data in this file than the monthly series in Ts.txt, and it is the this data that is used to make the urban adjustment.
PApars.pre-flags
By analysing urban and rural stations step2 creates this table of parameters that control what adjustments are going to be made (to urban stations).
PApars.list
The parameters in PApars.pre-flags are annotated with a flag that affects the exact adjustment made.
Ts.GHCN.CL.PA
The data from Ts.GHCN.CL are read in and urban stations are adjusted according to the parameters previously computed and stored in PApars.list. This file contains the adjusted data and is the output of step2.
BX.Ts.GHCN.CL.PA.1200
An empty file created by step3. The GISS version of GISTEMP creates a gridded dataset ( SBBX1880.Ts.GHCN.CL.PA.1200 see below) with 8000 cells (subboxes) and from this also creates a gridded dataset with 80 cells (boxes) which is what this file would be. Currently ccc-gistemp does not create the 80 cell version.
SBBX1880.Ts.GHCN.CL.PA.1200
This is the gridded output of step3. It’s created by considering each grid cell in turn, and combining (usually several) station records into one record for each cell. From this point on only gridded data is used.
SBBX.HadR2
This file contains sea surface data from Hadley and Reynolds version 2 (the “Had” and “R2″ in its name). It’s the result of step4 which takes the input file of the same name (in the input/) directory, and adds in any updates that have been downloaded. Usually we run without any updates, and in this case step4 simply copies this file from the input/ directory.
ZON.Ts.ho2.GHCN.CL.PA.1200.step1
This is a temporary file used by step5. Step5 takes the two subbox files, SBBX1880.Ts.GHCN.CL.PA.1200 containing land data, and SBBX.HadR2 containing ocean data, and merges the land and ocean data together creates a gridded file with 80 boxes. The gridded file appears in the result/ directory: BX.Ts.ho2.GHCN.CL.PA.1200.
The data in the gridded file are combined to produce a data series for each of 8 latitudinal zones, then from those 8 zones another 6 are produce for large scale regions, including the 3 for Northern Hemispehere, Southern Hemisphere, and Global average. That zonal data is stored in this file.
ZON.Ts.ho2.GHCN.CL.PA.1200
The zonal data are read and an alternative computation is done where the global average is the simple average of the northern and southern hemispheres, as opposed to the previous calculation with uses an area weighted average.
ANNZON.Ts.ho2.GHCN.CL.PA.1200
Annual anomalies are computed from the monthly data series for each zone.
Whilst the data for this and the previous file are being computed, the text files that hold summaries of this data are written to the result/ directory.
Site updates
Posted by Nick.Barnes | Filed under Uncategorized
After several late nights trying to correct misapprehensions in a few places in the blogosphere, I have updated the goals and about pages to remove any ambiguity between this project as it currently stands and the CCC project at Ravenbrook which immediately preceded it.
Hopefully now some critics will join us and work to improve climate science software.
Project history
Posted by Nick.Barnes | Filed under Uncategorized
A potted history of the project so far:
- I had the idea for the project in 2007, after the first release of GISTEMP code. I saw it criticised online for various failings, from the ridiculous (e.g. “I demanded this code and now you’ve released it I don’t understand it”) to the sublime (e.g. the many attacks on a line of code which quite legitimately translated temperatures in Fahrenheit into tenths of degrees Celsius). It was plain to me that any software with results which might determine critical public policy should be more accessible than this. Ideally it ought to be possible for any interested member of the public to download the source code and inspect it.
- I presented my ideas to colleagues at Ravenbrook Limited in the spring of 2008. It was agreed that Ravenbrook should pursue such a project on a pro bono basis: we’d use our systems to host an open-source project, but nobody would be paid for their time.
- David Jones and I got started on the code over the summer of 2008, and presented our first results at PyconUK in September 2008.
- There was considerable interest at the conference and online, including a number of offers of help. Wanting to widen participation in the project, but not keen to host and support the infrastructure, we decided to use a Google Code project, and a Google Groups mailing list, and to consider a wiki or blog. We set those up and various volunteers started work, including John Keyes who later created and hosts this blog and Paul Ollis who has contributed a considerable amount of code.
- Our real lives intervened, and David and I didn’t do anything very much on the CCC project until the autumn of 2009, when we restarted work on the Python reimplementation and on this blog. Just in time for the CRU email hacking incident to stir up a lot of public interest in climate code quality.
We find bug in GISTEMP; GISS fixes it
Posted by Nick.Barnes | Filed under Uncategorized
Reto Ruedy of GISS has changed GISTEMP to fix a collection of minor bugs in STEP5’s SBBXotoBX.f, which David Jones and I found while re-implementing STEP5 in Python. The fix did not have any effects on the final numeric outputs of GISTEMP.
This particular program combined land and ocean temperature data. Each sub-box (an area of about 64,000 km^2) is given an “ocean weight”, depending on the amount of ocean data and the distance of the nearest surface station. Then the land and ocean series for each sub-box are given weights depending on the ocean weight and on the number of valid monthly temperatures. Then the 200 series for each box (the land and ocean series for each of 100 sub-boxes) are combined in order of decreasing weight to form a single series for the box.
The error was in the way the land and ocean series were combined after sorting into order: sometimes the index of an entry in the sorted set was used to index into the unsorted set.
As it happens, with the parameters used for this program, in particular the Rintrp parameter set to zero, this error has no effect because the ocean weight is always either 1 or 0, so after sorting the second half of the set of data series always has zero weight.
In email to David and myself, Reto Ruedy expressed thanks to us and to the CCC-GISTEMP project.