GEANT4-based easy and flexible framework for nuclear medicine applications

GAMOS: a GEANT4-based easy and flexible
framework for nuclear medicine applications
Pedro Arce, Pedro Rato, Mario Cañadas and Juan Ignacio Lagares
Abstract—The use of Monte Carlo has proved to be an essential
tool in nuclear medicine, to assist in the design of new medical devices, in the development of new image reconstruction algorithms
and correction techniques in PET and SPECT, for the precise
determination of the dose in radiotherapy, etc. Among the several
general-purpose codes, Geant4 is widely used for its modern
technology, its flexibility and its wide range of applications.
Nevertheless the use of Geant4 in nuclear medicine requires often
a long learning-curve that implies a good knowledge of C++
and the Geant4 codes itself to write the code needed to obtain
the required results. GAMOS, the Geant4-based Architecture for
Medicine-Oriented Simulations, facilitates the use of Geant4 by
providing a simple script language that covers almost all the
needs of a nuclear medicine simulation. Its modular and flexible
design, based on the use of the plug-in technology, as well as
a clear documentation and detailed examples, makes easy to
extend the framework to cover any extra need an expert user
may have. We describe in this paper the basic components of
GAMOS as well as provide a few examples of its use in PET
and Radiotherapy simulations.
Index Terms—Monte Carlo, Geant4, nuclear medicine, PET,
radiotherapy, scripting, plug-in technology.
ONTE Carlo techniques are becoming more and more
widely used in the field of nuclear medicine. Several
general purpose and specialised codes are available for these
type of simulations. Among them, the Geant4 toolkit is the
only general purpose one that is written in C++ and modern
software technologies. It includes a set of physics models
well-validated for the range of interest in nuclear medicine
and it has outstanding capabilities for the description and
visualisation of the geometry. Its great flexibility allows the
user to have a detailed understanding of and control over all
the steps of the simulation. Nevertheless, the use of Geant4
requires some knowledge of C++ and the user usually needs
a long learning curve to be able to tailor it to her/his needs.
The first objective of GAMOS is to provide an easy,
script-based language, architecture that substitute the C++
programming usually required for Geant4 simulations. This
scripting language covers almost all the needs in the medical
physics domain, so that a normal user would not require to add
any extra C++ code to run its application, but only select in the
input script file the options GAMOS provides. Nevertheless, in
the field of nuclear medicine the Monte Carlo codes are mainly
used today for research purposes. Researchers often want to
have a deep understanding of the details of a simulation or
P. Arce is with the Department of Basic Research, CIEMAT, Madrid
P. Rato and J.I. Lagares are with the Department of Technology, CIEMAT,
want to try new things. This is why the authors of GAMOS do
not assume that every need of a nuclear medicine simulation
user can be covered, as an expert user will likely require sooner
or later some peculiar functionality that is not foreseen in
the framework. To satisfy this, GAMOS includes as a main
objective from its first inception the provision of a flexible
framework. We consider that the best way to achieve this is
the to base GAMOS on the plug-in technology, so that a user
can write a new component, transform it into a new plug-in
in a very easy way and then select this new component with a
user command in the initial script, mixing it seamlessly with
the other GAMOS or own components. Through a modular
design, together with a clear documentation and step-by-step
examples of each plug-in type (geometry, physics, generator
distribution, user actions, etc.) we have tried to make easy the
writing of this extra functionality with a minimal knowledge
of C++ or Geant4 details.
GAMOS is composed a core layer that covers the basic
needs of a medical physics simulation. On top of it there are
some applications to provide extra functionality for a given
field, like PET or Radiotherapy. A general user does not need
to operate on these two layers, but only write a text script with
the different commands provided by them to select the options
required for her/his needs.
We describe in this chapter the capabilities of GAMOS
in the different aspects of the simulation: geometry, physics,
primary particles, user actions, signal processing, scoring,
histogramming, etc.
A. Geometry
GAMOS provides the possibility of building the geometry
through a text file. The format is based on simple tags whose
meaning is self-explanatory, as can be seen on the example
below. The meaning and order of the parameters in each tag
is the same as in the corresponding Geant4 C++ class.
The user may define isotopes, elements and materials,
including all the elements and materials in the Geant4 material
database, that include all elements from Z=1 to Z=107, all
one-element materials from Z=1 to Z=98 plus almost 200
materials common to the nuclear medicine domain. Also many
other materials common in the PET and radiotherapy field
are already pre-defined in GAMOS for user convenience (see
GAMOS User’s Guide [1] for a full list of them). The mean
excitation energy of the ionisation potential can be set for
each material, in case the user want to replace the one Geant4
calculates automatically from the material components.
The format also supports all Geant4 solid types, including
twisted solids, tessellated solids and boolean operations among
them. Also all types of Geant4 placements are supported: simple, division, replica, assemblies and a few parameterisations
(linear, square and circular), including the use of reflections.
Rotations matrices to be used in placements can be defined in
three different ways: by giving the angle of rotation around the
X, Y and Z axis, by giving the theta and phi angle of each of
the three axis after rotation or by giving the nine elements of
the rotation matrix. Colour and transparency can be selected
for each volume and the visualisation of a volume can be
switched off.
The user may define a parameter (see example below) of
type number or string and use it later through the text. Also
arithmetic expressions can be used, e.g. 3.*cos(30.*deg)+4.
Default units are provided for each type of variables, although
they user may overwrite them by writing them explicitly. In
case the geometry is a complicated one, it can be split in
several files and they can be selected all or a subset of them
in the final geometry.
Documentation and examples are provided to extend the
format by adding new tags and by mixing a text geometry with
a C++ geometry on the same job. If the user has a geometry
written in C++ GAMOS also provides the utility of loading it
and dumping into a text file, by using a couple of commands
in the input script.
We show here an example of a simple geometry example
to illustrate the easiness in writing it and in understanding a
geometry written in this format:
// Define parameters
:P POSZ 5.
:P Hmass 1.00794
:P Omass 15.999
// Define elements and materials
:ELEM Hydrogen H 1. $Hmass
:ELEM Oxygen O 8 $Omass
:P WaterMass 2.*$Hmass+$Omass
:MIXT Water 1.*g/cm3 2
Hydrogen 2.*$Hmass/$WaterMas
// Define and place volumes
:ROTM RM0 0. 0. 0. // unit rot. matrix
:VOLU world BOX 100. 100. 100. G4_AIR
:VOLU "my tube" TUBE 0. 10. 20. 0. Water
:PLACE "my tube" 1 world R00 0. 0.
The user may also describe the geometry in the standard Geant4 way, through a C++ class inheriting of
G4VUserDetectorConstruction. Adding a line before compiling this class will transform it into a plug-in, so that this
geometry can be selected trough a user command in the input
script file.
The reading of voxelised phantom geometries like those of
DICOM files is also supported. To transform the Hounsfield
number of a DICOM image to materials and densities in a
format directly readable by GAMOS, one can use the Geant4
example examples/extended/medical/DICOM.
GAMOS includes an algorithm for fast navigation in regular
geometries that optimizes at the same time the memory
consumption. This algorithm has been recently included in
the official Geant4 release, version 9.1.
B. Physics
GAMOS provides a physics list, selectable by a user command, that includes all the electromagnetic processes. The use
of different models (standard, low energy or Penelope) can
be selected for each particle type through a user command.
Another physics list provides the needed hadronic processes
for simulation of a hadrontherapy setup.
The user may also describe the physics list in the
standard Geant4 way, through a C++ class inheriting of
G4VUserPhysicsList. Adding a line before compiling this class
will transform it into a plug-in, so that this physics list can
be selected trough a user command in the input script file.
In the same way, any of the existing Geant4 physics lists can
be converted into a plug-in and thereafter it can be selected
through a user command.
1) Cuts: The production cuts, that is the minimum energy of particles produced by ionisation and bremsstrahlung
processes[2], can also be controlled in GAMOS through user
commands. User can define regions (groups of volumes)
through a command and use another command to set the cuts
for the different particles.
In a similar way the limits that a user can define to the
particle tracking [3] can also be set for the different volumes
and particles trough simple user commands.
C. Primary generator
The GAMOS primary generator supports the creation of
several number of particles or decaying isotopes in the same
event. For each particle or isotope the user may select a
different distribution of time, energy, position or direction, or
use the default one provided. The most common distributions
used in nuclear medicine are available, and the user may easily
create a new one with a few lines of code following the
examples provided, and after transforming it into a plug-in
use it the same way as any GAMOS distribution.
The primary generator can be described in the standard Geant4 way, through a C++ class inheriting of
G4VUserPrimaryGeneratorAction. Adding a line before compiling this class will transform it into a plug-in, so that this
primary generator can be selected trough a user command in
the input script file.
D. Sensitive detectors
To simulate the signals left by the particles in the detectors,
Geant4 provides the sensitive detector and hits classes. Nevertheless, simulating a detector in Geant4 implies the writing
of several C++ classes with complicated relationships. All this
can be easily done in GAMOS by using one of the predefined
sensitive detector types. A single user command associates a
sensitive detector type to a volume and GAMOS takes care of
creating the appropriate signals (hits) when a particle reaches
the volume.
To provide a more realistic simulation, the user can also
define for each detector a measuring time, so that hits during
that time will be indistinguishable and will be accumulated,
and a dead time for a volume or a hierarchy of volumes, so
that when a hit is produced in one of the volumes the full
set is inactive during the defined period of time. Paralizable
or non-paralizable dead time behaviour can be selected for
each detector type. Through user commands the resolution in
position, energy and time can also be set independently for
each detector.
For optimising the CPU time in dedicated studies, the hits
can be written in a text or binary file and they can be later read
in for doing the corresponding studies (classifying the events,
histogramming variables, etc.). The hits created by tracks in
the sensitive detectors or those read from a file will have
exactly the same format, so the same code can be used to
analyse them in both cases.
For the simulation of the detector effects associated to
the digitization of the signals, i.e. triggers, pulse shapes,
samplings, etc., which are very detector specific, GAMOS
provides a basic framework and some examples in the applications. Also the transformation of the digital signals into
“reconstructed hits”, containing the position, energy, time, etc.,
can be done in GAMOS using the basic framework provided.
Some examples provided in the code may serve the user to
simulate the details of the hardware functioning.
The sensitive detector, digitizers and hits reconstructors are
also plug-ins, therefore the user can create a new one and use
it as any GAMOS one.
E. User actions
The Geant4 user action classes are the main way
for the user to modify the running conditions and
to extract the required information [4]. In Geant4
the user may only have one user action of each
G4VUserSteppingAction and one different C++ class
has to be written for each user action type. GAMOS overrides
this limitation of Geant4, so that any number of user actions
of any type can be combined in an application and user
actions classes may inherit from several types at the same
GAMOS provides many user actions for obtaining statistical
information tables, building histograms, modify the Geant4
running conditions, do dedicated studies (like time spent or
production cuts), etc. Each user action is documented in the
corresponding section of the GAMOS User’s Guide [1]. All
of them can be selected with a single command:
/gamos/userAction USER ACTION
This command can be filled with extra arguments of filter
names (see section below) so that the corresponding user
action will only be effective for the tracks or track steps
accepted by the filters. In the same way classifier names can
be added so that the user action may fill the corresponding
statistical tables or histograms taking into account the provided
User actions are also plug-in’s, so that a user may follow
the templates provided and write a new one with the desired
functionality and use it as any other GAMOS one.
F. Scoring
We consider that scoring is often an important part of a
simulation. Therefore we have made an effort to provide a
comprehensive and flexible scoring framework.
A user can select with a user command any of the wide
range of scorers that Geant4 provides. For the list of available
scorers we refer to the Geant4 documentation [5].
GAMOS adds new functionality to the Geant4 scorers by
providing the possibility of assigning several scorers of the
same of different type to the same volume, each one with a
different set of filtering algorithms and with a different set of
printers, so that the user can choose one or several formats
for the output. Each scorer can also be associated with a
classifier, so that there will be a different count for each of
the classification types (one for each volume copy number, or
one per each volume name, or one per each particle, or one
per each energy bin, ...).
Scorers and score printers are plug-in’s so that a user can
easily create new ones and use them seamlessly with the
existing ones through user commands.
G. Filters
A filter is a class that receives a track or a track step
information and accepts it or not depending on some given
criteria. Different filters are available in GAMOS to cover the
following needs:
• Accept a particle if it is charged
• Accept a particle if it is neutral
• Accept a particle if it is a gamma
• Accept a particle if it is an electron
• Accept a particle if it is a positron
• Accept a particle if it is an electron or a positron
• Accept a particle if it is a gamma, electron or positron
• Accept a particle if it is in the list provided as extra
parameters in the user command
• Accept a particle if it is a primary (it does not come from
another particle)
• Accept a particle if it is a secondary (it comes from
another particle)
• Accept a particle if its kinetic energy is between the
values given by the two extra parameters in the user
Filters are also plug-in’s and therefore the user can create
its own one if those provided by GAMOS do not satisfy the
desired requirements.
H. Classifiers
A classifier is a class that receives a track step information
and returns a different index (an integer) depending on some
given criteria. In other words it classifies the step and return
the index of its classification. These classes are unique to
GAMOS, as Geant4 does not provide this functionality.
The following classifiers are available in GAMOS:
• By 1 ancestor: It assigns a different index to different
copy numbers of a volume. It has an extra argument that
sets the level of the ancestor; if it is N = 0, it will use
the copy numbers of the volume itself, it is N > 0, it
will look for the copy numbers of the N ancestor
• By several ancestors: It assigns a different index to
different copy numbers of a volume. It has an two
extra arguments that set the number of ancestor levels
NAncestor and the maximum number of copies in a level
NShift. The index is built as
N Ancestor−1
N Shif tN ∗ copyN umber of N ancestor
N =0
By logical volume: It assigns a different index to different
logical volumes (see Geant4 manual for an explanation
of the different geometry objects [4])
• By physical volume: It assigns a different index to
different physical volumes (see Geant4 manual for an
explanation of the different geometry objects [4])
• By region: It assigns a different index to different regions
(see Geant4 manual for an explanation of the different
geometry objects [4])
• By kinetic energy: The user must define a minimum, a
maximum and a width of the energy intervals. It creates
kinetic energy intervals with these values and assigns a
different index to different intervals
Classifiers are plug-in’s, so that a user an create its own
classifier and select it within a user command.
I. Histograms
Many of the users that start to use Geant4 have already some
experience, often a good expertise, in some histogramming
package, like Matlab, Origin, GNUplot, ... GAMOS gives the
user the freedom to use any of these packages, by providing
its own histogram format that is a simple text file, indeed a
CSV (Comma Separated Value) file, which can be easily read
by any of the most common histogram packages. It also has
as an option the possibility to produce histograms in ROOT
[6] format.
The code to create and fill the different histograms is the
same whatever output format is chosen. A user command
serves to select the output format.
We have made a substantial effort to provide tools to help
users in knowing all the details of what is happening in the
simulation as well as to help in optimising GEANT4 for
her/his application.
This tools include:
• Flexible user actions
• Flexible and powerful scoring
• Many control histograms
Detailed verbosity control
Detailed CPU time study by particles, volumes, energy
bins, ...
• Profiling CPU time
• Setting cuts by regions through user commands
• Automatic optimisation of cuts
• Variance reduction techniques
Some of these have already been explained in the previous
sections, we will explain the rest in this chapter.
A. Verbosity
The verbosity control is an important ingredient to debug
or understand a simulation program. Therefore 6 levels of
verbosity have been defined in GAMOS code (a level includes
the previous levels):
-1 = Silent: no messages
0 = Error: only error messages
1 = Warning: only warning messages
2 = Info: basic information of running is printed (usually
messages at run or event initialization/termination)
3 = Debug: debug information of running is printed (usually messages at track initialization/termination or each
tracking step)
4 = Test: this level is only meant for testing, when a code
is being developed
To give extra flexibility, each simulation field (geometry,
physics, primary generator, ...) has its own verbosity manager,
so that the verbosity level can be controlled independently,
through a distinct user command. Details are also provided in
the GAMOS documentation to help the user create its own
verbosity manager and use it through a user command. To
avoid speed penalties, all the verbosity code is suppressed if
the GAMOS NO VERBOSE option is set up before compiling.
The Geant4 tracking verbosity, that gives detailed information of the particle tracking step by step can be controlled by
event or by track in GAMOS. This can be very useful when
a problem is found in a certain event after a long simulation
time, and switching the verbosity for all the events before the
problematic one would create a too-big output.
B. CPU time studies
If you want to optimise your simulation an interesting
information can be where the CPU time is spent, specially
to identify the areas where most of the CPU time is spent so
that you can design good strategies for optimisation. GAMOS
provides an utility to know how much time is spent on each
area: these areas can be the logical volumes, the physical
volumes, the regions, user-defined energy bins or the particle
types. Also combinations of several of these areas can be
selected. To use it it is only needed to add a user command in
the input script and GAMOS will write at the end of the job
a table with how much user, real and system time has been
spent on each element (each particle, volume, energy bin, ...).
If you want to have a very detailed information of which
methods in your code spent more CPU time, GAMOS provides
an example of the use of the gprof utility. This is a common
utility available in all Linux systems that gives the time spent
on each method of each class and also the accumulated time
(the time spent on all the methods invoked by a method).
Other variance reduction techniques are already under implementation in GAMOS and will be available in future
C. Automatic optimisation of cuts
The production cuts and user limits are powerful methods
to tune a simulation so that a lot of CPU time can be spared
by not tracking the particles that are not going to contribute to
the desired results. Nevertheless the tuning of cuts is usually
a long and difficult task. We have developed in GAMOS a
method to help the user to obtain the optimal value of the
production cuts and user limits for her/his application in a
single job, by adding a few commands in the input script.
We describe here the basic idea of the method, more details
can be found in the GAMOS User’s Guide [1].
To use this utility the user has to define in a clear way
which are the results she/he does not want to change when
cuts change, for example
• Number of particles reaching a region
• Dose distribution
• Number/Energy/spatial distribution of detector signals
• Shower shape in a volume
• .....
For each track that contribute to the result GAMOS stores
all its history: for itself and each of its ancestors stores
energy, range, region, process and particle type. In the case of
production cuts this information is stored at particle creation.
In the case of user limits this information is stored at each step
(for parents only the steps before the creation of the interesting
At the end of the run the user can get for each region/process/particle a list of all the ranges or energies of
all the particles created. Then it can easily be known when
applying a cut value how many particles are below it.
This is valid if the user is only interested in counting how
many particles are lost. For other cases another approach
should be used. For example if the user wants to check how
the dose distribution changes, a set of filters can be built, each
one with a set of cut values. This filters do not really cut the
particles but only serve to tag a particle if it would have been
killed by the set of cuts in the filter. Therefore, for each track
that contribute to the results, GAMOS can check if it (or any
of its ancestors) would have been killed by each of these sets
of cut values. If the results are built N times (what can be
done in one single job), each one only using only those tracks
that pass one filter, each result can be compared to see how it
change with each set of cuts.
D. Variance reduction techniques
Two bremsstrahlung techniques are available through user
commands. They are mainly focused for its use in the simulation of a radiotherapy accelerator. The first one consists
on a simple splitting of bremsstrahlung gammas all with the
same weight. The second one checks that the split gammas
point towards the patient and if not, plays Russian roulette
with them.
To simulate a PET detector the utilities we have described
previously can be used. Nevertheless there are other utilities
specific for the PET field that we mention here.
Any PET detector can be simulated with the simple text
format that was described above. On top of that there is an
utility to simulate simple PET detectors by defining only a
few parameters, namely
• Number of crystals per block
• Number of blocks of crystals per ring
• Number of rings of blocks
• Crystal size, trans-axial
• Crystal size, axial
• Crystal size, radial
• Detector ring diameter
Several types of sensitive detectors are selectable by user
commands, and the user can create its own one and make it a
plug-in. Once a sensitive detector is chosen GAMOS creates
automatically the detector signals with detailed information.
This signals can be written in a text or binary file, to retrieve
them in the next job. An special format can be selected,
compatible with the STIR software for tomographic image
reconstruction [7].
To simulate in detail the electronics behaviour, several detector effects are implemented, like energy, position and time
resolution, measuring time and dead time. A basic framework
for the digitization and later signal reconstruction is provided
with a few examples.
Several PET detectors have been simulated or are being
simulated by users, and results agree with the experimental
We mention here the GAMOS utilities that satisfy the
requirements of a simulation of a gamma or electron radiotherapy accelerator and the calculation of dose deposited
in GAMOS. Given the big flexibility of GAMOS other radiotherapy fields can be also covered, as brachytherapy or
A. Accelerator simulation
Any accelerator (with any kind of MLCs) can be simulated
with the simple text format that was described above.
Assuming that the particles propagate along the Z axis, as
it is common in radiotherapy accelerator simulations, phase
space files in IAEA format [8] can be written. This includes
the options of writing different phase space files in several Z
planes in the same job, stopping the particles after the last Z
plane or not, saving the header files after a given number of
events (not to lose everything if job is aborted), saving the
information of the regions that the particle has traversed and
writing histograms by particle type at each Z plane.
To optimise the accelerator simulation particles can be
optionally killed if they reach a big transversal position, or
the available bremsstrahlung splitting techniques can be used.
Also examples to determine automatically the production cuts
and user limits (see section above) are provided. An study
to provide the best electromagnetic physics parameters for a
radiotherapy simulation is being done [9].
Another set of user commands are available to read back
the IAEA phase space files and use them as primary generator.
This includes the options of displacing or rotating the phase
space particles, reusing the phase space particles several times
(with an automatic calculation of reuse number and the optional mirroring in X and Y), recycling the phase space files,
skipping a number of events at the beginning of the file and
writing histograms with the information of the particles read.
B. Dose in phantom simulation
The functionality provided in GAMOS to be able to calculate the dose in a phantom includes the utilities for building
a phantom geometry out of DICOM files and for scoring the
dose in the phantom voxels.
Simple voxelised phantoms can be created with a few
commands. Also DICOM files with patient information can
be transformed to a text format using the Geant4 utilities
and can then be read with GAMOS. Also the format used
by the EGSnrc[10] code can also be read by GAMOS. When
a voxelised phantom geometry is read, an utility is provided
to split one material in several ones if voxel densities are
different. The phantom geometry read can be displaced or
rotated with a couple of user commands.
The scoring of dose deposited in the phantom can be simulated with a few user commands. The fast regular navigation
technique of Geant4 is also available in GAMOS (where
the developing and testing of this technique has been done).
Different printing formats for the dose results can be selected:
• Text in standard output
• Dose histograms (X, Y, Z, XY, XZ, YZ, dose, dosevolume)
• Text file with dose and error at each voxel
• Binary file with dose and dose2 at each voxel (to properly
take into account correlations)
The dose can be given in total or by event, properly taking
into account the tracks correlations into the errors for each
case. In the second case a proper management of original
number of events when reading phase space files is done.
step. The installation and compilation of GAMOS is based on
a set of simple scripts that use the ’make’ utility in a similar
way as Geant4. GAMOS installation has been tested in over 10
Linux distribution/compiler options, therefore if you can install
Geant4 on your system you should have no problem installing
GAMOS. As for Geant4, GAMOS can also run on a Macintosh
computer or on a Windows platform under Vmware[11] or
The user’s guide covers all the available functionality of
each of the GAMOS components (geometry, physics, scoring,
...) providing examples of every user command. It also explains how to extend the framework by creating a new plug-in.
Once GAMOS is installed you may run the test examples to
check your installation and you can follow the tutorials. Three
tutorials are available: PET, Radiotherapy and plug-in’s. Each
one consists of about ten exercises of increasing difficulty that
cover the most important functionality in a field. They can be
done by the user her/himself by reading the slides where they
are proposed and follow the instructions in the user’s guide to
get the desired results. A reference output is provided to check
with the one obtained by the user, and also final solutions are
GAMOS is GEANT4-based framework for doing simulations in the different fields of nuclear medicine. The two
objectives present from its first inception are to provide a
framework that is user-friendly and flexible at the same time.
To reach this aim many utilities are provided to allow
doing full Geant4 simulation of a nuclear medicine application
through simple user commands. The plug-in technology allows
to extend the provided functionality by converting C++ classes
into user commands,with the only requirement of adding
one line in the C++ code. All this together with a detailed
documentation, several step-by-step tutorials, an extensive set
of utilities to extract detailed information and several tools to
optimise CPU performance, make of GAMOS a powerful tool
for the simulation of nuclear medicine applications.
GAMOS core is application independent, but several full
medical applications are being built on top of GAMOS core
and, given the flexibility of its design, others could easily
Four GAMOS tutorials have already been given and
GAMOS is in use in several institutions in Europe, America
and Asia. The code is maintained by the CIEMAT institution and can be downloaded from the GAMOS web page:
C. Analysis of results
A set of easy-to-use executables and ROOT scripts ease the
analysis of phase space and dose files. They serve to sum phase
space or dose files from different jobs, to get basic information
of the file contents, to fill histograms out of the produced files
or to compare results from two files.
The main source of documentation is the GAMOS User’s
Guide [1]. It explains first how to install GAMOS step by
[1] doc.html
Related flashcards
Create flashcards