//____________________________________________________________________
//
// Forward Multiplicity Detector based on Silicon wafers. This class
-// contains the base procedures for the Forward Multiplicity detector
-// Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
-// which has 1 or 2 rings of silicon sensors.
+// is the driver for especially simulation.
+//
+// The Forward Multiplicity Detector consists of 3 sub-detectors FMD1,
+// FMD2, and FMD3, each of which has 1 or 2 rings of silicon sensors.
//
// This is the base class for all FMD manager classes.
//
// +--------+<>--+ | +------------------+
// | AliFMD | +--| AliFMDSDigitizer |
// +--------+<>--+ +------------------+
-// 1 | +-----------------+
-// +--| AliFMDSimulator |
-// +-----------------+
-// ^
-// |
-// +-------------+-------------+
-// | |
-// +--------------------+ +-------------------+
-// | AliFMDGeoSimulator | | AliFMDG3Simulator |
-// +--------------------+ +-------------------+
-// ^ ^
-// | |
-// +-----------------------+ +----------------------+
-// | AliFMDGeoOldSimulator | | AliFMDG3OldSimulator |
-// +-----------------------+ +----------------------+
-//
+// 1 | +---------------------+
+// +--| AliFMDReconstructor |
+// +---------------------+
//
// * AliFMD
// This defines the interface for the various parts of AliROOT that
// simulator tasks are responsible to implment the geoemtry, and
// process hits.
//
-// * AliFMDGeoSimulator
-// This is a concrete implementation of the AliFMDSimulator that
-// uses the TGeo classes directly only.
+// * AliFMDReconstructor
+// This is a concrete implementation of the AliReconstructor that
+// reconstructs pseudo-inclusive-multiplicities from digits (raw or
+// from simulation)
//
-// * AliFMDG3Simulator
-// This is a concrete implementation of the AliFMDSimulator that
-// uses the TVirtualMC interface with GEANT 3.21-like messages.
+// Calibration and geometry parameters are managed by separate
+// singleton managers. These are AliFMDGeometry and
+// AliFMDParameters. Please refer to these classes for more
+// information on these.
//
// These files are not in the same directory, so there's no reason to
class AliFMDPoints : public AliPoints
{
public:
+ /** Constructor
+ @param hit Hit to draw
+ @param color Color of hit */
AliFMDPoints(AliFMDHit* hit, UInt_t color)
: AliPoints(1), fMarker(0)
{
fP[1] = hit->Y();
fP[2] = hit->Z();
}
+ /** Destructor */
~AliFMDPoints()
{
// if (fMarker) delete fMarker;
{
//
// Create the geometry of Forward Multiplicity Detector. The actual
- // construction of the geometry is delegated to the class AliFMDRing
- // and AliFMDSubDetector and the relevant derived classes.
- //
- // The flow of this member function is:
- //
- // FOR rings fInner and fOuter DO
- // AliFMDRing::Init();
- // END FOR
- //
- // Set up hybrud card support (leg) volume shapes
- //
- // FOR rings fInner and fOuter DO
- // AliFMDRing::SetupGeometry();
- // END FOR
- //
- // FOR subdetectors fFMD1, fFMD2, and fFMD3 DO
- // AliFMDSubDetector::SetupGeomtry();
- // END FOR
- //
- // FOR subdetectors fFMD1, fFMD2, and fFMD3 DO
- // AliFMDSubDetector::Geomtry();
- // END FOR
+ // construction of the geometry is delegated to the class
+ // AliFMDGeometryBuilder, invoked by the singleton manager
+ // AliFMDGeometry.
//
AliFMDGeometry* fmd = AliFMDGeometry::Instance();
fmd->SetDetailed(fDetailed);
// FMD Air$ Air (Air in the FMD)
// FMD Plastic$ Plastic (Support legs for the hybrid cards)
//
- // Pointers to TGeoMedium objects are retrived from the TGeoManager
- // singleton. These pointers are later used when setting up the
- // geometry
+ // The geometry builder should really be the one that creates the
+ // materials, but the architecture of AliROOT makes that design
+ // akward. What should happen, was that the AliFMDGeometryBuilder
+ // made the mediums, and that this class retrives pointers from the
+ // TGeoManager, and registers the mediums here. Alas, it's not
+ // really that easy.
+ //
AliDebug(10, "\tCreating materials");
// Get pointer to geometry singleton object.
AliFMDGeometry* geometry = AliFMDGeometry::Instance();
void
AliFMD::Init()
{
+ // Initialize the detector
+ //
AliDebug(1, "Initialising FMD detector object");
// AliFMDGeometry* fmd = AliFMDGeometry::Instance();
// fmd->InitTransformations();
void
AliFMD::FinishEvent()
{
+ // Called at the end of the an event in simulations. If the debug
+ // level is high enough, then the `bad' hits are printed.
+ //
if (AliLog::GetDebugLevel("FMD", "AliFMD") < 10) return;
if (fBad && fBad->GetEntries() > 0) {
AliWarning((Form("EndEvent", "got %d 'bad' hits", fBad->GetEntries())));
AliFMD::BuildGeometry()
{
//
- // Build simple ROOT TNode geometry for event display
- //
- // Build a simplified geometry of the FMD used for event display
- //
- // The actual building of the TNodes is done by
- // AliFMDSubDetector::SimpleGeometry.
+ // Build simple ROOT TNode geometry for event display. With the new
+ // geometry modeller, TGeoManager, this seems rather redundant.
AliDebug(10, "\tCreating a simplified geometry");
AliFMDGeometry* fmd = AliFMDGeometry::Instance();
void
AliFMD::LoadPoints(Int_t /* track */)
{
- //
- // Store x, y, z of all hits in memory
+ // Store x, y, z of all hits in memory for display.
+ //
+ // Normally, the hits are drawn using TPolyMarker3D - however, that
+ // is not very useful for the FMD. Therefor, this member function
+ // is overloaded to make TMarker3D, via the class AliFMDPoints.
+ // AliFMDPoints is a local class.
//
if (!fHits) {
AliError(Form("fHits == 0. Name is %s",GetName()));
void
AliFMD::DrawDetector()
{
- //
- // Draw a shaded view of the Forward multiplicity detector
- //
- // DebugGuard guard("AliFMD::DrawDetector");
+ // Draw a shaded view of the Forward multiplicity detector. This
+ // isn't really useful anymore.
AliDebug(10, "\tDraw detector");
-
-#if 0
- //Set ALIC mother transparent
- gMC->Gsatt("ALIC","SEEN",0);
- //
- gMC->Gdopt("hide", "on");
- gMC->Gdopt("shad", "on");
- gMC->Gsatt("*", "fill", 7);
- gMC->SetClipBox(".");
- gMC->SetClipBox("*", 0, 1000, -1000, 1000, -1000, 1000);
- gMC->DefaultRange();
- gMC->Gdraw("alic", 40, 30, 0, 12, 12, .055, .055);
- gMC->Gdhead(1111, "Forward Multiplicity Detector");
- gMC->Gdman(16, 10, "MAN");
- gMC->Gdopt("hide", "off");
-#endif
}
//____________________________________________________________________
Int_t
AliFMD::DistanceToPrimitive(Int_t, Int_t)
{
- //
// Calculate the distance from the mouse to the FMD on the screen
- // Dummy routine
+ // Dummy routine.
//
return 9999;
}
}
}
-
-
//____________________________________________________________________
void
AliFMD::SetHitsAddressBranch(TBranch *b)
Float_t l,
Bool_t stop)
{
- //
// Add a hit to the list
//
// Parameters:
void
AliFMD::ResetSDigits()
{
- //
- // Reset number of digits and the digits array for this detector
+ // Reset number of digits and the digits array for this detector.
//
fNsdigits = 0;
if (fSDigits) fSDigits->Clear();
*
* See cxx source for full Copyright notice
*/
+/** @mainpage ALICE FMD Off-line code
+
+ @section intro Introduction:
+
+ This file contains a short overview of the FMD code. It is by no
+ means authoritative - only the code is good for that. However,
+ I'll try to explain things a bit here.
+
+ @section structure Structure:
+
+ There are 4 libraries build for the FMD. These are
+
+ - libFMDbase: This contains the basic stuff, like data classes and
+ managers.
+ - libFMDsim: This contains code used by the simulation only. That
+ includes the detector class AliFMD and it's derivatives. It
+ also contains the code for building the geometry, as well as the
+ digitisers and raw data writer.
+ - libFMDrec: Code needed for the reconstruction. This include the
+ reconstruction code itself, as well as a raw data reader.
+ - libFMDutil: This is a special library that contains various
+ utility classes for the FMD expert/developer/tester. It
+ includes code to read all data produced by the FMD, a simple
+ event display, and code to make fake calibration and alignment
+ data. This library is @e not loaded by aliroot
+ automatically. The user has to load it herself:
+ @code
+ gSystem->Load("libFMDutil.so");
+ @endcode
+ The content of these libraries is detailed more below.
+
+ @subsection base libFMDbase:
+
+ This currently (18th or March 2006) contains the classes
+
+ - AliFMDBaseDigit, AliFMDDigit, AliFMDSDigit: Base class for
+ digits, real digits, and summable digits. The are all data
+ classes that holds the ADC value(s) for a single strip.
+ - AliFMDBoolMap: A map of booleans, one for each strip.
+ - AliFMDUShortMap: A map of unsigned short integers, one for each
+ strip.
+ - AliFMDDetector, AliFMD1, AliFMD2, AliFMD3: 3 classes that holds
+ the parameters for each of the 3 FMD sub-detectors. These
+ derive from AliFMDDetector, and are managed by AliFMDGeometry.
+ Each of these also contains the translation from sensor
+ reference frame to global reference frame.
+ - AliFMDRing: Parameters for the FMD rings (inner and outer type).
+ These are managed by AliFMDGeometry.
+ - AliFMDGeometry: Manager of FMD geometry data. All code queries
+ this manager for geometry parameters, so that the data is always
+ consistent.
+ - AliFMDParameters: Manager of FMD parameters, like calibration
+ parameters. This class fetches data from CDB if necessary.
+ All code queries this manager for parameters, so that the data
+ is always consistent.
+ - AliFMDCalibPedestal, AliFMDCalibGain, AliFMDCalibSampleRate,
+ AliFMDAltroMapping: Containers of calibration parameters. These
+ correspond to the pedestal and its width, the gain of each
+ strip, the oversampling rate used in read-out, and the map from
+ hardware address to detector.
+ - AliFMDAltroIO, AliFMDAltroReader, AliFMDAltroWriter: Low-level
+ classes to do input/output on ALTRO formated buffers.
+
+
+
+ @subsection sim libFMDsim:
+
+ This currently (18th or March 2006) contains the classes
+
+ - AliFMDEdepMap: Cache of energy deposited and total number of
+ hits for each strip. The digitiser AliFMDDigitizer uses this to
+ store simulation data before making digits.
+ - AliFMDHit: A hit in the FMD active elements, as described by the
+ simulation back-end during transport.
+ - AliFMD, AliFMDv0, AliFMDv1: Simulation drivers for the FMD.
+ AliFMD is the base class. AliFMDv0 corresponds to a simulation
+ where no hits are created, but the material distribution is
+ right. AliFMDv1 is like AliFMDv0, except that hits are
+ produced.
+ - AliFMDGeometryBuilder: Build the FMD geometry in terms of TGeo
+ objects. The information for building the geometry is retrieved
+ from AliFMDGeometry.
+ - AliFMDBaseDigitizer, AliFMDDigitizer, AliFMDSDigitizer: Base
+ class for the digitisers. AliFMDDigitizer makes `real' digits
+ (AliFMDDigit) from hits, and AliFMDSDigitizer makes summable
+ digits from hits.
+ - AliFMDRawWriter: Writes a pseudo raw data file from the digits
+ created by the digitisers. It uses the AliFMDAltroMapping from
+ AliFMDParameters to make the mapping from detector coordinates
+ to hardware addresses.
+
+ @subsection rec libFMDrec:
+
+ This currently (18th or March 2006) contains the classes
+
+ - AliFMDReconstructor: Reconstruct (in a naiive way) the charged
+ particle multiplicity in the FMD strips. This also writes an
+ AliESDFMD object to the ESD files (that class is in libESD).
+
+ - AliFMDRecPoint: Reconstructed point in the FMD. These objects
+ are made AliFMDReconstructor.
+
+ - AliFMDRawReader: Classes to read raw data files.
+
+ @subsection util libFMDutil:
+
+ This currently (18th or March 2006) contains the classes
+
+ - AliFMDInput, AliFMDInputHits, AliFMDInputDigits,
+ AliFMDInputSDigits, AliFMDInputRecPoints: Base class, and
+ concrete classes to read in FMD generated data. These provide a
+ simple and unified way of getting the data. Hooks are defined
+ to process hits, tracks, digits, and reconstructed points, as
+ well as geometry and ESD data. See for example the scripts
+ @c DrawHits.C, @c DrawHitsDigits.C, @c DrawHitsRecs.C, @c
+ DrawDigitsRecs.C in the @c FMD/scripts sub-directory.
+
+ - AliFMDDisplay: Simple event display for FMD data, including
+ hits, digits, reconstructed points and ESD data.
+
+ - AliFMDCalibFaker, AliFMDAlignFaker: Classes to write fake (or
+ dummy) calibration and alignment data. These derive from
+ TTask.
+
+ @section authors Authors:
+
+ - Alla Maevskaya <Alla.Maevskaia@cern.ch>
+ - Christian Holm Christensen <cholm@nbi.dk>
+*/
+/** @defgroup FMD_sim Simulation */
//____________________________________________________________________
//
// provides concrete implementations.
// This class is sooooo crowded
//
-#ifndef ALIDETECTOR_H
+#ifndef ALIDETECTOR_H
# include <AliDetector.h>
#endif
#ifndef ROOT_TBranch
class AliFMDHit;
//____________________________________________________________________
+/** @class AliFMD AliFMD.h <FMD/AliFMD.h>
+ @brief Forward Multiplicity Detector based on Silicon wafers.
+ This class is the driver for especially simulation.
+
+ The Forward Multiplicity Detector consists of 3 sub-detectors FMD1,
+ FMD2, and FMD3, each of which has 1 or 2 rings of silicon sensors.
+
+ This is the base class for all FMD manager classes.
+
+ The actual code is done by various separate classes. Below is
+ diagram showing the relationship between the various FMD classes
+ that handles the simulation
+
+ @verbatim
+ +----------+ +----------+
+ | AliFMDv1 | | AliFMDv0 |
+ +----------+ +----------+
+ | | +-----------------+
+ +----+--------------+ +--| AliFMDDigitizer |
+ | | +-----------------+
+ | +---------------------+ |
+ | +--| AliFMDBaseDigitizer |<--+
+ V 1 | +---------------------+ |
+ +--------+<>--+ | +------------------+
+ | AliFMD | +--| AliFMDSDigitizer |
+ +--------+<>--+ +------------------+
+ 1 | +---------------------+
+ +--| AliFMDReconstructor |
+ +---------------------+
+ @endverbatim
+
+ - AliFMD
+ This defines the interface for the various parts of AliROOT that
+ uses the FMD, like AliFMDSimulator, AliFMDDigitizer,
+ AliFMDReconstructor, and so on.
+ - AliFMDv0
+ This is a concrete implementation of the AliFMD interface.
+ It is the responsibility of this class to create the FMD
+ geometry.
+ - AliFMDv1
+ This is a concrete implementation of the AliFMD interface.
+ It is the responsibility of this class to create the FMD
+ geometry, process hits in the FMD, and serve hits and digits to
+ the various clients.
+ - AliFMDSimulator
+ This is the base class for the FMD simulation tasks. The
+ simulator tasks are responsible to implment the geoemtry, and
+ process hits.
+ - AliFMDReconstructor
+ This is a concrete implementation of the AliReconstructor that
+ reconstructs pseudo-inclusive-multiplicities from digits (raw or
+ from simulation)
+
+ Calibration and geometry parameters are managed by separate
+ singleton managers. These are AliFMDGeometry and
+ AliFMDParameters. Please refer to these classes for more
+ information on these.
+ */
class AliFMD : public AliDetector
{
public:
+ /** Default constructor. Do not use. */
AliFMD();
+ /** Normal constructor
+ @param name Name of object.
+ @param title Title of object. */
AliFMD(const char *name, const char *title);
+ /** Copy constructor
+ @param other Object to copy from */
AliFMD(const AliFMD& other);
+ /** Destructor */
virtual ~AliFMD();
+ /** Assignment operator
+ @param other Object to assign from
+ @return Reference to this object */
AliFMD& operator=(const AliFMD& other);
- // Use old implementation
- void UseOld(Bool_t use=kTRUE) { fUseOld = use; }
- void UseAssembly(Bool_t use=kTRUE) { fUseAssembly = use; }
+ /** Wheter to make a detailed geometry
+ @param use If true, make detailed geometry */
void UseDetailed(Bool_t use=kTRUE) { fDetailed = use; }
- // GEometry ANd Tracking (GEANT :-)
+ /** @{*/
+ /** @name GEometry ANd Tracking (GEANT :-) */
+ /** Define the geometry. This is done by asking the manager
+ AliFMDGeometry to construct the geometry. This in turn calls
+ AliFMDGeometryBuilder. */
virtual void CreateGeometry();
+ /** Create the tracking mediums used by the FMD. This associates
+ the tracking mediums defined with the FMD in the
+ TVirtualMCApplication (AliMC).
+
+ The defined mediums are
+ - @c FMD @c Si$ Silicon (active medium in sensors)
+ - @c FMD @c C$ Carbon fibre (support cone for FMD3 and vacuum pipe)
+ - @c FMD @c Al$ Aluminium (honeycomb support plates)
+ - @c FMD @c PCB$ Printed Circuit Board (FEE board with VA1_3)
+ - @c FMD @c Chip$ Electronics chips (currently not used)
+ - @c FMD @c Air$ Air (Air in the FMD)
+ - @c FMD @c Plastic$ Plastic (Support legs for the hybrid cards)
+ */
virtual void CreateMaterials();
+ /** Initialize this detector */
virtual void Init();
+ /** This member function is called when ever a track deposites
+ energy (or similar) in an FMD tracking medium. In this base
+ class this member function is pure abstract. In concrete
+ sub-classes, the member function may make hits or other
+ stuff. */
virtual void StepManager() = 0;
+ /** Called at the end of each simulation event. If the debug level
+ is high enough a list of @e bad hits is printed. */
virtual void FinishEvent();
+ /** @}*/
- // Graphics and event display
+ /** @{*/
+ /** @name Graphics and event display */
+ /** Build simple ROOT TNode geometry for event display. With the new
+ geometry modeller, TGeoManager, this seems rather redundant. */
virtual void BuildGeometry();
+ /** Draw a shaded view of the Forward multiplicity detector. This
+ isn't really useful anymore. */
virtual void DrawDetector();
+ /** Calculate the distance from the mouse to the FMD on the screen
+ Dummy routine */
virtual Int_t DistanceToPrimitive(Int_t px, Int_t py);
+ /** Store x, y, z of all hits in memory for display.
+ Normally, the hits are drawn using TPolyMarker3D - however, that
+ is not very useful for the FMD. Therefor, this member function
+ is overloaded to make TMarker3D, via the class AliFMDPoints.
+ AliFMDPoints is a local class.
+ @param track the track number to load the hits for */
virtual void LoadPoints(Int_t track);
+ /** @}*/
- // Hit and digit management
+ /** @{ */
+ /** @name Hit and digit management */
+ /* Create Tree branches for the FMD.
+ @param opt One of
+ - @c H Make a branch of TClonesArray of AliFMDHit's
+ - @c D Make a branch of TClonesArray of AliFMDDigit's
+ - @c S Make a branch of TClonesArray of AliFMDSDigit's */
virtual void MakeBranch(Option_t *opt=" ");
+ /** Set the TClonesArray to read hits into.
+ @param b The branch to containn the hits */
virtual void SetHitsAddressBranch(TBranch *b);
+ /** Set branch address for the Hits, Digits, and SDigits Tree. */
virtual void SetTreeAddress();
+ /** Get the array of summable digits
+ @return summable digits */
virtual TClonesArray* SDigits() { return fSDigits; }
+ /** Reset the array of summable digits */
virtual void ResetSDigits();
+ /** Add a hit to the hits tree
+ @param track Track #
+ @param ivol Volume parameters, interpreted as
+ - ivol[0] [UShort_t ] Detector #
+ - ivol[1] [Char_t ] Ring ID
+ - ivol[2] [UShort_t ] Sector #
+ - ivol[3] [UShort_t ] Strip #
+ @param hits Hit information
+ - hits[0] [Float_t ] Track's X-coordinate at hit
+ - hits[1] [Float_t ] Track's Y-coordinate at hit
+ - hits[3] [Float_t ] Track's Z-coordinate at hit
+ - hits[4] [Float_t ] X-component of track's momentum
+ - hits[5] [Float_t ] Y-component of track's momentum
+ - hits[6] [Float_t ] Z-component of track's momentum
+ - hits[7] [Float_t ] Energy deposited by track
+ - hits[8] [Int_t ] Track's particle Id #
+ - hits[9] [Float_t ] Time when the track hit */
virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits);
+ /** Add a hit to the list
+ @param track Track #
+ @param detector Detector # (1, 2, or 3)
+ @param ring Ring ID ('I' or 'O')
+ @param sector Sector # (For inner/outer rings: 0-19/0-39)
+ @param strip Strip # (For inner/outer rings: 0-511/0-255)
+ @param x Track's X-coordinate at hit
+ @param y Track's Y-coordinate at hit
+ @param z Track's Z-coordinate at hit
+ @param px X-component of track's momentum
+ @param py Y-component of track's momentum
+ @param pz Z-component of track's momentum
+ @param edep Energy deposited by track
+ @param pdg Track's particle Id #
+ @param t Time when the track hit
+ @param l Track length through the material.
+ @param stop Whether track was stopped or disappeared */
virtual AliFMDHit* AddHitByFields(Int_t track,
UShort_t detector,
Char_t ring,
Float_t t=0,
Float_t len=0,
Bool_t stopped=kFALSE);
+ /** Add a digit to the Digit tree
+ @param digits
+ - digits[0] [UShort_t] Detector #
+ - digits[1] [Char_t] Ring ID
+ - digits[2] [UShort_t] Sector #
+ - digits[3] [UShort_t] Strip #
+ - digits[4] [UShort_t] ADC Count
+ - digits[5] [Short_t] ADC Count, -1 if not used
+ - digits[6] [Short_t] ADC Count, -1 if not used
+ @param notused Not used */
virtual void AddDigit(Int_t *digits, Int_t* notused=0);
+ /** add a real digit
+ @param detector Detector # (1, 2, or 3)
+ @param ring Ring ID ('I' or 'O')
+ @param sector Sector # (For inner/outer rings: 0-19/0-39)
+ @param strip Strip # (For inner/outer rings: 0-511/0-255)
+ @param count1 ADC count (a 10-bit word)
+ @param count2 ADC count (a 10-bit word), or -1 if not used
+ @param count3 ADC count (a 10-bit word), or -1 if not used */
virtual void AddDigitByFields(UShort_t detector=0,
Char_t ring='\0',
UShort_t sector=0,
UShort_t count1=0,
Short_t count2=-1,
Short_t count3=-1);
+ /** Add a digit to the Digit tree
+ @param digits
+ - digits[0] [UShort_t] Detector #
+ - digits[1] [Char_t] Ring ID
+ - digits[2] [UShort_t] Sector #
+ - digits[3] [UShort_t] Strip #
+ - digits[4] [UShort_t] ADC Count
+ - digits[5] [Short_t] ADC Count, -1 if not used
+ - digits[6] [Short_t] ADC Count, -1 if not used */
virtual void AddSDigit(Int_t *digits);
+ /** add a summable digit - as coming from data
+ @param detector Detector # (1, 2, or 3)
+ @param ring Ring ID ('I' or 'O')
+ @param sector Sector # (For inner/outer rings: 0-19/0-39)
+ @param strip Strip # (For inner/outer rings: 0-511/0-255)
+ @param count1 ADC count (a 10-bit word)
+ @param count2 ADC count (a 10-bit word), or -1 if not used */
virtual void AddSDigitByFields(UShort_t detector=0,
Char_t ring='\0',
UShort_t sector=0,
UShort_t count1=0,
Short_t count2=-1,
Short_t count3=-1);
+ /** @}*/
- // Digitisation
+ /** @{ */
+ /** @name Digitisation */
+ /** Create a digitizer object
+ @param manager Digitization manager
+ @return a newly allocated AliFMDDigitizer */
virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+ /** Create AliFMDDigit's from AliFMDHit's. This is done by creating
+ an AliFMDDigitizer object, and executing it. */
virtual void Hits2Digits();
+ /** Create AliFMDSDigit's from AliFMDHit's. This is done by creating
+ an AliFMDSDigitizer object, and executing it. */
virtual void Hits2SDigits();
+ /** @}*/
- // Raw data
+ /** @{ */
+ /** @name Raw data */
+ /** Turn digits into raw data. This uses the class AliFMDRawWriter
+ to do the job. Please refer to that class for more
+ information. */
virtual void Digits2Raw();
+ /** @}*/
- // Utility
+ /** @{ */
+ /** @name Utility */
+ /** Browse this object
+ @param b Browser to show this object in */
void Browse(TBrowser* b);
+ /** @}*/
protected:
+ /** Initialize hit array if not already done, and return pointert.
+ @return Hit array */
TClonesArray* HitsArray();
+ /** Initialize digit array if not already done, and return pointert.
+ @return Digit array */
TClonesArray* DigitsArray();
+ /** Initialize summable digit array if not already done, and return
+ pointert.
+ @return Summable digit array */
TClonesArray* SDigitsArray();
TClonesArray* fSDigits; // Summable digits
class AliFMDRing;
//__________________________________________________________________
-// Geometry description and parameters of the FMD1
-// detector.
-//
-// The FMD1 only has one ring.
-//
+/** @class AliFMD1 AliFMD1.h <FMD/AliFMD1.h>
+ Geometry description and parameters of the FMD1 detector.
+ The FMD1 has only one ring.
+ @ingroup FMD_base
+*/
class AliFMD1 : public AliFMDDetector
{
public:
+ /** Constructor
+ @param inner Pointer to inner ring description */
AliFMD1(AliFMDRing* inner);
+ /** Destructor */
virtual ~AliFMD1() {}
+ /** Initialize */
virtual void Init() { AliFMDDetector::Init(); }
ClassDef(AliFMD1,1)
};
AliFMD2::AliFMD2(AliFMDRing* inner, AliFMDRing* outer)
: AliFMDDetector(2, inner, outer)
{
+ // Constructor
SetInnerZ(83.4);
SetOuterZ(75.2);
}
void
AliFMD2::Init()
{
+ // Initialize
AliFMDDetector::Init();
SetInnerHoneyHighR(GetOuterHoneyHighR());
}
# include "AliFMDDetector.h"
#endif
-// Geometry description and parameters of the FMD2
-// detector.
-// This has two rings.
+//____________________________________________________________________
+/** @class AliFMD2 AliFMD2.h <FMD/AliFMD2.h>
+ Geometry parameters of the FMD2 detector. This has two rings.
+ @ingroup FMD_base
+*/
class AliFMD2 : public AliFMDDetector
{
protected:
public:
+ /** Constructor
+ @param inner Pointer to inner ring description
+ @param outer Pointer to outer ring description */
AliFMD2(AliFMDRing* inner, AliFMDRing* outer);
/** Initialize the geometry */
virtual void Init();
# include "AliFMDDetector.h"
#endif
-// Geometry description and parameters of the FMD3 detector.
-// FMD3 has a fairly complicated support structure.
-// The cone also supports the beam-pipe.
-//
+/** @class AliFMD3 AliFMD3.h <FMD/AliFMD3.h>
+ Geometry parameters of the FMD3 detector. FMD3 has a fairly
+ complicated support structure. The cone also supports the
+ beam-pipe.
+ @ingroup FMD_base
+*/
class AliFMD3 : public AliFMDDetector
{
public:
+ /** Constructor
+ @param inner Pointer to inner ring description
+ @param outer Pointer to outer ring description */
AliFMD3(AliFMDRing* inner, AliFMDRing* outer);
+ /** Destructor */
virtual ~AliFMD3(){}
/** Initialize the geometry */
//
// Forward Multiplicity Detector based on Silicon wafers.
//
-// This task creates fake alignrations. Which alignration, depends on
+// This task creates fake alignment. Which alignment, depends on
// the bit mask passed to the constructor, or added by `AddAlign'.
//
-// The default is to write all alignration parameters to a local
+// The default is to write all alignment parameters to a local
// storage `local://cdb' which is a directory in the current
// directory.
//
class TClonesArray;
class TString;
+/** @class AliFMDAlignFaker
+ This task creates fake alignment. Which alignment, depends on the
+ bit mask passed to the constructor, or added by `AddAlign'.
+
+ The default is to write all alignment parameters to a local
+ storage @c local://cdb which is a directory in the current
+ directory.
+ @ingroup FMD_util
+*/
class AliFMDAlignFaker : public TTask
{
public:
+ /** What to make alignments for */
enum EWhat {
+ /** MAke alignment for sensors */
kSensors = 1,
+ /** Make alignment for half-rings */
kHalves
};
enum {
+ /** All types of alignment */
kAll = (1<<kHalves|1<<kSensors)
};
+ /** Constructor
+ @param mask Bit mask of what to make alignments for
+ @param geo File to read geometry from, if needed
+ @param loc Where to store the result */
AliFMDAlignFaker(Int_t mask=kAll,
const char* geo="geometry.root",
const char* loc="local://cdb");
+ /** Destructor */
virtual ~AliFMDAlignFaker() {}
+ /** Add something to make alignment for
+ @param w Bit of alignment mask */
void AddAlign(EWhat w) { SETBIT(fMask, w); }
+ /** Remove something to make alignment for
+ @param w Bit of alignment mask */
void RemoveAlign(EWhat w) { CLRBIT(fMask, w); }
+ /** Set alignment select mask
+ @param mask Bit mask */
void SetAlign(Int_t mask) { fMask = mask; }
+ /** Set the displacement (translation) of sensors. The displacement
+ is selected random uniformly between the corresponding minimum
+ and maximum.
+ @param x1 Minimum X displacement (in centimeters)
+ @param y1 Minimum Y displacement (in centimeters)
+ @param z1 Minimum Z displacement (in centimeters)
+ @param x2 Maximum X displacement (in centimeters)
+ @param y2 Maximum Y displacement (in centimeters)
+ @param z2 Maximum Z displacement (in centimeters) */
void SetSensorDisplacement(Double_t x1=0, Double_t y1=0, Double_t z1=0,
Double_t x2=.01, Double_t y2=.01, Double_t z2=0);
+ /** Set the rotation of sensors. The displacement is selected
+ random uniformly between the corresponding minimum and maximum.
+ @param x1 Minimum X rotation (in degrees)
+ @param y1 Minimum Y rotation (in degrees)
+ @param z1 Minimum Z rotation (in degrees)
+ @param x2 Maximum X rotation (in degrees)
+ @param y2 Maximum Y rotation (in degrees)
+ @param z2 Maximum Z rotation (in degrees) */
void SetSensorRotation(Double_t x1=0, Double_t y1=0, Double_t z1=0,
Double_t x2=.5, Double_t y2=.5, Double_t z2=.5);
+ /** Set the displacement (translation) of half-rings. The
+ displacement is selected random uniformly between the
+ corresponding minimum and maximum.
+ @param x1 Minimum X displacement
+ @param y1 Minimum Y displacement
+ @param z1 Minimum Z displacement
+ @param x2 Maximum X displacement
+ @param y2 Maximum Y displacement
+ @param z2 Maximum Z displacement */
void SetHalfDisplacement(Double_t x1=0, Double_t y1=0, Double_t z1=0,
Double_t x2=.05, Double_t y2=.05, Double_t z2=.05);
+ /** Set the rotation of half-rings. The displacement is selected
+ random uniformly between the corresponding minimum and maximum.
+ @param x1 Minimum X rotation (in degrees)
+ @param y1 Minimum Y rotation (in degrees)
+ @param z1 Minimum Z rotation (in degrees)
+ @param x2 Maximum X rotation (in degrees)
+ @param y2 Maximum Y rotation (in degrees)
+ @param z2 Maximum Z rotation (in degrees) */
void SetHalfRotation(Double_t x1=0, Double_t y1=0, Double_t z1=0,
Double_t x2=0, Double_t y2=0, Double_t z2=0);
+ /** Set the output file name. Should be a valid CDB URL.
+ @param file CDB URL */
void SetOutput(const char* file) { SetTitle(file); }
+ /** Set the file to read the geometry from.
+ @param file File name */
void SetGeometryFile(const char* file) { SetName(file); }
+ /** Make the alignment objects.
+ @param option Not used. */
void Exec(Option_t* option="");
protected:
+ /** Make the alignment object for a path
+ @param path Node path.
+ @param volID Volume identifier
+ @param transX Translation in X
+ @param transY Translation in Y
+ @param transZ Translation in Z
+ @param rotX Rotation around X axis
+ @param rotY Rotation around Y axis
+ @param rotZ Rotation around Z axis
+ @return @c true on success */
Bool_t MakeAlign(const TString& path, Int_t volID,
Double_t transX, Double_t transY, Double_t transZ,
Double_t rotX, Double_t rotY, Double_t rotZ);
+ /** Align a sensor
+ @param path of a sensor
+ @param id Volume id */
Bool_t MakeAlignSensor(const TString& path, Int_t id);
+ /** Align a half-ring
+ @param path of a sensor
+ @param id Volume id */
Bool_t MakeAlignHalf(const TString& path, Int_t id);
+ /** Write to CDB */
void WriteToCDB();
+ /** Write to file */
void WriteToFile();
Long_t fMask; // What to write
- TVector3 fSensorTransMin;
- TVector3 fSensorTransMax;
- TVector3 fSensorRotMin;
- TVector3 fSensorRotMax;
- TVector3 fHalfTransMin;
- TVector3 fHalfTransMax;
- TVector3 fHalfRotMin;
- TVector3 fHalfRotMax;
- Int_t fRunMin;
- Int_t fRunMax;
- TClonesArray* fArray;
+ TVector3 fSensorTransMin; // Minimum translations of a sensor
+ TVector3 fSensorTransMax; // Maximum translations of a sensor
+ TVector3 fSensorRotMin; // Minimum rotation of a sensor
+ TVector3 fSensorRotMax; // Maximum rotation of a sensor
+ TVector3 fHalfTransMin; // Minimum translations of a half-ring
+ TVector3 fHalfTransMax; // Maximum translations of a half-ring
+ TVector3 fHalfRotMin; // Minimum rotation of a half-ring
+ TVector3 fHalfRotMax; // Maximum rotation of a half-ring
+ Int_t fRunMin; // Run validity start
+ Int_t fRunMax; // Run validity end
+ TClonesArray* fArray; // Cache
ClassDef(AliFMDAlignFaker,0)
};
#include <TObject.h>
//____________________________________________________________________
+/** @class AliFMDAltroIO AliFMDAltroIO.h <FMD/AliFMDAltroIO.h>
+ @brief Base class for ALTRO Input/Output classes.
+ @ingroup FMD_base
+ */
class AliFMDAltroIO : public TObject
{
- public:
+public:
/** Type of 40 bit words (signed) */
typedef long long W40_t;
/** Type of 10 bit words (signed) */
};
//____________________________________________________________________
+/** @class AliFMDAltroReader AliFMDAltroIO.h <FMD/AliFMDAltroIO.h>
+ @brief Class to read ALTRO formated raw data from an AliRawReader
+ object.
+ @code
+ AliRawReader* reader = new AliRawReaderFile(0);
+ AliFMDRawReader* fmdReader = new AliFMDRawReader(reader);
+ TClonesArray* array = new TClonesArray("AliFMDDigit");
+ fmdReader->ReadAdcs(array);
+ @endcode
+*/
class AliFMDAltroReader : public AliFMDAltroIO
{
public:
};
//____________________________________________________________________
+/** @class AliFMDAltroWriter AliFMDAltroIO.h <FMD/AliFMDAltroIO.h>
+ @brief Class to write ALTRO formated raw data from an array of
+ AliFMDDigit objects.
+ @code
+ AliFMDRawWriter* fmdWriter = new AliFMDRawWriter(0);
+ TClonesArray* array = fmd->DigitArray();
+ fmdWriter->WriteDigits(array);
+ @endcode
+ */
class AliFMDAltroWriter : public AliFMDAltroIO
{
public:
//_____________________________________________________________________________
AliFMDAltroMapping::AliFMDAltroMapping()
-{}
+{
+ // Constructor
+}
//_____________________________________________________________________________
Bool_t
AliFMDAltroMapping::ReadMapping()
{
+ // Read map from file - not used
return kTRUE;
}
//_____________________________________________________________________________
void
AliFMDAltroMapping::DeleteMappingArrays()
-{}
+{
+ // Clear map in memory
+}
//____________________________________________________________________
Bool_t
# include <TArrayI.h>
#endif
+//____________________________________________________________________
+/** @class AliFMDAltroMapping
+ @brief Class that encodes a map to/from ALTRO hardware address to
+ FMD detector coordinates.
+
+ The hardware address consist of a DDL number and 12bits of ALTRO
+ addresses. The ALTRO address are formatted as follows.
+ @verbatim
+ 12 7 4 0
+ |---------------|---------|------------|
+ | Board # | ALTRO # | Channel # |
+ +---------------+---------+------------+
+ @endverbatim
+
+ @ingroup FMD_base
+ */
class AliFMDAltroMapping : public AliAltroMapping
{
public:
+ /** Constructor */
AliFMDAltroMapping();
+ /** Map a hardware address into a detector index.
+ @param ddl Hardware DDL number
+ @param hwaddr Hardware address.
+ @param det On return, the detector #
+ @param ring On return, the ring ID
+ @param sec On return, the sector #
+ @param str On return, the strip #
+ @return @c true on success, false otherwise */
Bool_t Hardware2Detector(UInt_t ddl, UInt_t hwaddr,
UShort_t& det, Char_t& ring,
UShort_t& sec, UShort_t& str) const;
+ /** Map a detector index into a hardware address.
+ @param det The detector #
+ @param ring The ring ID
+ @param sec The sector #
+ @param str The strip #
+ @param ddl On return, hardware DDL number
+ @param hwaddr On return, hardware address.
+ @return @c true on success, false otherwise */
Bool_t Detector2Hardware(UShort_t det, Char_t ring,
UShort_t sec, UShort_t str,
UInt_t& ddl, UInt_t& hwaddr) const;
+ /** Here to take care of a a misspelling in base class
+ @param sector Sector number
+ @param str Strip number
+ @param ring Ring ID as an integer
+ @return Hardware address */
Int_t GetHWAdress(Int_t sector, Int_t str, Int_t ring) const
{
return GetHWAddress(sector, str, ring);
}
+ /** convert a partial detector index into a hardware address
+ @param sector Sector number
+ @param str Strip number
+ @param ring Ring ID as an integer
+ @return Hardware address */
Int_t GetHWAddress(Int_t sector, Int_t str, Int_t ring) const;
+ /** Get the pad-row (or sector) corresponding to hardware address
+ @param hwaddr hardware address
+ @return Sector number */
Int_t GetPadRow(Int_t hwaddr) const;
+ /** Get the pad (or strip) corresponding to hardware address
+ @param hwaddr hardware address
+ @return Strip number */
Int_t GetPad(Int_t hwaddr) const;
+ /** Get the sector (or ring) corresponding to hardware address
+ @param hwaddr hardware address
+ @return Ring ID as an integer */
Int_t GetSector(Int_t hwaddr) const;
protected:
+ /** Read map from file - not used
+ @return @c true on success */
virtual Bool_t ReadMapping();
+ /** Clear map in memory */
virtual void DeleteMappingArrays();
ClassDef(AliFMDAltroMapping, 1) // Read raw FMD Altro data
# include <AliFMDMap.h>
#endif
+/** @class AliFMDBoolMap
+ @brief MAp of per strip boolean values.
+ @ingroup FMD_base
+ */
class AliFMDBoolMap : public AliFMDMap
{
public:
+ /** Copy constructor
+ @param other Object to copy from. */
AliFMDBoolMap(const AliFMDBoolMap& other);
+ /** Constructor
+ @param maxDet Number of detectors (3)
+ @param maxRing Number of rings (2)
+ @param maxSec Number of sectors (40)
+ @param maxStr Number of strips (20) */
AliFMDBoolMap(size_t maxDet = kMaxDetectors,
size_t maxRing = kMaxRings,
size_t maxSec = kMaxSectors,
size_t maxStr = kMaxStrips);
+ /** Destructor */
virtual ~AliFMDBoolMap() { delete [] fData; }
+ /** Assignment operator
+ @param other Object to assign from
+ @return reference to this object. */
AliFMDBoolMap& operator=(const AliFMDBoolMap& other);
+ /** Reset to value
+ @param v Value to reset from */
virtual void Reset(const Bool_t& v=Bool_t());
+ /** Access operator
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @return reference value stored for the strip */
virtual Bool_t& operator()(UShort_t det,
Char_t ring,
UShort_t sec,
UShort_t str);
+ /** Access operator
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @return value stored for the strip */
virtual const Bool_t& operator()(UShort_t det,
Char_t ring,
UShort_t sec,
#endif
#include "AliFMDParameters.h" // ALIFMDPARAMETERS_H
+/** @class AliFMDCalibFaker
+ @brief Class to make fake calibration parameters.
+ @code
+ AliFMDCalibFaker f(0);
+ f.AddCalib(kPedestal);
+ f.AddCalib(kGain);
+ f.Exec();
+ @endcode
+ @ingroup FMD_util
+ */
class AliFMDCalibFaker : public TTask
{
public:
+ /** What to make */
enum EWhat {
+ /** Zero suppressio threshold */
kZeroSuppression = 1,
+ /** Sample rate */
kSampleRate,
+ /** Pedestals */
kPedestal,
+ /** Gain */
kPulseGain,
+ /** Dead map */
kDeadMap,
+ /** Hardware map */
kAltroMap
};
enum {
+ /** All parameters */
kAll = (1<<kZeroSuppression|1<<kSampleRate|1<<kPedestal|
1<<kPulseGain|1<<kDeadMap|1<<kAltroMap)
};
+ /** Constructor
+ @param mask Bit mask of what to make
+ @param loc Where to store the results */
AliFMDCalibFaker(Int_t mask=kAll, const char* loc="local://cdb");
+ /** Destructor */
virtual ~AliFMDCalibFaker() {}
+ /** Add a parameter to output
+ @param w Bit of parameter */
void AddCalib(EWhat w) { SETBIT(fMask, w); }
+ /** Remove a parameter from output
+ @param w Bit of parameter */
void RemoveCalib(EWhat w) { SETBIT(fMask, w); }
+ /** Set the bit mask of what to make
+ @param mask bit mask */
void SetCalib(Int_t mask) { fMask = mask; }
+ /** Set seed for random gain. The gain is distributed flatly from
+ 90 to 110 percent of the seed.
+ @param g Seed for gain */
void SetGainSeed(Float_t g) { fGain = g; }
+ /** Set the threshold factor. The actual threshold is the gain seed
+ times the factor
+ @param t Factor */
void SetThresholdFactor(Float_t t) { fThresholdFactor = t; }
+ /** Set the limits for the random pedestal. The pedestal values are
+ randomly distributed in the range
+ @param min Minimum of range
+ @param max Maximum of range */
void SetPedestalRange(Float_t min, Float_t max)
{
fPedestalMin = min;
fPedestalMax = (max < min ? min : max);
}
+ /** Set run validty range
+ @param min Minimum run number
+ @param max Maximum run number */
void SetRunRange(Int_t min, Int_t max)
{
fRunMin = min;
fRunMax = (max < min ? min : max);
}
+ /** Set the likelyness that a strip is dead.
+ @param chance Chance of dead channel. */
void SetDeadChance(Float_t chance) { fDeadChance = chance; }
+ /** Set Sample rate
+ @param rate Rate */
void SetRate(UShort_t rate) { fRate = rate; }
+ /** Set the zero suppression threshold
+ @param t Threshold (in ADC counts) */
void SetZeroThreshold(UShort_t t) { fZeroThreshold = t; }
+ /** Set the default output storage. It must be a CDB URL.
+ @param url CDB URL. */
void SetDefaultStorage(const char* url) { SetTitle(url); }
+ /** Make the fake calibration parameters
+ @param option Not used */
void Exec(Option_t* option="");
protected:
+ /** Make zero suppression parameters
+ @return Map of zero suppression */
virtual AliFMDCalibZeroSuppression* MakeZeroSuppression();
+ /** Make sample rate parameters
+ @return Map of sample rate */
virtual AliFMDCalibSampleRate* MakeSampleRate();
+ /** Make pedestal parameters
+ @return Map of pedestal */
virtual AliFMDCalibPedestal* MakePedestal();
+ /** Make gain parameters
+ @return Map of gain */
virtual AliFMDCalibGain* MakePulseGain();
+ /** Make dead channel parameters
+ @return Map of dead channel */
virtual AliFMDCalibDeadMap* MakeDeadMap();
+ /** Make a hardware map
+ @return hardware map */
virtual AliFMDAltroMapping* MakeAltroMap();
Long_t fMask; // What to write
# include <AliFMDFloatMap.h>
#endif
//____________________________________________________________________
-//
-// Gain value and width for each strip in the FMD
-//
+/** Gain value and width for each strip in the FMD
+ @ingroup FMD_base
+*/
class AliFMDCalibGain : public TObject
{
public:
+ /** Constructor */
AliFMDCalibGain();
+ /** Destructor */
~AliFMDCalibGain() {}
+ /** Copy constructor
+ @param o object to copy from */
AliFMDCalibGain(const AliFMDCalibGain& o);
+ /** Assignment operator
+ @param o Object to assign from */
AliFMDCalibGain& operator=(const AliFMDCalibGain& o);
+ /** Set the values for a strip.
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @param val Value of gain */
void Set(UShort_t det, Char_t ring, UShort_t sec, UShort_t str, Float_t val);
+ /** Set the global threshold
+ @param thres Threshold */
void Set(Float_t thres) { fThreshold = thres; }
+ /** Get gain for a strip.
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @param val Value of gain
+ @return Gain for strip */
Float_t Value(UShort_t det, Char_t ring, UShort_t sec, UShort_t str);
+ /** @return threshold */
Float_t Threshold() const { return fThreshold; }
private:
- AliFMDFloatMap fValue;
- Float_t fThreshold;
+ AliFMDFloatMap fValue; // Map
+ Float_t fThreshold; // Global threshold
ClassDef(AliFMDCalibGain, 1) // Gain data for the FMD
};
# include <AliFMDFloatMap.h>
#endif
//____________________________________________________________________
-//
-// Pedestal value and width for each strip in the FMD
-//
+/** Pedestal value and width for each strip in the FMD
+ @ingroup FMD_base
+*/
class AliFMDCalibPedestal : public TObject
{
public:
+ /** CTOR */
AliFMDCalibPedestal();
+ /** DTOR */
~AliFMDCalibPedestal() {}
+ /** Copy ctor
+ @param o Object to copy from */
AliFMDCalibPedestal(const AliFMDCalibPedestal& o);
+ /** Assignment
+ @param o Object to assign from
+ @return Reference to this object */
AliFMDCalibPedestal& operator=(const AliFMDCalibPedestal& o);
+ /** Set the values for a strip.
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @param ped Value of pedestal
+ @param pedW Width of pedestal */
void Set(UShort_t det, Char_t ring, UShort_t sec, UShort_t str,
Float_t ped, Float_t pedW);
+ /** Get pedestal for a strip.
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @param val Value of gain
+ @return Pedestal for strip */
Float_t Value(UShort_t det, Char_t ring, UShort_t sec, UShort_t str);
+ /** Get pedestal width for a strip.
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @param val Value of gain
+ @return Pedestal width for strip */
Float_t Width(UShort_t det, Char_t ring, UShort_t sec, UShort_t str);
private:
- AliFMDFloatMap fValue;
- AliFMDFloatMap fWidth;
+ AliFMDFloatMap fValue; /** Pedestal */
+ AliFMDFloatMap fWidth; /** Pedestal width */
ClassDef(AliFMDCalibPedestal, 1) // Pedestal data for the FMD
};
# include <TArrayI.h>
#endif
//____________________________________________________________________
-//
-// Gain value and width for each strip in the FMD
-//
+/** Gain value and width for each strip in the FMD
+ @ingroup FMD_base
+*/
class AliFMDCalibSampleRate : public TObject
{
public:
+ /** CTOR */
AliFMDCalibSampleRate();
+ /** Copy CTOR
+ @param o Object to copy from */
AliFMDCalibSampleRate(const AliFMDCalibSampleRate& o);
+ /** Assignment operator
+ @param o Object to assign from
+ @return Reference to assign from */
AliFMDCalibSampleRate& operator=(const AliFMDCalibSampleRate& o);
+ /** Set sample for a DDL
+ @param ddl DDL (detector)
+ @param rate Sample rate */
void Set(UShort_t ddl, UShort_t rate);
+ /** Get sample rate for a detector
+ @param ddl Detector (DDL) identifier
+ @return Sample rate */
UShort_t Rate(UShort_t ddl) const;
protected:
TArrayI fRates; // Sample rates
class AliFMDRing;
class TGeoMatrix;
-
+/** @defgroup FMD_base Basic classes */
//__________________________________________________________________
/** Base class for the geometry description and parameters of the FMD
sub detectors FMD1, FMD2, and FMD3.
This class hold common parameters of the specific FMD detectors.
+ @ingroup FMD_base
*/
class AliFMDDetector : public TNamed
{
public:
+ /** Constructor
+ @param id Detector number
+ @param inner Pointer to inner ring geometry
+ @param outer Pointer to inner outer geometry
+ @return */
AliFMDDetector(Int_t id, AliFMDRing* inner, AliFMDRing* outer);
+ /** Copy CTOR
+ @param other Object to copy from. */
AliFMDDetector(const AliFMDDetector& other);
+ /** Assignment operator
+ @param other Object to assign from
+ @return reference to this object */
AliFMDDetector& operator=(const AliFMDDetector& other);
virtual ~AliFMDDetector() {}
/** Initialize the geometry */
@return Z position of ring or 0 on failure */
Double_t GetRingZ(Char_t id) const;
+ /** Translate detector coordinates (detector, ring, sector, strip)
+ to spatial coordinates (x, y, z) in the master reference frame
+ of ALICE. The member function uses the transformations
+ previously obtained from the TGeoManager.
+ @param ring Ring id
+ @param sector Sector number
+ @param strip Strip number
+ @param x On return, X coordinate
+ @param y On return, Y coordinate
+ @param z On return, Z coordinate */
void Detector2XYZ(Char_t ring, UShort_t sector, UShort_t strip,
Double_t& x, Double_t& y, Double_t& z) const;
+ /** Translate spatial coordinates (x,y,z) in the master reference
+ frame of ALICE to the detector coordinates (detector, ring,
+ sector, strip). Note, that if this method is to be used in
+ reconstruction or the like, then the input z-coordinate should
+ be corrected for the events interactions points z-coordinate,
+ like
+ @code
+ geom->XYZ2Detector(x,y,z-ipz,d,r,s,t);
+ @endverbatim
+ @param x X coordinate
+ @param y Y coordinate
+ @param z Z coordinate
+ @param ring On return, Ring id
+ @param sector On return, Sector number
+ @param strip On return, Strip number
+ @return @c false of (@a x, @a y, @a z) is not within this
+ detector. */
Bool_t XYZ2Detector(Double_t x, Double_t y, Double_t z,
Char_t& ring, UShort_t& sector, UShort_t& strip) const;
protected:
+ /** Check if we have all transformations for a ring
+ @param ring Ring to check for
+ @return @c true if we got all transforms */
Bool_t HasAllTransforms(Char_t ring) const;
+ /** Get transformation matrix for a sector in a ring
+ @param ring Ring id
+ @param sector Sector numberr
+ @return Matrix on success, 0 otherwise */
TGeoMatrix* FindTransform(Char_t ring, UShort_t sector) const;
Int_t fId; // Detector number
Double_t fInnerZ; // Position of outer ring along z
Double_t fOuterHoneyHighR; // Outer radius of outer honeycomb
AliFMDRing* fInner; // Pointer to inner ring information
AliFMDRing* fOuter; // Pointer to outer ring information
- TObjArray* fInnerTransforms; // List of inner module <-> global
- TObjArray* fOuterTransforms; // List of outer module <-> global
+ TObjArray* fInnerTransforms; // List of inner module global
+ TObjArray* fOuterTransforms; // List of outer module global
ClassDef(AliFMDDetector, 1); //
};
#endif
//____________________________________________________________________
+/** @class AliFMDBaseDigit AliFMDDigit.h <FMD/AliFMDDigit.h>
+ @brief base class for digits
+ @ingroup FMD_base
+ */
class AliFMDBaseDigit : public TObject
{
public:
+ /** CTOR */
AliFMDBaseDigit();
+ /** Constrctor
+ @param detector Detector
+ @param ring Ring
+ @param sector Sector
+ @param strip Strip */
AliFMDBaseDigit(UShort_t detector,
Char_t ring='\0',
UShort_t sector=0,
UShort_t strip=0);
+ /** DTOR */
virtual ~AliFMDBaseDigit() {}
+ /** @return Detector # */
UShort_t Detector() const { return fDetector; }
+ /** @return Ring ID */
Char_t Ring() const { return fRing; }
+ /** @return sector # */
UShort_t Sector() const { return fSector; }
+ /** @return strip # */
UShort_t Strip() const { return fStrip; }
+ /** Print information
+ @param opt Not used */
virtual void Print(Option_t* opt="") const;
+ /** @return Name */
const char* GetName() const;
protected:
UShort_t fDetector; // (Sub) Detector # (1,2, or 3)
};
//____________________________________________________________________
+/** @class AliFMDDigit AliFMDDigit.h <FMD/AliFMDDigit.h>
+ @brief class for digits
+ @ingroup FMD_base
+ */
class AliFMDDigit : public AliFMDBaseDigit
{
public:
+ /** CTOR */
AliFMDDigit();
+ /** Constrctor
+ @param detector Detector
+ @param ring Ring
+ @param sector Sector
+ @param strip Strip
+ @param count1 ADC (first sample)
+ @param count2 ADC (second sample, or -1 if not used)
+ @param count3 ADC (third sample, or -1 if not used) */
AliFMDDigit(UShort_t detector,
Char_t ring='\0',
UShort_t sector=0,
UShort_t count=0,
Short_t count2=-1,
Short_t count3=-1);
+ /** DTOR */
virtual ~AliFMDDigit() {}
+ /** @return ADC count (first sample) */
UShort_t Count1() const { return fCount1; }
+ /** @return ADC count (second sample, or -1 if not used) */
Short_t Count2() const { return fCount2; }
+ /** @return ADC count (third sample, or -1 if not used) */
Short_t Count3() const { return fCount3; }
+ /** @return Canonical ADC counts */
UShort_t Counts() const;
+ /** Print info
+ @param opt Not used */
void Print(Option_t* opt="") const;
+ /** @return Title */
const char* GetTitle() const;
protected:
UShort_t fCount1; // Digital signal
}
//____________________________________________________________________
+/** @class AliFMDSDigit AliFMDDigit.h <FMD/AliFMDDigit.h>
+ @brief class for summable digits
+ @ingroup FMD_base
+ */
class AliFMDSDigit : public AliFMDBaseDigit
{
public:
+ /** CTOR */
AliFMDSDigit();
+ /** Constrctor
+ @param detector Detector
+ @param ring Ring
+ @param sector Sector
+ @param strip Strip
+ @param count1 ADC (first sample)
+ @param count2 ADC (second sample, or -1 if not used)
+ @param count3 ADC (third sample, or -1 if not used) */
AliFMDSDigit(UShort_t detector,
Char_t ring='\0',
UShort_t sector=0,
UShort_t count=0,
Short_t count2=-1,
Short_t count3=-1);
+ /** DTOR */
virtual ~AliFMDSDigit() {}
+ /** @return ADC count (first sample) */
UShort_t Count1() const { return fCount1; }
+ /** @return ADC count (second sample, or -1 if not used) */
Short_t Count2() const { return fCount2; }
+ /** @return ADC count (third sample, or -1 if not used) */
Short_t Count3() const { return fCount3; }
- Float_t Edep() const { return fEdep; }
+ /** @return Canonical ADC counts */
UShort_t Counts() const;
+ /** @return Energy deposited */
+ Float_t Edep() const { return fEdep; }
+ /** Print info
+ @param opt Not used */
void Print(Option_t* opt="") const;
protected:
Float_t fEdep; // Energy deposited
//====================================================================
+/** @class AliFMDBaseDigitizer AliFMDDigitizer.h <FMD/AliFMDDigitizer>
+ @brief Base class for digitizers.
+
+ This class contains the procedures simulation ADC signal for the
+ Forward Multiplicity detector : Hits->Digits and Hits->SDigits
+
+ Digits consists of
+ - Detector #
+ - Ring ID
+ - Sector #
+ - Strip #
+ - ADC count in this channel
+
+ Summable digits consists of
+ - Detector #
+ - Ring ID
+ - Sector #
+ - Strip #
+ - Total energy deposited in the strip
+ - ADC count in this channel
+
+ As the Digits and SDigits have so much in common, the classes
+ AliFMDDigitizer and AliFMDSDigitizer are implemented via a base
+ class AliFMDBaseDigitizer.
+ @verbatim
+ +---------------------+
+ | AliFMDBaseDigitizer |
+ +---------------------+
+ ^
+ |
+ +----------+---------+
+ | |
+ +-----------------+ +------------------+
+ | AliFMDDigitizer | | AliFMDSDigitizer |
+ +-----------------+ +------------------+
+ @endverbatim
+ These classes uses parameters fetched from the AliFMDParameters
+ manager.
+
+ The shaping function of the VA1 is generally given by
+ @f[
+ f(x) = A(1 - \exp(-Bx))
+ @f]
+ where A is the total charge collected in the pre-amp., and B is a
+ paramter that depends on the shaping time of the VA1 circut.
+
+ When simulating the shaping function of the VA1 pre-amp. chip, we
+ have to take into account, that the shaping function depends on
+ the previous value of read from the pre-amp.
+
+ That results in the following algorithm:
+ @code
+ last = 0;
+ for (i=0; i < n_pre_amp_charge; i++) {
+ charge = GetCharge(i);
+ if (last < charge)
+ f(t) = (charge - last) * (1 - exp(-B * t)) + last
+ else
+ f(t) = (last - charge) * exp(-B * t) + charge)
+ for (j=0; j < sample_rate; j++)
+ adc[j] = f(i / (# samples))
+ last = charge
+ }
+ @endcode
+ Here, the first loop is over all charges collected by the VA1
+ chip, and the @c sample_rate is how many times the ALTRO ADC
+ samples each of the 128 charges from the pre-amp.
+
+ The @c charge is the total charge @f$ Q@f$ collected by the VA1
+ pre-amplifier for a strip. @f$ Q@f$ is then given by
+ @f[
+ Q = \frac{E}{e}\frac{S}{r}
+ @f]
+ where @f$ E@f$ is the total energy deposited in a silicon strip,
+ @f$ R@f$ is the dynamic range of the VA1 pre-amp, @f$ e@f$ is the
+ energy deposited by a single MIP, and @f$ S@f$ ALTRO channel size
+ in each time step.
+
+ The energy deposited per MIP is given by
+ @f$
+ e = M \rho w
+ @f$
+ where @f$ M@f$ is the universal number
+ @f$ 1.664 \mbox{keV}\mbox{cm}^{2}\mbox{g}^{-1}@f$, @f$ \rho@f$ is
+ the density of silicon, and @f$ w@f$ is the depth of the silicon
+ sensor.
+
+ The final ADC count is given by
+ @f[
+ C' = C + P
+ @f]
+ where @f$ P@f$ is the (randomized) pedestal.
+
+ This class uses the class template AliFMDEdepMap to make an
+ internal cache of the energy deposted of the hits. The class
+ template is instantasized as
+
+ The first member of the values is the summed energy deposition in a
+ given strip, while the second member of the values is the number of
+ hits in a given strip. Using the second member, it's possible to
+ do some checks on just how many times a strip got hit, and what
+ kind of error we get in our reconstructed hits. Note, that this
+ information is currently not written to the digits tree. I think a
+ QA (Quality Assurance) digit tree is better suited for that task.
+ However, the information is there to be used in the future.
+ @ingroup FMD_sim
+ */
class AliFMDBaseDigitizer : public AliDigitizer
{
public:
+ /** CTOR */
AliFMDBaseDigitizer();
+ /** Normal CTOR
+ @param manager Manager of digitization */
AliFMDBaseDigitizer(AliRunDigitizer * manager);
+ /** Normal ctor
+ @param name Name
+ @param title Title */
AliFMDBaseDigitizer(const Char_t* name, const Char_t* title);
+ /** DTOR */
virtual ~AliFMDBaseDigitizer();
- // Do the main work
+ /** Initialize */
virtual Bool_t Init();
- // Extra member functions
- void SetShapingTime(Float_t t=10) { fShapingTime = t; }
+ /** The response shape of the VA1 shaping circuit is approximently
+ given by
+ @f[
+ f(x) = A(1 - \exp(-Bx))
+ @f]
+ where @f$ A@f$ is the total charge collected by the pre-amp.,
+ and @f$ B@f$ is parameter that depends on the shaping time of
+ the @b VA1 pre-amp. This member function sets the parameter @f$
+ B@f$
+ @param B */
+ void SetShapingTime(Float_t B=10) { fShapingTime = B; }
+ /** @return Get the shaping time */
Float_t GetShapingTime() const { return fShapingTime; }
protected:
+ /** Sum energy deposited contributions from each hit in a cache
+ @param fmd Pointer to detector */
virtual void SumContributions(AliFMD* fmd);
+ /** For the stored energy contributions in the cache, convert the
+ energy signal to ADC counts, and store the created digit in
+ the digits array
+ @param fmd Pointer to detector */
virtual void DigitizeHits(AliFMD* fmd) const;
+ /** Convert the total energy deposited to a (set of) ADC count(s).
+ See also the class description for more details.
+ @param edep Total energy deposited in detector
+ @param last Last charge collected in previous VA1 channnel
+ @param detector Detector #
+ @param ring Ring ID
+ @param sector Sector #
+ @param strip Strip #
+ @param counts Array holding the counts on return */
virtual void ConvertToCount(Float_t edep,
Float_t last,
UShort_t detector,
UShort_t sector,
UShort_t strip,
TArrayI& counts) const;
+ /** Make a pedestal
+ @param detector Detector #
+ @param ring Ring ID
+ @param sector Sector #
+ @param strip Strip #
+ @return Pedestal value */
virtual UShort_t MakePedestal(UShort_t detector,
Char_t ring,
UShort_t sector,
UShort_t strip) const;
+ /** Add noise to each sample */
virtual void AddNoise(TArrayI&) const {}
+ /** Add a digit to output */
virtual void AddDigit(AliFMD* /* fmd */,
UShort_t /* detector */,
Char_t /* ring */,
AliFMDEdepMap fEdep; // Cache of Energy from hits
Float_t fShapingTime; // Shaping profile parameter
+ /** Copy CTOR
+ @param o object to copy from */
AliFMDBaseDigitizer(const AliFMDBaseDigitizer& o)
: AliDigitizer(o) {}
+ /** Assignment operator
+ @return Reference to this object */
AliFMDBaseDigitizer& operator=(const AliFMDBaseDigitizer&) { return *this; }
ClassDef(AliFMDBaseDigitizer,2) // Base class for FMD digitizers
};
//====================================================================
+/** @class AliFMDDigitizer
+ @brief Concrete digitizer to make digits from hits. See also
+ AliFMDBaseDigitizer documentation.
+ @ingroup FMD_sim
+ */
class AliFMDDigitizer : public AliFMDBaseDigitizer
{
public:
+ /** CTOR */
AliFMDDigitizer();
+ /** CTOR
+ @param manager Manager of digitization */
AliFMDDigitizer(AliRunDigitizer * manager);
+ /** DTOR */
virtual ~AliFMDDigitizer() {}
+ /** Do everything
+ @param option Not used */
virtual void Exec(Option_t* option=0);
protected:
+ /** Add a digit to output.
+ @param fmd Pointer to detector object
+ @param detector Detector #
+ @param ring Ring ID
+ @param sector Sector number
+ @param strip Strip number
+ @param edep Energy deposited (not used)
+ @param count1 ADC count 1
+ @param count2 ADC count 2 (-1 if not used)
+ @param count3 ADC count 3 (-1 if not used) */
virtual void AddDigit(AliFMD* fmd,
UShort_t detector,
Char_t ring,
UShort_t count1,
Short_t count2,
Short_t count3) const;
+ /** MAke a pedestal
+ @param detector Detector #
+ @param ring Ring ID
+ @param sector Sector number
+ @param strip Strip number
+ @return Random noise */
virtual UShort_t MakePedestal(UShort_t detector,
Char_t ring,
UShort_t sector,
UShort_t strip) const;
+ /** Check that digit data is consistent
+ @param digit Digit
+ @param nhits Number of hits
+ @param counts ADC counts */
virtual void CheckDigit(AliFMDDigit* digit,
UShort_t nhits,
const TArrayI& counts);
};
//====================================================================
+/** @class AliFMDSDigitizer AliFMDDigitizer.h <FMD/AliFMDDigitizer.h>
+ @brief Concrete implementation to make summable digits.
+ See also class documentation of AliFMDBaseDigitizer
+ @ingroup FMD_sim
+ */
class AliFMDSDigitizer : public AliFMDBaseDigitizer
{
public:
+ /** CTOR */
AliFMDSDigitizer();
+ /** CTOR
+ @param headerFile Where to write headings
+ @param sdigFile Where to write digits. */
AliFMDSDigitizer(const Char_t* headerFile, const Char_t* sdigFile="");
+ /** DTOR */
virtual ~AliFMDSDigitizer();
+ /** Do it all
+ @param option Not used */
virtual void Exec(Option_t* option=0);
protected:
+ /** Add a digit to output.
+ @param fmd Pointer to detector object
+ @param detector Detector #
+ @param ring Ring ID
+ @param sector Sector number
+ @param strip Strip number
+ @param edep Energy deposited (not used)
+ @param count1 ADC count 1
+ @param count2 ADC count 2 (-1 if not used)
+ @param count3 ADC count 3 (-1 if not used) */
virtual void AddDigit(AliFMD* fmd,
UShort_t detector,
Char_t ring,
class TButton;
//___________________________________________________________________
+/** @class AliFMDDisplay
+ @brief Utility class to visualize FMD data in geometry.
+ @ingroup FMD_util
+ */
class AliFMDDisplay : public AliFMDInput
{
public:
+ /** Constructor
+ @param gAliceFile galice file*/
AliFMDDisplay(const char* gAliceFile="galice.root");
+ /** DTOR */
virtual ~AliFMDDisplay() {}
+ /** Singleton access function
+ @return Singleton object. */
static AliFMDDisplay* Instance();
+ /** Continue to next event */
void Continue() { fWait = kFALSE; }
+ /** Zoom mode */
void Zoom() { fZoomMode = kTRUE; }
+ /** Pick mode */
void Pick() { fZoomMode = kFALSE; }
+ /** Called when a mouse or similar event happens in the display.
+ @param event Event type
+ @param px where the event happened in pixels along X
+ @param py where the event happened in pixels along Y */
void ExecuteEvent(Int_t event, Int_t px, Int_t py);
+ /** Calculate distance from point @f$ (p_x,p_y)@f$ to this object.
+ @param px Pixel X coordinate
+ @param py Pixel Y coordinate
+ @return distance. */
Int_t DistancetoPrimitive(Int_t px, Int_t py);
+ /** Paint into canvas
+ @param option Not used */
void Paint(Option_t* option="") { (void)option; }
+ /** Initialize
+ @return @c false on error */
virtual Bool_t Init();
+ /** Called at beginning of an event
+ @param event Event number
+ @return @c false on error */
virtual Bool_t Begin(Int_t event);
+ /** Called at end of an event
+ @return @c false on error */
virtual Bool_t End();
+ /** Visualize a hit
+ @param hit Hit
+ @param p Track
+ @return @c false on error */
virtual Bool_t ProcessHit(AliFMDHit* hit, TParticle* p);
+ /** Visualize a digit
+ @param digit Digit to draw
+ @return @c false on error */
virtual Bool_t ProcessDigit(AliFMDDigit* digit);
+ /** Visualize a raw digit
+ @param digit Raw digit.
+ @return @c false on error */
virtual Bool_t ProcessRaw(AliFMDDigit* digit);
+ /** Visualize a reconstructed point.
+ @param recpoint Reconstructed point
+ @return @c false on error */
virtual Bool_t ProcessRecPoint(AliFMDRecPoint* recpoint);
+ /** Look up a color index, based on the value @a x and the maximum
+ value of @a x
+ @param x Value
+ @param max Maximum (for example 1023 for digits)
+ @return @c false on error */
virtual Int_t LookupColor(Float_t x, Float_t max) const;
protected:
static AliFMDDisplay* fgInstance; // Static instance
# include "AliFMDMap.h"
#endif
//____________________________________________________________________
-//
-// Cache of Energy deposited, hit information per strip.
-// Contains a pair of fEdep and fN
-// fEdep is the summed energy deposition, and fN is the number of hits
-//
-
-//____________________________________________________________________
+/** Cache of Energy deposited, hit information per strip.
+ Contains a pair of energy deposited @c fEdep and
+ number of hits @c fN, @c fEdep is the summed energy deposition,
+ and @c fN is the number of hits
+ @ingroup FMD_sim
+*/
class AliFMDEdepHitPair
{
public:
Float_t fEdep; // summed energy deposition
UShort_t fN; // Number of hits
+ /** CTOR */
AliFMDEdepHitPair() : fEdep(0), fN(0) {}
+ /** DTOR */
+ virtual ~AliFMDEdepHitPair() {}
+ /** Assignment operator
+ @param o Object to assign from
+ @return Reference to this object */
AliFMDEdepHitPair& operator=(const AliFMDEdepHitPair& o)
{ fEdep = o.fEdep; fN = o.fN; return *this; }
+ /** Copy CTOR
+ @param o Object to copy from */
AliFMDEdepHitPair(const AliFMDEdepHitPair& o) : fEdep(o.fEdep), fN(o.fN) {}
+ ClassDef(AliFMDEdepHitPair, 1)
};
//____________________________________________________________________
+/** Map of Energy deposited, hit information per strip.
+ Contains a pair of energy deposited @c fEdep and
+ number of hits @c fN, @c fEdep is the summed energy deposition,
+ and @c fN is the number of hits */
class AliFMDEdepMap : public AliFMDMap
{
public:
+ /** Copy constructor
+ @param other Object to copy from.
+ @return */
AliFMDEdepMap(const AliFMDEdepMap& other);
+ /** Constructor
+ @param maxDet Number of detectors (3)
+ @param maxRing Number of rings (2)
+ @param maxSec Number of sectors (40)
+ @param maxStr Number of strips (20) */
AliFMDEdepMap(size_t maxDet = kMaxDetectors,
size_t maxRing= kMaxRings,
size_t maxSec = kMaxSectors,
size_t maxStr = kMaxStrips);
+ /** DTOR */
virtual ~AliFMDEdepMap() { delete [] fData; }
AliFMDEdepMap& operator=(const AliFMDEdepMap& other);
+ /** Reset to default */
virtual void Reset();
+ /** Reset to value
+ @param v Value to reset from */
virtual void Reset(const AliFMDEdepHitPair& val);
+ /** Access operator
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @return reference value stored for the strip */
virtual AliFMDEdepHitPair& operator()(UShort_t detector,
Char_t ring,
UShort_t sector,
UShort_t strip);
+ /** Access operator
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @return value stored for the strip */
virtual const AliFMDEdepHitPair& operator()(UShort_t detector,
Char_t ring,
UShort_t sector,
UShort_t strip) const;
protected:
- size_t fTotal; //
+ size_t fTotal; // Total number of entries
AliFMDEdepHitPair* fData; //[fTotal] The data
ClassDef(AliFMDEdepMap, 2) // Cache of edep,hit information per strip
};
//__________________________________________________________________
/** Singleton object of FMD geometry descriptions and parameters.
+ This class is a singleton that handles the geometry parameters of
+ the FMD detectors.
+
+ The actual code is done by various separate classes. Below is
+ diagram showing the relationship between the various FMD classes
+ that handles the geometry
+ @verbatim
+ +------------+
+ +- | AliFMDRing |
+ 2 | +------------+
+ +----------------+<>--+ |
+ | AliFMDGeometry | ^
+ +----------------+<>--+ V 1..2
+ 3 | +----------------+
+ +-| AliFMDDetector |
+ +----------------+
+ ^
+ |
+ +-------------+-------------+
+ | | |
+ +---------+ +---------+ +---------+
+ | AliFMD1 | | AliFMD2 | | AliFMD3 |
+ +---------+ +---------+ +---------+
+
+ @endverbatim
+ - AliFMDRing
+ This class contains all stuff needed to do with a ring. It's
+ used by the AliFMDDetector objects to instantise inner and
+ outer rings. The AliFMDRing objects are shared by the
+ AliFMDDetector objects, and owned by the AliFMDv1 object.
+ - AliFMD1, AliFMD2, and AliFMD3
+ These are specialisation of AliFMDDetector, that contains the
+ particularities of each of the sub-detector system. It is
+ envisioned that the classes should also define the support
+ volumes and material for each of the detectors.
+
+ @ingroup FMD_base
*/
class AliFMDGeometry : public AliGeometry
{
public:
+ /** @return Singleton */
static AliFMDGeometry* Instance();
+ /** Initialize */
virtual void Init();
+ /** Initialize transforms */
virtual void InitTransformations();
+ /** @return Get inner description */
AliFMDRing* GetInner() const { return fInner; }
+ /** @return Get outer description */
AliFMDRing* GetOuter() const { return fOuter; }
+ /** @return Get FMD1 description */
AliFMD1* GetFMD1() const { return (fUseFMD1 ? fFMD1 : 0); }
+ /** @return Get FMD2 description */
AliFMD2* GetFMD2() const { return (fUseFMD2 ? fFMD2 : 0); }
+ /** @return Get FMD3 description */
AliFMD3* GetFMD3() const { return (fUseFMD3 ? fFMD3 : 0); }
+ /** Get description of a sub-detector
+ @param i Sub-detector #
+ @return Description of sub-detector, or 0 */
AliFMDDetector* GetDetector(Int_t i) const;
+ /** Get description of a ring
+ @param i Ring id
+ @return Description of ring, or 0 */
AliFMDRing* GetRing(Char_t i) const;
+ /** @param i IF true, disable sub-detector @a i */
void Disable(Int_t i);
+ /** @param i IF true, enable sub-detector @a i */
void Enable(Int_t i);
+ /** @return Density @f$ \rho@f$ of silicon */
Double_t GetSiDensity() const { return 2.33; }
+ /** Translate detector coordinates (detector, ring, sector, strip)
+ to spatial coordinates (x, y, z) in the master reference frame
+ of ALICE. The member function uses the transformations
+ previously obtained from the TGeoManager.
+ @param detector Detector number
+ @param ring Ring id
+ @param sector Sector number
+ @param strip Strip number
+ @param x On return, X coordinate
+ @param y On return, Y coordinate
+ @param z On return, Z coordinate */
void Detector2XYZ(UShort_t detector, Char_t ring,
UShort_t sector, UShort_t strip,
Double_t& x, Double_t& y, Double_t& z) const;
+ /** Translate spatial coordinates (x,y,z) in the master reference
+ frame of ALICE to the detector coordinates (detector, ring,
+ sector, strip). Note, that if this method is to be used in
+ reconstruction or the like, then the input z-coordinate should
+ be corrected for the events interactions points z-coordinate,
+ like
+ @code
+ geom->XYZ2Detector(x,y,z-ipz,d,r,s,t);
+ @endverbatim
+ @param x X coordinate
+ @param y Y coordinate
+ @param z Z coordinate
+ @param detector On return, Detector number
+ @param ring On return, Ring id
+ @param sector On return, Sector number
+ @param strip On return, Strip number
+ @return @c false of (@a x, @a y, @a z) is not within this
+ detector. */
Bool_t XYZ2Detector(Double_t x, Double_t y, Double_t z,
UShort_t& detector, Char_t& ring,
UShort_t& sector, UShort_t& strip) const;
+ /** Make the geometry. This delegates to AliFMDGeometryBuilder */
void Build();
+ /** @return Get detector offset in paths */
Int_t GetDetectorOff() const { return fDetectorOff; }
+ /** @return Get sensor offset in paths */
Int_t GetModuleOff() const { return fModuleOff; }
+ /** @return Get ring offset in paths */
Int_t GetRingOff() const { return fRingOff; }
+ /** @return Get ring sector in paths */
Int_t GetSectorOff() const { return fSectorOff; }
+ /** @param off Detector off-set set in geometry path */
void SetDetectorOff(Int_t off) { fDetectorOff = off; }
+ /** @param off Module off-set set in geometry path */
void SetModuleOff(Int_t off) { fModuleOff = off; }
+ /** @param off Ring off-set set in geometry path */
void SetRingOff(Int_t off) { fRingOff = off; }
+ /** @param off Sectord off-set set in geometry path */
void SetSectorOff(Int_t off) { fSectorOff = off; }
+ /** Check if volume @a vol is marked as active
+ @param vol Volume ID
+ @return @c true if @a vol is declared active */
Bool_t IsActive(Int_t vol) const;
+ /** Set active volumes
+ @param active Active volume id array
+ @param n elements of @a active */
void SetActive(Int_t* active, Int_t n);
+ /** @param id Register volume @a id to be active */
void AddActive(Int_t id);
+ /** Set an external geometry builder
+ @param b Geometry builder */
void SetBuilder(AliFMDGeometryBuilder* b) { fBuilder = b; }
+ /** Extract informaton from TGeoManager */
void ExtractGeomInfo();
+ /** Whether we are to use a detailed geometry or not
+ @param det if @c true, make a detailed geometry. */
void SetDetailed(Bool_t det) { fDetailed = det; }
+ /** @return @c true if geometry is detailed */
Bool_t IsDetailed() const { return fDetailed; }
+ /** @param ass Whether to use assemblies or not */
void UseAssembly(Bool_t ass) { fUseAssembly = ass; }
// AliGeometry member functions
+ /** Get global coordinates cooresponding to a rec point.
+ @param p Reconstructed point.
+ @param pos On return, the position
+ @param mat On return, the material at @a post */
virtual void GetGlobal(const AliRecPoint* p, TVector3& pos,
TMatrixF& mat) const;
+ /** Get global coordinates cooresponding to a rec point.
+ @param p Reconstructed point.
+ @param pos On return, the position */
virtual void GetGlobal(const AliRecPoint* p, TVector3& pos) const;
+ /** Check if particle will hit an active detector element. Note
+ done yet.
+ @param particle Track
+ @return @c true if @a particle will hit this detector */
virtual Bool_t Impact(const TParticle* particle) const;
protected:
Bool_t fIsInitialized; // Whether singleton is initalized
Bool_t fUseFMD2; // Wheter to Use FMD2 or not
Bool_t fUseFMD3; // Wheter to Use FMD3 or not
static AliFMDGeometry* fgInstance; // Singleton instance
+ /** CTOR */
AliFMDGeometry();
+ /** Copy CTOR
+ @param other To copy from */
AliFMDGeometry(const AliFMDGeometry& other);
+ /** Assignment operator
+ @param other To assig from
+ @return reference to this. */
AliFMDGeometry& operator=(const AliFMDGeometry& other);
virtual ~AliFMDGeometry() {}
// Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
// which has 1 or 2 rings of silicon sensors.
//
-// This is the base class for all FMD manager classes.
-//
-// The actual code is done by various separate classes. Below is
-// diagram showing the relationship between the various FMD classes
-// that handles the simulation
-//
-// +--------+ 1 +-----------------+
-// | AliFMD |<>-----| AliFMDGeometryBuilder |
-// +--------+ +-----------------+
-// ^
-// |
-// +-------------+-------------+
-// | |
-// +--------------------+ +-------------------+
-// | AliFMDGeometryBuilder | | AliFMDG3Simulator |
-// +--------------------+ +---------+---------+
-// ^
-// |
-// +--------------------+
-// | AliFMDOldSimulator |
-// +--------------------+
-//
-// * AliFMD
-// This defines the interface for the various parts of AliROOT that
-// uses the FMD, like AliFMDGeometryBuilder, AliFMDDigitizer,
-// AliFMDReconstructor, and so on.
-//
-// * AliFMDGeometryBuilder
-// This is the base class for the FMD simulation tasks. The
-// simulator tasks are responsible to implment the geoemtry, and
-// process hits.
-//
-// * AliFMDGeometryBuilder
-// This is a concrete implementation of the AliFMDGeometryBuilder that
-// uses the TGeo classes directly only. This defines the active
-// volume as an ONLY XTRU shape with a divided MANY TUBS shape
-// inside to implement the particular shape of the silicon
-// sensors.
-//
-// * AliFMDG3Simulator
-// This is a concrete implementation of the AliFMDGeometryBuilder that
-// uses the TVirtualMC interface with GEANT 3.21-like messages.
-// This implements the active volume as a divided TUBS shape. Hits
-// in the corners should be cut away at run time (but currently
-// isn't).
-//
-// * AliFMDOldSimulator
-// This is a concrete implementation of AliFMDGeometryBuilder. It
-// approximates the of the rings as segmented disks.
//
#include "AliFMDGeometryBuilder.h" // ALIFMDGEOSIMULATOR_H
#include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
class AliFMD3;
//____________________________________________________________________
+/** @class AliFMDGeometryBuilder
+ @brief Builder of FMD geometry.
+ This class takes care of actually building the geometry using the
+ @b TGeo classes. Various parameters are fecthed from the
+ AliFMDGeometry manager.
+ @ingroup FMD_sim
+ */
class AliFMDGeometryBuilder : public TTask
{
public:
- AliFMDGeometryBuilder();
/** CTOR */
+ AliFMDGeometryBuilder();
+ /** CTOR
+ @param detailed Whether to make a detailed geometry. */
AliFMDGeometryBuilder(Bool_t detailed);
virtual ~AliFMDGeometryBuilder() {}
/** Register */
*/
//___________________________________________________________________
//
-// AliFMDhit is the hit class for the FMD. Hits are the information
-// that comes from a Monte Carlo at each step as a particle mass
-// through sensitive detector elements as particles are transported
-// through a detector.
-//
#ifndef ALIHIT_H
# include <AliHit.h>
#endif
//___________________________________________________________________
+/** AliFMDhit is the hit class for the FMD. Hits are the information
+ that comes from a Monte Carlo at each step as a particle mass
+ through sensitive detector elements as particles are transported
+ through a detector.
+ @ingroup FMD_sim
+*/
class AliFMDHit : public AliHit
{
public:
+ /** Default CTOR */
AliFMDHit();
+ /** Normal FMD hit ctor
+ @param shunt ???
+ @param track Track #
+ @param detector Detector # (1, 2, or 3)
+ @param ring Ring ID ('I' or 'O')
+ @param sector Sector # (For inner/outer rings: 0-19/0-39)
+ @param strip Strip # (For inner/outer rings: 0-511/0-255)
+ @param x Track's X-coordinate at hit
+ @param y Track's Y-coordinate at hit
+ @param z Track's Z-coordinate at hit
+ @param px X-component of track's momentum
+ @param py Y-component of track's momentum
+ @param pz Z-component of track's momentum
+ @param edep Energy deposited by track
+ @param pdg Track's particle Id #
+ @param t Time when the track hit */
AliFMDHit(Int_t shunt,
Int_t track,
UShort_t detector,
Float_t t=0,
Float_t l=0,
Bool_t stop=kFALSE);
+ /** DTOR */
virtual ~AliFMDHit() {}
+ /** @return Detector # */
UShort_t Detector() const { return fDetector; }
+ /** @return Ring ID */
Char_t Ring() const { return fRing; }
+ /** @return Sector # */
UShort_t Sector() const { return fSector; }
+ /** @return Strip # */
UShort_t Strip() const { return fStrip; }
+ /** @return Energy deposited (MeV) */
Float_t Edep() const { return fEdep; }
+ /** @return Track @f$ p_x@f$ - momentum in @f$ x@f$ (GeV) */
Float_t Px() const { return fPx; }
+ /** @return Track @f$ p_y@f$ - momentum in @f$ y@f$ (GeV) */
Float_t Py() const { return fPy; }
+ /** @return Track @f$ p_z@f$ - momentum in @f$ z@f$ (GeV) */
Float_t Pz() const { return fPz; }
+ /** @return Track @f$ |p|@f$ - momentum (GeV) */
Float_t P() const;
+ /** @return Track @f$ m@f$ - mass (GeV) */
Float_t M() const;
+ /** @return Track @f$ q@f$ - charge (1/3) */
Float_t Q() const;
+ /** @return Track PDG id number */
Int_t Pdg() const { return fPdg; }
+ /** @return Time of hit in seconds */
Float_t Time() const { return fTime; }
+ /** @return Path length through silicon */
Float_t Length() const { return fLength; }
+ /** @return Whether track was stopped in silicon */
Bool_t IsStop() const { return fStop; }
+ /** Print info
+ @param opt Not used */
void Print(Option_t* opt="") const;
+ /** @return Get Name */
const char* GetName() const;
+ /** @return Get title */
const char* GetTitle() const;
+ /** Set enenrgy deposited
+ @param edep Energy deposited */
void SetEdep(Float_t edep) { fEdep = edep; }
protected:
UShort_t fDetector; // (Sub) Detector # (1,2, or 3)
* See cxx source for full Copyright notice
*/
//___________________________________________________________________
-//
-// The classes defined here, are utility classes for reading in data
-// for the FMD. They are put in a seperate library to not polute the
-// normal libraries. The classes are intended to be used as base
-// classes for customized class that do some sort of analysis on the
-// various types of data produced by the FMD.
-//
+/** @defgroup FMD_util Utility classes.
+
+ The classes defined here, are utility classes for reading in data
+ for the FMD. They are put in a seperate library to not polute the
+ normal libraries. The classes are intended to be used as base
+ classes for customized class that do some sort of analysis on the
+ various types of data produced by the FMD.
+*/
#include <TObject.h>
#ifndef ROOT_TString
# include <TString.h>
class TChain;
//___________________________________________________________________
+/** @class AliFMDInput
+ @brief Base class for reading in various FMD data.
+ The class loops over all found events. For each event the
+ specified data is read in. The class then loops over all
+ elements of the read data, and process these with user defined
+ code.
+ @code
+ struct DigitInput : public AliFMDInput
+ {
+ DigitInput()
+ {
+ // Load digits
+ AddLoad(kDigits);
+ // Make a histogram
+ fHist = new TH1F("adc", "ADC spectra", 1024, -.5, 1023.5);
+ }
+ // Process one digit.
+ Bool_t ProcessDigit(AliFMDDigit* d)
+ {
+ fHist->Fill(d->Counts());
+ return kTRUE;
+ }
+ // After processing all events, display spectrum
+ Bool_t Finish()
+ {
+ fHist->Draw();
+ }
+ TH1F* fHist;
+ };
+
+ void AdcSpectrum()
+ {
+ DigitInput di;
+ di.Run();
+ }
+ @endcode
+ This class allows for writing small scripts, that can be compiled
+ with AcLIC, to do all sorts of tests, quick prototyping, and so
+ on. It has proven to be quiet useful. One can load more than
+ one type of data in one derived class, to for example to make
+ comparisons between hits and reconstructed points. See also the
+ various scripts in @c FMD/scripts.
+ @ingroup FMD_util
+ */
class AliFMDInput : public TObject
{
public:
+ /** The kinds of data that can be read in. */
enum ETrees {
kHits = 1, // Hits
kKinematics, // Kinematics (from sim)
kRaw, // Read raw data
kGeometry // Not really a tree
};
+ /** CTOR */
AliFMDInput();
+ /** CTOR
+ @param gAliceFile galice file */
AliFMDInput(const char* gAliceFile);
+ /** DTOR */
virtual ~AliFMDInput() {}
+ /** Add a data type to load
+ @param tree Data to load */
virtual void AddLoad(ETrees tree) { SETBIT(fTreeMask, tree); }
+ /** Remove a data type to load
+ @param tree Data to @e not load */
virtual void RemoveLoad(ETrees tree) { CLRBIT(fTreeMask, tree); }
+ /** @return # of available events */
virtual Int_t NEvents() const;
+ /** Initialize the class. If a user class overloads this member
+ function, then this @e must be explicitly called
+ @return @c false on error */
virtual Bool_t Init();
+ /** Callled at the beginning of each event. If a user class
+ overloads this member function, then this @e must be explicitly
+ called.
+ @param event Event number
+ @return @c false on error */
virtual Bool_t Begin(Int_t event);
+ /** Process one event. This loops over all the loaded data. Users
+ can overload this member function, but then it's @e strongly
+ recommended to explicitly call this classes version.
+ @return @c false on error */
virtual Bool_t Event();
+ /** Called at the end of each event.
+ @return @c false on error */
virtual Bool_t End();
+ /** Called at the end of the run.
+ @return @c false on error */
virtual Bool_t Finish() { return kTRUE; }
+ /** Run a full job.
+ @return @c false on error */
virtual Bool_t Run();
+ /** Loop over all hits, and call ProcessHit with that hit, and
+ optionally the corresponding kinematics track.
+ @return @c false on error */
virtual Bool_t ProcessHits();
+ /** Loop over all digits, and call ProcessDigit for each digit.
+ @return @c false on error */
virtual Bool_t ProcessDigits();
+ /** Loop over all summable digits, and call ProcessSDigit for each
+ digit.
+ @return @c false on error */
virtual Bool_t ProcessSDigits();
+ /** Loop over all digits read from raw data files, and call
+ ProcessRawDigit for each digit.
+ @return @c false on error */
virtual Bool_t ProcessRawDigits();
+ /** Loop over all reconstructed points, and call ProcessRecPoint for
+ each reconstructed point.
+ @return @c false on error */
virtual Bool_t ProcessRecPoints();
+ /** Process one hit, and optionally it's corresponding kinematics
+ track. Users should over this to process each hit.
+ @return @c false on error */
virtual Bool_t ProcessHit(AliFMDHit*, TParticle*) { return kTRUE; }
+ /** Process one digit. Users should over this to process each digit.
+ @return @c false on error */
virtual Bool_t ProcessDigit(AliFMDDigit*) { return kTRUE; }
+ /** Process one summable digit. Users should over this to process
+ each summable digit.
+ @return @c false on error */
virtual Bool_t ProcessSDigit(AliFMDSDigit*) { return kTRUE; }
+ /** Process one digit from raw data files. Users should over this
+ to process each raw digit.
+ @return @c false on error */
virtual Bool_t ProcessRawDigit(AliFMDDigit*) { return kTRUE; }
+ /** Process one reconstructed point. Users should over this to
+ process each reconstructed point.
+ @return @c false on error */
virtual Bool_t ProcessRecPoint(AliFMDRecPoint*) { return kTRUE; }
+ /** Process ESD data for the FMD. Users should overload this to
+ deal with ESD data.
+ @return @c false on error */
virtual Bool_t ProcessESD(AliESDFMD*) { return kTRUE; }
protected:
class AliFMDCalibSampleRate;
class AliFMDAltroMapping;
+/** This class is a singleton that handles various parameters of the
+ FMD detectors. This class reads from the Conditions DB to get the
+ various parameters, which code can then request from here. In that
+ way, all code uses the same data, and the interface is consistent.
+
+ Some of the parameter managed are
+ - @c fPedestal, @c fPedestalWidth
+ Mean and width of the pedestal. The pedestal is simulated
+ by a Guassian, but derived classes my override MakePedestal
+ to simulate it differently (or pick it up from a database).
+ - @c fVA1MipRange
+ The dymamic MIP range of the VA1_ALICE pre-amplifier chip
+ - @c fAltroChannelSize
+ The largest number plus one that can be stored in one
+ channel in one time step in the ALTRO ADC chip.
+ - @c fSampleRate
+ How many times the ALTRO ADC chip samples the VA1_ALICE
+ pre-amplifier signal. The VA1_ALICE chip is read-out at
+ 10MHz, while it's possible to drive the ALTRO chip at
+ 25MHz. That means, that the ALTRO chip can have time to
+ sample each VA1_ALICE signal up to 2 times. Although it's
+ not certain this feature will be used in the production,
+ we'd like have the option, and so it should be reflected in
+ the code.
+
+ @ingroup FMD_base
+*/
class AliFMDParameters : public TNamed
{
public:
+ /** Singleton access
+ @return single to */
static AliFMDParameters* Instance();
+ /** Initialize the manager. This tries to read the parameters from
+ CDB. If that fails, the class uses the hard-coded parameters.
+ */
void Init();
- // Set various `Fixed' parameters
+ /** @{ */
+ /** @name Set various `Fixed' parameters */
void SetVA1MipRange(UShort_t r=20) { fVA1MipRange = r; }
void SetAltroChannelSize(UShort_t s=1024) { fAltroChannelSize = s;}
void SetChannelsPerAltro(UShort_t size=128) { fChannelsPerAltro = size; }
void SetPedestalFactor(Float_t f=3) { fPedestalFactor = f; }
+ /** @} */
- // Set various variable parameter defaults
+ /** @{ */
+ /** @name Set various variable parameter defaults */
void SetZeroSuppression(UShort_t s=0) { fFixedZeroSuppression = s; }
void SetSampleRate(UShort_t r=1) { fFixedSampleRate = (r>2?2:r);}
void SetPedestal(Float_t p=10) { fFixedPedestal = p; }
void SetPedestalWidth(Float_t w=1) { fFixedPedestalWidth = w; }
void SetThreshold(Float_t t=0) { fFixedThreshold = t; }
+ /** @} */
- // Get `Fixed' various parameters
+ /** @{ */
+ /** @name Get `Fixed' various parameters */
UShort_t GetVA1MipRange() const { return fVA1MipRange; }
UShort_t GetAltroChannelSize() const { return fAltroChannelSize; }
UShort_t GetChannelsPerAltro() const { return fChannelsPerAltro; }
Float_t GetEdepMip() const;
Float_t GetPedestalFactor() const { return fPedestalFactor; }
+ /** @} */
- // Get variable parameters
+ /** @{ */
+ /** @name Get variable parameters */
Bool_t IsDead(UShort_t detector,
Char_t ring,
UShort_t sector,
Bool_t Detector2Hardware(UShort_t det, Char_t ring, UShort_t sec,
UShort_t str, UInt_t& ddl, UInt_t& addr) const;
AliFMDAltroMapping* GetAltroMap() const;
+ /** @} */
+
enum {
kBaseDDL = 0x1000 // DDL offset for the FMD
};
static const char* fgkAltroMap; // Path to AltroMap calib object
static const char* fgkZeroSuppression; // Path to ZeroSuppression cal object
protected:
+ /** CTOR */
AliFMDParameters();
+ /** DTOR */
virtual ~AliFMDParameters() {}
+ /** Singleton instance */
static AliFMDParameters* fgInstance; // Static singleton instance
+ /** Initialize gains. Try to get them from CDB */
void InitPulseGain();
+ /** Initialize pedestals. Try to get them from CDB */
void InitPedestal();
+ /** Initialize dead map. Try to get it from CDB */
void InitDeadMap();
+ /** Initialize sample rates. Try to get them from CDB */
void InitSampleRate();
+ /** Initialize zero suppression thresholds. Try to get them from CDB */
void InitZeroSuppression();
+ /** Initialize hardware map. Try to get it from CDB */
void InitAltroMap();
Bool_t fIsInit; // Whether we've been initialised
//____________________________________________________________________
+/** @brief Class to read ALTRO formated raw data from an AliRawReader
+ object.
+ @code
+ AliRawReader* reader = new AliRawReaderFile(0);
+ AliFMDRawReader* fmdReader = new AliFMDRawReader(reader);
+ TClonesArray* array = new TClonesArray("AliFMDDigit");
+ fmdReader->ReadAdcs(array);
+ @endcode
+ @ingroup FMD_rec
+*/
class AliFMDRawReader : public TTask
{
public:
+ /** CTOR
+ @param reader Raw reader
+ @param array Output tree */
AliFMDRawReader(AliRawReader* reader, TTree* array);
+ /** DTOR */
virtual ~AliFMDRawReader() {}
+ /** Read in, and store in output tree
+ @param option Not used */
virtual void Exec(Option_t* option="");
+ /** Read ADC's into a TClonesArray of AliFMDDigit objects.
+ @param array Array to read into
+ @return @c true on success */
virtual Bool_t ReadAdcs(TClonesArray* array);
protected:
TTree* fTree; //! Pointer to tree to read into
delete altro;
}
}
-#endif
//____________________________________________________________________
void
Int_t((ring == 'I' ? 0 : 1)),
data.fN, data.fArray, fThreshold);
}
+#endif
class TClonesArray;
//____________________________________________________________________
+/** @class AliFMDRawWriter
+ @brief Class to write ALTRO formated raw data from an array of
+ AliFMDDigit objects.
+ @code
+ AliFMDRawWriter* fmdWriter = new AliFMDRawWriter(0);
+ TClonesArray* array = fmd->DigitArray();
+ fmdWriter->WriteDigits(array);
+ @endcode
+ @ingroup FMD_sim
+*/
class AliFMDRawWriter : public TTask
{
public:
+ /** Constructor
+ @param fmd Pointer to detector object. */
AliFMDRawWriter(AliFMD* fmd);
+ /** Destructor */
virtual ~AliFMDRawWriter() {}
+ /** Write the output from AliFMD object.
+ @param option Not used */
virtual void Exec(Option_t* option="");
-protected:
+ /** Write an array of AliFMDDigit objects as raw ALTRO data.
+ @param digits Array of AliFMDDigit objects to convert to raw
+ ALTRO data. */
virtual void WriteDigits(TClonesArray* digits);
- virtual void WriteChannel(AliAltroBuffer* altro,
- UShort_t strip, UShort_t sector, Char_t ring,
- const TArrayI& data);
+protected:
+ /* Write a single channel. This member function is obsolete. */
+ // virtual void WriteChannel(AliAltroBuffer* altro, UShort_t strip,
+ // UShort_t sector, Char_t ring, const TArrayI& d);
AliFMD* fFMD; //! Pointer to detector description
UShort_t fSampleRate; // The sample rate (0 -> inferred from data)
UShort_t fChannelsPerAltro; // Number of pre-amp. channels/adc channel
# include <TObject.h>
#endif
+/** Reconstructed FMD points. It contains the pseudo-inclusive
+ multiplicity
+ @ingroup FMD_rec
+ */
class AliFMDRecPoint: public TObject
{
public:
+ /** CTOR */
AliFMDRecPoint();
+ /** Constrctor
+ @param detector Detector
+ @param ring Ring
+ @param sector Sector
+ @param strip Strip
+ @param eta Psuedo-rapidity @f$ \eta@f$
+ @param phi Azimuthal angle @f$ \varphi@f$
+ @param edep Energy deposited
+ @param particles Psuedo-inclusive multiplicity */
AliFMDRecPoint(UShort_t detector, Char_t ring,
- UShort_t sector, UShort_t strip,
- Float_t eta, Float_t phi,
- Float_t edep, Float_t particles);
+ UShort_t sector, UShort_t strip,
+ Float_t eta, Float_t phi,
+ Float_t edep, Float_t particles);
+ /** DTOR */
virtual ~AliFMDRecPoint() {};
- UShort_t Detector() const { return fDetector; }
- Char_t Ring() const { return fRing; }
- UShort_t Sector() const { return fSector; }
- UShort_t Strip() const { return fStrip; }
+ /** @return Detector # */
+ UShort_t Detector() const { return fDetector; }
+ /** @return Ring ID */
+ Char_t Ring() const { return fRing; }
+ /** @return sector # */
+ UShort_t Sector() const { return fSector; }
+ /** @return strip # */
+ UShort_t Strip() const { return fStrip; }
+ /** @return Psuedo-rapidity @f$ \eta@f$ */
Float_t Eta() const { return fEta; }
+ /** @return phi Azimuthal angle @f$ \varphi@f$ */
Float_t Phi() const { return fPhi; }
+ /** @return edep Energy deposited */
Float_t Edep() const { return fEdep; }
+ /** @return particles Psuedo-inclusive multiplicity */
Float_t Particles() const { return fParticles; }
+ /** Print information
+ @param opt Not used */
virtual void Print(Option_t* opt="D") const;
+ /** @return Name */
const char* GetName() const;
+ /** @return Title */
const char* GetTitle() const;
protected:
UShort_t fDetector; // Detector #
// a DDL file (or similar), and stores the read ADC counts in an
// internal cache (fAdcs).
//
-// From the cached values it then calculates the number of particles
-// that hit a region of the FMDs, as specified by the user.
-//
-// The reconstruction can be done in two ways: Either via counting the
-// number of empty strips (Poisson method), or by converting the ADC
-// signal to an energy deposition, and then dividing by the typical
-// energy loss of a particle.
-//
-// +---------------------+ +---------------------+
-// | AliFMDReconstructor |<>-----| AliFMDMultAlgorithm |
-// +---------------------+ +---------------------+
-// ^
-// |
-// +-----------+---------+
-// | |
-// +-------------------+ +------------------+
-// | AliFMDMultPoisson | | AliFMDMultNaiive |
-// +-------------------+ +------------------+
-//
-// AliFMDReconstructor acts as a manager class. It contains a list of
-// AliFMDMultAlgorithm objects. The call graph looks something like
-//
-//
-// +----------------------+ +----------------------+
-// | :AliFMDReconstructor | | :AliFMDMultAlgorithm |
-// +----------------------+ +----------------------+
-// | |
-// Reconstruct +-+ |
-// ------------>| | PreRun +-+
-// | |------------------------------->| |
-// | | +-+
-// | |-----+ (for each event) |
-// | | | *ProcessEvent |
-// |+-+ | |
-// || |<---+ PreEvent +-+
-// || |------------------------------>| |
-// || | +-+
-// || |-----+ |
-// || | | ProcessDigits |
-// ||+-+ | |
-// ||| |<---+ |
-// ||| | *ProcessDigit(digit) +-+
-// ||| |----------------------------->| |
-// ||| | +-+
-// ||+-+ |
-// || | PostEvent +-+
-// || |------------------------------>| |
-// || | +-+
-// |+-+ |
-// | | PostRun +-+
-// | |------------------------------->| |
-// | | +-+
-// +-+ |
-// | |
-//
-//
-//
//-- Authors: Evgeny Karpechev(INR) and Alla Maevsksia
// Latest changes by Christian Holm Christensen <cholm@nbi.dk>
//
//
//-- Authors: Evgeny Karpechev (INR) and Alla Maevskaia (INR)
// Latest changes by Christian Holm Christensen <cholm@nbi.dk>
-/*
- Reconstruct nember of particles in given group of pads for given
- FMDvolume determine by numberOfVolume ,
- numberOfMinSector,numberOfMaxSector, numberOfMinRing,
- numberOfMaxRing Reconstruction method choose dependence on number
- of empty pads
- */
/* $Id$ */
//____________________________________________________________________
-//
-// Class to do reconstruction of events based on the FMD data. The
-// class will do two kinds of reconstruction, one based on energy
-// deposition, and one using hit patterns.
-//
-
// Header guards in the header files speeds up the compilation
// considerably. Please leave them in.
#ifndef ALIRECONSTRUCTOR_H
class AliESD;
class AliESDFMD;
+/** @defgroup FMD_rec Reconstruction */
//____________________________________________________________________
+/** This is a class that reconstructs AliFMDRecPoint objects from of
+ Digits. This class reads either digits from a TClonesArray or raw
+ data from a DDL file (or similar), and applies calibrations to get
+ psuedo-inclusive multiplicities per strip.
+ @ingroup FMD_rec
+ */
class AliFMDReconstructor: public AliReconstructor
{
public:
+ /** CTOR */
AliFMDReconstructor();
+ /** Copy CTOR
+ @param other Object to copy from. */
AliFMDReconstructor(const AliFMDReconstructor& other);
+ /** DTOR */
virtual ~AliFMDReconstructor();
+ /** Assignment operator
+ @param other Object to assign from
+ @return reference to this object */
AliFMDReconstructor& operator=(const AliFMDReconstructor& other);
+ /** Initialize the reconstructor. Here, we initialize the geometry
+ manager, and finds the local to global transformations from the
+ geometry. The calibration parameter manager is also
+ initialized (meaning that the calibration parameters is read
+ from CDB). Next, we try to get some information about the run
+ from the run loader passed.
+ @param runLoader Run loader to use to load and store data.
+ */
virtual void Init(AliRunLoader* runLoader);
+ /** Flag that we can convert raw data into digits.
+ @return always @c true */
virtual Bool_t HasDigitConversion() const { return kTRUE; }
+ /** Convert raw data read from the AliRawReader @a reader into
+ digits. This is done using AliFMDRawReader and
+ AliFMDAltroReader. The digits are put in the passed TTree @a
+ digitsTree.
+ @param reader Raw reader.
+ @param digitsTree Tree to store read digits in. */
virtual void ConvertDigits(AliRawReader* reader, TTree* digitsTree) const;
+ /** Flag that we can do one-event reconstruction.
+ @return always @c true */
virtual Bool_t HasLocalReconstruction() const { return kTRUE; }
+ /** Reconstruct one event from the digits passed in @a digitsTree.
+ The member function creates AliFMDRecPoint objects and stores
+ them on the output tree @a clusterTree. An FMD ESD object is
+ created in parallel.
+ @todo Make sure we get a vertex.
+ @param digitsTree Tree holding the digits of this event
+ @param clusterTree Tree to store AliFMDRecPoint objects in. */
virtual void Reconstruct(TTree* digitsTree, TTree* clusterTree) const;
+ /** Put in the ESD data, the FMD ESD data. The object created by
+ the Reconstruct member function is copied to the ESD object.
+ @param digitsTree Tree of digits for this event - not used
+ @param clusterTree Tree of reconstructed points for this event
+ - not used.
+ @param esd ESD object to store data in.
+ */
virtual void FillESD(TTree* digitsTree, TTree* clusterTree,
AliESD* esd) const;
+ /** Not used */
virtual void SetESD(AliESD* esd) { fESD = esd; }
private:
+ /** Hide base classes unused function */
void Reconstruct(AliRawReader*, TTree*) const;
+ /** Hide base classes unused function */
void Reconstruct(AliRunLoader*) const;
+ /** Hide base classes unused function */
void Reconstruct(AliRunLoader*, AliRawReader*) const;
+ /** Hide base classes unused function */
void FillESD(AliRawReader*, TTree*, AliESD*) const;
+ /** Hide base classes unused function */
void FillESD(AliRunLoader*, AliESD*) const;
+ /** Hide base classes unused function */
void FillESD(AliRunLoader*, AliRawReader*, AliESD*) const;
protected:
+ /** Process AliFMDDigit objects in @a digits. For each digit, find
+ the psuedo-rapidity @f$ \eta@f$, azimuthal angle @f$ \varphi@f$,
+ energy deposited @f$ E@f$, and psuedo-inclusive multiplicity @f$
+ M@f$.
+ @param digits Array of digits. */
virtual void ProcessDigits(TClonesArray* digits) const;
+ /** Substract pedestals from raw ADC in @a digit
+ @param digit Digit data
+ @return Pedestal subtracted ADC count. */
virtual UShort_t SubtractPedestal(AliFMDDigit* digit) const;
+ /** Converts number of ADC counts to energy deposited. This is
+ done by
+ @f[
+ E_i = A_i g_i
+ @f]
+ where @f$ A_i@f$ is the pedestal subtracted ADC counts, and @f$
+ g_i@f$ is the gain for the @f$ i^{\mbox{th}}@f$ strip.
+ @param digit Raw data
+ @param eta Psuedo-rapidity of digit.
+ @param count Pedestal subtracted ADC counts
+ @return Energy deposited @f$ E_i@f$ */
virtual Float_t Adc2Energy(AliFMDDigit* digit, Float_t eta,
UShort_t count) const;
+ /** Converts an energy signal to number of particles. In this
+ implementation, it's done by
+ @f[
+ M_i = E_i / E_{\mbox{MIP}}
+ @f]
+ where @f$ E_i@f$ is the energy deposited, and @f$
+ E_{\mbox{MIP}}@f$ is the average energy deposited by a minimum
+ ionizing particle
+ @param digit Raw data
+ @param edep Energy deposited @f$ E_i@f$
+ @return Psuedo-inclusive multiplicity @f$ M@f$ */
virtual Float_t Energy2Multiplicity(AliFMDDigit* digit, Float_t edep) const;
+ /** Calculate the physical coordinates psuedo-rapidity @f$ \eta@f$,
+ azimuthal angle @f$ \varphi@f$ of the strip corresponding to
+ the digit @a digit. This is done by using the information
+ obtained, and previously cached by AliFMDGeometry, from the
+ TGeoManager.
+ @param digit Digit.
+ @param eta On return, psuedo-rapidity @f$ \eta@f$
+ @param phi On return, azimuthal angle @f$ \varphi@f$ */
virtual void PhysicalCoordinates(AliFMDDigit* digit, Float_t& eta,
Float_t& phi) const;
Outer (@c 'O') the two objects of this class is owned by the
Geometry::FMD singleton object. The 3 Geometry::FMDDetector
objects shares these two instances as needed.
+ @ingroup FMD_base
*/
class AliFMDRing : public TNamed
{
public:
+ /** CTOR
+ @param fId Ring ID */
AliFMDRing(Char_t fId);
+ /** DTOR */
virtual ~AliFMDRing() {}
/** Initialize the ring geometry */
virtual void Init();
@return the ith vertex */
TVector2* GetVertex(Int_t i) const;
+ /** Not used */
void Detector2XYZ(UShort_t sector, UShort_t strip,
Double_t& x, Double_t& y, Double_t& z) const;
+ /** Not used */
Bool_t XYZ2Detector(Double_t x, Double_t y, Double_t z,
UShort_t& sector, UShort_t& strip) const;
private:
# include "AliFMDMap.h"
#endif
//____________________________________________________________________
-//
-// Cache of Energy deposited, hit information perr strip
-//
-
-//____________________________________________________________________
+/** @class AliFMDUShortMap
+ @brief Map of an integer per strip
+ @ingroup FMD_base
+ */
class AliFMDUShortMap : public AliFMDMap
{
public:
+ /** Copy constructor
+ @param other Object to copy from. */
AliFMDUShortMap(const AliFMDUShortMap& other);
+ /** Constructor
+ @param maxDet Number of detectors (3)
+ @param maxRing Number of rings (2)
+ @param maxSec Number of sectors (40)
+ @param maxStr Number of strips (20) */
AliFMDUShortMap(size_t maxDet = kMaxDetectors,
size_t maxRing= kMaxRings,
size_t maxSec = kMaxSectors,
size_t maxStr = kMaxStrips);
+ /** Destructor */
virtual ~AliFMDUShortMap() { delete [] fData; }
+ /** Assignment operator
+ @param other Object to assign from
+ @return reference to this object. */
AliFMDUShortMap& operator=(const AliFMDUShortMap& other);
+ /** Reset to value
+ @param v Value to reset from */
virtual void Reset(const UShort_t& val=UShort_t());
+ /** Access operator
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @return reference value stored for the strip */
virtual UShort_t& operator()(UShort_t detector,
Char_t ring,
UShort_t sector,
UShort_t strip);
+ /** Access operator
+ @param det Detector
+ @param ring Ring
+ @param sec Sector
+ @param str Strip
+ @return value stored for the strip */
virtual const UShort_t& operator()(UShort_t detector,
Char_t ring,
UShort_t sector,
#endif
//____________________________________________________________________
+/** Forward Multiplicity Detector based on Silicon wafers. This class
+ contains the base procedures for the Forward Multiplicity detector
+ Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
+ which has 1 or 2 rings of silicon sensors.
+
+ This contains the coarse version of the FMD - that is, the
+ simulation produces no hits in the FMD volumes, and the sensors
+ are not divided into strips and sectors. Useful for material
+ budget calculations
+ @ingroup FMD_sim
+ */
class AliFMDv0 : public AliFMD
{
public:
+ /** CTOR */
AliFMDv0() {}
+ /** CTOR
+ @param name Name
+ @param title Title */
AliFMDv0(const char *name, const char *title="Coarse geometry")
: AliFMD(name, title)
{}
- virtual ~AliFMDv0()
- {}
+ /** DTOR */
+ virtual ~AliFMDv0() {}
// Required member functions
+ /** @return Version number - always 0 */
virtual Int_t IsVersion() const {return 0;}
+ /** Function called at each hit. Empty */
virtual void StepManager() {}
ClassDef(AliFMDv0,1) // Coarse FMD geometry
#endif
//____________________________________________________________________
+/** Forward Multiplicity Detector based on Silicon wafers. This class
+ contains the base procedures for the Forward Multiplicity detector
+ Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
+ which has 1 or 2 rings of silicon sensors.
+
+ This class contains the detailed version of the FMD - that is,
+ hits are produced during simulation.
+ @ingroup FMD_sim
+*/
class AliFMDv1 : public AliFMD
{
public:
+ /** CTOR */
AliFMDv1()
: AliFMD(),
fCurrentDeltaE(0),
fCurrentV(),
fCurrentP(),
fCurrentPdg(0) { fDetailed = kTRUE; }
+ /** CTOR
+ @param name Name
+ @param title Title */
AliFMDv1(const char *name, const char *title="Detailed geometry")
: AliFMD(name, title),
fCurrentDeltaE(0),
fCurrentV(),
fCurrentP(),
fCurrentPdg(0) { fDetailed = kTRUE; }
+ /** DTOR */
virtual ~AliFMDv1() {}
// Required member functions
+ /** Get version number
+ @return always 1 */
virtual Int_t IsVersion() const {return 1;}
+ /** Member function that is executed each time a hit is made in the
+ FMD. None-charged particles are ignored. Dead tracks are
+ ignored.
+
+ The procedure is as follows:
+ - IF NOT track is alive THEN RETURN ENDIF
+ - IF NOT particle is charged THEN RETURN ENDIF
+ - IF NOT volume name is "STRI" or "STRO" THEN RETURN ENDIF
+ - Get strip number (volume copy # minus 1)
+ - Get phi division number (mother volume copy #)
+ - Get module number (grand-mother volume copy #)
+ - section # = 2 * module # + phi division # - 1
+ - Get ring Id from volume name
+ - Get detector # from grand-grand-grand-mother volume name
+ - Get pointer to sub-detector object.
+ - Get track position
+ - IF track is entering volume AND track is inside real shape THEN
+ - Reset energy deposited
+ - Get track momentum
+ - Get particle ID #
+ - ENDIF
+ - IF track is inside volume AND inside real shape THEN
+ - Update energy deposited
+ - ENDIF
+ - IF track is inside real shape AND (track is leaving volume,
+ or it died, or it is stopped THEN
+ - Create a hit
+ - ENDIF
+ */
virtual void StepManager();
protected:
+ /** Translate VMC coordinates to detector coordinates
+ @param v On output, Current position
+ @param detector On output, detector #
+ @param ring On output, ring id
+ @param sector On output, sector #
+ @param strip On output, strip #
+ @return @c true on success */
Bool_t VMC2FMD(TLorentzVector& v, UShort_t& detector,
Char_t& ring, UShort_t& sector, UShort_t& strip) const;
+ /** Translate VMC coordinates to detector coordinates
+ @param copy Volume copy number
+ @param v On output, Current position
+ @param detector On output, detector #
+ @param ring On output, ring id
+ @param sector On output, sector #
+ @param strip On output, strip #
+ @return @c true on success */
Bool_t VMC2FMD(Int_t copy, TLorentzVector& v,
UShort_t& detector, Char_t& ring,
UShort_t& sector, UShort_t& strip) const;
+ /** Check if hit is bad. A hit is bad if
+ @f[
+ \Delta E > |Q|^2 p / m > 1
+ @f]
+ holds, where @f$ \Delta E@f$ is the energy loss in this step,
+ @f$ Q@f$ is the particle charge, @f$ p@f$ is the track momentum,
+ and @f$ m@f$ is the particle mass. If a track is marked as
+ bad, it's kept in a cache, and can be printed at the end of the
+ event.
+ @param trackno Track number
+ @param pdg PDG particle type ID
+ @param absQ Absolute value of particle charge
+ @param p Track momentum
+ @param edep Energy loss in this step.
+ @return @c true if hit is `bad' */
Bool_t CheckHit(Int_t trackno, Int_t pdg, Float_t absQ,
const TLorentzVector& p, Float_t edep) const;
--- /dev/null
+# Doxyfile 1.4.6
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME = "ALICE FMD Off-line"
+PROJECT_NUMBER = 0.1
+OUTPUT_DIRECTORY =
+CREATE_SUBDIRS = NO
+OUTPUT_LANGUAGE = English
+USE_WINDOWS_ENCODING = NO
+BRIEF_MEMBER_DESC = NO
+REPEAT_BRIEF = YES
+ABBREVIATE_BRIEF = "The $name class" \
+ "The $name widget" \
+ "The $name file" \
+ is \
+ provides \
+ specifies \
+ contains \
+ represents \
+ a \
+ an \
+ the
+ALWAYS_DETAILED_SEC = YES
+INLINE_INHERITED_MEMB = NO
+FULL_PATH_NAMES = YES
+STRIP_FROM_PATH = /home/hehi/cholm/work/alice/aliroot/FMD/
+STRIP_FROM_INC_PATH =
+SHORT_NAMES = NO
+JAVADOC_AUTOBRIEF = NO
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP = YES
+INHERIT_DOCS = YES
+SEPARATE_MEMBER_PAGES = NO
+TAB_SIZE = 8
+ALIASES =
+OPTIMIZE_OUTPUT_FOR_C = NO
+OPTIMIZE_OUTPUT_JAVA = NO
+BUILTIN_STL_SUPPORT = NO
+DISTRIBUTE_GROUP_DOC = NO
+SUBGROUPING = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL = YES
+EXTRACT_PRIVATE = YES
+EXTRACT_STATIC = YES
+EXTRACT_LOCAL_CLASSES = YES
+EXTRACT_LOCAL_METHODS = NO
+HIDE_UNDOC_MEMBERS = NO
+HIDE_UNDOC_CLASSES = NO
+HIDE_FRIEND_COMPOUNDS = NO
+HIDE_IN_BODY_DOCS = NO
+INTERNAL_DOCS = NO
+CASE_SENSE_NAMES = YES
+HIDE_SCOPE_NAMES = NO
+SHOW_INCLUDE_FILES = YES
+INLINE_INFO = YES
+SORT_MEMBER_DOCS = YES
+SORT_BRIEF_DOCS = NO
+SORT_BY_SCOPE_NAME = NO
+GENERATE_TODOLIST = YES
+GENERATE_TESTLIST = YES
+GENERATE_BUGLIST = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS =
+MAX_INITIALIZER_LINES = 30
+SHOW_USED_FILES = YES
+SHOW_DIRECTORIES = NO
+FILE_VERSION_FILTER =
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET = YES
+WARNINGS = YES
+WARN_IF_UNDOCUMENTED = YES
+WARN_IF_DOC_ERROR = YES
+WARN_NO_PARAMDOC = YES
+WARN_FORMAT = "$file:$line: $text"
+WARN_LOGFILE =
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT = /home/hehi/cholm/work/alice/aliroot/FMD
+FILE_PATTERNS = *.h
+RECURSIVE = NO
+EXCLUDE =
+EXCLUDE_SYMLINKS = NO
+EXCLUDE_PATTERNS =
+EXAMPLE_PATH = /home/hehi/cholm/work/alice/aliroot/FMD/scripts/
+EXAMPLE_PATTERNS = *.C
+EXAMPLE_RECURSIVE = NO
+IMAGE_PATH =
+INPUT_FILTER =
+FILTER_PATTERNS =
+FILTER_SOURCE_FILES = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER = NO
+INLINE_SOURCES = NO
+STRIP_CODE_COMMENTS = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION = NO
+USE_HTAGS = NO
+VERBATIM_HEADERS = NO
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX = YES
+COLS_IN_ALPHA_INDEX = 5
+IGNORE_PREFIX =
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML = YES
+HTML_OUTPUT = html
+HTML_FILE_EXTENSION = .html
+HTML_HEADER =
+HTML_FOOTER =
+HTML_STYLESHEET =
+HTML_ALIGN_MEMBERS = YES
+GENERATE_HTMLHELP = NO
+CHM_FILE =
+HHC_LOCATION =
+GENERATE_CHI = NO
+BINARY_TOC = NO
+TOC_EXPAND = NO
+DISABLE_INDEX = NO
+ENUM_VALUES_PER_LINE = 4
+GENERATE_TREEVIEW = NO
+TREEVIEW_WIDTH = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX = NO
+LATEX_OUTPUT = latex
+LATEX_CMD_NAME = latex
+MAKEINDEX_CMD_NAME = makeindex
+COMPACT_LATEX = NO
+PAPER_TYPE = a4wide
+EXTRA_PACKAGES =
+LATEX_HEADER =
+PDF_HYPERLINKS = NO
+USE_PDFLATEX = NO
+LATEX_BATCHMODE = NO
+LATEX_HIDE_INDICES = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF = NO
+RTF_OUTPUT = rtf
+COMPACT_RTF = NO
+RTF_HYPERLINKS = NO
+RTF_STYLESHEET_FILE =
+RTF_EXTENSIONS_FILE =
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN = NO
+MAN_OUTPUT = man
+MAN_EXTENSION = .3
+MAN_LINKS = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML = NO
+XML_OUTPUT = xml
+XML_SCHEMA =
+XML_DTD =
+XML_PROGRAMLISTING = YES
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD = NO
+PERLMOD_LATEX = NO
+PERLMOD_PRETTY = YES
+PERLMOD_MAKEVAR_PREFIX =
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING = YES
+MACRO_EXPANSION = YES
+EXPAND_ONLY_PREDEF = NO
+SEARCH_INCLUDES = YES
+INCLUDE_PATH =
+INCLUDE_FILE_PATTERNS =
+PREDEFINED =
+EXPAND_AS_DEFINED =
+SKIP_FUNCTION_MACROS = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+TAGFILES =
+GENERATE_TAGFILE =
+ALLEXTERNALS = NO
+EXTERNAL_GROUPS = YES
+PERL_PATH = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS = YES
+HIDE_UNDOC_RELATIONS = YES
+HAVE_DOT = YES
+CLASS_GRAPH = YES
+COLLABORATION_GRAPH = YES
+GROUP_GRAPHS = YES
+UML_LOOK = YES
+TEMPLATE_RELATIONS = NO
+INCLUDE_GRAPH = YES
+INCLUDED_BY_GRAPH = YES
+CALL_GRAPH = NO
+GRAPHICAL_HIERARCHY = YES
+DIRECTORY_GRAPH = YES
+DOT_IMAGE_FORMAT = png
+DOT_PATH =
+DOTFILE_DIRS =
+MAX_DOT_GRAPH_WIDTH = 1024
+MAX_DOT_GRAPH_HEIGHT = 1024
+MAX_DOT_GRAPH_DEPTH = 1000
+DOT_TRANSPARENT = NO
+DOT_MULTI_TARGETS = YES
+GENERATE_LEGEND = YES
+DOT_CLEANUP = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine
+#---------------------------------------------------------------------------
+SEARCHENGINE = NO
// #pragma link C++ class AliFMDMap<std::pair<Float_t,UShort_t> >;
// #pragma link C++ typedef AliFMDEdepMap;
#pragma link C++ class AliFMDEdepMap+;
+#pragma link C++ class AliFMDEdepHitPair+;
#pragma link C++ class AliFMDHit+;
#pragma link C++ class AliFMD+;
#pragma link C++ class AliFMDv0+;