Understanding the complexities involved in a nuclear reactor is demanding. As in most other such cases when teaching complex concepts, enabling the students to actually work the problem (or, as in this case, a part of it) will help them to grasp the problems and underlying concepts more quickly and probably better.

What are the Teaching Benefits from using this CSE exercise?

The exercise presented here uses the concept of Computing in Science Education (CSE) to teach the students about transuranium waste accumulation in a nuclear (power) reactor. They will need to use their computing skills (which we assume they have) to write a program that simulates the nuclear reactions inside the reactor core (hence learning about fission, nuclear decay paths, and n-capture and the importance of cross-sections in steering these processes). If such a complex process is described using normal differential equations, the resulting set of fantastically complex coupled equations is far too demanding to handle for most Nuclear and Radiochemistry (NRC) students (and perhaps also their teachers..), nor would it be time inside normal curricula to handle such complex mathematics. Traditionally the teacher only explain how difficult it would be, explain how transuranium waste is building up and adding difficulty in the waste handling process and then move on to the next subject. The approach taken for this exercise is to use the number crunching capabilities of the modern desktop computer to dispense with the complex coupled equations and instead just calculate the change in the amount of the relevant nuclei in many small time-steps (e.g. each minute during a whole year of operation). Definitely not something you would like to do by hand, but the computer doesn't mind!

With this exercise the students will be activated and work out for themselves solutions that give them insights into the following:
• Fission, nuclear decay paths, and n-capture and the importance of cross-sections in steering these processes (as mentioned above)
• Where to find relevant nuclear parameters like cross-section and decay branching. To keep it manageable and the programming easy we have simplified the reactor to only have thermal neutrons (cross sections can be fetched from the nuclear chart and no neutron-energy complexity have to be considered).

Once the program is up and running, the students can use it to investigate:
• The dynamics of transuranium waste build-up in a nuclear reactor. (Of course, the exercise can be extended to also consider the fission fragment waste, but that will make the task much bigger).
• Study the effects fuel composition has on the production of waste (in particular, the effect of having 238U present is easy to study with this simulation).
• By turning off the reactor (zero neutron flux) the simulation can be run when only decay occurs (fission and delayed neutrons are ignored), thus studying the dynamics the composition of nuclear waste as as function of timer.
• Study the effect of neutron flux magnitude on the composition and changes in the fuel (and waste).

Time needed

How much time the students will need highly depend on the organization and level of guidance. Certainly it will also depend on the programming skills of the students. At University of Oslo we ran a pilot project where a bachelor student (Johannes Ø. Matsdal) was engaged to develop this exercise and write a working program. He used about 3 weeks to make the program work. His background was from a 10 cp course in Radioactivity and Radiochemistry (UiO course code KJM3900). With such an approach, where part of the effort headed off in the wrong direction since ideas and experiences was gained along the way, a large chunk of student time will be consumed by this project. This can seriously be reduced by providing a step-by-step guide that ensures that the student always head in the right direction. The problem can also be split into several separate steps that could each constitute a stand-alone exercise, but exercises that eventually would add up to provide the waste generation simulation program.

This kind of CSE exercise would probably also benefit from letting the students work in teams, where they can use their collective programming skills and work out problems and approaches by discussions among themselves. Furthermore, that would enable the computer geeks (there will nearly always be some) to work with others not so familiar with computer programming. The team should then divide tasks between themselves enabling everybody, based on their capabilities, to contribute (programming, putting together input data, testing the program, working examples, managing the group, plotting results, writing reports, etc., etc.).

Finally, if a readymade program (a little contrary to the CSE concept, but whatever works..) or maybe better part of the code is provided, the needed time can be seriously reduced. You, as the teacher, will have to work out an implementation that is right for your course and situation (and we would love to hear about your experience with it!).

Hopefully, as teachers use this concept for teaching about nuclear reactors and waste, we can provide examples of actual implementations here.
This is a rather large project and time the student should needs, will be 2.5-4 weeks (not including the weekends), depending on their background in programming and the language used.

Choice of Programming Language

Ideally both you - the teacher - and the students should be proficient in the chosen programming language. If you do not have enough programming experience yourself, you can engage an assistant teacher (student?) to help out with the programming. If your students have extensive programming skills, you can depend on them to be able to solve the computer part of the problem. But this might be a little risky and probably demand a rather brave teacher..

There is no reason why not most normal programming languages should be applicable to this exercise (as long as they can handle mathematics properly). Watch out for the precision used in handling real numbers, round-off errors can give very strange behavior which can be difficult to identify unless you look out for it. Your students are unlikely to have experience with this.

