How to install wgrib2 in OSX

Prompted by both my own struggles with wgrib2 compilation and a plea on the rNOMADS email listserv, I’m going to describe how to compile and install wgrib2 on Mac OS.

First of all, some background: wgrib2 is an excellent utility written by Wesley Ebisuzaki at NOAA.  It allows for a number of swift and stable operations on GRIB2 files (a common file format for weather and climate data).  It is also a requirement for using grib files in rNOMADS (the function ReadGrib() in particular).

So here’s how to install it on Mac OS.

  1.  Get Command Line Tools for Xcode (search for it on Duckduckgo or your engine of choice) and also make sure gcc is installed. If you don’t know what gcc is, stop now and find someone who does (it will save you a lot of time).
  2. Download wgrib2 here (note download links are pretty far down the page).
  3. Untar the tarball somewhere, and roll up your sleeves.  cd into the resulting wgrib directory.
  4.  In the makefile, uncomment the lines

    #export cc=gcc
    #export FC=gfortran
    Also search for makefile.darwin in the makefile and uncomment the line containing it.  You’ll see instructions to this effect in the makefile anyway.
  5. Now we have to edit the included libpng package, since it is untarred by the makefile and doesn’t inherit our compiler specifications in step 4. Ensuring that we’re in the wgrib directory:

    tar -xvf libpng-1.2.57.tar.gz
    cd libpng-1.2.57/scripts/

    now edit the makefile.darwin file, changing

    CC=cc

    to

    CC=gcc

    Now, return to the wgrib directory, and re-tar libpng!

    tar -cf libpng-1.2.57.tar libpng-1.2.57
    gzip libpng-1.2.57.tar

    If it asks you if you want to replace the original tar.gz file, say “yes”.  What we’ve done here is edited libpng to make sure it uses the right compiler.
  6. Finally, type make to build wgrib2.

If you are still having problems (for example, libaec complaining that there is no c compiler), make sure that all the compiler commands (gcc, cc, etc.) all point to something other than clang (the default compiler that comes with OSX).  You may have to edit your bash_profile file to ensure this.

As always, contact me on the form below if you’re having unresolvable issues.

Instruments for High-Altitude Balloons

For many of us, an important motivation of launching balloons high in the atmosphere is to put instruments up there. Of course, the fact that instruments are heavier than air means they resist attempts to get them in the atmosphere and are prone to falling out of it. So, airborne sensors need to be light enough to be lifted by an affordable balloon and cheap enough to make risk of crash acceptable. I spent a big chunk of the last couple years designing and building a custom instrument with these characteristics in mind; this post describes how I did it.

My particular field is infrasound, sound waves whose pitch is too low for humans to hear. Infrasound waves normally come from very large sources like lightning, volcanoes, nuclear bomb tests, windmills, and even large animals like tigers or elephants. Unlike audible sound, infrasound waves can propagate long distances without dissipating as heat, which makes them useful for monitoring nuclear and volcanic blasts. Putting microphones high in the air could help improve geographic coverage in our otherwise land-based monitoring networks.

Solar balloons offer an affordable and flexible means of putting cheap, lightweight sensors in the sky. However, commercial infrasound instrumentation falls short in those aspects. To be sure, we do have a few high-quality data loggers and sensors to choose from, but none is lightweight or cheap enough to fly on solar balloons. The closest is the Omnirecs DATACUBE-3 (below, right). Including batteries and sensor, it weighs more than 1 kg and can cost a few thousand USD (depending on quantity and options chosen).

My normal research is on volcano acoustics. I’m not normally worrying about flying microphones on balloons, but I faced similar instrument limitations in volcano fieldwork. For example, my most recent project involved a hike with 2000 m of elevation gain to install 17 instruments near the vent of Tungurahua volcano. On a hike like that, the last thing I need is to be weighed down with heavy instruments, or even heavy batteries for the instruments. Plus, the instruments near the vent are definitely in harm’s way, and I don’t want to accidentally blow up an expensive sensor.

jfa-tungurahua

The upper slopes of Tungurahua: loose, rocky, steep, and prone to ballistic fall during eruptions.

The answer was that I needed to design my own instrument. This process had two parts: firmware (programming the microcontroller) and hardware (finding the right components and connecting them together). Fortunately for me, I began this project around 2012-2013 when a revival in hobbyist electronics was in full swing, and had access to components that are powerful but still novice-friendly.

