AliAnalysisTaskMuonResolution.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKMUONRESOLUTION_H
#define ALIANALYSISTASKMUONRESOLUTION_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */ 

//Author: Philippe Pillot - SUBATECH Nantes

#include <TString.h>
#include <TMatrixD.h>
#include <TF1.h>
#include "AliAnalysisTaskSE.h"
#include "AliMuonEventCuts.h"
#include "AliMuonTrackCuts.h"

class TH1;
class TH2;
class TGraphErrors;
class TObjArray;
class TList;
class AliMUONTrack;
class AliMUONTrackParam;
class AliMUONGeometryTransformer;
class AliMUONVCluster;

class AliAnalysisTaskMuonResolution : public AliAnalysisTaskSE {
public:
  
  AliAnalysisTaskMuonResolution();
  AliAnalysisTaskMuonResolution(const char *name);
  virtual ~AliAnalysisTaskMuonResolution();
  
  void SetDefaultStorage(const char* ocdbPath) { fDefaultStorage = ocdbPath; }
  
  void SetStartingResolution(Int_t chId, Double_t valNB, Double_t valB);
  void SetStartingResolution(Double_t valNB[10], Double_t valB[10]);
  void GetStartingResolution(Double_t valNB[10], Double_t valB[10]) const;
  
  void SetHalfChShift(Int_t hchId, Double_t valNB, Double_t valB);
  void SetHalfChShift(Double_t valNB[20], Double_t valB[20]);
  void GetHalfChShift(Double_t valNB[20], Double_t valB[20]) const;
  void ShiftHalfCh(Bool_t flag = kTRUE) { fShiftHalfCh = flag; }
  void PrintHalfChShift(Bool_t flag = kTRUE) { fPrintHalfChShift = flag; }
  
  void SetDEShift(Int_t iDE, Double_t valNB, Double_t valB);
  void SetDEShift(Double_t valNB[200], Double_t valB[200]);
  void GetDEShift(Double_t valNB[200], Double_t valB[200]) const;
  void ShiftDE(Bool_t flag = kTRUE) { fShiftDE = flag; }
  void PrintDEShift(Bool_t flag = kTRUE) { fPrintDEShift = flag; }
  
  void SetMinMomentum(Double_t val) { fMinMomentum = val; }
  
  void SetMinPt(Double_t val) { fMinPt = val; }
  
  // set standard cuts to select events to be considered
  void SetMuonEventCuts(AliMuonEventCuts &eventCuts);
  
  // set standard cuts to select tracks to be considered
  void SetMuonTrackCuts(AliMuonTrackCuts &trackCuts);
  
  void SetExtrapMode(Int_t val) { fExtrapMode = val; }
  
  void CorrectForSystematics(Bool_t flag = kTRUE) { fCorrectForSystematics = flag; }
  
  void SetAlignStorage(const char* ocdbPath, Int_t version = -1, Int_t subVersion = -1);
  
  void ReAlign(const char* oldAlignStorage = 0x0, Int_t oldVersion = -1, Int_t oldSubVersion = -1,
               const char* newAlignStorage = "", Int_t newVersion = -1, Int_t newSubVersion = -1);
  
  TObjArray* GetCanvases() {return fCanvases;}
  
  void ShowProgressBar(Bool_t flag = kTRUE) {fShowProgressBar = flag;}
  
  void PrintClusterRes(Bool_t perCh = kTRUE, Bool_t perDE = kFALSE) {fPrintClResPerCh = perCh; fPrintClResPerDE = perDE;}
  
  void FitResiduals(Bool_t flag = kTRUE);
  
  void RemoveMonoCathodClusters(Bool_t flag = kTRUE, Bool_t checkAllPads = kTRUE) {fRemoveMonoCathCl = flag; fCheckAllPads = checkAllPads;}
  
  void ImproveTracks(Bool_t flag = kTRUE) {fImproveTracks = flag;}
  
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *);
  virtual void   NotifyRun();
  virtual void   Terminate(Option_t *);
  
