How Do You Model Radioactive Decay in a Game When Adding Material Over Time?

[miscellanea]

I'm looking to simulate a radioactive pile in the context of a simple computer game. The problem is, however, that for various reasons I can't use a straightforward tick-by-tick simulation.

Instead I'm looking for an equation that can be solved based on time and would give me the amount of stuff remaining in the pile. And this is quite easy:

R\left(t\right)=R_0\left(\frac{1}{2}\right)^{\frac{t}{t_h}}

Where t_h is the half-life of the element and R_0 is the initial amount at t=0

But there's a complication. Extra material can be added to the pile at any t (For example, 5 units added at t=15) Which is still quite simple. Each added amount could be modeled as a separate pile and the R\left(t\right) of all piles could be added together:

R_{total}\left(t\right)=\sum_{i=0}^{n}R_{i}\left(t\right)

(Without taking piles into account if t < t_{i_{0}})

But there's one more complication and this is the one I'm unable to crack.

Extra material is to be added at a steady rate over several time units. (For example, 5 units added between t_0=17 and t_1=19) So there's a function which grows a pile between the pile's t_0 and t_1 and looks something like:

R(t)=\left(\frac{m}{a} t - t_0\right) if t\in\left[t_0,t_1\right] and m = the total amount added to create the pile and a=t_1 - t_0 or the time it takes to create the pile.

The problem is that I can't figure out how to start applying the decay function while the pile is still being created. At t_1 the amount of stuff in the pile will be equal to m, which shouldn't happen as some of the stuff should have decayed already.

So my question would be: how do I model the lifetime of a decaying pile in such a way that takes into account the fact that it can take several time units to initially create the pile with material being added at a steady rate?

What I'd like to end up with is a graph showing the past, present, and future combined size of all piles and the ability to add events at any point in time that contribute new material to this combined pile.

 

[CompuChip]

So let T be the half-value time, and C(t) the function that indicates how much you add at time t. Then you could do something like:

R(t + \Delta t) = R(t) \left( \frac12 \right)^{\Delta t / T} + N(t, t + \Delta t)
or
R(t + \Delta t) = (R(t) + N(t, t + \Delta t)) \left( \frac12 \right)^{\Delta t / T}
(depending on whether you first add and then decay, or vice versa), and with N denoting the amount added during the step:
N(t, t + \Delta t) = \int_{t}^{t + \Delta t} C(t') dt'
Then you set R(0) and solve iteratively (calculating each next step from the previous), or plug in some explicit forms of C(t) and derive a differential equation

Does that help any? If not, I apologize, I'm not quite sure what you want/

 

[miscellanea]

If I understand you correctly (and it's been over two years since I last did maths on this level, so I'm sorry if I get something wrong) your solution requires a step-by-step (an iterative) calculation. And that's a somewhat valid solution, but I would much prefer to have a solution that doesn't require a step-by-step calculation.

I did a quick step-by-step simulation using a small Python script and plotted the results with OpenOffice:

http://elver.files.wordpress.com/2008/12/simgraph.png

What I'd like to do is end up with a formula that takes t_0 (in this case 0) and t_1 (in this case 500) and the half-life of the particles and the rate at which they are added and finally, when plotted, spit out the blue line above.

 

[CompuChip]

Yes, you understood me correctly.

As I said, it is much easier to write down a recursion. Just to show you what I have in mind, let me give you a relatively easy example. I hope you have your calculus ready
Suppose that every time-unit (second) we add a constant amount of n particles, and the half-life is T. Then the recursion equation reads
R(t + \Delta t) = \left( \frac12 \right)^{\Delta t / T} R(t) + n \Delta.
We can Taylor-expand the power around \Delta t = 0, giving
R(t + \Delta t) \simeq \left(1 - \frac{\log 2}{T} \Delta \right) R(t) + n \Delta + \mathcal O(\Delta^2).
Therefore,
\frac{R(t + \Delta t) - R(t)}{\Delta t} \simeq - \frac{\log 2}{T} R(t) + n + \mathcal O(\Delta).
If we now take the limit \Delta t \to 0 we get the differential equation
R'(t) = -\frac{\log 2}{T} R(t) + n.
If you solve this with an initial condition R(0) = R₀, for example, you get
R(t) = \frac{n T}{\log 2} \left( 1 - 2^{-t/T} \right) + R_0 2^{-t/T}.
Of course, if you want to have an arbitrary time-dependent function n(t) to add the particles, it becomes little more complicated, especially if n(t) will be discontinuous (e.g. a constant > 0 up to some time and 0 from then on). Or you could take multiple of this solutions and patch them up (for example, take n = 100 up to t = 50 with R₀ = 0; then from t = 50 take another such solution with n = 0 where you pick R₀ to match the end value of the first part, etc.)

You decide
Didn't mean to scare you off, but this is the simplest I could think of... so I suggest the recursion equation.

 

[miscellanea]

Wow. Okay, that is quite scary. I've done the things you describe in the past, so I can see where you're going with this, but it's been so long, I don't remember enough to actually apply any of that anymore.

I'm going to try finding a way to simulate this instead of trying to solve it as an equation.