Run update21 to create the cs21/labs/06 directory. Then cd into your cs21/labs/06 directory and create the python program for lab 6 in this directory (handin21 looks for your lab 6 assignment in your cs21/labs/06 directory):

$ update21
$ cd cs21/labs/06

In your cs21/lab/06 directory, you will create a single python program, halfLife.py, that will contain your solution for lab 6. Note: this lab is to be completed in one file, halfLife.py. Please complete all subtasks listed below as part of a larger program. Be sure to read through the whole lab document before starting, and you can run handin21 multiple times to turn in the portion of the program you have completed at any point in time.

Your programs are graded on both correctness and style. Please review the comments regarding programming style on the main page.

The goal of this assignment is to practice using while loops as well as creating and using functions. Your program, at a high level, will simulate radioactive decay of atoms according to a substance's half life. A half life is the amount of time it takes for a substance undergoing decay to decrease by half. It is a very important concept in the sciences. Archaeologists, for example, use the half-life of carbon-14 to calculate the age of fossils precisely (known as carbon dating).

Your program will ask the user for the number of atoms in the starting population and the half-life period and simulate the decay of atoms one half-life at a time until there are no more atoms left. Follow the steps below to create your program.

Open a file named halfLife.py and write a function getPositiveInt(message) which returns a positive integer from user input. getPositiveInt has the following parameter:

• message: a string that defines the prompt instructions for the user.

The getPositiveInt function should return a positive number of type int.

If the user enters a negative number, your function should print an error message and then reprint the prompt instructions. getPositiveInt should print the instructions until the user enters a positive number.

If the user enters a real number, your function should convert it to an int. Remember, to convert a floating point value to an int, use the int() function. For example, x = int(8.7) converts the float value 8.7 to the int value 8 (i.e., it truncates 8.7), assigning x the int value of 8.

Once you have your getPositiveInt function implemented, test it by making calls to it from the main function. Here is a sample result where main invokes getPositiveInt with the argument "How many apples do you have? "

How many apples do you have? -3
That is not a positive integer! Try again.
How many apples do you have? 0
This is not a positive integer! Try again.
How many apples do you have? 3

Here, the function should return the value 3. Another sample run with the argument "Enter number of atoms: "

Enter number of atoms: 100.5

Here, the function returns 100.

Write a function oneHalfLife(pop_size, time) that simulates one half life. This function has two parameters:

1. pop_size: The current (or pre-decay) number of atoms in the population
2. time: The period for one half-life (i.e., how long it takes for half the atoms to decay)

The function should return the number of atoms left after the half life is finished. The number should be an integer.

oneHalfLife should perform 3 actions:

• Have the computer sleep for the duration passed in the parameter time.
• Reduce the number of atoms by one half. Any fractional numbers should be truncated.
• Return the number of atoms remaining.

Once you have written this function, be sure to write some code to test your function (you are not required to keep this test in the final solution).

Write a function, decayToZero(start_size, time), which simulates a population of atoms decaying to 0 atoms. This function has two parameters:

1. start_size: The initial population size
2. time: The period for one half-life (i.e., how long it takes for half the atoms to decay)

decayToZero should:

• perform several rounds of half-life decay, where each round calls oneHalfLife to cut the number atoms of atoms in half.
• at the end of each round, print the remaining population size.
• continue rounds of decay until no atoms are remaining.
• keep track of how many total half-life periods have occurred.

The function should return the total number of half-life periods it took to decay all atoms.

Write a main program using the functions defined above to simulate the decay of a population of atoms. Your main function should satisfy the following requirements:

• From the user, obtain the number of initial atoms (a positive integer)
• From the user, obtain the half-life period (any non-negative real-valued number). You should not use getPositiveInt for this. You can assume the user provides valid input, but feel free to validate the values.
• Print a statement indicating the initial population size.
• Simulate the decay of the population of atoms until no atoms remain by calling decayToZero
• When complete, output the number of half-life periods and total duration of time it took to decay all of the atoms in the inital population. The total duration is the simulated life of the population, and is related to the period time and total number of rounds of half-life decay.

Your program may define additional functions as you see fit. Your program, however, must employ the required functions getPositiveInt, oneHalfLife, and decayToZero wherever possible to meet the requirements of this assignment. Here is a sample run of the program:

$ python halfLife.py

This program simulates the decay of radioactive atoms

Enter number of atoms: -9
That is not a positive integer! Try again.
Enter number of atoms: 100
Enter length of half-life in seconds: 0.2

The initial population size is: 100
There are 50 atoms left
There are 25 atoms left
There are 12 atoms left
There are 6 atoms left
There are 3 atoms left
There are 1 atoms left
There are 0 atoms left

The atoms lasted 7 generations for a total of 1.4 seconds

Have fun and test out different radioactive substances. Krypton-81m has a half life of 13 seconds; lithium-8 is only 0.838 seconds. I don't suggest trying carbon-14. With a half-life of 5715 years, you might be waiting a long time for your results!

Once you are satisfied with your program, hand it in by typing handin21 in a terminal window.

For added difficulty, see if you can simulate the half-life problem visually. That is, create a graphical window with the population of atoms specified by the user drawn on the screen. After each half-life period, remove half of the drawn atoms. You can even play with the random library to randomly pick which half of atoms get removed! Note: this should only be attempted after you satisfy the program requirements. There is no credit for this portion, but feel free to have fun and go beyond the specifications!