AliCentralMultiplicityTask.h

Go to the documentation of this file.

// 
// Base class for classes that calculate the multiplicity in the
// SPD clusters event-by-event
// 
#ifndef ALICENTRALMULTIPLICITYTASK_H
#define ALICENTRALMULTIPLICITYTASK_H

#include "AliBaseESDTask.h"
#include "AliFMDEventInspector.h"
#include "AliAODCentralMult.h"
class AliCentralCorrectionManager;
class AliESDEvent;
class AliMultiplicity;
class TH2D;
class TList;
class TTree;
class TObjArray;

class AliCentralMultiplicityTask : public AliBaseESDTask
{
public:
  AliCentralMultiplicityTask(const char* name); 
  AliCentralMultiplicityTask();
  virtual Bool_t Book();
  virtual void CreateBranches(AliAODHandler* ah);
  virtual Bool_t PreData(const TAxis& v, const TAxis& e);
  virtual Bool_t PreEvent();
  virtual Bool_t Event(AliESDEvent& esd);
  virtual Bool_t Finalize();
  virtual void Print(Option_t* option="") const;
  virtual void SetUseSecondary(Bool_t use) { fUseSecondary = use; }
  virtual void SetUseAcceptance(Bool_t use) { fUseAcceptance = use; }
  virtual void SetMakeDiagnostics(Bool_t use=true) { fStore = use; }
  AliFMDEventInspector& GetEventInspector() { return fInspector; }
  const AliFMDEventInspector& GetEventInspector() const { return fInspector; }

protected:
  AliCentralMultiplicityTask(const AliCentralMultiplicityTask& o);
  AliCentralMultiplicityTask& operator=(const AliCentralMultiplicityTask& o);
  virtual void ProcessESD(TH2D& hist, 
        const AliMultiplicity* spdmult) const;
  struct VtxBin : public TObject
  {
    VtxBin(Int_t iVz=0, Double_t minIpZ=0, Double_t maxIpZ=0);
    VtxBin(const VtxBin& o);
    VtxBin& operator=(const VtxBin& o);
    const char* GetName() const;
    void SetupForData(TList* l, TH2* coverage, Bool_t store=true);
    void Correct(TH2D&  aodHist,
     Bool_t useSecondary,
     Bool_t useAcceptance,
     Bool_t sum=true) const;
    void Print(Option_t* option="") const;

    Int_t        fId;     // Vertex bin number 
    Double_t     fMinIpZ; // Least value of ipZ 
    Double_t     fMaxIpZ; // Largest value of ipZ 
    Int_t        fEtaMin; // Smallest eta bin to use 
    Int_t        fEtaMax; // Largest eta bin to use 
    TH2*         fSec;    // Our secondary correction
    TH1*         fAcc;    // Our acceptance correction 
    mutable TH2* fHits;   // Diagnostics sum 

    // ClassDef(VtxBin,1);
  };
    
protected: 
  Bool_t MakeSimpledNdeta(const TList* input, 
        TList*       output,
        Double_t&    nTr, 
        Double_t&    nTrVtx, 
        Double_t&    nAcc);
  TAxis* DefaultEtaAxis() const { return new TAxis(200,-4,6); }
  TAxis* DefaultVertexAxis() const { return new TAxis(10,-10,10); }
  AliFMDEventInspector   fInspector;        // Inspect events 
  AliAODCentralMult      fAODCentral;       // Output object
  Bool_t                 fUseSecondary;     // Whether to secondary map
  Bool_t                 fUseAcceptance;    // Whether to use acceptance corr.
  Int_t                  fIvz;              // Event's vertex bin 
  TH2D*                  fNClusterTracklet; // # of clusters vs tracklets 
  TH2D*                  fClusterPerTracklet; // Clusters per tracklet. 
  TH1D*                  fNCluster;         
  TH1D*                  fNTracklet;        
  TObjArray*             fVtxList;          
  Bool_t                 fStore;            // Store diagnostics
  TH2D*                  fHData;            // Sum of signals 
private:
  ClassDef(AliCentralMultiplicityTask,5)    // Forward multiplicity class
};

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