jfa-logos

The various companies and online forums I used to design the instrument. Most of these cater to hobbyists and beginners.

The Arduino system makes firmware way easier than it used to be. Arduino is a combination of a microcontroller (very, very basic computer), user-friendly circuit board, and programming interface that makes it easy for hobbyists to program the microcontroller and connect peripherals to it. It’s perfect for a beginner. In my case, the firmware’s job was to read data from several inputs, do a little processing, and write output data to a micro SD card. Inputs included an analog-digital converter listening to the infrasound microphone, a GPS (for precise timing and location), a temperature sensor, and a battery voltage tracker.

jfa-arduinoide

The Arduino IDE speeds up the process of writing and testing code.

Without the Arduino system to simplify this process, it wouldn’t really be accessible to someone like me. I’m a geophysicist, not an electrical engineer! But it still wasn’t easy, and it took me a couple years of off-and-on work before I really got it working well.

The hardware part of this project began with a bunch of user-friendly breakout boards wired to the Arduino. A breakout board is a little circuit board that includes some principal component (say, a micro-SD socket, or a GPS) and all the various minor components needed to make it work. The user simply then has to make a few connections (i.e., power, ground, and communication wires) between the microcontroller and breakout board to make it work. Breakout boards are important because a bunch of little things–for example, bypass capacitors and level shifters–have to be added for the principal components to work properly. These little things are often obvious to electrical engineers but can be overwhelming to beginners. Platforms like Arduino and Raspberry Pi might be the foundation of hobbyist electronics these days, but breakout boards make it possible to do cool things with those platforms.

One bit of advice to the DIY instrument designer: if you base your design on the Arduino, don’t use an actual Arduino in the final product. Use a bare-bones variant instead. Real Arduinos have a lot of nice features that unfortunately burn a lot of power, and you can reduce power draw by up to a factor of 30 by using a bare-bones knockoff. I used the Diavolino from EvilMadScientist at first, but am now designing my own board with a built-in efficient power supply instead.

jfa-gps        jfa-adc

jfa-arduino

Top left: GPS breakout board. Top right: analog-digital converter breakout board. Bottom: Arduino Uno, the most common Arduino version.

After getting the breakout boards to play nicely with the Arduino, it was time to design a printed circuit board (PCB) to house them. This might have been the most daunting part of this process. Two circuit design programs are common among hobbyists: KiCAD (free and open-source), and the light version of Eagle (free, not open-source, restricted to non-commerical use, but popular). Like a lot of scientific software, these programs take a while to learn.

In each program, the first step is to draw a schematic showing conceptually how components connect to each other. So, for example, if your circuit included a resistor and capacitor, your schematic would include the resistor symbol connected to a capacitor symbol, but no information about the size, shape, or position of the components.

jfa-kicad_schematic

Schematic editor in KiCAD

After drawing the schematic, the user decides how to lay out the circuit in physical space–specifically, where the components and electrical connections are located on the top and bottoms surfaces of the circuit board. The first step is choosing a physical footprint for each component. Then, a PCB editor window helps the user place component footprints on physical locations on the board and draw wires connecting them. The files created in this process can be sent to a manufacturer (I use Advanced Circuits, based in Aurora, Colorado, USA).

jfa-kicad_pcb

PCB Editor in KiCAD

The final product is called the Gem infrasound logger (named for the “Gem State” Idaho, where it was developed). Parts for it cost about $250 and it takes a few hours to assemble. This is about an order of magnitude cheaper than the cheapest commercial alternative. On the other hand, I put an uncountable number of hours (hundreds, at least) into designing and revising the Gem. On the other other hand, I learned some valuable skills in the process, and my next electronics project (a power-efficient Arduino board) was much easier as a result.

And of course, it’s turned out to be useful in applications beyond volcanoes. Danny Bowman (of Sandia National Labs, and this blog) has launched them on balloons. Tim Ronan (grad student at UNC-Chapel Hill) used them in his research studying river rapids. (Turns out that being lightweight is important when microphones have to be installed by kayak through class-IV whitewater!) Danny and Tim both helped me a lot by testing Gem versions that were still in development, for which I am grateful.

Was it worth it? As a grad student, my time is cheap and half my job is to learn new skills, so spending a lot of it learning how to do this was a good investment. If I was a professional scientist whose labor was more expensive, it might not be such a good decision: better to pay an engineer to do it, even if the product costs more to develop.

