Why is Platinum More Expensive than Gold?

During a discussion at dinner today, I asked a question that seems silly and naive:  why is platinum more expensive than gold?  The answer, I think, is interesting and surprisingly complicated.

I read an article recently that said that the majority of the universe's gold and platinum originates from neutron star collisions, and in fact that 7 to 10 times more platinum comes from these collisions than gold.  Figure 1 shows a reproduced and modified figure from the article where they show the expected mass fraction ejected of a variety of atomic mass numbers.  It's noteworthy that gold is stable only at mass number 197, whereas platinum is stable at mass numbers 194, 195 and 196.  Roughly 1/3 of the platinum around today is atomic mass 194, 1/3 is 195, about 1/4 is 196, and most of the rest is atomic mass 198.

Figure 1:  Adapted from Goreily et. al. (2011).  Mass fractions of heavy elements ejected from neutron star collisions.  This is believed to be the major source of heavy elements in the universe.

If we assume that all of the ejecta at each mass number ends up being the corresponding element, then summing the mass fractions for platinum 194, 195, 196 and 198 in figure 1 we see that the mass fraction of platinum ejected from the collision of two neutron stars is about 0.015, and the mass fraction of gold ejected is 0.002.  That means that about 7.5 times more platinum coming out of our collision than gold.

Now our chunks of platinum and gold hurtle out of a gravity wave inducing neutron star collision into space and eventually land in our solar system in the form of meteors.  There's no reason to believe that platinum and gold have separated out significantly on their way to Earth since the abundance of these elements on Earth are 1.9 micrograms/gram for platinum and 0.16 micrograms/gram for gold--so there is roughly 11.8 times more platinum than gold in our planet as a whole by mass.

However, the platinum in the core and the mantle is all but inaccessible to us.  The abundance of platinum and gold in the crust on the other hand is roughly equal at 0.0037 parts per million for platinum and 0.0031 parts per million for gold.  It is still not worth mining either unless some natural process concentrates it, and it seems that there must be fewer such natural processes that lead to the concentration of platinum since only 179 tons of platinum were mined in 2012 compared to 2,700 tons of gold.  For instance, gold deposits form at fault lines when rapid pressure changes during earthquakes cause dissolved gold to precipitate from water underground.  I could not find any articles on natural mechanisms for concentration of platinum.

Finally, there is human history working in favor of gold.  Gold has been known and collected for as long as recorded history, whereas platinum was only recently discovered in the mid-1750s.  Nearly all of the gold that humans have ever collected is still with us in one form or another, and it is estimated that all of the gold that humans have ever possessed equals about 283,000 metric tons, compared to only about 6,000 metric tons of platinum.

So, thanks to geology and human history, we have gone from platinum being 7.5 times more common than gold in neutron star collisions to being substantially scarcer than gold in our possession.  Without considering global demand, it's still fair to say this scarcity in supply is why platinum is more expensive than gold.

Folding Kinetics of Riboswitch Transcriptional Terminators and Sequesterers

A golden buprestid found near Port Angeles
sparkles like an exotic jewel.

A paper that I started as a graduate student, Folding Kinetics of Riboswitch Transcriptional Terminators and Sequesterers, was recently published in Entropy.  I won't reproduce the paper here, but instead I wanted to give a layman's explanation of what we found.

A riboswitch is a piece of RNA that serves both as a detector of some kinds of molecules and a switch to turn a gene's expression on and off.  For example, bacteria might be able to consume a certain kind of nutrient.  If the nutrient was found in the bacteria's environment, it would turn on a gene to make some proteins that can metabolize the nutrient.  The bacteria could use a riboswitch to sense the nutrient and to turn on the gene to digest it.

Some riboswitches work at the time of gene transcription, and work by stopping the RNA polymerase from completing the messenger RNA.  This process is called transcriptional termination.  Obviously, these riboswitches must perform their task quickly, because the RNA polymerase is able to make a gene on the timescale of seconds.

