I started making the interpolation library today. I have functions to find the spatial range of the data so that I can build an appropriately scaled interpolation grid. I also wrote the function to build the interpolation grid. Right now, it just makes a regular grid. It might want to eventually be more dense centrally, but that's a fairly simple tweak. Right now, I'm waiting on a real data file so that I can actually try an interpolation.

It should be noted right now that everything: reading in all the data into one massive array (30,000 points), finding the data range, and building the interpolation grid (1,000,000 points) takes about a second. I think I'm going to try just a normal, nearest neighbor interpolation with no optimizations and see how long it takes before I start trying to create zones to save time.

So, a lot of updates. First of all, the GUI is pretty much ready to go, save for the additional fields that will surely be necessary. Also, Eric installed all of the necessary Python libraries so that it will run on the astro machines, so I've transferred everything over to them.

Also, Asif and I managed to figure out HDF to a certain extent, which is to say that we managed to install the HDF4 libraries locally and compile and run some code that we found on the internet on a small data set of his. It became immediately apparent that reading HDF data would take a long time to figure out, and considering that I'm leaving soon, Asif and I decided that it would be best if I just focused on an ASCII reader so that there would be some working code when I leave.

To that end, I've started creating a C library for manipulating the ASCII output from the new 3D simulations. First, I had to figure out makefiles (which was made easier by Bruce Maxwell's tutorial), but eventually I got my code nicely organized and modular. I just finished up the code to read an entire timestep into a 2D array that's entirely general, as long as the files are in the same format as I currently have. I think Asif and I need to work out a specific format that he can hold to so that I can more or less freeze in that code.

I implemented the settings files today. I have yet to make it load the default settings when the program is opened, but this is one hell of a good step. Also, I implemented the logarithmic axes options. This is starting to become a real application!

Somehow, I broke the redraw, but I've fixed that. I also put in some rudimentary parameter checking, I'm now loading the defaults at startup, and I also added an image of Orion instead of that glaring white square on startup. I think it's cute.

The GUI is becoming more and more useful. I've started implementing reading some of the plot parameters from the GUI and implementing them. Also, I've added a "Redraw plot" button that will redraw the plot without rerunning the entire program, which is something that I wish I'd done with Postproc. Also, the data for the plot now get read from a file to help facilitate this.

I talked to Jeff Knerr about reading HDF files, and he gave me some useful info, links, and code. Hopefully I can get started on reading those files relatively soon. Also, I've started figuring out how to use matplotlib in conjunction with my program to create images. Right now, I can plot things and save them to disk. I still need to read those images onto the canvas in the GUI.

The GUI is now fully functional. The next step is to get the plotting and image-saving working.

The GUI is pretty much done. I have all of the fields for the parameters that I think will be needed; they all recieve bland default values. When the "Run Program" button is pressed, the values in all of the fields are written to .params.txt in the same directory. The goal is for this file to be read by a C program that is called by the GUI.

I still need to implement file browsing and all of the plotting stuff, but I think I'm well on my way.

After meeting with Asif a couple weeks ago, I decided to start on Orion3D, which will postprocess the new 3D simulations that Asif is slowly gaining the ability to do. The plan (as laid out on the code page) is to have a Python frontend GUI that calls C code to perform the actual postprocessing. The reason for the switch to C from IDL is that I'm going to need to do a lot of interpolation if I plan on taking absorption into account, and IDL is sloooooow at interpolation. I'm making the GUI in Python mostly because it's easy, and I know how to call C code from inside Python.