In any case, the final product justifies the effort, regardless of who did it. I now have a cheap logger that I can put high on volcanoes and on balloons. It’s been used in several projects around the world now, and it will remain a key part of my infrasound research.

jfa-solarballoon

A solar balloon carrying a Gem lifting off in Albuquerque, NM, USA. Photo by Danny Bowman.

jfa-sites

A subset of the many sites where the Gem has been tested.

How to build a high altitude solar balloon

This balloon can deliver a 2 lb payload to 72,000 ft (22 km) and fly for as long as the sun shines.  It can be hand launched by two people without the aid of electricity and lift gas.  The envelope is built from cheap, easy to find materials.  Total construction time is 4-6 hours for a team of two.

It’s best to find a large area, such as a gym, for building the envelope.  Take care to not damage the plastic – I recommend taking your shoes off so that you can step on the balloon material without ripping it.  When it comes time to darken the envelope, I highly recommend *not* doing it somewhere where lots of charcoal dust will cause a problem.  We recently did it in a parking deck, which meant that spills were no big deal and also kept the wind from blowing the balloon around.

Materials:

-400 x 12 foot sheet of 0.33 mil plastic sheeting (sold as “light duty paint dropcloth” at hardware stores)

-Several rolls of heavy duty clear packing tape, such as these on Amazon.

-Scissors

-Permanent marker

-Tape measure

-Heavy duty string or cord (I use parachute cord)

-Air float charcoal, at least 1 lb

Building the envelope:

This is where you cut the plastic into the required shape, tape it together into a balloon, and check it for holes.  Click here to see a time lapse of this process.

Step 1: Cut the plastic sheeting into five 30 ft sections.  This is around the 10 second mark in the video above.

Step 2: Unfold them until you have five 30 x 12 rectangular sheets of plastic.  This is around the 15 second mark in the video above.

Step 3.  Fold each sheet once across the longer section and once across the shorter section.  Now you have five 15 x 6 ft sections.  This is between the 15 and 25 second mark in the video.

Step 4.  Lay the five sheets on top of each other, all facing the same way.  Find the corner that forms the center of the original sheet (this is where the fold seams all meet each other).  That corner is in the video around the 28 second mark, next to the guy in the blue shirt.  We spend

Step 5.  Consider the corner described in the previous point as the origin, the long part of the sheets as the X axis, and the short part of the sheets as the Y axis, draw the following points using a permanent marker (units in inches):

X Y

0 72

18 71

36 68

54 64

72 58

90 51

108 42

126 33

144 22

162 11

180 0

These points describe a half gore pattern, which is how we turn two dimensional objects (plastic sheets) into a 3 dimensional object (a spherical balloon).  Here, it happens to be a sine curve.  This is from the 40 to the 50 second mark in the time lapse.

Step 6:  Carefully insure that all sheets in the stack are lined up with each other (from about 28 to 40 seconds in the video).  Then, using a pair of scissors, carefully cut along the curved line defined by the points drawn on the top sheet (50-52 second mark).

Step 7: Unfold the sheets; you should have 5 diamond shaped ones.  These are gores, and they form the envelope of the balloon.  The other, roughly triangular pieces of plastic are trash (52-54 second mark).

Step 8:  Tape one edge of the first gore to one edge of the second gore using packing tape.  The seam should be centered in the tape, with no gaps between successive pieces of tape.  We have one person hold the two sheets together and the other tape them together, see photo below:

bowman_solarballoon_06.jpg

Taping the gores together.  If you have more people, you can have multiple teams going at once!  Photo by Mary Lide Parker, UNC Research Communications.

Step 9.  Add the next three gores successively, to make an ever larger sheet of plastic.  Finally, tape the two ends of the sheet together: you’ve now made a ball a little more than 19 feet across (the envelope of the balloon!)  This process takes up from the 1 minute to about the 2 minute mark in the video.

Step 10:  Find one of the two “poles” of the balloon (where the taped seams all meet).  Cut the pole off to make a hole about 5 feet across.  This will become the bottom of the balloon, and allow you to fill it with air.  We do this at 2:14 in the video.

Step 11:  Carefully tow the balloon back and forth, holding the hole open.  It will begin to fill with air.  This is from 2:15 to 2:17.

bowman_solarballoon_08.jpg

Filling the balloon with air prior to checking for holes.  Photo credit: Mary Lide Parker, UNC Research Communications.

