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