private:
  
  AliAnalysisTaskMuonResolution(const AliAnalysisTaskMuonResolution& rhs);
  AliAnalysisTaskMuonResolution& operator = (const AliAnalysisTaskMuonResolution& rhs);
  
  void ModifyClusters(AliMUONTrack& track);
  void Zoom(TH1* h, Double_t fractionCut = 0.01);
  void ZoomLeft(TH1* h, Double_t fractionCut = 0.02);
  void ZoomRight(TH1* h, Double_t fractionCut = 0.02);
  void GetMeanRMS(TH1* h, Double_t& mean, Double_t& meanErr,Double_t& rms, Double_t& rmsErr, TGraphErrors* gMean = 0x0,
      TGraphErrors* gRMS = 0x0, Int_t i = 0, Double_t x = 0, Bool_t zoom = kTRUE, Bool_t enableFit = kTRUE);
  void FillMeanSigmaClusterVsX(const TH2* hIn, const TH2* hOut, TGraphErrors* gMean, TGraphErrors* gSigma);
  void Cov2CovP(const AliMUONTrackParam &param, TMatrixD &covP);
  void CheckPads(AliMUONVCluster *cl, Bool_t &hasBending, Bool_t &hasNonBending) const;
  void CheckPadsBelow(AliMUONVCluster *cl, Bool_t &hasBending, Bool_t &hasNonBending) const;
  