This exercise is probably to complex to be suitable as a task for learning computer programming. The students writing the program should have all the basic understanding of writing computer code and how to construct the basic algorithms (i.e. know about terms like: For-loops, If-else constructs, while-loops, arrays, etc. It would probably be better to use object-oriented programming methods, so such knowledge would be an advantage.

Data Presentation and Reports

For certain, this exercise should not just be about making the program work (students tend to put much focus on this and forget the real purpose of writing the program in the first place..). Thus, it is important that once the program is up and running, it will be used to work real problems related to nuclear waste generation. These problems should be related to expected learning outcomes for the course. It is also a good opportunity to train the students in presenting experimental data properly and write proper scientific reports. Make sure the students have good tools for producing proper scientific graphs.

Ideas for a step-by-step implementation

Below is a layout of a step-by-step approach to implementing this CSE exercise. It would probably be a good idea to set deadlines for each step and have some sort of delivery to mark completion of each step.

Step 1: Define the problem

The student or student group should ensure that they understand the problem they are going to solve. Read up on relevant theory, select programming language and start thinking about how to approach the writing of the program and organizing the data. If in a group, how to divide tasks and make a project management plan.

Step 2: Part one of the Computer Program - Organizing the Data

Decide on how the data, which has been defined in Step 1, should be stored inside the program. A good way to do this is by using a two-dimensional matrix structure like the nuclear chart where each element is an "object" or "cluster" containing all relevant data for the nucleus it represents, including the amount present in the fuel/waste. The position inside the matrix is determined by the nucleus' N and Z numbers). Make subroutines that:
• initialize the matrix,
• allow you to inspect any given element (nucleus) in the matrix
• allow you to edit any given element (nucleus parameters) in the matrix
• load data into the matrix from an input file
• write data from the matrix back into such an input file
Optionally the following would also be helpful:
• A matrix view showing the amount of each nucleus
• Alternatively (or in addition) a histogram type of view would be a nice touch

• Calculate N and Z for a given nucleus (specify mass-number A and element symbol as input)
• Generate nucleus name (A and element symbol) for given N and Z
• Calculate matrix position for given N and Z
• Calculate N and Z for a given matrix position

Step 3: Part two of the Computer Program - Nuclear Reactions

Make a subroutine "CalcNucleusChange" which for a specified time interval calculate for a given matrix element (nucleus) how much of it will undergo:
• fission
• n-capture
• radioactive decay (take branching into account)
The output from this subroutine should be directed into a copy of the matrix where not only the changes for the given nucleus is reflected but also all the other nuclei (matrix elements) which are being populated through n-capture and radioactive decay. The subruotine need to be thoroughly tested and its correct working verified. Any error in this subroutine will make the program flawed. Watch out for decays which produce nuclei outside the defined matrix (unless you have chosen to represent the whole nuclear chart) and also nuclei that are unknown (unknown half-life).

Make a subroutine that for a given time interval traverse the complete matrix and call the "CalcNucleusChange" subroutine for each element to calculate the complete change in the matrix during this time interval. As input for CalcNucleusChange the original matrix should be used, all output should be directed into a single copy of the original matrix. Make sure that you copy the data from the original matrix into the new one before you start traversing the matrix, otherwise it will only contain the changes and not the total amounts.

Step 4: Finished Computer Program

Make a loop that will call on the subroutine that updates the matrix for one time-step as many times it will take to add up to the time you would like the reactor to "run". For short times and many steps this can take quite some time. Ensure that the users are kept updated on progress and that the computer did not "die". It would be good to provide the user with a cancel button to halt calculations that takes too long time.

The program should keep track of "fuel history", i.e. a record of "reactor" operation time and, if asked for "cool down time" (operation with zero neutron flux) to ensure that simulations are properly recorded.

This step should include a thorough test of the complete program to ensure that it is ready for the simulations and to avoid that one at a later stage will need to go back and do "bug-fixes".

Step 5: Performing the Simulations

Now the students should use the program to simulate the operation of different types of nuclear reactors and analyze the consequences the initial fuel mixture will have on the generated waste. This has been described in detail elsewhere and will not be repeated here.

Step 6: Presenting Data and Reporting

The amount of data produced in Step 5 makes a good oppertunity to train the students in how to present their data (graphs and histograms, tables if appropriate, etc.) and writing up a report with their findings and conclusions.

This step could (should) also include a discussion about the limitations of the approach taken in this exercise. This of course is first and foremost the simplification that only thermal neutrons are considered and that the neutron flux is assumed constant throughout the reactor core and as a function of time.