ITS/AliITSTrackleterSPDEff.h

   1 #ifndef ALIITSTRACKLETERSPDEFF_H
   2 #define ALIITSTRACKLETERSPDEFF_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /* $Id$ */
   7
   8 //____________________________________________________________________
   9 //
  10 // AliITSTrackleterSPDEff - find SPD chips efficiencies by using tracklets.
  11 //
  12 // This class was originally derived from AliITSMultReconstructor (see
  13 // it for more details). Later on, the inheritance was changed to AliTracker
  14 // It is the class for the Trackleter used to estimate
  15 // SPD plane efficiency.
  16 // The trackleter prediction is built using the vertex and 1 cluster.
  17
  18 //
  19 //
  20 //  Author :  Giuseppe Eugenio Bruno, based on the skeleton of Reconstruct method  provided by Tiziano Virgili
  21 //  email:    giuseppe.bruno@ba.infn.it
  22 //
  23 //____________________________________________________________________
  24
  25 class AliStack;
  26 class TTree;
  27 class TH1F;
  28 class TH2F;
  29 #include "AliTracker.h"
  30 #include "AliITSPlaneEffSPD.h"
  31 #include "AliPlaneEff.h"
  32
  33 class AliITSTrackleterSPDEff : public  AliTracker
  34 {
  35 public:
  36   AliITSTrackleterSPDEff();
  37   virtual ~AliITSTrackleterSPDEff();
  38   Int_t Clusters2Tracks(AliESDEvent *esd);
  39   Int_t PostProcess(AliESDEvent *);
  40
  41   virtual Int_t PropagateBack(AliESDEvent*) {return 0;}
  42   virtual Int_t RefitInward(AliESDEvent*) {return 0;}
  43   Int_t LoadClusters(TTree* cl) {LoadClusterArrays(cl); return 0;} // see implementation in AliITSMultReconstructor
  44   virtual void UnloadClusters() {return;}
  45   virtual AliCluster *GetCluster(Int_t) const {return NULL;}
  46
  47   // Main method to perform the trackleter and the SPD efficiency evaluation
  48   void Reconstruct(AliStack* pStack=0x0, TTree* tRef=0x0, Bool_t lbkg=kFALSE);
  49
  50   void SetReflectClusterAroundZAxisForLayer(Int_t ilayer,Bool_t b=kTRUE){  // method to study residual background:
  51     if(b) {AliInfo(Form("All clusters on layer %d will be rotated by 180 deg around z",ilayer));
  52            SetLightBkgStudyInParallel(kFALSE);}
  53     if(ilayer==0) fReflectClusterAroundZAxisForLayer0=b;                   // a rotation by 180degree around the Z axis
  54     else if(ilayer==1) fReflectClusterAroundZAxisForLayer1=b;              // (x->-x; y->-y) to all RecPoints on a
  55     else AliInfo("Nothing done: input argument (ilayer) either 0 or 1");   // given layer is applied. In such a way
  56   }                                                                        // you remove all the true tracklets.
  57   void SetLightBkgStudyInParallel(Bool_t b = kTRUE); // if you set this on, then the estimation of the
  58                                                      // SPD efficiency is done as usual for data, but in
  59                                                      // parallel a light (i.e. without control histograms, etc.)
  60                                                      // evaluation of combinatorial background is performed
  61                                                      // with the usual ReflectClusterAroundZAxisForLayer method.
  62   Bool_t GetLightBkgStudyInParallel() const {return fLightBkgStudyInParallel;}
  63   void SetOnlyOneTrackletPerC2(Bool_t b = kTRUE) {fOnlyOneTrackletPerC2 = b;}
  64   void SetPhiWindowL2(Float_t w=0.08) {fPhiWindowL2=w;}
  65   void SetZetaWindowL2(Float_t w=1.) {fZetaWindowL2=w;}
  66
  67   void SetPhiWindowL1(Float_t w=0.08) {fPhiWindowL1=w;}  // method to set the cuts in the interpolation
  68   void SetZetaWindowL1(Float_t w=1.) {fZetaWindowL1=w;}  // phase; use method of the base class for extrap.
  69   void SetOnlyOneTrackletPerC1(Bool_t b = kTRUE) {fOnlyOneTrackletPerC1 = b;} // as in the base class but
  70   void SetMinContVtx(Int_t min=3) {fMinContVtx=min;} // set minimum n. of contributors to vertex
  71
  72   Int_t GetNClustersLayer1() const {return fNClustersLay1;}
  73   Int_t GetNClustersLayer2() const {return fNClustersLay2;}
  74   Int_t GetNTracklets() const {return fNTracklets;}
  75
  76   Float_t* GetClusterLayer1(Int_t n) {return fClustersLay1[n];}
  77   Float_t* GetClusterLayer2(Int_t n) {return fClustersLay2[n];}
  78   Float_t* GetTracklet(Int_t n) {return fTracklets[n];}
  79                                                                               // for the inner layer
  80   void SetUpdateOncePerEventPlaneEff(Bool_t b = kTRUE) {fUpdateOncePerEventPlaneEff = b;}
  81
  82   AliITSPlaneEffSPD* GetPlaneEffSPD() const {return fPlaneEffSPD;}  // return a pointer to the AliITSPlaneEffSPD
  83   AliPlaneEff *GetPlaneEff() {return (AliPlaneEff*)fPlaneEffSPD;}   // return the pointer to AliPlaneEff
  84
  85   void SetMC(Bool_t mc=kTRUE) {fMC=mc; fMC? InitPredictionMC() : DeletePredictionMC(); return;}  // switch on access to MC true
  86   Bool_t GetMC() const {return fMC;}  // check the access to MC true
  87   // Only for MC: use only "primary" particles (according to PrimaryTrackChecker) for the tracklet prediction
  88   void SetUseOnlyPrimaryForPred(Bool_t flag=kTRUE) {CallWarningMC(); fUseOnlyPrimaryForPred = flag; }
  89   // Only for MC: use only "secondary" particles (according to PrimaryTrackChecker) for the tracklet prediction
  90   void SetUseOnlySecondaryForPred(Bool_t flag=kTRUE) {CallWarningMC(); fUseOnlySecondaryForPred = flag;}
  91   // Only for MC: associate a cluster to the tracklet prediction if  from the same particle
  92   void SetUseOnlySameParticle(Bool_t flag=kTRUE) {CallWarningMC(); fUseOnlySameParticle = flag;}
  93   // Only for MC: associate a cluster to the tracklet prediction if  from different particles
  94   void SetUseOnlyDifferentParticle(Bool_t flag=kTRUE) {CallWarningMC(); fUseOnlyDifferentParticle = flag;}
  95   //  Only for MC: re-define "primary" a particle if it is also "stable" (according to definition in method DecayingTrackChecker)
  96   void SetUseOnlyStableParticle(Bool_t flag=kTRUE) {CallWarningMC(); fUseOnlyStableParticle = flag;}
  97   // only for MC: Getters relative to the above setters
  98   Bool_t GetUseOnlyPrimaryForPred() const {CallWarningMC(); return fUseOnlyPrimaryForPred; }
  99   Bool_t GetUseOnlySecondaryForPred() const {CallWarningMC(); return fUseOnlySecondaryForPred;}
 100   Bool_t GetUseOnlySameParticle() const {CallWarningMC(); return fUseOnlySameParticle;}
 101   Bool_t GetUseOnlyDifferentParticle() const {CallWarningMC(); return fUseOnlyDifferentParticle;}
 102   Bool_t GetUseOnlyStableParticle() const {CallWarningMC(); return fUseOnlyStableParticle;}
 103   // Getters for the data members related to MC true statisitcs (see below)
 104   Int_t GetPredictionPrimary(const UInt_t key) const;
 105   Int_t GetPredictionSecondary(const UInt_t key) const;
 106   Int_t GetClusterPrimary(const UInt_t key) const;
 107   Int_t GetClusterSecondary(const UInt_t key) const;
 108   Int_t GetSuccessPP(const UInt_t key) const;
 109   Int_t GetSuccessTT(const UInt_t key) const;
 110   Int_t GetSuccessS(const UInt_t key) const;
 111   Int_t GetSuccessP(const UInt_t key) const;
 112   Int_t GetFailureS(const UInt_t key) const;
 113   Int_t GetFailureP(const UInt_t key) const;
 114   Int_t GetRecons(const UInt_t key) const;
 115   Int_t GetNonRecons(const UInt_t key) const;
 116   Int_t GetPredictionPrimary(const UInt_t mod, const UInt_t chip) const
 117         {return GetPredictionPrimary(fPlaneEffSPD->GetKey(mod,chip));};
 118   Int_t GetPredictionSecondary(const UInt_t mod, const UInt_t chip) const
 119         {return GetPredictionSecondary(fPlaneEffSPD->GetKey(mod,chip));};
 120   Int_t GetClusterPrimary(const UInt_t mod, const UInt_t chip) const
 121         {return GetClusterPrimary(fPlaneEffSPD->GetKey(mod,chip));};
 122   Int_t GetClusterSecondary(const UInt_t mod, const UInt_t chip) const
 123         {return GetClusterSecondary(fPlaneEffSPD->GetKey(mod,chip));};
 124   Int_t GetSuccessPP(const UInt_t mod, const UInt_t chip) const
 125         {return GetSuccessPP(fPlaneEffSPD->GetKey(mod,chip));};
 126   Int_t GetSuccessTT(const UInt_t mod, const UInt_t chip) const
 127        {return GetSuccessTT(fPlaneEffSPD->GetKey(mod,chip));};
 128   Int_t GetSuccessS(const UInt_t mod, const UInt_t chip) const
 129        {return GetSuccessS(fPlaneEffSPD->GetKey(mod,chip));};
 130   Int_t GetSuccessP(const UInt_t mod, const UInt_t chip) const
 131        {return GetSuccessP(fPlaneEffSPD->GetKey(mod,chip));};
 132   Int_t GetFailureS(const UInt_t mod, const UInt_t chip) const
 133        {return GetFailureS(fPlaneEffSPD->GetKey(mod,chip));};
 134   Int_t GetFailureP(const UInt_t mod, const UInt_t chip) const
 135        {return GetFailureP(fPlaneEffSPD->GetKey(mod,chip));};
 136   Int_t GetRecons(const UInt_t mod, const UInt_t chip) const
 137        {return GetRecons(fPlaneEffSPD->GetKey(mod,chip));};
 138   Int_t GetNonRecons(const UInt_t mod, const UInt_t chip) const
 139        {return GetNonRecons(fPlaneEffSPD->GetKey(mod,chip));};
 140   // methods to write/reas cuts and MC statistics into/from file
 141   // if filename contains  ".root", then data are stored into histograms (->root file).
 142   void SavePredictionMC(TString filename="TrackletsMCpred.root") const;
 143   void ReadPredictionMC(TString filename="TrackletsMCpred.root");
 144   // Print some class info in ascii form to stream (cut values and MC statistics)
 145   virtual void PrintAscii(ostream *os)const;
 146   // Read some class info in ascii form from stream (cut values and MC statistics)
 147   virtual void ReadAscii(istream *is);
 148   Bool_t GetHistOn() const {return fHistOn;}; // return status of histograms
 149   // write histograms into a root file on disk
 150   Bool_t WriteHistosToFile(TString filename="TrackleterSPDHistos.root",Option_t* option = "RECREATE");
 151   // switch on/off the extra histograms
 152   void SetHistOn(Bool_t his=kTRUE) {fHistOn=his;
 153          if(GetHistOn()) {DeleteHistos(); BookHistos();} else DeleteHistos(); return;}
 154
 155 protected:
 156   AliITSTrackleterSPDEff(const AliITSTrackleterSPDEff& mr); // protected method: no copy allowed from outside
 157   AliITSTrackleterSPDEff& operator=(const AliITSTrackleterSPDEff& mr);
 158 //
 159 //// From AliITSMultReconstructor
 160 //
 161   Float_t**     fClustersLay1;               //! clusters in the 1st layer of ITS
 162   Float_t**     fClustersLay2;               //! clusters in the 2nd layer of ITS
 163
 164   Float_t**     fTracklets;            //! tracklets
 165   Bool_t*       fAssociationFlag;      //! flag for the associations
 166
 167   Int_t         fNClustersLay1;        // Number of clusters (Layer1)
 168   Int_t         fNClustersLay2;        // Number of clusters (Layer2)
 169   Int_t         fNTracklets;           // Number of tracklets
 170
 171   // Following members are set via AliITSRecoParam
 172   Bool_t        fOnlyOneTrackletPerC2;         // Allow only one tracklet per cluster in the outer layer
 173   Float_t       fPhiWindowL2;                    // Search window in phi
 174   Float_t       fZetaWindowL2;                   // Search window in eta
 175   Float_t       fPhiOverlapCut;                // Fiducial window in phi for overlap cut
 176   Float_t       fZetaOverlapCut;               // Fiducial window in eta for overlap cut
 177
 178   Bool_t        fHistOn;               // Option to define and fill the histograms
 179
 180   TH1F*         fhClustersDPhiAcc;     //! Phi2 - Phi1 for tracklets
 181   TH1F*         fhClustersDThetaAcc;   //! Theta2 - Theta1 for tracklets
 182   TH1F*         fhClustersDZetaAcc;    //! z2 - z1projected for tracklets
 183   TH1F*         fhClustersDPhiAll;     //! Phi2 - Phi1 all the combinations
 184   TH1F*         fhClustersDThetaAll;   //! Theta2 - Theta1 all the combinations
 185   TH1F*         fhClustersDZetaAll;    //! z2 - z1projected all the combinations
 186
 187   TH2F*         fhDPhiVsDThetaAll;     //! 2D plot for all the combinations
 188   TH2F*         fhDPhiVsDThetaAcc;     //! same plot for tracklets
 189   TH2F*         fhDPhiVsDZetaAll;      //! 2d plot for all the combination
 190   TH2F*         fhDPhiVsDZetaAcc;      //! same plot for tracklets
 191
 192   TH1F*         fhetaTracklets;        //! Pseudorapidity distr. for tracklets
 193   TH1F*         fhphiTracklets;        //! Azimuthal (Phi) distr. for tracklets
 194   TH1F*         fhetaClustersLay1;     //! Pseudorapidity distr. for Clusters L. 1
 195   TH1F*         fhphiClustersLay1;     //! Azimuthal (Phi) distr. for Clusters L. 1
 196 //
 197 //
 198   Bool_t*       fAssociationFlag1;    //! flag for the associations (Layer 1)
 199   UInt_t*       fChipPredOnLay2;      //! prediction for the chip traversed by the tracklet
 200                                       //  based on vtx and ClusterLay1 (to be used in extrapolation)
 201   UInt_t*       fChipPredOnLay1;      //! prediction for the chip traversed by the tracklet
 202                                       // based on vtx and ClusterLay2 (to be used in interpolation)
 203   Int_t         fNTracklets1;   // Number of tracklets layer 1
 204   // possible cuts :
 205   Float_t       fPhiWindowL1;     // Search window in phi (Layer 1)
 206   Float_t       fZetaWindowL1;    // SEarch window in zeta (Layer 1)
 207   Bool_t        fOnlyOneTrackletPerC1; // only one tracklet per cluster in L. 1
 208   Bool_t        fUpdateOncePerEventPlaneEff;  //  If this is kTRUE, then you can update the chip efficiency only once
 209   Int_t         fMinContVtx;  // minimum number of contributors (tracklets) to the vertex for the event to be used
 210                                               //  per event in that chip. This to avoid double counting from the
 211                                               //  same tracklets which has two rec-points on one layer.
 212   Bool_t*       fChipUpdatedInEvent;          //!  boolean (chip by chip) to flag which chip has been updated its efficiency
 213                                               //  in that event
 214   AliITSPlaneEffSPD* fPlaneEffSPD; //! pointer to SPD plane efficiency class
 215   AliITSPlaneEffSPD* fPlaneEffBkg; //! pointer to SPD plane efficiency class for background evaluation
 216   Bool_t   fReflectClusterAroundZAxisForLayer0;  // if kTRUE, then a 180degree rotation around Z is applied to all
 217   Bool_t   fReflectClusterAroundZAxisForLayer1;  // clusters on that layer (x->-x; y->-y)
 218   Bool_t   fLightBkgStudyInParallel; // if this is kTRUE, the basic and correct evaluation of background is performed
 219                                      // in paralell to standard SPD efficiency evaluation
 220   Bool_t   fMC; // Boolean to access Kinematics (only for MC events )
 221   Bool_t   fUseOnlyPrimaryForPred; // Only for MC: if this is true, build tracklet prediction using only primary particles
 222   Bool_t   fUseOnlySecondaryForPred; // Only for MC: if this is true build tracklet prediction using only secondary particles
 223   Bool_t   fUseOnlySameParticle; // Only for MC: if this is true, assign a success only if clusters from same particles
 224                                  // (i.e. PP or SS) otherwise ignore the combination
 225   Bool_t   fUseOnlyDifferentParticle; // Only for MC: if this is true, assign a success only if clusters from different particles
 226                                       // (i.e. PP' or PS or SS') otherwise ignore the combination
 227   Bool_t   fUseOnlyStableParticle; // Only for MC: if this is kTRUE then method PrimaryTrackChecker return kTRUE only
 228                                 //              for particles decaying (eventually) after pixel layers
 229   Int_t *fPredictionPrimary;  //! those for correction of bias from secondaries
 230   Int_t *fPredictionSecondary; //! chip_by_chip: number of Prediction built with primaries/secondaries
 231   Int_t *fClusterPrimary;  //!   number of clusters on a given chip fired by (at least) a primary
 232   Int_t *fClusterSecondary; //!  number of clusters on a given chip fired by (only) secondaries
 233   Int_t *fSuccessPP;     //! number of successes by using the same primary track (vs. chip of the success)
 234   Int_t *fSuccessTT;     //! number of successes by using the same track (either a primary or a secondary) (vs. chip of the success)
 235   Int_t *fSuccessS;      //! number of successes by using a secondary for the prediction (vs. chip of the success)
 236   Int_t *fSuccessP;      //! number of successes by using a primary for the prediction (vs. chip of the success)
 237   Int_t *fFailureS;      //! number of failures by using a secondary for the prediction (vs. chip of the failure)
 238   Int_t *fFailureP;      //! number of failures by using a primary for the prediction (vs. chip of the failure)
 239   Int_t *fRecons;        //! number of particle which can be reconstructed (only for MC from TrackRef)
 240   Int_t *fNonRecons;     //! unmber of particle which cannot be reconstructed (only for MC from TrackRef)
 241  // extra histograms with respect to the base class AliITSMultReconstructor
 242   TH1F*         fhClustersDPhiInterpAcc;   //! Phi2 - Phi1 for tracklets (interpolation phase)
 243   TH1F*         fhClustersDThetaInterpAcc; //! Theta2 - Theta1 for tracklets (interpolation phase)
 244   TH1F*         fhClustersDZetaInterpAcc;  //! z2 - z1projected for tracklets (interpolation phase)
 245   TH1F*         fhClustersDPhiInterpAll;   //! Phi2 - Phi1 all the combinations (interpolation phase)
 246   TH1F*         fhClustersDThetaInterpAll; //! Theta2 - Theta1 all the combinations (interpolation phase)
 247   TH1F*         fhClustersDZetaInterpAll;  //! z2 - z1projected all the combinations (interpolation phase)
 248   TH2F*         fhDPhiVsDThetaInterpAll; //! 2D plot for all the combinations
 249   TH2F*         fhDPhiVsDThetaInterpAcc; //! same plot for tracklets
 250   TH2F*         fhDPhiVsDZetaInterpAll;  //! 2d plot for all the combination
 251   TH2F*         fhDPhiVsDZetaInterpAcc;  //! same plot for tracklets
 252   TH1F*         fhetaClustersLay2; //! Pseudorapidity distr. for Clusters L. 2
 253   TH1F*         fhphiClustersLay2; //! Azimuthal (Phi) distr. for Clusters L. 2
 254   TH1F*         fhClustersInChip; //! number of fired clusters versus chip number [0,1199]
 255   TH2F**        fhClustersInModuleLay1; //! distribution of cluster in the module Lay 1 (sub-chip scale)
 256   TH2F**        fhClustersInModuleLay2; //! distribution of cluster in the module Lay 2 (sub-chip scale)
 257 //
 258   Double_t GetRLayer(Int_t layer); // return average radius of layer (0,1) from Geometry
 259   Bool_t PrimaryTrackChecker(Int_t ipart,AliStack* stack=0x0);  // check if a MC particle is primary (need AliStack)
 260   Int_t DecayingTrackChecker(Int_t ipart,AliStack* stack=0x0);  // For a primary particle, check if it is stable (see cxx)
 261 // check if a MC particle is reconstructable
 262   Bool_t IsReconstructableAt(Int_t layer,Int_t iC,Int_t ipart,Float_t* vtx,AliStack* stack=0x0,TTree* ref=0x0);
 263   void InitPredictionMC(); // allocate memory for cuts and MC data memebers
 264   void DeletePredictionMC(); // deallocate memory
 265   // method to locate a chip using current vtx and polar coordinate od tracklet w.r.t. to vtx (zVtx may not be given)
 266   Bool_t FindChip(UInt_t &key, Int_t layer,  Float_t* vtx, Float_t thetaVtx, Float_t phiVtx, Float_t zVtx=999.);
 267   // method to transform from Global Cilindrical coordinate to local (module) Cartesian coordinate
 268   Bool_t FromGloCilToLocCart(Int_t ilayer,Int_t idet, Double_t r, Double_t phi, Double_t z,
 269                            Float_t &xloc, Float_t &zloc);
 270   // method to obtain the module (detector) index using global coordinates
 271   Int_t FindDetectorIndex(Int_t layer, Double_t phi, Double_t z);
 272   // this method gives you the intersections between a line and a circle (centred in the origin)
 273   // using polar coordinates
 274   Bool_t FindIntersectionPolar(Double_t vtx[2],Double_t phiVtx, Double_t R,Double_t &phi);
 275   Bool_t SetAngleRange02Pi(Double_t &angle); // set the range of angle in [0,2pi[
 276   Bool_t SetAngleRange02Pi(Float_t  &angle)
 277   {Double_t tmp=(Double_t)angle; Bool_t ret=SetAngleRange02Pi(tmp);angle=(Float_t)tmp;return ret;};
 278   void CallWarningMC() const {if(!fMC) AliWarning("You can use this method only for MC! Call SetMC() first");}
 279   Bool_t SaveHists();
 280   void BookHistos(); // booking of extra histograms w.r.t. base class
 281   void DeleteHistos(); //delete histos from memory
 282   // Method to apply a rotation by 180degree to all RecPoints (x->-x; y->-y) on a given layer
 283   void ReflectClusterAroundZAxisForLayer(Int_t ilayer); // to be used for backgnd estimation on real data
 284
 285   void LoadClusterArrays(TTree* tree);
 286
 287   ClassDef(AliITSTrackleterSPDEff,6)
 288 };
 289 // Input and output function for standard C++ input/output (for the cut values and MC statistics).
 290 ostream &operator<<(ostream &os,const AliITSTrackleterSPDEff &s);
 291 istream &operator>>(istream &is, AliITSTrackleterSPDEff &s);
 292 #endif
 293