private:
  
  enum eResiduals {
    kResidualPerChClusterIn             = 0,  
    kResidualPerChClusterOut            = 2,  
    kTrackResPerCh                      = 4,  
    kMCSPerCh                           = 6,  
    kClusterRes2PerCh                   = 8,  
    kResidualPerDEClusterIn             = 10, 
    kResidualPerDEClusterOut            = 12, 
    kTrackResPerDE                      = 14, 
    kMCSPerDE                           = 16, 
    kResidualPerHalfChClusterIn         = 18, 
    kResidualPerHalfChClusterOut        = 20, 
    kTrackResPerHalfCh                  = 22, 
    kMCSPerHalfCh                       = 24, 
    kLocalChi2PerCh                     = 26, 
    kLocalChi2PerDE                     = 29  
  };
  
  enum eResidualsVsP {
    kResidualInChVsPClusterIn           = 0,  
    kResidualInChVsPClusterOut          = 20, 
    kResidualVsPClusterIn               = 40, 
    kResidualVsPClusterOut              = 42  
  };
  
  enum eResidualsVsCent {
    kResidualInChVsCentClusterIn        = 0,  
    kResidualInChVsCentClusterOut       = 20, 
    kResidualVsCentClusterIn            = 40, 
    kResidualVsCentClusterOut           = 42  
  };
  
  enum eResidualsVsAngle {
    kResidualInChVsAngleClusterIn       = 0,  
    kResidualInChVsAngleClusterOut      = 20, 
    kResidualVsAngleClusterIn           = 40, 
    kResidualVsAngleClusterOut          = 42, 
    kResidualInHalfChVsAngleClusterIn   = 44  
  };
  
  enum eLocalChi2 {
    kLocalChi2PerChMean                 = 0,  
    kLocalChi2PerDEMean                 = 3   
  };
  
  enum eChamberRes {
    kResidualPerChMeanClusterIn         = 0,  
    kResidualPerChMeanClusterOut        = 2,  
    kResidualPerChSigmaClusterIn        = 4,  
    kResidualPerChSigmaClusterOut       = 6,  
    kResidualPerChDispersionClusterOut  = 8,  
    kCombinedResidualPerChSigma         = 10, 
    kTrackResPerChMean                  = 12, 
    kMCSPerChMean                       = 14, 
    kClusterResPerCh                    = 16, 
    kCalcClusterResPerCh                = 18, 
    kResidualPerDEMeanClusterIn         = 20, 
    kResidualPerDEMeanClusterOut        = 22, 
    kCombinedResidualPerDESigma         = 24, 
    kClusterResPerDE                    = 26, 
    kResidualPerHalfChMeanClusterIn     = 28, 
    kResidualPerHalfChMeanClusterOut    = 30, 
    kCombinedResidualPerHalfChSigma     = 32, 
    kClusterResPerHalfCh                = 34, 
    kResidualMeanClusterInVsP           = 36, 
    kCombinedResidualSigmaVsP           = 38, 
    kCombinedResidualAllChSigmaVsP      = 40, 
    kResidualMeanClusterInVsCent        = 42, 
    kCombinedResidualSigmaVsCent        = 44, 
    kCombinedResidualAllChSigmaVsCent   = 46, 
    kResidualMeanClusterInVsAngle       = 48, 
    kCombinedResidualSigmaVsAngle       = 50, 
    kCombinedResidualAllChSigmaVsAngle  = 52, 
    kHChResidualMeanClusterInVsAngle    = 54  
  };
  
  enum eTrackRes {
    kUncorrPRes                         = 0,  
    kPRes                               = 1,  
    kUncorrPtRes                        = 2,  
    kPtRes                              = 3,  
    kUncorrSlopeRes                     = 4,  
    kSlopeRes                           = 6   
  };
  
  enum eCanvases {
    kResPerCh                           = 0,  
    kResPerDE                           = 1,  
    kResPerHalfCh                       = 2,  
    kResPerChVsP                        = 3,  
    kResPerChVsCent                     = 4,  
    kResPerChVsAngle                    = 5,  
    kShiftPerChVsP                      = 6,  
    kShiftPerChVsCent                   = 7,  
    kShiftPerChVsAngle                  = 8,  
    kDetailResPerCh                     = 9,  
    kDetailResPerHalfCh                 = 13, 
    kDetailResPerDE                     = 17  
  };
  
  static const Int_t fgkMinEntries; 
  
  TObjArray*  fResiduals;       
  TObjArray*  fResidualsVsP;    
  TObjArray*  fResidualsVsCent; 
  TObjArray*  fResidualsVsAngle;
  TObjArray*  fLocalChi2;       
  TObjArray*  fChamberRes;      
  TObjArray*  fTrackRes;        
  TObjArray*  fCanvases;        
  TObjArray*  fTmpHists;        
  
  Double_t fClusterResNB[10];   
  Double_t fClusterResB[10];    
  
  Double_t fHalfChShiftNB[20];  
  Double_t fHalfChShiftB[20];   
  
  Double_t fDEShiftNB[200];     
  Double_t fDEShiftB[200];      
  
  TString  fDefaultStorage;        
  Int_t    fNEvents;               
  Bool_t   fShowProgressBar;       
  Bool_t   fPrintClResPerCh;       
  Bool_t   fPrintClResPerDE;       
  TF1*     fGaus;                  
  Double_t fMinMomentum;           
  Double_t fMinPt;                 
  Int_t    fExtrapMode;            
  Bool_t   fCorrectForSystematics; 
  Bool_t   fRemoveMonoCathCl;      
  Bool_t   fCheckAllPads;          
  Bool_t   fImproveTracks;         
  Bool_t   fShiftHalfCh;           
  Bool_t   fPrintHalfChShift;      
  Bool_t   fShiftDE;               
  Bool_t   fPrintDEShift;          
  Bool_t   fOCDBLoaded;            
  Int_t    fNDE;                   
  Int_t    fDEIndices[1100];       
  Int_t    fDEIds[200];            
  Bool_t   fReAlign;               
  TString  fOldAlignStorage;       
  Int_t    fOldAlignVersion;       
  Int_t    fOldAlignSubVersion;    
  TString  fNewAlignStorage;       
  Int_t    fNewAlignVersion;       
  Int_t    fNewAlignSubVersion;    
  AliMUONGeometryTransformer* fOldGeoTransformer; 
  AliMUONGeometryTransformer* fNewGeoTransformer; 
  
  AliMuonEventCuts* fMuonEventCuts; 
  AliMuonTrackCuts* fMuonTrackCuts; 
  
  ClassDef(AliAnalysisTaskMuonResolution, 5); // chamber resolution analysis
};

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::SetStartingResolution(Int_t chId, Double_t valNB, Double_t valB)
{
  if (chId < 0 || chId >= 10) return;
  fClusterResNB[chId] = valNB;
  fClusterResB[chId] = valB;
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::SetStartingResolution(Double_t valNB[10], Double_t valB[10])
{
  for (Int_t i = 0; i < 10; i++) {
    fClusterResNB[i] = valNB[i];
    fClusterResB[i] = valB[i];
  }
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::GetStartingResolution(Double_t valNB[10], Double_t valB[10]) const
{
  for (Int_t i = 0; i < 10; i++) {
    valNB[i] = fClusterResNB[i];
    valB[i] = fClusterResB[i];
  }
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::SetHalfChShift(Int_t hchId, Double_t valNB, Double_t valB)
{
  if (hchId < 0 || hchId >= 20) return;
  fHalfChShiftNB[hchId] = valNB;
  fHalfChShiftB[hchId] = valB;
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::SetHalfChShift(Double_t valNB[20], Double_t valB[20])
{
  for (Int_t i = 0; i < 20; i++) {
    fHalfChShiftNB[i] = valNB[i];
    fHalfChShiftB[i] = valB[i];
  }
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::GetHalfChShift(Double_t valNB[20], Double_t valB[20]) const
{
  for (Int_t i = 0; i < 20; i++) {
    valNB[i] = fHalfChShiftNB[i];
    valB[i] = fHalfChShiftB[i];
  }
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::SetDEShift(Int_t iDE, Double_t valNB, Double_t valB)
{
  if (iDE < 0 || iDE >= 200) return;
  fDEShiftNB[iDE] = valNB;
  fDEShiftB[iDE] = valB;
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::SetDEShift(Double_t valNB[200], Double_t valB[200])
{
  for (Int_t i = 0; i < 200; i++) {
    fDEShiftNB[i] = valNB[i];
    fDEShiftB[i] = valB[i];
  }
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::GetDEShift(Double_t valNB[200], Double_t valB[200]) const
{
  for (Int_t i = 0; i < 200; i++) {
    valNB[i] = fDEShiftNB[i];
    valB[i] = fDEShiftB[i];
  }
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::SetAlignStorage(const char* ocdbPath, Int_t version, Int_t subVersion)
{
  if (ocdbPath) {
    fNewAlignStorage = ocdbPath;
    fNewAlignVersion = version;
    fNewAlignSubVersion = subVersion;
  } else {
    fNewAlignStorage = "none";
    fNewAlignVersion = -1;
    fNewAlignSubVersion = -1;
  }
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::ReAlign(const char* oldAlignStorage, Int_t oldVersion, Int_t oldSubVersion,
                                                   const char* newAlignStorage, Int_t newVersion, Int_t newSubVersion)
{
  if (oldAlignStorage) {
    fOldAlignStorage = oldAlignStorage;
    fOldAlignVersion = oldVersion;
    fOldAlignSubVersion = oldSubVersion;
  } else {
    fOldAlignStorage = "none";
    fOldAlignVersion = -1;
    fOldAlignSubVersion = -1;
  }
  if (newAlignStorage) {
    fNewAlignStorage = newAlignStorage;
    fNewAlignVersion = newVersion;
    fNewAlignSubVersion = newSubVersion;
  } else {
    fNewAlignStorage = "none";
    fNewAlignVersion = -1;
    fNewAlignSubVersion = -1;
  }
  fReAlign = kTRUE;
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::FitResiduals(Bool_t flag)
{
  delete fGaus;
  if (flag) fGaus = new TF1("fGaus","gaus");
  else fGaus = NULL;
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::SetMuonEventCuts(AliMuonEventCuts &eventCuts)
{
  delete fMuonEventCuts;
  fMuonEventCuts = new AliMuonEventCuts(eventCuts);
}

//________________________________________________________________________
inline void AliAnalysisTaskMuonResolution::SetMuonTrackCuts(AliMuonTrackCuts &trackCuts)
{
  delete fMuonTrackCuts;
  fMuonTrackCuts = new AliMuonTrackCuts(trackCuts);
}

#endif