AliFMDReconstructor.h

Go to the documentation of this file.

#ifndef ALIFMDRECONSTRUCTOR_H
#define ALIFMDRECONSTRUCTOR_H
//
//  Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
//  reserved. 
//
//  See cxx source for full Copyright notice                               
//
//  AliFMDReconstructor.h 
//  Task Class for making TreeR for FMD                        
//
//-- Authors: Evgeny Karpechev (INR) and Alla Maevskaia (INR)
//   Latest changes by Christian Holm Christensen <cholm@nbi.dk>
/* $Id$ */
//____________________________________________________________________
// Header guards in the header files speeds up the compilation
// considerably.  Please leave them in. 
#ifndef ALIRECONSTRUCTOR_H
# include <AliReconstructor.h>
#endif
#include "AliLog.h"
#include <AliFMDBoolMap.h>

//____________________________________________________________________
class TTree;
class TClonesArray;
class AliFMDDigit;
class AliRawReader;
class AliFMDRawReader;
class AliESDEvent;
class AliESDFMD;
class AliFMDRecoParam;
class TH1;


//____________________________________________________________________
class AliFMDReconstructor: public AliReconstructor 
{
public:
  AliFMDReconstructor();
  virtual ~AliFMDReconstructor();

  virtual void   Init();
  virtual Bool_t HasDigitConversion() const { return kTRUE; }
  virtual void   ConvertDigits(AliRawReader* reader, TTree* digitsTree) const;
  virtual void   Reconstruct(TTree* digitsTree, TTree* clusterTree) const;
  virtual void   Reconstruct(AliRawReader *, TTree*) const;
  virtual void Reconstruct(AliFMDRawReader& reader) const;
  virtual void   FillESD(TTree* digitsTree, TTree* clusterTree, 
       AliESDEvent* esd) const;
  virtual void   FillESD(AliRawReader*, TTree* clusterTree, 
       AliESDEvent* esd) const;
  AliESDFMD* GetESDObject() const { return fESDObj; }
  virtual void Digitize(AliRawReader* reader, 
      TClonesArray* sdigits) const;
  
  virtual void   SetESD(AliESDEvent* esd) { fESD = esd; }
  virtual void SetNoiseFactor(Float_t f=3) { fNoiseFactor = f; }
  virtual void SetAngleCorrect(Bool_t use=kTRUE) { fAngleCorrect = use; }
  void SetDiagnose(Bool_t use=kTRUE) { fDiagnostics = use; }
  virtual void ProcessDigits(TClonesArray* digits,
           const AliFMDRawReader& rawRead) const;
    
protected:
  AliFMDReconstructor(const AliFMDReconstructor&); //Not implemented
  AliFMDReconstructor& operator=(const AliFMDReconstructor&); //Not implemented
  Bool_t PreReconstruct() const;
  virtual void GetVertex(AliESDEvent* esd) const;
  virtual void UseRecoParam(Bool_t set=kTRUE) const;
  virtual void ProcessDigits(TClonesArray* digits) const;
  virtual void ProcessDigit(AliFMDDigit* digit) const;
  virtual void ProcessSignal(UShort_t det, 
           Char_t   rng, 
           UShort_t sec, 
           UShort_t str, 
           Short_t  adc) const;
  virtual void DigitizeSignal(TClonesArray* sdigits, 
            UShort_t      det, 
            Char_t         rng, 
            UShort_t       sec, 
            UShort_t       str, 
            UShort_t       sam,
            Short_t        adc) const;
  virtual UShort_t SubtractPedestal(UShort_t det, 
            Char_t   rng, 
            UShort_t sec, 
            UShort_t str, 
            UShort_t adc, 
            Float_t  noiseFactor,
            Bool_t   zsEnabled, 
            UShort_t zsNoiseFactor) const;
  virtual UShort_t SubtractPedestal(UShort_t det, 
            Char_t   rng, 
            UShort_t sec, 
            UShort_t str, 
            Short_t  adc) const;
  virtual Float_t  Adc2Energy(UShort_t det, 
            Char_t   rng, 
            UShort_t sec, 
            UShort_t str, 
            UShort_t count) const;
  virtual Float_t  Adc2Energy(UShort_t det, 
            Char_t   rng, 
            UShort_t sec, 
            UShort_t str, 
            Float_t  eta, 
            UShort_t count) const;
  virtual Float_t  Energy2Multiplicity(UShort_t det, 
               Char_t   rng, 
               UShort_t sec, 
               UShort_t str, 
               Float_t  edep) const;
  virtual void     PhysicalCoordinates(UShort_t det, 
               Char_t   rng, 
               UShort_t sec, 
               UShort_t str, 
               Float_t& eta, 
               Float_t& phi) const;
  void MarkDeadChannels(AliESDFMD* esd) const;

  const AliFMDRecoParam* GetParameters() const;
  Int_t GetIdentifier() const;
  enum Vertex_t {
    kNoVertex,   // Got no vertex
    kGenVertex,  // Got generator vertex 
    kESDVertex   // Got ESD vertex 
  };
  mutable TClonesArray* fMult;          // Cache of RecPoints
  mutable Int_t         fNMult;         // Number of entries in fMult 
  mutable TTree*        fTreeR;         // Output tree 
  mutable Float_t       fCurrentVertex; // Z-coordinate of primary vertex
  mutable AliESDFMD*    fESDObj;        // ESD output object
  mutable Float_t       fNoiseFactor;   // Factor of noise to check
  mutable Bool_t        fAngleCorrect;  // Whether to angle correct
  mutable Vertex_t      fVertexType;    // What kind of vertex we got
  AliESDEvent*          fESD;           // ESD object(?)
  Bool_t                fDiagnostics;   // Wheter to do diagnostics
  TH1*                  fDiagStep1; // Diagnostics histogram
  TH1*                  fDiagStep2; // Diagnostics histogram
  TH1*                  fDiagStep3; // Diagnostics histogram
  TH1*                  fDiagStep4; // Diagnostics histogram
  TH1*                  fDiagAll; // Diagnostics histogram
  mutable Bool_t        fZS[3];         // Zero-suppredded?
  mutable UShort_t      fZSFactor[3];   // Noise factor for Zero-suppression
  mutable AliFMDBoolMap fBad;           // Strip marked bad
  Bool_t                fZombie;        // Are we a zombie?
private:
   
  ClassDef(AliFMDReconstructor, 3)  // class for the FMD reconstruction
}; 
#endif
//____________________________________________________________________
//
// Local Variables:
//   mode: C++
// End:
//
// EOF
//