Step 12:  At this point, it should be pretty clear whether or not you built the balloon correctly.  If everything looks good, send a brave soul inside to check the envelope for holes (gaps in seam tape are the most common culprits).  Someone on the outside can fix the holes as they are found.  Be careful, of course, since the air supply in there is finite.  This is from 2:18 to 2:36 in the video.

bowman_solarballoon_12.jpg

Checking each seam for holes.  Photo credit: Mary Lide Parker, UNC Research Communications.

Step 13:  Deflate and pack the balloon.  Start from the pole opposite the hole, and slowly push air towards the open end of the balloon.  Don’t go too fast or you’ll pop sections of the balloon.  It’s pretty simple to then stuff the balloon into a big garbage bag for storage.  This is from 2:37 to the end of the video.

Rigging the balloon:

The open hole on one side of the balloon is very weak and susceptible to tearing.  Also, it does not provide any means of attaching a payload.  Thus, we need to reinforce it and provide a way to attach our equipment.

A simple way to do this is to run some tape around the bottom, poke some holes in the tape, attach some string, and tie your payload on.  Our first versions had this system, but it was not ideal; in fact it is probably why we had an “unscheduled rapid disassembly” at 72,000 ft last May.

A much better way is to tie a length of strong cord (parachute cord, for example) into a loop slightly larger than the opening of the balloon.  Pull the opening through the loop, fold it around the loop, and tape the edge of the opening to the outer envelope of the balloon.  This provides a very strong lining system for the bottom.  A payload can be attached by tying guy lines onto the cord loop.  I believe the best place for these guy lines is right at each seam, since the seam tape provides a means of distributing the load along a relatively strong portion of the envelope.  The photo below shows one edge of the balloon with the parachute cord folded in, as well as one payload attachment string.

IMG_1001.JPG

Darkening the envelope:

This is the most fun part (besides launching).  Find a place that is protected from the wind but will allow you to make a big mess.  As mentioned earlier in the post, an indoor parking deck is ideal.

Unpack the balloon and lay it out on the ground. Throw a generous quantity of air float charcoal into the open end, and shake it all the way through the balloon.  The charcoal is so fine it will coat the interior of the balloon, changing it from white to dirty gray.

IMG_0871.JPG

Midway through darkening our solar balloon.

Then, wait for good weather conditions:

CkJ1x7MVAAEathy.jpg:large.jpeg

Two solar balloons and their payloads in storage.

Launching:

The launch procedure is simple: tow the balloon back and forth until it fills with air, attach the payload, let the whole thing heat up for a bit, and off it goes.   Here’s a video of us doing it.  Simple, right?  No.

Actually, launching solar balloons is hard.  It’s a lot harder than helium balloons, since ground conditions are much more restrictive.  With this in mind:

An ideal day for solar ballooning has clear skies and calm ground winds.  This is actually pretty rare, and you may have to wait several weeks for an opening.  If you start to get impatient, keep in mind that even winds barely strong enough to move leaves can make handling a 20 foot tall balloon very dicey.  Early mornings (just after dawn) are best.

An ideal site for a launch is a large open field, where slowly rising balloons will not get caught in trees, power lines, etc.  An alternative is a parking lot between tall buildings, since wind tends to go around them.  This is risky, though, since the balloon can still hit and potentially snag on them.

Finally, if you are planning on recovering your payload, realize that the balloon will fly until the sun sets.  This means that even a 10 mph wind can carry the balloon 120 miles, assuming 12 hours at float.  Many times, the winds in the upper troposphere/lower stratosphere are much stronger.  Careful consideration of the wind profile from 0 to 100,000 ft above sea level is thus imperative before attempting a full day flight with payload recovery.

Happy ballooning!

New updates to the rNOMADS package and big changes in the GFS model

I rolled out a big update to the rNOMADS package in R about two weeks ago.  Now, the list of real time weather, ocean, and sea ice models available through rNOMADS updates automatically by scraping the NOMADS web site.  This way, changes in model inventories will be instantly reflected in rNOMADS without the need for a new version release.

Keep abreast of future updates to rNOMADS by subscribing to the mailing list here.  Feel free to ask for help or make comments on this list as well.

In other news, NOAA just updated the Global Forecast System to provide 0.25 x 0.25 degree output – doubling the resolution of the model!  Check out this crystal clear views of surface temperatures across the planet (source code below the image):

