AliFMDSharingFilter.h

Go to the documentation of this file.

//
// Class to do the sharing correction.  That is, a filter that merges 
// adjacent strip signals presumably originating from a single particle 
// that impinges on the detector in such a way that it deposite energy 
// into two or more strips. 
//
#ifndef ALIFMDSHARINGFILTER_H
#define ALIFMDSHARINGFILTER_H

#include <TNamed.h>
#include <TH2.h>
#include <TList.h>
#include "AliForwardUtil.h"
#include "AliFMDMultCuts.h"
class AliESDFMD;
class TAxis;
class TList;
class TH2;
class AliFMDFloatMap;

class AliFMDSharingFilter : public TNamed
{
public: 
  enum Status { 
    kNone             = 1, 
    kCandidate        = 2, 
    kMergedWithOther  = 3, 
    kMergedInto       = 4
  };
  virtual ~AliFMDSharingFilter();
  AliFMDSharingFilter();
  AliFMDSharingFilter(const char* title);

  virtual void SetMergingDisabled(Bool_t disable) {fMergingDisabled = disable; }
  virtual void SetDebug(Int_t dbg=1) { fDebug = dbg; }
  void SetUseAngleCorrectedSignals(Bool_t use) { fCorrectAngles = use; }
  void SetZeroSharedHitsBelowThreshold(Bool_t use) { fZeroSharedHitsBelowThreshold = use; }
  void SetUseSimpleSharing(Bool_t use) { fUseSimpleMerging = use; }
  void SetAllow3Strips(Bool_t use) { fThreeStripSharing = use; }  
  void SetIgnoreESDWhenAngleCorrecting(Bool_t use) { fIgnoreESDForAngleCorrection = use; }
  /* @} */

  void SetupForData(const TAxis& axis);
  Bool_t Filter(const AliESDFMD& input, 
    Bool_t           lowFlux, 
    AliESDFMD&       output, 
    Double_t         zvtx);
  virtual void Terminate(const TList* dir, TList* output, Int_t nEvents);  
  virtual void CreateOutputObjects(TList* dir);
  /* @} */
  virtual void Print(Option_t* option="") const;

  AliFMDMultCuts& GetLCuts() { return fLCuts; }
  AliFMDMultCuts& GetHCuts() { return fHCuts; }
  const AliFMDMultCuts& GetLCuts() const { return fLCuts; }
  const AliFMDMultCuts& GetHCuts() const { return fHCuts; }
  void SetLCuts(const AliFMDMultCuts& c) { fLCuts = c; }
  void SetHCuts(const AliFMDMultCuts& c) { fHCuts = c; }
  /* @} */
protected:
  AliFMDSharingFilter(const AliFMDSharingFilter& o) : TNamed(o) {}
  AliFMDSharingFilter& operator=(const AliFMDSharingFilter&){return *this;}
  struct RingHistos : public AliForwardUtil::RingHistos
  { 
    RingHistos();
    RingHistos(UShort_t d, Char_t r);
    RingHistos(const RingHistos& o);
    RingHistos& operator=(const RingHistos& o);
    ~RingHistos();
    // void Clear(const Option_t* ="") { fNHits = 0; } 
    // void Incr() { fNHits++; } 
    // void Finish(); 
    void CreateOutputObjects(TList* dir);
    void Terminate(const TList* dir, Int_t nEvents);
    TH1D*     fBefore;          // Distribution of signals before filter
    TH1D*     fAfter;           // Distribution of signals after filter
    TH1D*     fSingle;          // Distribution of 1 signal after filter
    TH1D*     fDouble;          // Distribution of 2 signals after filter
    TH1D*     fTriple;          // Distribution of 3 signals after filter
    TH2D*     fSinglePerStrip;  // Distribution of 1 signal per strip
    TH2D*     fBeforeAfter;     // Correlation of before and after 
    TH2D*     fNeighborsBefore; // Correlation of neighbors 
    TH2D*     fNeighborsAfter;  // Correlation of neighbors 
    TH2D*     fSumESD;          // Summed ESD signal 
    TH2D*     fSum;             // Summed cluster signal 
    TH1D*     fNConsecutive;    // # consecutive strips with signal > low cut
    // ClassDef(RingHistos,4);
  };
  RingHistos* GetRingHistos(UShort_t d, Char_t r) const;
  Double_t SignalInStrip(const AliESDFMD& fmd, 
       UShort_t d,
       Char_t   r,
       UShort_t s,
       UShort_t t) const;
  Double_t AngleCorrect(Double_t mult, Double_t eta) const;
  Double_t DeAngleCorrect(Double_t mult, Double_t eta) const;
  virtual Double_t GetHighCut(UShort_t d, Char_t r, Double_t eta,
            Bool_t errors=true) const;
  virtual Double_t GetLowCut(UShort_t d, Char_t r, Double_t eta) const;
  TList    fRingHistos;      // List of histogram containers
  Bool_t   fCorrectAngles;   // Whether to work on angle corrected signals
  TH2*     fHighCuts;        // High cuts used
  TH2*     fLowCuts;         // High cuts used
  Int_t    fDebug;           // Debug level 
  Bool_t   fZeroSharedHitsBelowThreshold; // Zero shared strip below cut?
  AliFMDMultCuts fLCuts;     // Cuts object for low cuts
  AliFMDMultCuts fHCuts;     // Cuts object for high cuts
  Bool_t   fUseSimpleMerging;// enable simple sharing by HHD
  Bool_t   fThreeStripSharing; //In case of simple sharing allow 3 strips
  Bool_t   fMergingDisabled; // If true, do not merge
  Bool_t   fIgnoreESDForAngleCorrection; // Ignore ESD information when angle correcting
  ClassDef(AliFMDSharingFilter,11); //
};

#endif
// Local Variables:
//  mode: C++ 
// End: