FMD/AliFMDReconstructor.h

   1 #ifndef ALIFMDRECONSTRUCTOR_H
   2 #define ALIFMDRECONSTRUCTOR_H
   3 //
   4 //  Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
   5 //  reserved.
   6 //
   7 //  See cxx source for full Copyright notice
   8 //
   9 //  AliFMDReconstructor.h
  10 //  Task Class for making TreeR for FMD
  11 //
  12 //-- Authors: Evgeny Karpechev (INR) and Alla Maevskaia (INR)
  13 //   Latest changes by Christian Holm Christensen <cholm@nbi.dk>
  14 /* $Id$ */
  15 /** @file    AliFMDReconstructor.h
  16     @author  Christian Holm Christensen <cholm@nbi.dk>
  17     @date    Mon Mar 27 12:47:09 2006
  18     @brief   FMD reconstruction
  19 */
  20
  21 //____________________________________________________________________
  22 // Header guards in the header files speeds up the compilation
  23 // considerably.  Please leave them in.
  24 #ifndef ALIRECONSTRUCTOR_H
  25 # include <AliReconstructor.h>
  26 #endif
  27 #include "AliLog.h"
  28
  29 //____________________________________________________________________
  30 class TTree;
  31 class TClonesArray;
  32 class AliFMDDigit;
  33 class AliRawReader;
  34 class AliESDEvent;
  35 class AliESDFMD;
  36 class AliFMDRecoParam;
  37 class TH1;
  38
  39
  40 /** @defgroup FMD_rec Reconstruction */
  41 //____________________________________________________________________
  42 /**
  43  * @brief This is a class that reconstructs AliFMDRecPoint objects
  44  *        from of Digits.
  45  *
  46  * This class reads either digits from a TClonesArray or raw data
  47  * from a DDL file (or similar), and applies calibrations to get
  48  * psuedo-inclusive multiplicities per strip.
  49  *
  50  * @ingroup FMD_rec
  51  */
  52 class AliFMDReconstructor: public AliReconstructor
  53 {
  54 public:
  55   /**
  56    * CTOR
  57    */
  58   AliFMDReconstructor();
  59   /**
  60    * DTOR
  61    */
  62   virtual ~AliFMDReconstructor();
  63
  64   /**
  65    * Initialize the reconstructor.  Here, we initialize the geometry
  66    * manager, and finds the local to global transformations from the
  67    * geometry.   The calibration parameter manager is also
  68    * initialized (meaning that the calibration parameters is read
  69    * from CDB).
  70    */
  71   virtual void   Init();
  72   /**
  73    * Flag that we can convert raw data into digits.
  74    *
  75    * @return always @c true
  76    */
  77   virtual Bool_t HasDigitConversion() const { return kTRUE; }
  78   /**
  79    * Convert raw data read from the AliRawReader @a reader into
  80    * digits.  This is done using AliFMDRawReader and
  81    * AliFMDAltroReader.  The digits are put in the passed TTree @a
  82    * digitsTree.
  83    *
  84    * @param reader     Raw reader.
  85    * @param digitsTree Tree to store read digits in.
  86    */
  87   virtual void   ConvertDigits(AliRawReader* reader, TTree* digitsTree) const;
  88   /**
  89    * Reconstruct one event from the digits passed in @a digitsTree.
  90    * The member function creates AliFMDRecPoint objects and stores
  91    * them on the output tree @a clusterTree.  An FMD ESD object is
  92    * created in parallel.
  93    *
  94    * @param digitsTree  Tree holding the digits of this event
  95    * @param clusterTree Tree to store AliFMDRecPoint objects in.
  96    */
  97   virtual void   Reconstruct(TTree* digitsTree, TTree* clusterTree) const;
  98   /**
  99    * Not used
 100    * @todo Implement this, such that we'll reconstruct directly from
 101    *       the read ADC values rather than going via an intermedant
 102    *       TClonesArray of AliFMDDigits
 103    */
 104   virtual void   Reconstruct(AliRawReader *, TTree*) const;
 105   /**
 106    * Put in the ESD data, the FMD ESD data.  The object created by
 107    * the Reconstruct member function is copied to the ESD object.
 108    *
 109    * @param digitsTree   Tree of digits for this event - not used
 110    * @param clusterTree  Tree of reconstructed points for this event -
 111    *        not used.
 112    * @param esd ESD object to store data in.
 113    */
 114   virtual void   FillESD(TTree* digitsTree, TTree* clusterTree,
 115                          AliESDEvent* esd) const;
 116   /**
 117    * Forwards to above member function
 118    */
 119   virtual void   FillESD(AliRawReader*, TTree* clusterTree,
 120                          AliESDEvent* esd) const;
 121
 122   /**
 123    * Create SDigits from raw data
 124    *
 125    * @param reader  The raw reader
 126    * @param sdigits Array to fill with AliFMDSDigit objects.
 127    */
 128   virtual void Digitize(AliRawReader* reader,
 129                         TClonesArray* sdigits) const;
 130
 131   /**
 132    * Not used
 133    */
 134   virtual void   SetESD(AliESDEvent* esd) { fESD = esd; }
 135   /**
 136    * Set the noise factor
 137    *
 138    * @param f Factor to use
 139    */
 140   virtual void SetNoiseFactor(Float_t f=3) { fNoiseFactor = f; }
 141   /**
 142    * Set whether we should do angle correction or nor
 143    *
 144    * @param use If true, do angle correction
 145    */
 146   virtual void SetAngleCorrect(Bool_t use=kTRUE) { fAngleCorrect = use; }
 147   /**
 148    * Set whether we want to do diagnostics.  If this is enabled, a
 149    * file named @c FMD.Diag.root will be made.  It contains a set of
 150    * histograms for each event, filed in separate directories in the
 151    * file.  The histograms are
 152    * @verbatim
 153    * diagStep1   Read ADC vs. Noise surpressed ADC
 154    * diagStep2   Noise surpressed ADC vs. calculated Energy dep.
 155    * diagStep3   Energy deposition vs. angle corrected Energy dep.
 156    * diagStep4   Energy deposition vs. calculated multiplicity
 157    * diagAll     Read ADC vs. calculated multiplicity
 158    * @endverbatim
 159    *
 160    * @param use If true, make the diagnostics file
 161    */
 162   void SetDiagnose(Bool_t use=kTRUE) { fDiagnostics = use; }
 163    /**
 164    * Functions to use the FMD as an offline trigger. The idea is to read
 165    * the data until we are certain we have one particle. If no particle is
 166    * found the functions return kFALSE. These functions were added as a
 167    * result of the discussions in the First Physics Working Group.
 168    *    *
 169    * @param AliESDFMD* fmd the FMD data from one event.
 170    */
 171   static Bool_t GetFMDAsideBit(AliESDFMD* fmd);
 172   static Bool_t GetFMDCsideBit(AliESDFMD* fmd);
 173
 174 protected:
 175   /**
 176    * Copy CTOR
 177    *
 178    * @param other Object to copy from.
 179    */
 180   AliFMDReconstructor(const AliFMDReconstructor& other);
 181   /**
 182    * Assignment operator
 183    *
 184    * @param other Object to assign from
 185    *
 186    * @return reference to this object
 187    */
 188   AliFMDReconstructor& operator=(const AliFMDReconstructor& other);
 189   /**
 190    * Try to get the vertex from either ESD or generator header.  Sets
 191    * @c fCurrentVertex to the found Z posistion of the vertex (if
 192    * found), and sets the flag @c fVertexType accordingly
 193    *
 194    * @param esd ESD structure to get Vz from
 195    */
 196   virtual void GetVertex(AliESDEvent* esd) const;
 197   /**
 198    * Process AliFMDDigit objects in @a digits.  For each digit, find
 199    * the psuedo-rapidity @f$ \eta@f$, azimuthal angle @f$ \varphi@f$,
 200    * energy deposited @f$ E@f$, and psuedo-inclusive multiplicity @f$
 201    * M@f$.
 202    *
 203    * @param digits Array of digits.
 204    */
 205   virtual void     ProcessDigits(TClonesArray* digits) const;
 206   /**
 207    * Process a single digit
 208    *
 209    * @param digit Digiti to process
 210    */
 211   virtual void ProcessDigit(AliFMDDigit* digit) const;
 212   /**
 213    * Process the signal from a single strip.
 214    *
 215    * @param det Detector number
 216    * @param rng Ring identifier
 217    * @param sec Sector number
 218    * @param str Strip number
 219    * @param adc Number of ADC counts for this strip
 220    */
 221   virtual void ProcessSignal(UShort_t det,
 222                              Char_t   rng,
 223                              UShort_t sec,
 224                              UShort_t str,
 225                              Short_t  adc) const;
 226   /**
 227    * Process the signal from a single strip.
 228    *
 229    * @param sdigits Array to fill
 230    * @param det     Detector number
 231    * @param rng     Ring identifier
 232    * @param sec     Sector number
 233    * @param str     Strip number
 234    * @param sam     Sample number
 235    * @param adc     Number of ADC counts for this strip
 236    */
 237   virtual void DigitizeSignal(TClonesArray* sdigits,
 238                               UShort_t      det,
 239                               Char_t         rng,
 240                               UShort_t       sec,
 241                               UShort_t       str,
 242                               UShort_t       sam,
 243                               Short_t        adc) const;
 244   /**
 245    * Subtract the pedestal off the ADC counts.
 246    *
 247    * @param det           Detector number
 248    * @param rng           Ring identifier
 249    * @param sec           Sector number
 250    * @param str           Strip number
 251    * @param adc           ADC counts
 252    * @param noiseFactor   If pedestal substracted pedestal is less then
 253    *        this times the noise, then consider this to be 0.
 254    * @param zsEnabled     Whether zero-suppression is on.
 255    * @param zsNoiseFactor Noise factor used in on-line pedestal
 256    *        subtraction.
 257    *
 258    * @return The pedestal subtracted ADC counts (possibly 0), or @c
 259    *         USHRT_MAX in case of problems.
 260    */
 261   virtual UShort_t SubtractPedestal(UShort_t det,
 262                                     Char_t   rng,
 263                                     UShort_t sec,
 264                                     UShort_t str,
 265                                     UShort_t adc,
 266                                     Float_t  noiseFactor,
 267                                     Bool_t   zsEnabled,
 268                                     UShort_t zsNoiseFactor) const;
 269   /**
 270    * Substract pedestals from raw ADC in @a digit
 271    *
 272    * @param det   Detector number
 273    * @param rng   Ring identifier
 274    * @param sec   Sector number
 275    * @param str   Strip number
 276    * @param adc   Number of ADC counts
 277    *
 278    * @return Pedestal subtracted ADC count.
 279    */
 280   virtual UShort_t SubtractPedestal(UShort_t det,
 281                                     Char_t   rng,
 282                                     UShort_t sec,
 283                                     UShort_t str,
 284                                     Short_t  adc) const;
 285   /**
 286    * Converts number of ADC counts to energy deposited.   This is
 287    * done by
 288    * @f[
 289    * E_i = A_i g_i
 290    * @f]
 291    * where @f$ A_i@f$ is the pedestal subtracted ADC counts, and @f$
 292    * g_i@f$ is the gain for the @f$ i^{\mbox{th}}@f$ strip.
 293    *
 294    * @param det   Detector number
 295    * @param rng   Ring identifier
 296    * @param sec   Sector number
 297    * @param str   Strip number
 298    * @param eta   Psuedo-rapidity of digit.
 299    * @param count Pedestal subtracted ADC counts
 300    *
 301    * @return Energy deposited @f$ E_i@f$
 302    */
 303   virtual Float_t  Adc2Energy(UShort_t det,
 304                               Char_t   rng,
 305                               UShort_t sec,
 306                               UShort_t str,
 307                               UShort_t count) const;
 308   /**
 309    * Converts number of ADC counts to energy deposited.   This is
 310    * done by
 311    * @f[
 312    * E_i = A_i g_i
 313    * @f]
 314    * where @f$ A_i@f$ is the pedestal subtracted ADC counts, and @f$
 315    * g_i@f$ is the gain for the @f$ i^{\mbox{th}}@f$ strip.
 316    *
 317    * @param det   Detector number
 318    * @param rng   Ring identifier
 319    * @param sec   Sector number
 320    * @param str   Strip number
 321    * @param eta   Psuedo-rapidity of digit.
 322    * @param count Pedestal subtracted ADC counts
 323    *
 324    * @return Energy deposited @f$ E_i@f$
 325    */
 326   virtual Float_t  Adc2Energy(UShort_t det,
 327                               Char_t   rng,
 328                               UShort_t sec,
 329                               UShort_t str,
 330                               Float_t  eta,
 331                               UShort_t count) const;
 332   /**
 333    * Converts an energy signal to number of particles. In this
 334    * implementation, it's done by
 335    * @f[
 336    * M_i = E_i / E_{\mbox{MIP}}
 337    * @f]
 338    * where @f$ E_i@f$ is the energy deposited, and
 339    * @f$ E_{\mbox{MIP}}@f$ is the average energy deposited by a
 340    * minimum ionizing particle
 341    *
 342    * @param det   Detector number
 343    * @param rng   Ring identifier
 344    * @param sec   Sector number
 345    * @param str   Strip number
 346    * @param eta   On return, psuedo-rapidity @f$ \eta@f$
 347    * @param phi   On return, azimuthal angle @f$ \varphi@f$
 348    * @param edep Energy deposited @f$ E_i@f$
 349    *
 350    * @return Psuedo-inclusive multiplicity @f$ M@f$
 351    */
 352   virtual Float_t  Energy2Multiplicity(UShort_t det,
 353                                        Char_t   rng,
 354                                        UShort_t sec,
 355                                        UShort_t str,
 356                                        Float_t  edep) const;
 357   /**
 358    * Calculate the physical coordinates psuedo-rapidity @f$ \eta@f$,
 359    * azimuthal angle @f$ \varphi@f$ of the strip corresponding to
 360    * the digit @a digit.   This is done by using the information
 361    * obtained, and previously cached by AliFMDGeometry, from the
 362    * TGeoManager.
 363    *
 364    * @param det   Detector number
 365    * @param rng   Ring identifier
 366    * @param sec   Sector number
 367    * @param str   Strip number
 368    * @param eta   On return, psuedo-rapidity @f$ \eta@f$
 369    * @param phi   On return, azimuthal angle @f$ \varphi@f$
 370    */
 371   virtual void     PhysicalCoordinates(UShort_t det,
 372                                        Char_t   rng,
 373                                        UShort_t sec,
 374                                        UShort_t str,
 375                                        Float_t& eta,
 376                                        Float_t& phi) const;
 377   /**
 378    * Set-up reconstructor to use values from reconstruction
 379    * parameters, if present, for this event.   If the argument @a set
 380    * is @c false, then restore preset values.
 381    *
 382    * @param set
 383    */
 384   virtual void UseRecoParam(Bool_t set=kTRUE) const;
 385   /**
 386    * Utility member function to get the reconstruction parameters for
 387    * this event
 388    *
 389    * @return Pointer to AliFMDRecoParam object or null if not
 390    * available.
 391    */
 392   const AliFMDRecoParam* GetParameters() const;
 393   /**
 394    * Get the numeric identifier of this detector
 395    *
 396    * @return Should be 12
 397    */
 398   Int_t GetIdentifier() const;
 399   enum Vertex_t {
 400     kNoVertex,   // Got no vertex
 401     kGenVertex,  // Got generator vertex
 402     kESDVertex   // Got ESD vertex
 403   };
 404   mutable TClonesArray* fMult;          // Cache of RecPoints
 405   mutable Int_t         fNMult;         // Number of entries in fMult
 406   mutable TTree*        fTreeR;         // Output tree
 407   mutable Float_t       fCurrentVertex; // Z-coordinate of primary vertex
 408   mutable AliESDFMD*    fESDObj;        // ESD output object
 409   mutable Float_t       fNoiseFactor;   // Factor of noise to check
 410   mutable Bool_t        fAngleCorrect;  // Whether to angle correct
 411   mutable Vertex_t      fVertexType;    // What kind of vertex we got
 412   AliESDEvent*          fESD;           // ESD object(?)
 413   Bool_t                fDiagnostics;   // Wheter to do diagnostics
 414   TH1*                  fDiagStep1;     // Diagnostics histogram
 415   TH1*                  fDiagStep2;     // Diagnostics histogram
 416   TH1*                  fDiagStep3;     // Diagnostics histogram
 417   TH1*                  fDiagStep4;     // Diagnostics histogram
 418   TH1*                  fDiagAll;       // Diagnostics histogram
 419   mutable Bool_t        fZS[3];         // Zero-suppredded?
 420   mutable UShort_t      fZSFactor[3];   // Noise factor for Zero-suppression
 421 private:
 422
 423   ClassDef(AliFMDReconstructor, 3)  // class for the FMD reconstruction
 424 };
 425 #endif
 426 //____________________________________________________________________
 427 //
 428 // Local Variables:
 429 //   mode: C++
 430 // End:
 431 //
 432 // EOF
 433 //