World temperature at 2 m above ground using the 0.25 x 0.25 degree output of the Global Forecast System model.

World temperature at 2 m above ground using the 0.25 x 0.25 degree output of the Global Forecast System model.

 


library(rNOMADS)
library(GEOmap)

#Get dates of model output
model.urls <- GetDODSDates(“gfs_0p25”)

#Find day of most recent model run
latest.model <- tail(model.urls$url, 1)

#Find most recent model run on that day
model.runs <- GetDODSModelRuns(latest.model)

#Get the most recent model (excluding analysis only)
latest.model.run <- tail(model.runs$model.run[which(grepl(“z$”, model.runs$model.run))], 1)

#Define model domain
time <- c(0,0) #Analysis model
lon <- c(0, 1439) #All longitude points
lat <- c(0, 720) #All latitude points
variables <- c(“tmp2m”) #Temperature 2 m above ground

#Get data from NOMADS real time server
tmp.data <- DODSGrab(latest.model, latest.model.run,
variables, time, lon, lat, display.url = FALSE)

#Reformat it
tmp.grid <- ModelGrid(tmp.data, c(0.25, 0.25))

#Define color scale
colormap <- rev(rainbow(500, start = 0 , end = 5/6))

#Plot it
image(x = tmp.grid$x, y = sort(tmp.grid$y), z = tmp.grid$z[1,1,,], col = colormap,
xlab = “Longitude”, ylab = “Latitude”,
main = paste(“World Temperature at Ground Level:”,
tmp.grid$fcst.date))

plotGEOmap(coastmap, border = “black”, add = TRUE,
MAPcol = NA)

Persistence of Vision Frisbee

The first time I saw a persistence of vision (POV) clock I thought: “Wouldn’t that be cool on the side of the frisbee?”. It is a fun weekend project to make one. Here is an action shot of the POV frisbee I made:

IMG_4897

It looks better in person – this picture is the best we could do with a Canon camera held on a level surface. The frisbee is spelling out ‘bovine aero’. Below is a picture of a test in a darkened room:

IMG_4863

This is the perfect project for Adafruit’s tiny, lightweight Arduino compatible Trinket. The total cost of the materials was around $30:

Assembly is as simple as hooking up an LED & resistor in series to each digital out pin, writing some code to blink the lights in the correct order (see below), and attaching the circuit to the frisbee. Below are some pictures taken during assembly:

IMG_20141013_142138647_HDRIMG_20141013_142156068_HDR

Some insights, if anyone else tries this:

  • I considered using a load sensor to determine the rotation rate of the frisbee (a = v^2/r). If you know the rotational speed of the frisbee, you can time the LED outputs to write more consistently spaced letters. However, it turns out the POV illusion looks OK if you use a fixed letter writing rate (I used an ‘on’ time 1 ms per vertical column of letter).
  • To mount the LEDs on the frisbee, I drilled holes in the side and covered them with electrical tape. Punching the LEDs through the tape provided a stable mount for the LEDS.
  • I used letters made up of 5×5 pixel blocks. A better POV display could use more vertically stacked LEDs, or even multicolored LEDs.

Click below to see the code I used:

int B[25] = {1,1,1,1,1, 1,0,1,0,1, 1,0,1,0,1, 0,1,0,1,0, 0,0,0,0,0};
int O[25] = {0,1,1,1,0, 1,0,0,0,1, 1,0,0,0,1, 0,1,1,1,0, 0,0,0,0,0};
int V[25] = {1,1,1,1,0, 0,0,0,1,0, 0,0,0,0,1, 0,0,0,1,0, 1,1,1,1,0};
int I[25] = {0,0,0,0,0, 1,0,0,0,1, 1,1,1,1,1, 1,0,0,0,1, 0,0,0,0,0};
int N[25] = {1,1,1,1,1, 0,1,0,0,0, 0,0,1,0,0, 0,0,0,1,0, 1,1,1,1,1};
int E[25] = {1,1,1,1,1, 1,0,1,0,1, 1,0,1,0,1, 1,0,1,0,1, 0,0,0,0,0};
int A[25] = {0,1,1,1,1, 1,0,1,0,0, 1,0,1,0,0, 0,1,1,1,1, 0,0,0,0,0};
int R[25] = {1,1,1,1,1, 1,0,1,0,0, 1,0,1,1,0, 0,1,0,1,1, 0,0,0,0,0};
int S[25] = {0,1,0,0,1, 1,0,1,0,1, 1,0,1,0,1, 1,0,0,1,0, 0,0,0,0,0};
int P[25] = {1,1,1,1,1, 1,0,1,0,0, 1,0,1,0,0, 0,1,0,0,0, 0,0,0,0,0};
int C[25] = {0,1,1,1,0, 1,0,0,0,1, 1,0,0,0,1, 1,0,0,0,1, 0,0,0,0,0};
int space[25] = {0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0};

