KaliVeda
KaliVeda is an object oriented data analysis framework based on ROOT. Its main purpose is to provide simulation and analysis tools for the INDRA charged particle multidetector used in the study of nuclear multifragmentation at GANIL.
However, it has been conceived in such a way
as to
permit the
simulation of many other charged particle detectors, as well
as being
adapted to the analysis of general multiparticle events
encountered in
heavy ion collisions.
KaliVeda is developed and maintained for 32-
and
64-bit Linux systems (tested on Ubuntu, Scientific Linux,
Fedora).
Here is a brief overview of the different
tools
provided by KaliVeda:
Particles
&
Nuclei
Nuclear Reactions
Multiparticle Events
Materials &
Detectors
Interface
to
Data Acquisition System
Detector Calibration
Database of Detector
Parameters
Multidetector
Arrays
Multidetector
Array Geometry
Charged
Particle
Identification
Particle and
Event
Reconstruction
Global Variables
for Event Analysis
Relativistic kinematics of massive particles
are
the basis for the KVParticle
base class,
itself derived from TLorentzVector.
This
class gives all information on particle kinematics, in a
variety
of different user-defined Lorentz-boosted frames (see KVParticle::SetFrame).
In child class KVNucleus
we add specific
nuclear properties: atomic number, mass number, binding
energy, mass excess,
excitation
energy.
This class includes a mass
table for nearly all known nuclides, and a few commonly
used
methods for estimating
the
nuclear mass when only the atomic number Z is known. In
addition, nuclear arithmetic is possible using the usual '+',
'-', '+='
and '-=' operators: this allows to calculate very simply the
kinematics
and excitation energy of the nucleus or nuclei resulting from
capture
or emission of nuclei by other nuclei.
The class KV2Body
handles calculation of many useful quantities associated with
nuclear
reactions such as:
The laboratory and centre of mass scattering angle
and energy
of projectile
or target
can be
calculated for any given outgoing projectile laboratory angle.
KVEvent is a base
class
for the description of events resulting from nuclear
reactions,
composed of a number (multiplicity)
of
different nuclei. Looping over particles in the event is made
simple using the GetNextParticle()
iterator. The event kinematics can be "viewed" in different Lorentz
frames defined
by the user. The simulation of the detection of such an
event by a
multidetector array (filtering
simulation) is achieved using KVMultiDetArray::DetectEvent.
The main purpose of the KVMaterial class used to describe different materials in KaliVeda is to calculate the energy losses of heavy ions in targets and detectors, for use in detector simulation, event filtering, and also data calibration. Ideally this class should be replaced by an interface to e.g. GEANT4 and/or the ROOT geometry classes - this would also allow easy visualisation of detector structures and event geometries.
KVDetector is
a base
class for the description of (heavy ion) detectors, itself
derived from
KVMaterial. Whereas a KVMaterial object represents a piece of
matter
which can slow or stop heavy ions, a KVDetector associates one or more
layers of
materials with some kind of electronics
so that the result of the
passage of a charged particle in the
"active" layer
of the detector is some kind of signal(s);
this
signal is stored and later read back for
analysis
by some data acquisition system; the signal can be calibrated
by various
methods; after identification of a particle (see below)
its
energy loss in the detector corrected for dead zones,
non-active
layers, or particle-dependent (e.g. charge and/or
mass-dependent)
effects can be calculated.
The KVACQParam
class
provides a rudimentary interface between detectors and the
corresponding acquisition parameters, e.g. as in raw acquisition data for INDRA read
from GANIL
run files. It also gives access to coder pedestal
values,
as
classes describing the electronics
associated to detectors have not yet been fully implemented.
Base class KVCalibrator
is provided for the implementation of detector calibration
procedures.
Each detector has a dedicated list of
calibrator
objects which associate a set of parameters to some method of
calculating
the calibrated energy loss from the detector's raw data.
It is
possible to visualise the transfer function (calibrated
energy) vs.
(raw data) by using the KVCalibrator::MakeGraph
method.
Parameters concerning detector status,
physical
characteristics, identification procedures, energy
calibration, etc.,
for different runs of an experimental campaign are stored in a
database
implemented by classes derived from KVDataBase,
KVDBTable, KVDBRecord.
These
include: KVDBRun for the
description
of a given experimental run; KVDBParameterSet
which holds the identification or calibration parameters for a
given
detector; KVDBTape which
describes a data
acquisition tape (DLT); KVDBSystem
which
describes a given reaction studied over several runs.
The KVMultiDetArray
base class for the description of multidetector arrays
provides the
following functionalities:
Obviously it also provides access to all its
constituent detectors,
identification
telescopes, etc. The target
for the
current experimental run is also accessible via KVMultiDetArray::GetTarget.
The base class for detector positioning is KVPosition. It represents a solid
angle
element (theta_min, theta_max, phi_min, phi_max) at a given
distance
from the origin of the coordinate system (taken to be the
target
position by convention). This class provides methods for
establishing
the relative positioning of different elements of a
multidetector
array, deciding if two detectors are overlapping,
in angular alignment,
or
if one has a smaller
opening
angle than the other, etc. Interfaces to the ROOT
geometry classes exist to allow easy visualisation of
detector structures and event geometries.
Detectors cannot be
directly
placed into a multidetector array geometry (KVDetector
class has no
notion of positioning), they first have to be incorporated
into KVTelescope structures. A
KVTelescope, as
the name suggests, is a sandwich of detector layers with the same angular dimensions,
typically used for charged particle identification, but can in
fact
consist of a single detector. This is an unsatisfactory and
rather
confusing state of affairs which ought to be resolved or at
least
improved, especially as the abstract notion of "identification
telescope" is actually implemented in the class KVIDTelescope (see below).
There are two further levels in the
geometrical
hierarchy: KVRing and KVLayer.
A KVRing is a
collection
of telescopes occupying a certain solid angle, all at the same
distance
from the origin (target). The name 'ring' comes from the
axially-symmetric substructures used in multidetectors such as
INDRA,
but a
KVRing can in principle have any form; it may even be composed
of a
single KVTelescope/detector. In axially-symmetric
multidetector
geometries the KVRings are numbered according to their polar
angle, and
this numbering is used to give distinguishing names to the
same types
of detectors as a function of their position in the array.
A KVLayer is a
collection of rings of telescopes (usually, though not
necessarily, of
the same type). As KVTelescopes can only associate detectors
with the
same angular dimensions, this class is necessary to describe
structures
in which detectors of different opening angles are aligned
with the
target.
Finally, the
'ancillary' class
KVGroup is used to subdivide the
array
structure into groups of telescopes from different layers
which share
at least one common telescope (that with the largest opening
angle).
This is useful for simulating particle detection by the array
(one
first locates the group through which the particle will pass,
and then
the telescopes in the group, rather than testing all the
telescopes of
the array), and even essential when reconstructing particles
from data
(taking into account and eventually correcting the
simultaneous passage
of particles through the common telescope of the group). Once
the
structure of the multidetector array has been defined the
corresponding groups are automatically determined.
Particle identification is based on the
concept of identification
telescopes - this is an
abstract concept, a single detector
can
sometimes provide a full identification, and therefore be
considered to
be an identification 'telescope'. In the most general case,
two
detectors are associated in order to provide identification of
charged
particles (heavy ions) by the dE - E method. Each specific
implementation defines its own Identify
method
in order to establish the identity of a reconstructed
particle from the information stored in the telescope's
detector(s), however a general algorithm for the calibration
(i.e. determining the energy) of identified reconstructed
particles is
provided.
In the case where identification is based on
the
position of data points in the dE-E plane, it is common to use
identification grids composed of lines/cuts corresponding to all
possible
identifiable nuclei. Base classes are provided for lines and
grids used
to identify only the atomic number Z of the detected particle
(KVIDZLine, KVIDZGrid),
or
both Z and the mass number, A (KVIDZALine,
KVIDZAGrid). Although the
specific
details of the identification are left to be determined by
derived
classes, it is most likely to use the general algorithm
defined in
KVIDGrid for finding
the
closest identification line to a (dE,E) point, as well
as the WhereAmI
method implemented
in KVIDLine which allows e.g. to decide whether a data point
is
identifiable based on its position relative to some cut(s) in
the
(dE,E) plane.
A 'raw' event as 'seen' by the multidetector array is described
as a list
of groups hit by particles, as deduced
from the
active acqusition data parameters.
This is
handled by class KVDetectorEvent,
and is generated by KVMultiDetArray::GetDetectorEvent
(only the multidetector array can link raw acquisition
data to
physical detectors with their geometrical location etc.).
The next step is to analyse the hit groups
in order
to reconstruct physical particles, which constitute a
reconstructed
event. The base class for particles reconstructed from energy
losses in
successive detectors is KVReconstructedNucleus,
and
the base class for reconstructed events is KVReconstructedEvent. KVReconstructedEvent::ReconstructEvent
takes a KVDetectorEvent 'raw' event and turns it into a list
of
reconstructed particles. Particle
identification and calibration
then takes place using the identification
telescopes
hit by each particle.
A set of classes to describe many common
global
variables used for the analysis of multibody heavy ion
reactions is
provided. These are based on class KVVarGlob.
A
common use of such variables is to permit event sorting, and
classes
dedicated to this task are derived from KVTrieur.
Web design based on www.xmms.org - Hope you
don't
mind! Thankyou!