Other riboswitches work at the time of gene translation, and work by preventing a ribosome from binding to the messenger RNA and making the related protein.  We call these sequesterers.  The messenger RNA can be present in the cytoplasm for minutes or hours, so these riboswitches have a much longer timescale on which they may perform their task.

All riboswitches, like proteins, must fold into a particular shape in order to perform their tasks.

Using the open-source ViennaRNA software package, we simulated the folding of thiamine pyrophosphate riboswitches that use either the mechanism of transcriptional termination or sequestration to control their related genes and study the time it takes each type of riboswitch to fold into its functional shape.  We find evidence that the transcriptional terminators, which must operate on a faster timescale than sequesterers, are naturally selected to fold more efficiently.

Moonrise

Piper's Bellflower, growing in the
Alpine meadows at Hurricane Ridge.

I was at the Olympics this weekend with a friend, and on Saturday night after dark we went out with our cameras to try some long exposures.

It was dark there!  Even though we could clearly see the city lights from Port Angeles, it was so dark that the plane of the Milky Way was obviously visible in the night sky.  Feeling ambitious, I decided to take a very long 30 minute exposure with an inspired shot.  There was a teardrop camper parked on his parents' properly, resting idyllically under some fruit trees with the mountains in the background.  I decided to brightly light-paint the mechanical teardrop camper with an LED flashlight, and then light paint the underside of the trees more gently with the golden hue of an incandescent.  12 minutes into the shot, Nature decided to step in and paint everything else as the moon rose over the Olympics.  The result is one of my favorite photos I've ever taken.  Thanks to Benson for his assistance in light painting this shot!

30 minute exposure, ISO 100, f/3.5.  Light painted.  No photoshopping.  

An Arduino Time-Lapse Camera Using ArduCam

While experimenting with my pinhole cameras, I did a lot of thinking about capturing and displaying the passage of time.  Day and night, the change of seasons, sunrise, sunset, moonrise, moonset, tides, rush hour, busy times at restaurants, even life and death marks the passage of time.

There are plenty of commercially-available time-lapse photography devices.  These require either an AC power source, a solar panel or a beefy battery, expensive photography equipment, and are large and easy to spot.  Between the size and the expense, this strongly limits the duration of time lapse I would be able to take even if such a device wasn't prone to being stolen by the first philistine that came across it.  My goal is to make the smallest, most energy efficient and least expensive camera possible so that I am free to set them everywhere and see what the passage of time shows me.

To do this, I decided to give ArduCam a try.

Actually, I found ArduCam pretty disappointing and difficult to use for a few reasons:

• The open source libraries don't use any modern version control system like GitHub.  They're just a few files.  What's more, they fail to compile under Linux without changing the #include statements to correct for case-sensitivity.
• While the ArduCam website shows full-resolution images pulled from "supported" camera modules, the ArduCam Rev. B shield is unable to take bitmap images greater than 320 by 240 pixels because it has only a 3 megabit buffer.  For cameras with on-board JPEG compression it is able to take higher-resolution images, but they come out looking fuzzier than a Georgia peach because they must be made to fit in the buffer.  If these images were indeed taken with an ArduCam shield, they weren't done with any code made available on their website.
• The first "supported" camera I bought, the MT9D111, failed to take any worthwhile picture at any resolution.  I was only able to get it working with the OV2640 module.

Sample image taken with the "supported" MT9D111 camera using an example from the open-source ArduCam code.

So, the ArduCam was a bit of a let-down.  It is actually pretty impressive that someone figured out how to hack together a camera that interfaces with an Arduino, but it's not particularly useful.  The image size is pathetically small and the power draw is substantial (I'm able to take about 370 images on 4 AA batteries).  It may be useful for some applications, but quality time-lapse photography is not going to be one of them.

Let's take a look at my camera, my code, and the results.

My ArduCam