int letter_time;
int write_time;

void setup() {
  //use pins 0-4 for output
  pinMode(0, OUTPUT);
  pinMode(1, OUTPUT);
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);

  letter_time = 2; //delay between letters (ms)
  write_time = 1; //how long a led is activated for (ms)
}

//Write an letter to the POV display
void write_letter(int * letter) {
  //write letter, column by column
  for(int i = 0; i < 5; i++) {
    for(int j = 0; j < 5; j++) {
      digitalWrite(j, letter[j+i*5]);
    }
    delay(write_time);
  }

  //write space after letter
  for(int i = 0; i < 5; i++) {
    digitalWrite(i, 0);
  }
  delay(letter_time);
}

void loop() {
  write_letter(B);
  write_letter(O);
  write_letter(V);
  write_letter(I);
  write_letter(N);
  write_letter(E);
  write_letter(space);
  write_letter(A);
  write_letter(E);
  write_letter(R);
  write_letter(O);
  write_letter(space);
}

Accessing global weather model data using the rNOMADS package in R

*** UPDATE ***

rNOMADS 2.0.0 was released yesterday (5-15-2014), and it now has cross-platform support (meaning you can use its data retrieval capabilities in Windows and Mac as well as Linux).

Stay tuned for more tutorials and usage examples in the coming days.

***

The rNOMADS package interfaces with the NOAA Operational Model Archive and Distribution System to provide access to 60 operational (i.e. real time and prediction) models describing the state of the ocean and the atmosphere. rNOMADS has been used to get wind and wave data for a real time sailing game, to quantify solar energy available for power plants in Europe, and to predict helium balloon flights. We look forward to continuing to hear about novel and unexpected uses for this spectacular data set.

In this post, we show how to use rNOMADS to do the following:
1. Plot global temperature and wind at different atmospheric pressure levels
2. Produce a precise atmospheric temperature and wind profile for a specific point at a specific time

Links to source code are provided below each set of figures. A link to rNOMADS installation instructions is provided at the end of the post.

Global Temperature and Wind Maps

The Global Forecast System (GFS) model provides weather data on a 0.5 x 0.5 degree grid for the entire planet.  It is run 4 times daily, and produces a prediction every three hours out to 180 hours.  The zero hour “analysis” forecast is the state of the atmosphere at the model run time, and it uses some observational data to increase its accuracy.  Here, we plot the temperature at 2 m above the surface, the wind at 10 m above the surface, and the winds at 300 mb (around 9 kilometers elevation).  The 300 mb plot often shows the northern and southern jet streams quite well.

Temperature at the Earth's surface determined using the Global Forecast System model.

Temperature at the Earth’s surface determined using the Global Forecast System model.

Winds at the surface of the Earth from the GFS model.  Note the little spot of high winds - that's Tropical Cyclone Gillian, a Category 3 storm when this image was generated.

Winds at the surface of the Earth from the GFS model. Note the little spot of high winds south of Indonesia – that’s Tropical Cyclone Gillian, a Category 3 storm when this image was generated.

Jet streams and Rossby waves are clearly visible in this image of the wind speeds of the upper troposphere/lower stratosphere.

Jet streams and Rossby waves are clearly visible in this image of the wind speeds of the upper troposphere/lower stratosphere.

Download the source code for these images here.

 

Instantaneous Atmospheric Profile over Sakura-Jima volcano, Japan

It’s important to know which direction the winds are going directly above active volcanoes, because eruptions can carry ash into air space and over inhabited areas.  One impetus for the continued development of rNOMADS was to provide a one-stop solution for generating high precision wind profiles over specific points, allowing ash distribution prediction as soon as an eruption begins.  Here, we have generated a spatially and temporally interpolated wind and temperature profile over Sakura-Jima volcano, Japan.  The profile is calculated for the exact time when the source code is run.

Instantaneous temperature profile above Sakura-jima volcano, Japan.

Instantaneous temperature profile above Sakura-jima volcano, Japan.

