]>
Commit | Line | Data |
---|---|---|
275a301c | 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 | // | |
58e8dc31 | 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 | |
275a301c | 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 | ||
84161aec | 25 | class AliStack; |
58e8dc31 | 26 | class TTree; |
27 | class TH1F; | |
28 | class TH2F; | |
29 | #include "AliTracker.h" | |
275a301c | 30 | #include "AliITSPlaneEffSPD.h" |
58e8dc31 | 31 | #include "AliPlaneEff.h" |
275a301c | 32 | |
58e8dc31 | 33 | class AliITSTrackleterSPDEff : public AliTracker |
275a301c | 34 | { |
35 | public: | |
36 | AliITSTrackleterSPDEff(); | |
37 | virtual ~AliITSTrackleterSPDEff(); | |
0ea92079 | 38 | Int_t Clusters2Tracks(AliESDEvent *esd); |
58e8dc31 | 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 | ||
84161aec | 47 | // Main method to perform the trackleter and the SPD efficiency evaluation |
03ee9629 | 48 | void Reconstruct(AliStack* pStack=0x0, TTree* tRef=0x0, Bool_t lbkg=kFALSE); |
275a301c | 49 | |
0fce916f | 50 | void SetReflectClusterAroundZAxisForLayer(Int_t ilayer,Bool_t b=kTRUE){ // method to study residual background: |
03ee9629 | 51 | if(b) {AliInfo(Form("All clusters on layer %d will be rotated by 180 deg around z",ilayer)); |
52 | SetLightBkgStudyInParallel(kFALSE);} | |
0fce916f | 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. | |
03ee9629 | 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;} | |
58e8dc31 | 63 | void SetOnlyOneTrackletPerC2(Bool_t b = kTRUE) {fOnlyOneTrackletPerC2 = b;} |
7284b2b2 | 64 | void SetPhiWindowL2(Float_t w=0.08) {fPhiWindowL2=w;} |
65 | void SetZetaWindowL2(Float_t w=1.) {fZetaWindowL2=w;} | |
58e8dc31 | 66 | |
84161aec | 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 | |
0ea92079 | 70 | void SetMinContVtx(Int_t min=3) {fMinContVtx=min;} // set minimum n. of contributors to vertex |
58e8dc31 | 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];} | |
84161aec | 79 | // for the inner layer |
a3b31967 | 80 | void SetUpdateOncePerEventPlaneEff(Bool_t b = kTRUE) {fUpdateOncePerEventPlaneEff = b;} |
275a301c | 81 | |
58e8dc31 | 82 | AliITSPlaneEffSPD* GetPlaneEffSPD() const {return fPlaneEffSPD;} // return a pointer to the AliITSPlaneEffSPD |
83 | AliPlaneEff *GetPlaneEff() {return (AliPlaneEff*)fPlaneEffSPD;} // return the pointer to AliPlaneEff | |
275a301c | 84 | |
c6a05d92 | 85 | void SetMC(Bool_t mc=kTRUE) {fMC=mc; fMC? InitPredictionMC() : DeletePredictionMC(); return;} // switch on access to MC true |
84161aec | 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 | |
275a301c | 90 | void SetUseOnlySecondaryForPred(Bool_t flag=kTRUE) {CallWarningMC(); fUseOnlySecondaryForPred = flag;} |
84161aec | 91 | // Only for MC: associate a cluster to the tracklet prediction if from the same particle |
275a301c | 92 | void SetUseOnlySameParticle(Bool_t flag=kTRUE) {CallWarningMC(); fUseOnlySameParticle = flag;} |
84161aec | 93 | // Only for MC: associate a cluster to the tracklet prediction if from different particles |
275a301c | 94 | void SetUseOnlyDifferentParticle(Bool_t flag=kTRUE) {CallWarningMC(); fUseOnlyDifferentParticle = flag;} |
84161aec | 95 | // Only for MC: re-define "primary" a particle if it is also "stable" (according to definition in method DecayingTrackChecker) |
275a301c | 96 | void SetUseOnlyStableParticle(Bool_t flag=kTRUE) {CallWarningMC(); fUseOnlyStableParticle = flag;} |
84161aec | 97 | // only for MC: Getters relative to the above setters |
275a301c | 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;} | |
84161aec | 103 | // Getters for the data members related to MC true statisitcs (see below) |
275a301c | 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; | |
a3b31967 | 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; | |
275a301c | 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));}; | |
a3b31967 | 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));}; | |
c6a05d92 | 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). | |
17d531c2 | 142 | void SavePredictionMC(TString filename="TrackletsMCpred.root") const; |
143 | void ReadPredictionMC(TString filename="TrackletsMCpred.root"); | |
275a301c | 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 | |
84161aec | 149 | // write histograms into a root file on disk |
275a301c | 150 | Bool_t WriteHistosToFile(TString filename="TrackleterSPDHistos.root",Option_t* option = "RECREATE"); |
84161aec | 151 | // switch on/off the extra histograms |
58e8dc31 | 152 | void SetHistOn(Bool_t his=kTRUE) {fHistOn=his; |
275a301c | 153 | if(GetHistOn()) {DeleteHistos(); BookHistos();} else DeleteHistos(); return;} |
154 | ||
155 | protected: | |
84161aec | 156 | AliITSTrackleterSPDEff(const AliITSTrackleterSPDEff& mr); // protected method: no copy allowed from outside |
275a301c | 157 | AliITSTrackleterSPDEff& operator=(const AliITSTrackleterSPDEff& mr); |
58e8dc31 | 158 | // |
159 | //// From AliITSMultReconstructor | |
160 | // | |
17d531c2 | 161 | Float_t** fClustersLay1; //! clusters in the 1st layer of ITS |
162 | Float_t** fClustersLay2; //! clusters in the 2nd layer of ITS | |
58e8dc31 | 163 | |
17d531c2 | 164 | Float_t** fTracklets; //! tracklets |
165 | Bool_t* fAssociationFlag; //! flag for the associations | |
275a301c | 166 | |
58e8dc31 | 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 | |
7284b2b2 | 173 | Float_t fPhiWindowL2; // Search window in phi |
174 | Float_t fZetaWindowL2; // Search window in eta | |
58e8dc31 | 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 | ||
17d531c2 | 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 | |
58e8dc31 | 186 | |
17d531c2 | 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 | |
58e8dc31 | 191 | |
17d531c2 | 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 | |
58e8dc31 | 196 | // |
197 | // | |
17d531c2 | 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 | |
275a301c | 202 | // based on vtx and ClusterLay2 (to be used in interpolation) |
203 | Int_t fNTracklets1; // Number of tracklets layer 1 | |
a3b31967 | 204 | // possible cuts : |
275a301c | 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 | |
a3b31967 | 208 | Bool_t fUpdateOncePerEventPlaneEff; // If this is kTRUE, then you can update the chip efficiency only once |
0ea92079 | 209 | Int_t fMinContVtx; // minimum number of contributors (tracklets) to the vertex for the event to be used |
a3b31967 | 210 | // per event in that chip. This to avoid double counting from the |
211 | // same tracklets which has two rec-points on one layer. | |
17d531c2 | 212 | Bool_t* fChipUpdatedInEvent; //! boolean (chip by chip) to flag which chip has been updated its efficiency |
a3b31967 | 213 | // in that event |
17d531c2 | 214 | AliITSPlaneEffSPD* fPlaneEffSPD; //! pointer to SPD plane efficiency class |
03ee9629 | 215 | AliITSPlaneEffSPD* fPlaneEffBkg; //! pointer to SPD plane efficiency class for background evaluation |
0fce916f | 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) | |
03ee9629 | 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 | |
275a301c | 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 | |
17d531c2 | 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) | |
275a301c | 241 | // extra histograms with respect to the base class AliITSMultReconstructor |
17d531c2 | 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) | |
275a301c | 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) | |
a3b31967 | 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); | |
c6a05d92 | 263 | void InitPredictionMC(); // allocate memory for cuts and MC data memebers |
264 | void DeletePredictionMC(); // deallocate memory | |
275a301c | 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 | |
0fce916f | 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 | |
275a301c | 284 | |
58e8dc31 | 285 | void LoadClusterArrays(TTree* tree); |
286 | ||
03ee9629 | 287 | ClassDef(AliITSTrackleterSPDEff,6) |
275a301c | 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 | |
0ea92079 | 293 |