My camera uses the following components:

• Arduino Uno Rev. 3
• ArduCam Rev. B Shield
• OV2640 Camera Module
• 2GB MicroSD Card
• 4 AA batteries

Assembly is positively trivial.  Everything just fits together.  Build time is under a minute.

Note that while the ArduCam board can be made to work with the Arduino Mega, it requires some rewiring because the pinouts are not exactly the same.  The power efficiency could have been improved somewhat with a DC step-down buck converter, but I decided against doing this because even if the power efficiency was greater the image resolution was unacceptable.

An image taken with the OV2640 out an office window at Google Seattle.

The first iteration of my code simply took a picture, then waited a minute using delay before taking another, repeating until the camera ran out of battery.  This managed to take 364 bitmap images until it ran out of juice.  The second iteration of my code made use of the Sleep_n0m1 library to place the Arduino in sleep mode and wake it up each minute.  I had hoped that this would improve battery life substantially, but instead it managed only to take 370 images before running out of battery.

I assembled the time-lapse photos into a video using the following command with avconv on Linux:

avconv -f image2 -i %08d.BMP output.avi

Overall, this was an enlightening exercise but it's clear that if I want a very long-term and reasonably high-quality time lapse photo solution, the platform for that is not going to be ArduCam.

More Pinhole Photography from Mt. Rainier

I pulled 4 of my original 6 pinhole cameras from Mt. Rainier's Sunrise Area last weekend.  The results confirmed some follies of my original design and placement strategy:  First, the camera should be mounted vertically like the soda can sits.  Mounting the camera horizontally does not give the massive depth-of-field effect that I expected it to.  Second, the pinholes were way too large.  1mm diameter pinholes are way too big.  Finally, I underestimated the vigilance of passers-by.  The mountain was only open to visitors for three days total while my cameras were there, and one was crushed by some curious tourist during one of those three days.  Only one of the four cameras that I retrieved gave what I would call a worthwhile shot.  One thing that I like about it is that you can see the first few snowfalls:  horizontal bars show the ever-increasing level of the snow with the trees disappearing behind it over time!

Pinhole photo from Mt. Rainier's Sunrise area.  1mm pinhole, can mounted horizontally, and exposure lasted from October 6, 2012 to June 29, 2013. 

Arduino Scalable Single-Stage Coilgun

In my earlier post where I built an Arduino Laser Tripwire, I mentioned that I was going to use this as a component to a later project.  I've built a scalable, single-stage coilgun that uses inexpensive components and a relatively tame 50VDC.

The premise of a coilgun is simple:  a ferromagnetic or paramagnetic projectile is attracted towards any strong magnetic field it encounters.  By switching on a strong magnetic field inside a solenoid, we can attract the projectile into the coil of wire.  When the projectile is inside the wire, the field is switched off and the projectile continues on the path it was following as it was sucked into the field.

This prototype has only a single stage, meaning that only a single solenoid accelerates the projectile; However, it can easily be scaled up.  By placing another stage just like it in the path of the projectile, we can accelerate the projectile faster and faster.  The projectile will break the laser beam for the next unit, then the magnetic field in the next solenoid will be turned on thus accelerating the projectile further.

I can achieve this multistage coilgun by placing a clear plastic barrel down the center of my solenoids, then shining the laser through the barrel.

My charging circuit, a Delon voltage doubler.

My charging circuit is a simple Delon voltage doubler.  The voltage doubler uses a 12VA transformer to convert the 120V AC from a normal US wall outlet to 24V AC.  The capacitors only need to be 24V, but I happened to have 35V capacitors on hand.  To protect my Arduino from any reverse bias that might be introduced by the relay coil, I include a 1N4937 diode in my design for protection.

My Arduino laser tripwire module., modified from my earlier design.

