I would like to make a contribution, and would solicit comments from
members of the mailing list.
The Role Object Oriented Design in the Development of Software in Nuclear
Waste Management
The requirements for compliance with federal regulations (10CFR60) requires
that the performance of repository waste isolation systems must be
projected far into the future (10,000 to 1,000,000 years). Thus, the
performance-assessment calculations that are carried out on high-speed
computers are an important element to the licensing process for nuclear
waste repositories.
When one considers the processes involved in conducting performance
assessment calculations, one can quickly appreciates the complexities
involved. The placement of nuclear waste in an underground repository
results in a change in temperature that perturbs the existing natural
system resulting in heat transfer by conduction and convection through the
media. The increased temperature environment results in many other
changes. For example, the increase in temperature results in thermal
stress that would open or close fractures in the repository environment
that in turn would affect the hydrologic properties for radionuclide
transport. The increase in temperature will change radionuclide
solubilities. Geochemical reactions, and mineral alterations may occur.
The complexity of the current codes cannot be overemphasized. The
prediction of radionuclide migration depends on modeling and analysis of
complex coupled geomechanical, geohydrologic, and geochemical processes.
In addition to the code complexities, there are regulatory requirements for
computer software verification and validation. The codes solution methods
need to be verified by separate hand calculations or the codes need to be
benchmarked. Experiments conducted supporting our understanding of the
phenomena need to be modeled by the codes for code validation.
What do all of these activities mean? They mean that the codes are
changing all of the time data is acquired and that quality assurance
requirements are being applied to moving targets. In many cases, the
current codes are not qualified according to well established standards
that have developed in the nuclear power industry, and that have been
available for many years.
Software development using Object Oriented Design may be the answer to this
existing problem. It is interesting to note the substantial differences in
developing codes using Object Oriented Design from previous coding methods.
OOD in computer software development has been described as a "paradigm
shift." Indeed, it is a paradigm shift. It is a programming technique as
incorporated in C++ that is radically different from the procedure oriented
languages such as FORTRAN or BASIC.
OOD develops a series of classes that are comprised of constants,
variables, and member functions. In OOD, a hierarchy of classes is
developed in building the structure of the code. This hierarchy or
taxonomy of classes determines what is to be done, establishes definitive
interfaces and leaves the "how" or implementation to individual code
developers. OOD emphasizes "data hiding," or data encapsulation, and the
use of libraries of classes. When changes are made to the code, the class
structure may change with the definition of new classes that "inherit" the
variables, constants, and methods of existing classes. Software
development emphasizes the addition of code without significant
modification to existing code. An example may help to clarify these points
that was posed to me one year ago concerning a marathon race in Albuquerque.
Let's consider the case of two long distance runners. Tom starts out on a
certain path, and runs a full marathon. Mike starts out running one hour
later on a path that in part is the same as Tom's. The path that Tom took
starts in downtown Albuquerque. He runs west to the Rio Grande River, then
north along the river, and then returns along the same path to Central
Avenue which corresponds the old route 66 (You know you can get your kicks
on route 66!). The second runner starts at the same spot one hour later,
and takes a different path east on Central Avenue and then around a loop.
The problem that the two runners wanted to solve was would their paths
cross during the race. If their paths cross, at what time in their
respective races would this happen. Each runner has style of "turning
miles."
In solving this problem using OOD, I created a C++ code with a class that I
called runner. The public members of this class are his position (x,y),
cumulative distance run, and the path he is running on. The public member
function that provides the interface is a function that determines his
position. I declared several private members of the class that look up his
velocity for the "miles that he is turning," and another lookup function.
In the main program, I then declare two instances (objects) of the class
runner Tom and Mike, and I then simulate their races.
What we find interesting about this example is that we can easily identify
the instances of the objects runner asTom and Mike. We can picture the
runners, the course along which they are running, and their running styles.
We can picture state variables that describe their positions, and we can
picture the next instant in time in which the runners are advanced along
their respective courses. We can picture them running in opposite
directions along a portion of the course, and them "meeting" during the
race. In designing the structure of the software, we are concerned about
the structure of data, and what is to be done. The "how" something is done
(solution procedure) is of secondary concern in the design of the software.
In writing the C++ program, I was solving a specific problem that they had
posed. What is interesting to consider is software modifications. The
utility of OOD is that by creating classes, and using inheritance, we can
create a taxonomy of classes that allows for efficient extension of the
software. Suppose that we wanted to simulate a whole marathon race? We
might define other classes that would inherit the class runner. Perhaps we
would create a class called race that takes other information and uses it
to either increase or decrease their respective speeds. This might include
weather, topography, and altitude. We then simulate a whole series of
runners. Our purpose would be to determine the "dispersion" of the runners
during the race. They all started out closely packed together. They then
spread out based upon a multitude of factors.
How does OOD apply to developing codes in nuclear waste management? OOD
would greatly facilitates the organization of the software into a structure
that is more easily understood by software developers. Code modifications
could be made more easily. Once efforts are made to document existing
classes, any subsequent code development would not undo what has been
developed and documented.
As licensing issues become more important, OOD may hold the answer to
complying with the multitude of requirements for complex code development
in nuclear waste management.
John B. Case
9620 Admiral Dewey N.E.
Albuquerque, NM 87111
http://ourworld.compuserve.com/homepages/jbcase
This archive was generated by hypermail 2b29 : Wed Feb 20 2002 - 03:20:06 EST