An eruption at this instant would produce ashfalls east of the volcano for a plume height of 15 km.  However, if a truly massive 30 km high plume was produced, ashfalls would occur both east and west of the volcano.

An eruption at this instant would produce ashfalls east of the volcano for a plume height of 15 km. However, if a truly massive 30 km high plume was produced, ashfalls would occur both east and west of the volcano.

Download the source code for these images here.

 

Some of these scripts require the aqfig package in R to generate the colorbar legends.

Instructions on installing R, rNOMADS, and their dependencies are here.

How to build and launch candle balloons

Birthday candle powered hot air balloons are a lot of fun. Sure, you can buy kits on Amazon. But there’s nothing better than building the balloon yourself and watching it drift off into the night sky, finally burning out miles away and thousands of feet in the air. This post provides an equipment list and instructions for making the candle balloons in the video below:

Equipment List:

0.31 mil clear plastic paint dropcloth (get it at Home Depot or any large hardware store)

one pack of birthday candles

another spare candle

drinking straws

scotch tape

paper clip or sewing needle

clothes iron

lighter

How to Build the Balloon:

1.  Cut a 6 x 6 ft (~2 x 2 m) square of drop cloth.

2.  Fold it in half lengthwise.

Folded over piece of plastic ready to be sealed with an iron.

Folded over piece of plastic ready to be sealed with an iron.

3.  Seal the top and side by melting them together using the iron.  Leave the bottom open.  It may take a bit of adjusting to get the iron hot enough to weld the plastic together but not so much that it melts.  If you’ve not done this before, I suggest practising on a spare piece of plastic.  Once you’re done with the balloon, it will form a cylinder 6 ft high and about  2 ft in diameter.

4.  Make a frame to hold the candles by taping straws together to make a “+”sign.  Disassemble the paper clip to make a pin (or just grab a sewing pin).  Push the pin through the centre of the frame.  This pin will hold the candles onto the frame.

100_0546

5.  Make a double row of birthday candles (or just take the back off the pack of candles, leaving them lined up in a convenient package).  Drip wax from the spare candle onto the rows of birthday candles to bind them together.  This pack of candles is your heat source.  I call it an “engine” out of habit.

100_0544

6.  Attach the frame to the balloon (I usually poke holes through the plastic, then tape the frame to the bottom of the balloon on the outside).  Stick the engine on the pin.  The balloon is ready to fly!

Launching the Balloon

Call a friend and wait until the winds are very light.  In general, the best policy is to make sure that the wind is imperceptible and that it is not disturbing leaves on trees.  Go to a wide open area without nearby houses or isolated trees.  I’ve lost more balloons than I care to count in trees – and nearly hitting a house is almost as nerve wracking as explaining to the owner why his house burned down.  Thankfully, I have not had that experience!

Have one person hold the balloon up and another lay on the ground.  Light the candles, being sure to keep the plastic off the flames.  The balloon should reach neutral buoyancy in about thirty seconds.  Gently release the balloon when it is positively buoyant.  Do not try to fight the wind – if it starts blowing, walk with the wind to avoid it pushing plastic onto the flames or collapsing the balloon entirely.

Having hot wax dripped onto your jacket's just part of the experience!

Having hot wax dripped onto your jacket’s just part of the experience!

Safety and Legal Considerations

There are county level regulations in some parts of the USA that prohibit candle balloons.  The FAA regulation on unmanned free balloons permits the operation of balloons with payloads less than 4 pounds without restriction, but there is a catch-all clause stating that the balloon must not jeopardize health and safety.  So if the balloon starts a forest fire, burns down a house, or even causes a public disturbance, then you are liable.

I have had the police called on me once.  The homeowner who placed the call thought we were committing arson.  Once I explained what we were doing, the officers were perfectly fine with it, but they did point out that they’d be getting in contact if there were any house fires that night.  Our very first launch started a small fire when the balloon got stuck in the tree and the engine fell onto the ground.  I have seen another, poorly constructed balloon land in a parking lot when the frame fell apart.  Also speaking from personal experience – never, ever use the kind of candles that don’t blow out!  They keep going all the way down.

The take home message:  use common sense.  Launch after rain or snow.  Consider where the balloon may land if something goes wrong.  Remember that most people who see these have no idea what these balloons are, and they tend to assume the worst.  In any case, treat the balloons like fireworks, and you’ll have no problems.