I have modified my Arduino laser tripire module a bit for compatibility with my trigger circuit.  I need a 1N4937 diode to prevent the voltage from my main capacitor from flowing to ground through the 100 ohm resistor on the trigger circuit.  The indicator LEDs are all optional, and power draw on my Arduino could be reduced by removing them.

The firing module for my prototype coilgun.

The firing circuit is quite spartan, dominated by a large electrolytic capacitor and a cheap 2N6507G SCR.  The 2N6507G can withstand a surge current of 250A but costs only 66 cents to purchase, making it an ideal centerpiece for my firing circuit.  To simplify things further, I use an entire quarter-pound spool of 16AWG magnet wire for my solenoid.  No winding was necessary:  I simply purchased the spool, found both ends of the wire, sanded the insulating lacquer off, and crimped on terminals.  I measured its inductance at 185 microhenries.  To be absolutely sure to protect my capacitor from any reverse bias that might be introduced, I have a 1N4937 protection diode across both the solenoid and the terminals of the capacitor.

Complete schematics for my prototype, generated with KiCad.

Before getting to the demonstration, I will share the source code that I uploaded to my Arduino Uno.  This source is similar to that which I included in my previous post, except I have modified it in two ways.  First, it opens the power supply relay at the same time that the SCR is triggered.  Second, it includes a charge signal (output 10) as well as a tripped signal (output 11).

int ledPort = 13; int laserPort = 12; int tripPort = 11; int notTripPort = 10; int timerToggle = 1000; int timerCount = 0; boolean timerState = false; int onLevel = -1; int offLevel = -1; int currentLevel = -1; boolean tripped = false; void setup() { pinMode(ledPort, OUTPUT); pinMode(laserPort, OUTPUT); pinMode(tripPort, OUTPUT); pinMode(notTripPort, OUTPUT); digitalWrite(tripPort, LOW); digitalWrite(notTripPort, HIGH); // Check the state of the phototransistor with the laser on // and off. digitalWrite(laserPort, LOW); delay(1000); offLevel = analogRead(A0); digitalWrite(laserPort, HIGH); delay(1000); onLevel = analogRead(A0); } // An alive signal that appears on the arduino, // just to let me know the program is running. void timer() { timerCount++; if (timerCount == timerToggle) { timerCount = 0; timerState = !(timerState); if (timerState) { digitalWrite(ledPort, HIGH); } else { digitalWrite(ledPort, LOW); } } } void loop() { delay(1); timer(); if (!(tripped)) { currentLevel = analogRead(A0); if (currentLevel < onLevel - (onLevel - offLevel) / 10) { tripped = true; digitalWrite(tripPort, HIGH); digitalWrite(notTripPort, LOW); } } }

Source code for my coilgun, as uploaded to my Arduino Uno.

Finally, you may check the YouTube video below to see how it works!

Pinhole Camera, Mark 3

The underside of a limpet.

I pulled a couple more of my pinhole cameras from Magnolia Park the other day.  I've gotten better at hiding them!  This time two of three were still where I left them, and one was so well hidden that even when three of us were standing with our heads less than two feet from it we still took five minutes to find it.

These pictures were plagued by a problem from my original design:  the pinhole was simply too large.  The results were a little bit fuzzy, and the effects of condensation and mist rolling in from the Puget Sound are apparent.  Further, the summer sun was cut off at the bottom of the can.  These are problems that I hope to fix in my future pinhole camera projects.  In addition to using a smaller hole perhaps half a millimeter in diameter, I will place the hole higher up in the can.  In this manner, the can mounted vertically with the hole near the top will be less prone to cutting off the sun trails in the summer.  Further, I will include some silica gel inside the can to try to absorb some moisture before it can condense.  I will also experiment with a small amount of saran wrap or clear plastic over the pinhole to try to keep any moist air out.

Pinhole camera mounted among some trees and overlooking Puget Sound at Magnolia Park facing roughly Southwest.  Black and white satin finish paper, 1mm diameter pinhole, exposed from March 3 - June 17 2013.