X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSTrackleterSPDEff.h;h=e08d4f1362ce70b6e85ada5ba904de3aa641f1fd;hb=69c15b90395b1f5ea4d9e396be14c2cc1f1ff5b1;hp=514fc097116ed4304ef4be934ffd25deda2d3ef2;hpb=58e8dc31d3a168d1eabfa44d71b82f1380ca004f;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSTrackleterSPDEff.h b/ITS/AliITSTrackleterSPDEff.h index 514fc097116..e08d4f1362c 100644 --- a/ITS/AliITSTrackleterSPDEff.h +++ b/ITS/AliITSTrackleterSPDEff.h @@ -26,16 +26,19 @@ class AliStack; class TTree; class TH1F; class TH2F; +class AliPlaneEff; + #include "AliTracker.h" #include "AliITSPlaneEffSPD.h" -#include "AliPlaneEff.h" + +using std::istream; class AliITSTrackleterSPDEff : public AliTracker { public: AliITSTrackleterSPDEff(); virtual ~AliITSTrackleterSPDEff(); - Int_t Clusters2Tracks(AliESDEvent *); + Int_t Clusters2Tracks(AliESDEvent *esd); Int_t PostProcess(AliESDEvent *); virtual Int_t PropagateBack(AliESDEvent*) {return 0;} @@ -45,22 +48,27 @@ public: virtual AliCluster *GetCluster(Int_t) const {return NULL;} // Main method to perform the trackleter and the SPD efficiency evaluation - void Reconstruct(AliStack* pStack=0x0, TTree* tRef=0x0); - - void SetReflectClusterAroundZAxisForLayer(Int_t ilayer,Bool_t b=kTRUE){ // method to study residual background: - if(b) AliInfo(Form("All clusters on layer %d will be rotated by 180 deg around z",ilayer)); - if(ilayer==0) fReflectClusterAroundZAxisForLayer0=b; // a rotation by 180degree around the Z axis - else if(ilayer==1) fReflectClusterAroundZAxisForLayer1=b; // (x->-x; y->-y) to all RecPoints on a - else AliInfo("Nothing done: input argument (ilayer) either 0 or 1"); // given layer is applied. In such a way - } // you remove all the true tracklets. + void Reconstruct(AliStack* pStack=0x0, TTree* tRef=0x0, Bool_t lbkg=kFALSE); + void SetReflectClusterAroundZAxisForLayer(Int_t ilayer,Bool_t b=kTRUE); // method to study residual background: + // a rotation by 180degree around the Z axis + // (x->-x; y->-y) to all RecPoints on a + // given layer is applied. In such a way + // you remove all the true tracklets. + void SetLightBkgStudyInParallel(Bool_t b = kTRUE); // if you set this on, then the estimation of the + // SPD efficiency is done as usual for data, but in + // parallel a light (i.e. without control histograms, etc.) + // evaluation of combinatorial background is performed + // with the usual ReflectClusterAroundZAxisForLayer method. + Bool_t GetLightBkgStudyInParallel() const {return fLightBkgStudyInParallel;} void SetOnlyOneTrackletPerC2(Bool_t b = kTRUE) {fOnlyOneTrackletPerC2 = b;} - void SetPhiWindow(Float_t w=0.08) {fPhiWindow=w;} - void SetZetaWindow(Float_t w=1.) {fZetaWindow=w;} + void SetPhiWindowL2(Float_t w=0.08) {fPhiWindowL2=w;} + void SetZetaWindowL2(Float_t w=1.) {fZetaWindowL2=w;} void SetPhiWindowL1(Float_t w=0.08) {fPhiWindowL1=w;} // method to set the cuts in the interpolation void SetZetaWindowL1(Float_t w=1.) {fZetaWindowL1=w;} // phase; use method of the base class for extrap. void SetOnlyOneTrackletPerC1(Bool_t b = kTRUE) {fOnlyOneTrackletPerC1 = b;} // as in the base class but + void SetMinContVtx(Int_t min=3) {fMinContVtx=min;} // set minimum n. of contributors to vertex Int_t GetNClustersLayer1() const {return fNClustersLay1;} Int_t GetNClustersLayer2() const {return fNClustersLay2;} @@ -132,8 +140,8 @@ public: {return GetNonRecons(fPlaneEffSPD->GetKey(mod,chip));}; // methods to write/reas cuts and MC statistics into/from file // if filename contains ".root", then data are stored into histograms (->root file). - void SavePredictionMC(TString filename="TrackletsMCpred.txt") const; - void ReadPredictionMC(TString filename="TrackletsMCpred.txt"); + void SavePredictionMC(TString filename="TrackletsMCpred.root") const; + void ReadPredictionMC(TString filename="TrackletsMCpred.root"); // Print some class info in ascii form to stream (cut values and MC statistics) virtual void PrintAscii(ostream *os)const; // Read some class info in ascii form from stream (cut values and MC statistics) @@ -151,11 +159,11 @@ protected: // //// From AliITSMultReconstructor // - Float_t** fClustersLay1; // clusters in the 1st layer of ITS - Float_t** fClustersLay2; // clusters in the 2nd layer of ITS + Float_t** fClustersLay1; //! clusters in the 1st layer of ITS + Float_t** fClustersLay2; //! clusters in the 2nd layer of ITS - Float_t** fTracklets; // tracklets - Bool_t* fAssociationFlag; // flag for the associations + Float_t** fTracklets; //! tracklets + Bool_t* fAssociationFlag; //! flag for the associations Int_t fNClustersLay1; // Number of clusters (Layer1) Int_t fNClustersLay2; // Number of clusters (Layer2) @@ -163,35 +171,35 @@ protected: // Following members are set via AliITSRecoParam Bool_t fOnlyOneTrackletPerC2; // Allow only one tracklet per cluster in the outer layer - Float_t fPhiWindow; // Search window in phi - Float_t fZetaWindow; // Search window in eta + Float_t fPhiWindowL2; // Search window in phi + Float_t fZetaWindowL2; // Search window in eta Float_t fPhiOverlapCut; // Fiducial window in phi for overlap cut Float_t fZetaOverlapCut; // Fiducial window in eta for overlap cut Bool_t fHistOn; // Option to define and fill the histograms - TH1F* fhClustersDPhiAcc; // Phi2 - Phi1 for tracklets - TH1F* fhClustersDThetaAcc; // Theta2 - Theta1 for tracklets - TH1F* fhClustersDZetaAcc; // z2 - z1projected for tracklets - TH1F* fhClustersDPhiAll; // Phi2 - Phi1 all the combinations - TH1F* fhClustersDThetaAll; // Theta2 - Theta1 all the combinations - TH1F* fhClustersDZetaAll; // z2 - z1projected all the combinations + TH1F* fhClustersDPhiAcc; //! Phi2 - Phi1 for tracklets + TH1F* fhClustersDThetaAcc; //! Theta2 - Theta1 for tracklets + TH1F* fhClustersDZetaAcc; //! z2 - z1projected for tracklets + TH1F* fhClustersDPhiAll; //! Phi2 - Phi1 all the combinations + TH1F* fhClustersDThetaAll; //! Theta2 - Theta1 all the combinations + TH1F* fhClustersDZetaAll; //! z2 - z1projected all the combinations - TH2F* fhDPhiVsDThetaAll; // 2D plot for all the combinations - TH2F* fhDPhiVsDThetaAcc; // same plot for tracklets - TH2F* fhDPhiVsDZetaAll; // 2d plot for all the combination - TH2F* fhDPhiVsDZetaAcc; // same plot for tracklets + TH2F* fhDPhiVsDThetaAll; //! 2D plot for all the combinations + TH2F* fhDPhiVsDThetaAcc; //! same plot for tracklets + TH2F* fhDPhiVsDZetaAll; //! 2d plot for all the combination + TH2F* fhDPhiVsDZetaAcc; //! same plot for tracklets - TH1F* fhetaTracklets; // Pseudorapidity distr. for tracklets - TH1F* fhphiTracklets; // Azimuthal (Phi) distr. for tracklets - TH1F* fhetaClustersLay1; // Pseudorapidity distr. for Clusters L. 1 - TH1F* fhphiClustersLay1; // Azimuthal (Phi) distr. for Clusters L. 1 + TH1F* fhetaTracklets; //! Pseudorapidity distr. for tracklets + TH1F* fhphiTracklets; //! Azimuthal (Phi) distr. for tracklets + TH1F* fhetaClustersLay1; //! Pseudorapidity distr. for Clusters L. 1 + TH1F* fhphiClustersLay1; //! Azimuthal (Phi) distr. for Clusters L. 1 // // - Bool_t* fAssociationFlag1; // flag for the associations (Layer 1) - UInt_t* fChipPredOnLay2; // prediction for the chip traversed by the tracklet - // based on vtx and ClusterLay1 (to be used in extrapolation) - UInt_t* fChipPredOnLay1; // prediction for the chip traversed by the tracklet + Bool_t* fAssociationFlag1; //! flag for the associations (Layer 1) + UInt_t* fChipPredOnLay2; //! prediction for the chip traversed by the tracklet + // based on vtx and ClusterLay1 (to be used in extrapolation) + UInt_t* fChipPredOnLay1; //! prediction for the chip traversed by the tracklet // based on vtx and ClusterLay2 (to be used in interpolation) Int_t fNTracklets1; // Number of tracklets layer 1 // possible cuts : @@ -199,13 +207,17 @@ protected: Float_t fZetaWindowL1; // SEarch window in zeta (Layer 1) Bool_t fOnlyOneTrackletPerC1; // only one tracklet per cluster in L. 1 Bool_t fUpdateOncePerEventPlaneEff; // If this is kTRUE, then you can update the chip efficiency only once + Int_t fMinContVtx; // minimum number of contributors (tracklets) to the vertex for the event to be used // per event in that chip. This to avoid double counting from the // same tracklets which has two rec-points on one layer. - Bool_t* fChipUpdatedInEvent; // boolean (chip by chip) to flag which chip has been updated its efficiency + Bool_t* fChipUpdatedInEvent; //! boolean (chip by chip) to flag which chip has been updated its efficiency // in that event - AliITSPlaneEffSPD* fPlaneEffSPD; // pointer to SPD plane efficiency class + AliITSPlaneEffSPD* fPlaneEffSPD; //! pointer to SPD plane efficiency class + AliITSPlaneEffSPD* fPlaneEffBkg; //! pointer to SPD plane efficiency class for background evaluation Bool_t fReflectClusterAroundZAxisForLayer0; // if kTRUE, then a 180degree rotation around Z is applied to all Bool_t fReflectClusterAroundZAxisForLayer1; // clusters on that layer (x->-x; y->-y) + Bool_t fLightBkgStudyInParallel; // if this is kTRUE, the basic and correct evaluation of background is performed + // in paralell to standard SPD efficiency evaluation Bool_t fMC; // Boolean to access Kinematics (only for MC events ) Bool_t fUseOnlyPrimaryForPred; // Only for MC: if this is true, build tracklet prediction using only primary particles Bool_t fUseOnlySecondaryForPred; // Only for MC: if this is true build tracklet prediction using only secondary particles @@ -215,41 +227,45 @@ protected: // (i.e. PP' or PS or SS') otherwise ignore the combination Bool_t fUseOnlyStableParticle; // Only for MC: if this is kTRUE then method PrimaryTrackChecker return kTRUE only // for particles decaying (eventually) after pixel layers - Int_t *fPredictionPrimary; // those for correction of bias from secondaries - Int_t *fPredictionSecondary; // chip_by_chip: number of Prediction built with primaries/secondaries - Int_t *fClusterPrimary; // number of clusters on a given chip fired by (at least) a primary - Int_t *fClusterSecondary; // number of clusters on a given chip fired by (only) secondaries - Int_t *fSuccessPP; // number of successes by using the same primary track (vs. chip of the success) - Int_t *fSuccessTT; // number of successes by using the same track (either a primary or a secondary) (vs. chip of the success) - Int_t *fSuccessS; // number of successes by using a secondary for the prediction (vs. chip of the success) - Int_t *fSuccessP; // number of successes by using a primary for the prediction (vs. chip of the success) - Int_t *fFailureS; // number of failures by using a secondary for the prediction (vs. chip of the failure) - Int_t *fFailureP; // number of failures by using a primary for the prediction (vs. chip of the failure) - Int_t *fRecons; // number of particle which can be reconstructed (only for MC from TrackRef) - Int_t *fNonRecons; // unmber of particle which cannot be reconstructed (only for MC from TrackRef) + Int_t *fPredictionPrimary; //! those for correction of bias from secondaries + Int_t *fPredictionSecondary; //! chip_by_chip: number of Prediction built with primaries/secondaries + Int_t *fClusterPrimary; //! number of clusters on a given chip fired by (at least) a primary + Int_t *fClusterSecondary; //! number of clusters on a given chip fired by (only) secondaries + Int_t *fSuccessPP; //! number of successes by using the same primary track (vs. chip of the success) + Int_t *fSuccessTT; //! number of successes by using the same track (either a primary or a secondary) (vs. chip of the success) + Int_t *fSuccessS; //! number of successes by using a secondary for the prediction (vs. chip of the success) + Int_t *fSuccessP; //! number of successes by using a primary for the prediction (vs. chip of the success) + Int_t *fFailureS; //! number of failures by using a secondary for the prediction (vs. chip of the failure) + Int_t *fFailureP; //! number of failures by using a primary for the prediction (vs. chip of the failure) + Int_t *fRecons; //! number of particle which can be reconstructed (only for MC from TrackRef) + Int_t *fNonRecons; //! unmber of particle which cannot be reconstructed (only for MC from TrackRef) // extra histograms with respect to the base class AliITSMultReconstructor - TH1F* fhClustersDPhiInterpAcc; // Phi2 - Phi1 for tracklets (interpolation phase) - TH1F* fhClustersDThetaInterpAcc; // Theta2 - Theta1 for tracklets (interpolation phase) - TH1F* fhClustersDZetaInterpAcc; // z2 - z1projected for tracklets (interpolation phase) - TH1F* fhClustersDPhiInterpAll; // Phi2 - Phi1 all the combinations (interpolation phase) - TH1F* fhClustersDThetaInterpAll; // Theta2 - Theta1 all the combinations (interpolation phase) - TH1F* fhClustersDZetaInterpAll; // z2 - z1projected all the combinations (interpolation phase) - TH2F* fhDPhiVsDThetaInterpAll; // 2D plot for all the combinations - TH2F* fhDPhiVsDThetaInterpAcc; // same plot for tracklets - TH2F* fhDPhiVsDZetaInterpAll; // 2d plot for all the combination - TH2F* fhDPhiVsDZetaInterpAcc; // same plot for tracklets - TH1F* fhetaClustersLay2; // Pseudorapidity distr. for Clusters L. 2 - TH1F* fhphiClustersLay2; // Azimuthal (Phi) distr. for Clusters L. 2 + TH1F* fhClustersDPhiInterpAcc; //! Phi2 - Phi1 for tracklets (interpolation phase) + TH1F* fhClustersDThetaInterpAcc; //! Theta2 - Theta1 for tracklets (interpolation phase) + TH1F* fhClustersDZetaInterpAcc; //! z2 - z1projected for tracklets (interpolation phase) + TH1F* fhClustersDPhiInterpAll; //! Phi2 - Phi1 all the combinations (interpolation phase) + TH1F* fhClustersDThetaInterpAll; //! Theta2 - Theta1 all the combinations (interpolation phase) + TH1F* fhClustersDZetaInterpAll; //! z2 - z1projected all the combinations (interpolation phase) + TH2F* fhDPhiVsDThetaInterpAll; //! 2D plot for all the combinations + TH2F* fhDPhiVsDThetaInterpAcc; //! same plot for tracklets + TH2F* fhDPhiVsDZetaInterpAll; //! 2d plot for all the combination + TH2F* fhDPhiVsDZetaInterpAcc; //! same plot for tracklets + TH1F* fhetaClustersLay2; //! Pseudorapidity distr. for Clusters L. 2 + TH1F* fhphiClustersLay2; //! Azimuthal (Phi) distr. for Clusters L. 2 + TH1F* fhClustersInChip; //! number of fired clusters versus chip number [0,1199] + TH2F** fhClustersInModuleLay1; //! distribution of cluster in the module Lay 1 (sub-chip scale) + TH2F** fhClustersInModuleLay2; //! distribution of cluster in the module Lay 2 (sub-chip scale) // + void Init(); // initialize pointers and allocate memory Double_t GetRLayer(Int_t layer); // return average radius of layer (0,1) from Geometry Bool_t PrimaryTrackChecker(Int_t ipart,AliStack* stack=0x0); // check if a MC particle is primary (need AliStack) Int_t DecayingTrackChecker(Int_t ipart,AliStack* stack=0x0); // For a primary particle, check if it is stable (see cxx) // check if a MC particle is reconstructable - Bool_t IsReconstructableAt(Int_t layer,Int_t iC,Int_t ipart,Float_t* vtx,AliStack* stack=0x0,TTree* ref=0x0); + Bool_t IsReconstructableAt(Int_t layer,Int_t iC,Int_t ipart,const Float_t* vtx,const AliStack* stack=0x0,TTree* ref=0x0); void InitPredictionMC(); // allocate memory for cuts and MC data memebers void DeletePredictionMC(); // deallocate memory // method to locate a chip using current vtx and polar coordinate od tracklet w.r.t. to vtx (zVtx may not be given) - Bool_t FindChip(UInt_t &key, Int_t layer, Float_t* vtx, Float_t thetaVtx, Float_t phiVtx, Float_t zVtx=999.); + Bool_t FindChip(UInt_t &key, Int_t layer,const Float_t* vtx, Float_t thetaVtx, Float_t phiVtx, Float_t zVtx=999.); // method to transform from Global Cilindrical coordinate to local (module) Cartesian coordinate Bool_t FromGloCilToLocCart(Int_t ilayer,Int_t idet, Double_t r, Double_t phi, Double_t z, Float_t &xloc, Float_t &zloc); @@ -258,8 +274,8 @@ protected: // this method gives you the intersections between a line and a circle (centred in the origin) // using polar coordinates Bool_t FindIntersectionPolar(Double_t vtx[2],Double_t phiVtx, Double_t R,Double_t &phi); - Bool_t SetAngleRange02Pi(Double_t &angle); // set the range of angle in [0,2pi[ - Bool_t SetAngleRange02Pi(Float_t &angle) + Bool_t SetAngleRange02Pi(Double_t &angle) const; // set the range of angle in [0,2pi[ + Bool_t SetAngleRange02Pi(Float_t &angle) const {Double_t tmp=(Double_t)angle; Bool_t ret=SetAngleRange02Pi(tmp);angle=(Float_t)tmp;return ret;}; void CallWarningMC() const {if(!fMC) AliWarning("You can use this method only for MC! Call SetMC() first");} Bool_t SaveHists(); @@ -270,9 +286,10 @@ protected: void LoadClusterArrays(TTree* tree); - ClassDef(AliITSTrackleterSPDEff,3) + ClassDef(AliITSTrackleterSPDEff,6) }; // Input and output function for standard C++ input/output (for the cut values and MC statistics). ostream &operator<<(ostream &os,const AliITSTrackleterSPDEff &s); istream &operator>>(istream &is, AliITSTrackleterSPDEff &s); #endif +