]>
Commit | Line | Data |
---|---|---|
53fd478b | 1 | // ************************************************************************** |
2 | // * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | // * * | |
4 | // * Author: The ALICE Off-line Project. * | |
5 | // * Contributors are mentioned in the code where appropriate. * | |
6 | // * * | |
7 | // * Permission to use, copy, modify and distribute this software and its * | |
8 | // * documentation strictly for non-commercial purposes is hereby granted * | |
9 | // * without fee, provided that the above copyright notice appears in all * | |
10 | // * copies and that both the copyright notice and this permission notice * | |
11 | // * appear in the supporting documentation. The authors make no claims * | |
12 | // * about the suitability of this software for any purpose. It is * | |
13 | // * provided "as is" without express or implied warranty. * | |
14 | // ************************************************************************** | |
4c039060 | 15 | |
53fd478b | 16 | #include "AliRICH.h" |
17 | #include "AliRICHParam.h" | |
db910db9 | 18 | #include "AliRICHHelix.h" //ReadESD |
237c933d | 19 | #include <TFile.h> |
116cbefd | 20 | #include <TObjArray.h> |
3582c1f9 | 21 | #include <TParticle.h> |
22 | #include <AliStack.h> | |
db910db9 | 23 | #include <AliRun.h> |
24 | #include <AliMC.h> //ctor | |
e53ffca5 | 25 | #include <AliHeader.h> |
26 | #include <AliGenEventHeader.h> | |
27 | #include <AliGenHijingEventHeader.h> | |
e42a7b46 | 28 | #include <AliESD.h> |
db910db9 | 29 | #include <TH1F.h> //HitQA() |
30 | #include <TH2F.h> //Display() | |
d3eb6079 | 31 | #include <TBenchmark.h> |
998b831f | 32 | #include <AliLog.h> |
db910db9 | 33 | #include <TLatex.h> //Display() |
34 | #include <TCanvas.h> //Display() | |
35 | #include <TGraph.h> //Display() | |
36 | #include <TStyle.h> //Display() | |
37 | #include <TMarker.h> //Display() | |
c60862bf | 38 | ClassImp(AliRICH) |
39 | //__________________________________________________________________________________________________ | |
15d8311d | 40 | // RICH manager class |
c60862bf | 41 | //BEGIN_HTML |
15d8311d | 42 | /* |
43 | <img src="gif/alirich.gif"> | |
44 | */ | |
c60862bf | 45 | //END_HTML |
46 | //__________________________________________________________________________________________________ | |
db910db9 | 47 | AliRICH::AliRICH():AliDetector(),fSdig(0),fSdigCnt(0),fDig(0),fClu(0) |
53fd478b | 48 | { |
49 | //Default ctor should not contain any new operators | |
543d5224 | 50 | //AliDetector ctor deals with Hits and Digits |
15d8311d | 51 | }//AliRICH::AliRICH() |
c021cb15 | 52 | //__________________________________________________________________________________________________ |
fe4da5cc | 53 | AliRICH::AliRICH(const char *name, const char *title) |
db910db9 | 54 | :AliDetector(name,title),fSdig(0),fSdigCnt(0),fDig(0),fClu(0) |
53fd478b | 55 | { |
56 | //Named ctor | |
998b831f | 57 | AliDebug(1,"Start."); |
543d5224 | 58 | //AliDetector ctor deals with Hits and Digits (reset them to 0, does not create them) |
db910db9 | 59 | HitCreate(); gAlice->GetMCApp()->AddHitList(fHits); |
60 | fNcham=7; | |
61 | fCounters.ResizeTo(40); fCounters.Zero(); | |
998b831f | 62 | AliDebug(1,"Stop."); |
dfb4e77d | 63 | }//AliRICH::AliRICH(const char *name, const char *title) |
c021cb15 | 64 | //__________________________________________________________________________________________________ |
fe4da5cc | 65 | AliRICH::~AliRICH() |
53fd478b | 66 | { |
67 | //dtor | |
998b831f | 68 | AliDebug(1,"Start."); |
237c933d | 69 | |
c60862bf | 70 | |
71 | if(fHits) delete fHits; | |
db910db9 | 72 | if(fSdig) delete fSdig; |
c60862bf | 73 | if(fDigits) delete fDigits; |
db910db9 | 74 | if(fDig) {fDig->Delete(); delete fDig;} |
75 | if(fClu) {fClu->Delete(); delete fClu;} | |
998b831f | 76 | AliDebug(1,"Stop."); |
dfb4e77d | 77 | }//AliRICH::~AliRICH() |
c021cb15 | 78 | //__________________________________________________________________________________________________ |
dfb4e77d | 79 | void AliRICH::BuildGeometry() |
53fd478b | 80 | { |
81 | //Builds a TNode geometry for event display | |
8346f242 | 82 | AliDebug(1,"Start."); |
237c933d | 83 | |
998b831f | 84 | AliDebug(1,"Stop."); |
dfb4e77d | 85 | }//void AliRICH::BuildGeometry() |
a25b3368 | 86 | //__________________________________________________________________________________________________ |
dfb4e77d | 87 | void AliRICH::MakeBranch(Option_t* option) |
53fd478b | 88 | { |
89 | //Create Tree branches for the RICH. | |
998b831f | 90 | AliDebug(1,Form("Start with option= %s.",option)); |
dfb4e77d | 91 | |
92 | const Int_t kBufferSize = 4000; | |
dfb4e77d | 93 | |
dfb4e77d | 94 | const char *cH = strstr(option,"H"); |
95 | const char *cD = strstr(option,"D"); | |
96 | const char *cR = strstr(option,"R"); | |
97 | const char *cS = strstr(option,"S"); | |
98 | ||
c60862bf | 99 | if(cH&&TreeH()){//H |
db910db9 | 100 | HitCreate(); //branch will be created in AliDetector::MakeBranch |
c60862bf | 101 | }//H |
dfb4e77d | 102 | AliDetector::MakeBranch(option);//this is after cH because we need to guarantee that fHits array is created |
103 | ||
c60862bf | 104 | if(cS&&fLoader->TreeS()){//S |
db910db9 | 105 | SDigCreate(); MakeBranchInTree(fLoader->TreeS(),"RICH",&fSdig,kBufferSize,0) ; |
c60862bf | 106 | }//S |
dfb4e77d | 107 | |
c60862bf | 108 | if(cD&&fLoader->TreeD()){//D |
db910db9 | 109 | DigCreate(); |
110 | for(Int_t i=0;i<fNcham;i++){ | |
111 | MakeBranchInTree(fLoader->TreeD(),Form("%s%d",GetName(),i+1),&((*fDig)[i]),kBufferSize,0); | |
543d5224 | 112 | } |
c60862bf | 113 | }//D |
114 | ||
115 | if(cR&&fLoader->TreeR()){//R | |
db910db9 | 116 | CluCreate(); |
117 | for(Int_t i=0;i<fNcham;i++) | |
118 | MakeBranchInTree(fLoader->TreeR(),Form("%sClusters%d",GetName(),i+1), &((*fClu)[i]), kBufferSize, 0); | |
cb8189e7 | 119 | }//R |
998b831f | 120 | AliDebug(1,"Stop."); |
c021cb15 | 121 | }//void AliRICH::MakeBranch(Option_t* option) |
c60862bf | 122 | //__________________________________________________________________________________________________ |
dfb4e77d | 123 | void AliRICH::SetTreeAddress() |
53fd478b | 124 | { |
125 | //Set branch address for the Hits and Digits Tree. | |
998b831f | 126 | AliDebug(1,"Start."); |
c60862bf | 127 | |
dfb4e77d | 128 | TBranch *branch; |
dfb4e77d | 129 | |
c60862bf | 130 | if(fLoader->TreeH()){//H |
998b831f | 131 | AliDebug(1,"tree H is requested."); |
db910db9 | 132 | HitCreate();//branch map will be in AliDetector::SetTreeAddress |
c60862bf | 133 | }//H |
c021cb15 | 134 | AliDetector::SetTreeAddress();//this is after TreeH because we need to guarantee that fHits array is created |
135 | ||
c60862bf | 136 | if(fLoader->TreeS()){//S |
998b831f | 137 | AliDebug(1,"tree S is requested."); |
db910db9 | 138 | branch=fLoader->TreeS()->GetBranch(GetName()); if(branch){SDigCreate(); branch->SetAddress(&fSdig);} |
c60862bf | 139 | }//S |
dfb4e77d | 140 | |
c60862bf | 141 | if(fLoader->TreeD()){//D |
998b831f | 142 | AliDebug(1,"tree D is requested."); |
db910db9 | 143 | for(int i=0;i<fNcham;i++){ branch=fLoader->TreeD()->GetBranch(Form("%s%d",GetName(),i+1)); if(branch){DigCreate(); branch->SetAddress(&((*fDig)[i]));}} |
c60862bf | 144 | }//D |
dfb4e77d | 145 | |
c60862bf | 146 | if(fLoader->TreeR()){//R |
998b831f | 147 | AliDebug(1,"tree R is requested."); |
db910db9 | 148 | for(int i=0;i<fNcham;i++){ branch=fLoader->TreeR()->GetBranch(Form("%sClusters%d" ,GetName(),i+1)); if(branch){CluCreate(); branch->SetAddress(&((*fClu)[i]));}} |
c60862bf | 149 | }//R |
998b831f | 150 | AliDebug(1,"Stop."); |
dfb4e77d | 151 | }//void AliRICH::SetTreeAddress() |
c021cb15 | 152 | //__________________________________________________________________________________________________ |
db910db9 | 153 | // AliRICHHit* AliRICH::Hit(Int_t tid)const |
154 | // { | |
155 | // // Search for the first RICH hit belonging to the given tid | |
156 | // GetLoader()->LoadHits(); | |
157 | // for(Int_t iPrimN=0;iPrimN<GetLoader()->TreeH()->GetEntries();iPrimN++){//prims loop | |
158 | // GetLoader()->TreeH()->GetEntry(iPrimN); | |
159 | // for(Int_t iHitN=0;iHitN<Hits()->GetEntries();iHitN++){ | |
160 | // AliRICHHit *pHit=(AliRICHHit*)Hits()->At(iHitN); | |
161 | // if(tid==pHit->Track()) {GetLoader()->UnloadHits();return pHit;} | |
162 | // }//hits | |
163 | // }//prims loop | |
164 | // GetLoader()->UnloadHits(); | |
165 | // return 0; | |
166 | // } | |
167 | //__________________________________________________________________________________________________ | |
168 | void AliRICH::HitPrint(Int_t iEvtN)const | |
e42a7b46 | 169 | { |
170 | //Prints a list of RICH hits for a given event. Default is event number 0. | |
d3eb6079 | 171 | if(GetLoader()->GetRunLoader()->GetEvent(iEvtN)) return; |
998b831f | 172 | AliInfo(Form("List of RICH hits for event %i",iEvtN)); |
a25b3368 | 173 | if(GetLoader()->LoadHits()) return; |
e42a7b46 | 174 | |
175 | Int_t iTotalHits=0; | |
a25b3368 | 176 | for(Int_t iPrimN=0;iPrimN<GetLoader()->TreeH()->GetEntries();iPrimN++){//prims loop |
177 | GetLoader()->TreeH()->GetEntry(iPrimN); | |
178 | Hits()->Print(); | |
179 | iTotalHits+=Hits()->GetEntries(); | |
e42a7b46 | 180 | } |
a25b3368 | 181 | GetLoader()->UnloadHits(); |
998b831f | 182 | AliInfo(Form("totally %i hits",iTotalHits)); |
e42a7b46 | 183 | } |
184 | //__________________________________________________________________________________________________ | |
db910db9 | 185 | void AliRICH::SDigPrint(Int_t iEvtN)const |
e42a7b46 | 186 | { |
187 | //prints a list of RICH sdigits for a given event | |
d3eb6079 | 188 | if(GetLoader()->GetRunLoader()->GetEvent(iEvtN)) return; |
e42a7b46 | 189 | Info("PrintSDigits","List of RICH sdigits for event %i",iEvtN); |
a25b3368 | 190 | if(GetLoader()->LoadSDigits()) return; |
e42a7b46 | 191 | |
a25b3368 | 192 | GetLoader()->TreeS()->GetEntry(0); |
db910db9 | 193 | fSdig->Print(); |
a25b3368 | 194 | GetLoader()->UnloadSDigits(); |
db910db9 | 195 | Printf("totally %i sdigits",fSdig->GetEntries()); |
e42a7b46 | 196 | } |
197 | //__________________________________________________________________________________________________ | |
db910db9 | 198 | void AliRICH::DigPrint(Int_t iEvtN)const |
e42a7b46 | 199 | { |
200 | //prints a list of RICH digits for a given event | |
d3eb6079 | 201 | if(GetLoader()->GetRunLoader()->GetEvent(iEvtN)) return; |
db910db9 | 202 | Printf("List of RICH digits for event %i",iEvtN); |
a25b3368 | 203 | if(GetLoader()->LoadDigits()) return; |
e42a7b46 | 204 | |
205 | Int_t iTotalDigits=0; | |
a25b3368 | 206 | GetLoader()->TreeD()->GetEntry(0); |
db910db9 | 207 | if(!fDig) return; |
208 | for(Int_t iCham=0;iCham<fNcham;iCham++){ | |
209 | TClonesArray *pDigs=(TClonesArray*)fDig->At(iCham); iTotalDigits+=pDigs->GetEntries(); pDigs->Print(); | |
e42a7b46 | 210 | } |
a25b3368 | 211 | GetLoader()->UnloadDigits(); |
db910db9 | 212 | Printf("totally %i Digits",iTotalDigits); |
e42a7b46 | 213 | } |
214 | //__________________________________________________________________________________________________ | |
e53ffca5 | 215 | void AliRICH::OccupancyPrint(Int_t iEvtNreq)const |
c23b3bc0 | 216 | { |
217 | //prints occupancy for each chamber in a given event | |
e53ffca5 | 218 | Int_t iEvtNmin,iEvtNmax; |
219 | if(iEvtNreq==-1){ | |
220 | iEvtNmin=0; | |
221 | iEvtNmax=gAlice->GetEventsPerRun(); | |
222 | } else { | |
223 | iEvtNmin=iEvtNreq;iEvtNmax=iEvtNreq+1; | |
224 | } | |
225 | ||
226 | if(GetLoader()->GetRunLoader()->LoadHeader()) return; | |
227 | if(GetLoader()->GetRunLoader()->LoadKinematics()) return; | |
228 | ||
229 | // Info("Occupancy","for event %i",iEvtN); | |
230 | if(GetLoader()->LoadHits()) return; | |
c23b3bc0 | 231 | if(GetLoader()->LoadDigits()) return; |
232 | ||
233 | Int_t totPadsPerChamber = AliRICHParam::NpadsX()*AliRICHParam::NpadsY(); | |
e53ffca5 | 234 | |
e53ffca5 | 235 | |
910735ae | 236 | for(Int_t iEvtN=iEvtNmin;iEvtN<iEvtNmax;iEvtN++){ |
237 | Int_t nDigCh[kNchambers]={0,0,0,0,0,0,0}; | |
238 | Int_t iChHits[kNchambers]={0,0,0,0,0,0,0}; | |
239 | Int_t nPrim[kNchambers]={0,0,0,0,0,0,0}; | |
240 | Int_t nSec[kNchambers]={0,0,0,0,0,0,0}; | |
241 | AliInfo(Form("events processed %i",iEvtN)); | |
e53ffca5 | 242 | if(GetLoader()->GetRunLoader()->GetEvent(iEvtN)) return; |
243 | AliStack *pStack = GetLoader()->GetRunLoader()->Stack(); | |
244 | for(Int_t iPrimN=0;iPrimN<GetLoader()->TreeH()->GetEntries();iPrimN++){//prims loop | |
245 | GetLoader()->TreeH()->GetEntry(iPrimN); | |
246 | for(Int_t iHitN=0;iHitN<Hits()->GetEntries();iHitN++){ | |
247 | AliRICHHit *pHit = (AliRICHHit *)Hits()->At(iHitN); | |
248 | if(pHit->Eloss()>0){ | |
249 | iChHits[pHit->C()-1]++; | |
250 | if(pStack->Particle(pHit->GetTrack())->Rho()<0.01) nPrim[pHit->C()-1]++;else nSec[pHit->C()-1]++; | |
251 | } | |
252 | } | |
253 | } | |
254 | GetLoader()->TreeD()->GetEntry(0); | |
db910db9 | 255 | for(Int_t iCh=0;iCh<fNcham;iCh++) { |
256 | nDigCh[iCh]= ((TClonesArray*)fDig->At(iCh))->GetEntries(); | |
178bf747 | 257 | Double_t occupancy = (Double_t)nDigCh[iCh]/(Double_t)totPadsPerChamber; |
910735ae | 258 | Info("Occupancy","for chamber %i = %4.2f %% and charged prim tracks %i and sec. tracks %i with total %i", |
db910db9 | 259 | iCh+1,occupancy*100.,nPrim[iCh],nSec[iCh],iChHits[iCh]); |
910735ae | 260 | } |
261 | } | |
e53ffca5 | 262 | GetLoader()->UnloadHits(); |
c23b3bc0 | 263 | GetLoader()->UnloadDigits(); |
e53ffca5 | 264 | GetLoader()->GetRunLoader()->UnloadHeader(); |
265 | GetLoader()->GetRunLoader()->UnloadKinematics(); | |
c23b3bc0 | 266 | } |
267 | //__________________________________________________________________________________________________ | |
db910db9 | 268 | void AliRICH::CluPrint(Int_t iEvtN)const |
e42a7b46 | 269 | { |
270 | //prints a list of RICH clusters for a given event | |
db910db9 | 271 | Printf("List of RICH clusters for event %i",iEvtN); |
a25b3368 | 272 | GetLoader()->GetRunLoader()->GetEvent(iEvtN); |
273 | if(GetLoader()->LoadRecPoints()) return; | |
e42a7b46 | 274 | |
db910db9 | 275 | Int_t iCluCnt=0; |
a25b3368 | 276 | GetLoader()->TreeR()->GetEntry(0); |
db910db9 | 277 | for(Int_t iCham=0;iCham<fNcham;iCham++){ |
278 | TClonesArray *pClus=(TClonesArray*)fClu->At(iCham); iCluCnt+=pClus->GetEntries(); pClus->Print(); | |
e42a7b46 | 279 | } |
a25b3368 | 280 | GetLoader()->UnloadRecPoints(); |
db910db9 | 281 | Printf("totally %i clusters for event %i",iCluCnt,iEvtN); |
e42a7b46 | 282 | } |
db910db9 | 283 | //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
0fe8fa07 | 284 | void AliRICH::DisplayEvent(Int_t iEvtNmin,Int_t iEvtNmax)const |
285 | { | |
db910db9 | 286 | // Display digits, reconstructed tracks intersections and RICH rings if available |
287 | TH2F *pH2[8]; | |
0fe8fa07 | 288 | |
db910db9 | 289 | GetLoader()->LoadDigits(); |
0fe8fa07 | 290 | |
db910db9 | 291 | TLatex t; t.SetTextSize(0.1); |
292 | TCanvas *pC = new TCanvas("RICHDisplay","RICH Display",0,0,1226,900); pC->Divide(3,3); pC->cd(9); t.DrawText(0.2,0.4,"View to IP"); | |
f770edb5 | 293 | gStyle->SetPalette(1); |
0fe8fa07 | 294 | |
295 | ||
db910db9 | 296 | for(Int_t iCh=1;iCh<=fNcham;iCh++) { |
297 | pH2[iCh] = new TH2F(Form("RichDigH2_%i",iCh),Form("Chamber %i;cm;cm",iCh),165,0,AliRICHParam::PcSizeX(),144,0,AliRICHParam::PcSizeY()); | |
298 | pH2[iCh]->SetMarkerColor(kGreen); | |
299 | pH2[iCh]->SetMarkerStyle(29); | |
300 | pH2[iCh]->SetMarkerSize(0.4); | |
301 | pH2[iCh]->SetStats(kFALSE); | |
302 | pH2[iCh]->SetMaximum(300); | |
0fe8fa07 | 303 | } |
304 | ||
f770edb5 | 305 | if(iEvtNmax>gAlice->GetEventsPerRun()||iEvtNmax==0) iEvtNmax=gAlice->GetEventsPerRun()-1; |
0fe8fa07 | 306 | |
db910db9 | 307 | for(Int_t iEvt=iEvtNmin;iEvt<=iEvtNmax;iEvt++) {//events loop |
308 | pC->cd(3); t.DrawText(0.2,0.4,Form("Event %i",iEvt)); | |
0fe8fa07 | 309 | |
db910db9 | 310 | GetLoader()->GetRunLoader()->GetEvent(iEvt); //get event |
311 | GetLoader()->TreeD()->GetEntry(0); //get list of digits | |
312 | for(Int_t iCh=1;iCh<=fNcham;iCh++) {//chambers loop | |
313 | pH2[iCh]->Reset(); | |
314 | for(Int_t iDig=0;iDig < Digs(iCh)->GetEntries();iDig++) {//digits loop | |
315 | AliRICHDigit *pDig = (AliRICHDigit*)Digs(iCh)->At(iDig); | |
0fe8fa07 | 316 | TVector2 x2=AliRICHParam::Pad2Loc(pDig->Pad()); |
db910db9 | 317 | pH2[pDig->C()]->Fill(x2.X(),x2.Y(),pDig->Qdc()); |
0fe8fa07 | 318 | }//digits loop |
db910db9 | 319 | if(iCh==1) pC->cd(9); |
320 | if(iCh==2) pC->cd(8); | |
321 | if(iCh==3) pC->cd(6); | |
322 | if(iCh==4) pC->cd(5); | |
323 | if(iCh==5) pC->cd(4); | |
324 | if(iCh==6) pC->cd(2); | |
325 | if(iCh==7) pC->cd(1); | |
326 | pH2[iCh]->Draw("col"); | |
327 | ReadESD(iEvt,iCh); | |
f770edb5 | 328 | AliRICHParam::DrawSectors(); |
0fe8fa07 | 329 | }//chambers loop |
db910db9 | 330 | pC->Update(); |
331 | pC->Modified(); | |
f770edb5 | 332 | |
db910db9 | 333 | if(iEvt<iEvtNmax) {gPad->WaitPrimitive();pC->Clear();} |
0fe8fa07 | 334 | }//events loop |
335 | }//ShowEvent() | |
336 | //__________________________________________________________________________________________________ | |
337 | void AliRICH::Display()const | |
338 | { | |
339 | //Provides fast event display | |
340 | //For RICH only, full display is .x Display.C | |
341 | Bool_t isHits =!GetLoader()->LoadHits(); | |
342 | Bool_t isDigits =!GetLoader()->LoadDigits(); | |
343 | Bool_t isClusters=!GetLoader()->LoadRecPoints(); | |
344 | ||
345 | if(!isHits && !isDigits && !isClusters){Error("Exec","No hits digits and clusters. Nothing to display.");return;} | |
346 | ||
347 | TCanvas *pCanvas = new TCanvas("Display","RICH Display",0,0,600,600); | |
348 | ||
349 | TH2F *pHitsH2=0,*pDigitsH2=0,*pClustersH2=0; | |
350 | ||
351 | if(isHits) pHitsH2 = new TH2F("pHitsH2" , "Event Display;x,cm;y,cm",165,0,AliRICHParam::PcSizeX(), | |
352 | 144,0,AliRICHParam::PcSizeY()); | |
353 | if(pHitsH2) pHitsH2->SetStats(kFALSE); | |
354 | ||
355 | if(isDigits) pDigitsH2 = new TH2F("pDigitsH2" ,"Event Display",165,0,AliRICHParam::PcSizeX(), | |
356 | 144,0,AliRICHParam::PcSizeY()); | |
357 | if(isClusters) pClustersH2 = new TH2F("pClustersH2","Event Display",165,0,AliRICHParam::PcSizeX(), | |
358 | 144,0,AliRICHParam::PcSizeY()); | |
359 | ||
db910db9 | 360 | for(Int_t iEvt=0;iEvt<GetLoader()->GetRunLoader()->GetNumberOfEvents();iEvt++){//events Loop |
361 | GetLoader()->GetRunLoader()->GetEvent(iEvt); | |
0fe8fa07 | 362 | //display all the staff on chamber by chamber basis |
db910db9 | 363 | for(Int_t iCh=1;iCh<=fNcham;iCh++){//chambers loop |
0fe8fa07 | 364 | if(isHits) pHitsH2 ->Reset(); |
365 | if(isDigits) pDigitsH2 ->Reset(); | |
366 | if(isClusters) pClustersH2->Reset(); | |
367 | //deals with hits | |
368 | for(Int_t i=0;i<GetLoader()->TreeH()->GetEntries();i++){//TreeH loop | |
369 | GetLoader()->TreeH()->GetEntry(i); | |
db910db9 | 370 | for(Int_t iHit=0;iHit<Hits()->GetEntries();iHit++){//hits loop |
371 | AliRICHHit *pHit = (AliRICHHit*)Hits()->At(iHit); | |
372 | if(pHit->C()==iCh){ | |
373 | TVector2 hitLocX2 = AliRICHParam::Instance()->Mars2Lors(iCh,pHit->OutX3()); | |
0fe8fa07 | 374 | pHitsH2->Fill(hitLocX2.X(),hitLocX2.Y(),200); |
375 | }//if | |
376 | }//hits loop | |
377 | }//TreeH loop | |
db910db9 | 378 | pHitsH2->SetTitle(Form("event %i chamber %2i",iEvt,iCh)); |
0fe8fa07 | 379 | pHitsH2->SetMarkerColor(kRed); pHitsH2->SetMarkerStyle(29); pHitsH2->SetMarkerSize(0.4); |
380 | pHitsH2->Draw(); | |
381 | AliRICHParam::DrawSectors(); | |
382 | TLatex l; l.SetNDC(); l.SetTextSize(0.02); | |
383 | if(!isHits) {l.SetTextColor(kRed) ;l.DrawLatex(0.1,0.01,"No Hits" );} | |
384 | if(!isDigits) {l.SetTextColor(kGreen);l.DrawLatex(0.4,0.01,"No DIGITS" );} | |
385 | if(!isClusters) {l.SetTextColor(kBlue) ;l.DrawLatex(0.8,0.01,"No CLUSTERS");} | |
386 | pCanvas->Update(); pCanvas->Modified(); gPad->WaitPrimitive(); | |
387 | //deals with digits | |
388 | if(isDigits){ | |
389 | GetLoader()->TreeD()->GetEntry(0); | |
db910db9 | 390 | for(Int_t iDig=0;iDig < Digs(iCh)->GetEntries();iDig++){//digits loop |
391 | AliRICHDigit *pDig = (AliRICHDigit*)Digs(iCh)->At(iDig); | |
392 | TVector2 x2=AliRICHParam::Pad2Loc(pDig->Pad()); | |
393 | pDigitsH2->Fill(x2.X(),x2.Y(),100); | |
0fe8fa07 | 394 | }//digits loop |
395 | pDigitsH2->SetMarkerColor(kGreen); pDigitsH2->SetMarkerStyle(29); pDigitsH2->SetMarkerSize(0.4); | |
396 | pDigitsH2->Draw("same"); | |
397 | pCanvas->Update(); pCanvas->Modified(); gPad->WaitPrimitive(); | |
398 | }//if(isDigits) | |
399 | //deals with clusters | |
400 | if(isClusters){ | |
401 | GetLoader()->TreeR()->GetEntry(0); | |
db910db9 | 402 | for(Int_t iClu=0;iClu<Clus(iCh)->GetEntries();iClu++){//clusters loop |
403 | AliRICHCluster *pClu = (AliRICHCluster*)Clus(iCh)->At(iClu); | |
404 | pClustersH2->Fill(pClu->X(),pClu->Y(),50); | |
0fe8fa07 | 405 | }//clusters loop |
406 | pClustersH2->SetMarkerColor(kBlue); pClustersH2->SetMarkerStyle(29); pClustersH2->SetMarkerSize(0.4); | |
407 | pClustersH2->Draw("same"); | |
408 | pCanvas->Update(); pCanvas->Modified(); gPad->WaitPrimitive(); | |
409 | }//if(isClusters) | |
410 | }//chambers loop | |
411 | }//events Loop | |
412 | ||
413 | delete pCanvas; | |
414 | GetLoader()->UnloadHits(); | |
415 | if(isDigits) GetLoader()->UnloadDigits(); | |
416 | if(isClusters) GetLoader()->UnloadRecPoints(); | |
417 | }//Display() | |
db910db9 | 418 | //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
56030c8d | 419 | void AliRICH::ReadESD(Int_t iEventN, Int_t iChamber)const |
420 | { | |
421 | // | |
56030c8d | 422 | TFile *pFile=TFile::Open("AliESDs.root","read"); |
423 | if(!pFile || !pFile->IsOpen()) {AliInfo("ESD file not open.");return;} //open AliESDs.root | |
424 | TTree *pTree = (TTree*) pFile->Get("esdTree"); | |
425 | if(!pTree){AliInfo("ESD not found.");return;} //get ESD tree | |
426 | ||
56030c8d | 427 | |
428 | AliESD *pESD=new AliESD; pTree->SetBranchAddress("ESD", &pESD); | |
429 | ||
430 | pTree->GetEvent(iEventN); | |
431 | ||
56030c8d | 432 | Int_t iNtracks=pESD->GetNumberOfTracks(); |
433 | ||
434 | for(Int_t iTrackN=0;iTrackN<iNtracks;iTrackN++){//ESD tracks loop | |
435 | AliESDtrack *pTrack = pESD->GetTrack(iTrackN);// get next reconstructed track | |
e1e6896f | 436 | Double_t mom[3], pos[3]; |
437 | pTrack->GetPxPyPz(mom); TVector3 mom3(mom[0],mom[1],mom[2]); | |
438 | pTrack->GetXYZ(pos); TVector3 pos3(pos[0],pos[1],pos[2]); | |
439 | AliRICHHelix helix(pos3,mom3,(Int_t)pTrack->GetSign(),-0.1*pESD->GetMagneticField()); | |
db910db9 | 440 | Int_t iChamberOnRICH=helix.RichIntersect(AliRICHParam::Instance()); |
cc764ba7 | 441 | if(iChamberOnRICH==iChamber) { |
f770edb5 | 442 | TMarker *trackImpact = new TMarker(helix.PosPc().X(),helix.PosPc().Y(),kStar); |
443 | trackImpact->SetMarkerColor(kRed); | |
444 | trackImpact->Draw(); | |
cc764ba7 | 445 | // |
db910db9 | 446 | Int_t iChamberRecon = pTrack->GetRICHcluster()/1000000; |
cc764ba7 | 447 | if(iChamberRecon==iChamber) { |
448 | Double_t thetaCer = pTrack->GetRICHsignal(); | |
449 | if(thetaCer<0) continue; | |
450 | TVector3 entrance(helix.PosRad().X(),helix.PosRad().Y(),0); | |
2714766e | 451 | Float_t thetaTrack,phiTrack; |
cc764ba7 | 452 | pTrack->GetRICHthetaPhi(thetaTrack,phiTrack); |
453 | TVector3 vectorTrack; | |
454 | vectorTrack.SetMagThetaPhi(pTrack->GetP(),thetaTrack,phiTrack); | |
455 | AliInfo(Form("Draw ring started for track %i on chamber %i",iTrackN,iChamber)); | |
456 | AliInfo(Form("ThetaCer %f TrackTheta %f TrackPhi %f Momentum %f",thetaCer,thetaTrack,phiTrack,pTrack->GetP())); | |
2714766e | 457 | Float_t dx,dy; |
cc764ba7 | 458 | pTrack->GetRICHdxdy(dx,dy); |
cc764ba7 | 459 | DrawRing(entrance,vectorTrack,thetaCer); |
460 | } | |
56030c8d | 461 | } |
462 | } | |
463 | delete pESD; pFile->Close();//close AliESDs.root | |
464 | } | |
465 | //__________________________________________________________________________________________________ | |
466 | void AliRICH::DrawRing(TVector3 entrance,TVector3 vectorTrack,Double_t thetaCer)const | |
467 | { | |
468 | Double_t xGraph[100],yGraph[100]; | |
469 | Int_t nPointsToDraw = 0; | |
470 | for(Int_t i=0;i<100;i++) { | |
471 | Double_t phiCer = 2*TMath::Pi()*i/100; | |
db910db9 | 472 | TVector3 pos = AliRICHParam::Instance()->ForwardTracing(entrance,vectorTrack,thetaCer,phiCer); |
f770edb5 | 473 | if(pos.X()==-999) continue; |
56030c8d | 474 | xGraph[nPointsToDraw] = pos.X();yGraph[nPointsToDraw] = pos.Y();nPointsToDraw++; |
475 | } | |
cc764ba7 | 476 | // AliInfo(Form("Npoints per ring %i",nPointsToDraw)); |
56030c8d | 477 | TGraph *gra = new TGraph(nPointsToDraw,xGraph,yGraph); |
f770edb5 | 478 | gra->Draw("C"); |
56030c8d | 479 | } |
e53ffca5 | 480 | //__________________________________________________________________________________________________ |
481 | void AliRICH::SummaryOfEvent(Int_t iEvtN) const | |
482 | { | |
483 | //prints a summary for a given event | |
484 | AliInfo(Form("Summary of event %i",iEvtN)); | |
485 | GetLoader()->GetRunLoader()->GetEvent(iEvtN); | |
486 | if(GetLoader()->GetRunLoader()->LoadHeader()) return; | |
487 | if(GetLoader()->GetRunLoader()->LoadKinematics()) return; | |
488 | AliStack *pStack=GetLoader()->GetRunLoader()->Stack(); | |
489 | ||
490 | AliGenEventHeader* pGenHeader = gAlice->GetHeader()->GenEventHeader(); | |
491 | if(pGenHeader->InheritsFrom("AliGenHijingEventHeader")) { | |
492 | AliInfo(Form(" Hijing event with impact parameter b = %.2f (fm)",((AliGenHijingEventHeader*) pGenHeader)->ImpactParameter())); | |
493 | } | |
494 | Int_t nChargedPrimaries=0; | |
495 | for(Int_t i=0;i<pStack->GetNtrack();i++) { | |
496 | TParticle *pParticle = pStack->Particle(i); | |
497 | if(pParticle->IsPrimary()&&pParticle->GetPDG()->Charge()!=0) nChargedPrimaries++; | |
498 | } | |
499 | AliInfo(Form("Total number of primaries %i",pStack->GetNprimary())); | |
500 | AliInfo(Form("Total number of charged primaries %i",nChargedPrimaries)); | |
501 | AliInfo(Form("Total n. of tracks in stack(+sec) %i",pStack->GetNtrack())); | |
502 | GetLoader()->GetRunLoader()->UnloadHeader(); | |
503 | GetLoader()->GetRunLoader()->UnloadKinematics(); | |
504 | } | |
505 | //__________________________________________________________________________________________________ | |
db910db9 | 506 | void AliRICH::HitQA(Double_t cut,Double_t cutele,Double_t cutR) |
e53ffca5 | 507 | { |
508 | // Provides a set of control plots intended primarily for charged particle flux analisys | |
509 | // Arguments: cut (GeV) - cut on momentum of any charged particles but electrons, | |
510 | // cetele (GeV) - the same for electrons-positrons | |
511 | // cutR (cm) - cut on production vertex radius (cylindrical system) | |
512 | gBenchmark->Start("HitsAna"); | |
513 | ||
514 | Double_t cutPantiproton =cut; | |
515 | Double_t cutPkaonminus =cut; | |
516 | Double_t cutPpionminus =cut; | |
517 | Double_t cutPmuonminus =cut; | |
518 | Double_t cutPpositron =cutele; | |
519 | ||
520 | Double_t cutPelectron =cutele; | |
521 | Double_t cutPmuonplus =cut; | |
522 | Double_t cutPpionplus =cut; | |
523 | Double_t cutPkaonplus =cut; | |
524 | Double_t cutPproton =cut; | |
525 | ||
526 | ||
527 | TH2F *pEleHitRZ =new TH2F("EleHitRZ" ,Form("e^{+} e^{-} hit %s;z[cm];R[cm]" ,GetName()) , 400,-300,300 ,400,-500,500); //R-z plot 0cm<R<550cm -300cm<z<300cm | |
528 | TH2F *pEleHitRP =new TH2F("EleHitRP" ,Form("e^{+} e^{-} hit %s;p[GeV];R[cm]",GetName()) ,1000,-1 ,1 ,400, 0,550); //R-p plot 0cm<R<550cm -1GeV<p<1GeV | |
529 | TH1F *pEleAllP =new TH1F("EleAllP" , "e^{+} e^{-} all;p[GeV]" ,1000,-1 ,1 ); | |
530 | TH1F *pEleHitP =new TH1F("EleHitP" ,Form("e^{+} e^{-} hit %s;p[GeV]" ,GetName()) ,1000,-1 ,1 ); | |
531 | TH1F *pMuoHitP =new TH1F("MuoHitP" ,Form("#mu^{-} #mu^{+} hit %s;p[GeV]" ,GetName()) ,1000,-4 ,4 ); | |
532 | TH1F *pPioHitP =new TH1F("PioHitP" ,Form("#pi^{-} #pi^{+} hit %s;p[GeV]" ,GetName()) ,1000,-4 ,4 ); | |
533 | TH1F *pKaoHitP =new TH1F("KaoHitP" ,Form("K^{-} K^{+} hit %s;p[GeV]" ,GetName()) ,1000,-4 ,4 ); | |
534 | TH1F *pProHitP =new TH1F("ProHitP" ,Form("p^{-} p^{+} hit %s;p[GeV]" ,GetName()) ,1000,-4 ,4 ); | |
535 | TH2F *pFlux =new TH2F("flux" ,Form("%s flux with Rvertex<%.1fcm" ,GetName(),cutR),10 ,-5 ,5 , 10,0 ,10); //special text hist | |
8da90624 | 536 | TH2F *pVertex =new TH2F("vertex" ,Form("%s 2D vertex of RICH hit;x;y" ,GetName()) ,120 ,0 ,600 ,120,0 ,600); //special text hist |
537 | TH1F *pRho =new TH1F("rho" ,Form("%s r of RICH hit" ,GetName()) ,600 ,0 ,600); //special text hist | |
e53ffca5 | 538 | pFlux->SetStats(0); |
539 | pFlux->GetXaxis()->SetBinLabel(1 ,Form("p^{-}>%.3fGeV/c" ,cutPantiproton)); | |
540 | pFlux->GetXaxis()->SetBinLabel(2 ,Form("K^{-}>%.3fGeV/c" ,cutPkaonminus )); | |
541 | pFlux->GetXaxis()->SetBinLabel(3 ,Form("#pi^{-}>%.3fGeV/c" ,cutPpionminus )); | |
542 | pFlux->GetXaxis()->SetBinLabel(4 ,Form("#mu^{-}>%.3fGeV/c" ,cutPmuonminus )); | |
543 | pFlux->GetXaxis()->SetBinLabel(5 ,Form("e^{+}>%.3fGeV/c" ,cutPpositron )); | |
544 | ||
545 | pFlux->GetXaxis()->SetBinLabel(6 ,Form("e^{-}>%.3fGeV/c" ,cutPelectron )); | |
546 | pFlux->GetXaxis()->SetBinLabel(7 ,Form("#mu^{+}>%.3fGeV/c" ,cutPmuonplus )); | |
547 | pFlux->GetXaxis()->SetBinLabel(8 ,Form("#pi^{+}>%.3fGeV/c" ,cutPpionplus )); | |
548 | pFlux->GetXaxis()->SetBinLabel(9 ,Form("K^{+}>%.3fGeV/c" ,cutPkaonplus )); | |
549 | pFlux->GetXaxis()->SetBinLabel(10,Form("p^{+}>%.3fGeV/c" ,cutPproton )); | |
550 | ||
551 | pFlux->GetYaxis()->SetBinLabel(1,"sum"); | |
552 | pFlux->GetYaxis()->SetBinLabel(2,"ch1"); | |
553 | pFlux->GetYaxis()->SetBinLabel(3,"ch2"); | |
554 | pFlux->GetYaxis()->SetBinLabel(4,"ch3"); | |
555 | pFlux->GetYaxis()->SetBinLabel(5,"ch4"); | |
556 | pFlux->GetYaxis()->SetBinLabel(6,"ch5"); | |
557 | pFlux->GetYaxis()->SetBinLabel(7,"ch6"); | |
558 | pFlux->GetYaxis()->SetBinLabel(8,"ch7"); | |
559 | pFlux->GetYaxis()->SetBinLabel(9,"prim"); | |
560 | pFlux->GetYaxis()->SetBinLabel(10,"tot"); | |
561 | ||
562 | //end of hists definition | |
563 | ||
564 | Int_t iNevents=fLoader->GetRunLoader()->GetAliRun()->GetEventsPerRun(),iCntPrimParts=0,iCntTotParts=0; | |
565 | //load all needed trees | |
566 | fLoader->LoadHits(); | |
567 | fLoader->GetRunLoader()->LoadHeader(); | |
568 | fLoader->GetRunLoader()->LoadKinematics(); | |
569 | ||
570 | for(Int_t iEvtN=0;iEvtN < iNevents;iEvtN++){//events loop | |
571 | fLoader->GetRunLoader()->GetEvent(iEvtN); | |
572 | AliInfo(Form(" %i event processes",fLoader->GetRunLoader()->GetEventNumber())); | |
573 | AliStack *pStack= fLoader->GetRunLoader()->Stack(); | |
574 | ||
575 | for(Int_t iParticleN=0;iParticleN<pStack->GetNtrack();iParticleN++){//stack loop | |
576 | TParticle *pPart=pStack->Particle(iParticleN); | |
577 | ||
578 | if(iParticleN%10000==0) AliInfo(Form(" %i particles read",iParticleN)); | |
579 | ||
580 | switch(pPart->GetPdgCode()){ | |
581 | case kProtonBar: pFlux->Fill(-4.5,9); if(pPart->Rho()<0.01) pFlux->Fill(-4.5,8); break; | |
582 | case kKMinus: pFlux->Fill(-3.5,9); if(pPart->Rho()<0.01) pFlux->Fill(-3.5,8); break; | |
583 | case kPiMinus: pFlux->Fill(-2.5,9); if(pPart->Rho()<0.01) pFlux->Fill(-2.5,8); break; | |
584 | case kMuonMinus: pFlux->Fill(-1.5,9); if(pPart->Rho()<0.01) pFlux->Fill(-1.5,8); break; | |
585 | case kPositron: pFlux->Fill(-0.5,9); if(pPart->Rho()<0.01) pFlux->Fill(-0.5,8); pEleAllP->Fill(-pPart->P()); break; | |
586 | ||
587 | case kElectron: pFlux->Fill( 0.5,9); if(pPart->Rho()<0.01) pFlux->Fill( 0.5,8); pEleAllP->Fill( pPart->P()); break; | |
588 | case kMuonPlus: pFlux->Fill( 1.5,9); if(pPart->Rho()<0.01) pFlux->Fill( 1.5,8); break; | |
589 | case kPiPlus: pFlux->Fill( 2.5,9); if(pPart->Rho()<0.01) pFlux->Fill( 2.5,8); break; | |
590 | case kKPlus: pFlux->Fill( 3.5,9); if(pPart->Rho()<0.01) pFlux->Fill( 3.5,8); break; | |
591 | case kProton: pFlux->Fill( 4.5,9); if(pPart->Rho()<0.01) pFlux->Fill( 4.5,8); break; | |
592 | }//switch | |
593 | }//stack loop | |
594 | //now hits analiser | |
595 | for(Int_t iEntryN=0;iEntryN < fLoader->TreeH()->GetEntries();iEntryN++){//TreeH loop | |
596 | fLoader->TreeH()->GetEntry(iEntryN); //get current entry (prim) | |
597 | for(Int_t iHitN=0;iHitN < Hits()->GetEntries();iHitN++){//hits loop | |
598 | AliRICHHit *pHit = (AliRICHHit*)Hits()->At(iHitN); //get current hit | |
599 | TParticle *pPart=pStack->Particle(pHit->GetTrack()); //get stack particle which produced the current hit | |
8da90624 | 600 | |
601 | if(pPart->GetPDG()->Charge()!=0&&pPart->Rho()>0.1) pVertex->Fill(pPart->Vx(),pPart->Vy()); //safe margin for sec. | |
602 | if(pPart->GetPDG()->Charge()!=0) pRho->Fill(pPart->Rho()); //safe margin for sec. | |
e53ffca5 | 603 | if(pPart->R()>cutR) continue; //cut on production radius (cylindrical system) |
604 | ||
605 | switch(pPart->GetPdgCode()){ | |
606 | case kProtonBar: if(pPart->P()>cutPantiproton) {pProHitP->Fill(-pPart->P()); pFlux->Fill(-4.5,pHit->C());}break; | |
607 | case kKMinus : if(pPart->P()>cutPkaonminus) {pKaoHitP->Fill(-pPart->P()); pFlux->Fill(-3.5,pHit->C());}break; | |
608 | case kPiMinus : if(pPart->P()>cutPpionminus) {pPioHitP->Fill(-pPart->P()); pFlux->Fill(-2.5,pHit->C());}break; | |
609 | case kMuonMinus: if(pPart->P()>cutPmuonminus) {pMuoHitP->Fill(-pPart->P()); pFlux->Fill(-1.5,pHit->C());}break; | |
610 | case kPositron : if(pPart->P()>cutPpositron) {pEleHitP->Fill(-pPart->P()); pFlux->Fill(-0.5,pHit->C()); | |
611 | pEleHitRP->Fill(-pPart->P(),pPart->R()); pEleHitRZ->Fill(pPart->Vz(),pPart->R()); }break; | |
612 | ||
613 | case kElectron : if(pPart->P()>cutPelectron) {pEleHitP->Fill( pPart->P()); pFlux->Fill( 0.5,pHit->C()); | |
614 | pEleHitRP->Fill( pPart->P(),pPart->R()); pEleHitRZ->Fill(pPart->Vz(),pPart->R()); }break; | |
615 | case kMuonPlus : if(pPart->P()>cutPmuonplus) {pMuoHitP->Fill( pPart->P()); pFlux->Fill( 1.5,pHit->C());}break; | |
616 | case kPiPlus : if(pPart->P()>cutPpionplus) {pPioHitP->Fill( pPart->P()); pFlux->Fill( 2.5,pHit->C());}break; | |
617 | case kKPlus : if(pPart->P()>cutPkaonplus) {pKaoHitP->Fill( pPart->P()); pFlux->Fill( 3.5,pHit->C());}break; | |
618 | case kProton : if(pPart->P()>cutPproton) {pProHitP->Fill( pPart->P()); pFlux->Fill( 4.5,pHit->C());}break; | |
619 | } | |
620 | }//hits loop | |
621 | }//TreeH loop | |
622 | iCntPrimParts +=pStack->GetNprimary(); | |
623 | iCntTotParts +=pStack->GetNtrack(); | |
624 | }//events loop | |
625 | //unload all loaded staff | |
626 | fLoader->UnloadHits(); | |
627 | fLoader->GetRunLoader()->UnloadHeader(); | |
628 | fLoader->GetRunLoader()->UnloadKinematics(); | |
629 | //Calculater some sums | |
630 | Stat_t sum=0; | |
631 | //sum row, sum over rows | |
632 | for(Int_t i=1;i<=pFlux->GetNbinsX();i++){ | |
633 | sum=0; for(Int_t j=2;j<=8;j++) sum+=pFlux->GetBinContent(i,j); | |
634 | pFlux->SetBinContent(i,1,sum); | |
635 | } | |
636 | ||
637 | //display everything | |
638 | new TCanvas("canvas1",Form("Events %i Nprims=%i Nparticles=%i",iNevents,iCntPrimParts,iCntTotParts),1000,900); pFlux->Draw("text"); gPad->SetGrid(); | |
639 | //total prims and particles | |
640 | TLatex latex; latex.SetTextSize(0.02); | |
641 | sum=0; for(Int_t i=1;i<=pFlux->GetNbinsX();i++) sum+=pFlux->GetBinContent(i,10); latex.DrawLatex(5.1,9.5,Form("%.0f",sum)); | |
642 | sum=0; for(Int_t i=1;i<=pFlux->GetNbinsX();i++) sum+=pFlux->GetBinContent(i,9); latex.DrawLatex(5.1,8.5,Form("%.0f",sum)); | |
643 | for(Int_t iChN=1;iChN<=kNchambers;iChN++) { | |
644 | sum=0; for(Int_t i=1;i<=pFlux->GetNbinsX();i++) sum+=pFlux->GetBinContent(i,iChN+1);latex.DrawLatex(5.1,iChN+0.5,Form("%.0f",sum)); | |
645 | } | |
646 | sum=0; for(Int_t i=1;i<=pFlux->GetNbinsX();i++) sum+=pFlux->GetBinContent(i,1); latex.DrawLatex(5.1,0.5,Form("%.0f",sum)); | |
647 | ||
648 | new TCanvas("cEleAllP" ,"e" ,200,100); pEleAllP->Draw(); | |
649 | new TCanvas("cEleHitRP" ,"e" ,200,100); pEleHitRP->Draw(); | |
650 | new TCanvas("cEleHitRZ" ,"e" ,200,100); pEleHitRZ->Draw(); | |
651 | new TCanvas("cEleHitP" ,"e" ,200,100); pEleHitP->Draw(); | |
652 | new TCanvas("cMuoHitP" ,"mu",200,100); pMuoHitP->Draw(); | |
653 | new TCanvas("cPioHitP" ,"pi",200,100); pPioHitP->Draw(); | |
654 | new TCanvas("cKaoHitP" ,"K" ,200,100); pKaoHitP->Draw(); | |
655 | new TCanvas("cProHitP" ,"p" ,200,100); pProHitP->Draw(); | |
8da90624 | 656 | new TCanvas("cVertex" ,"2d vertex" ,200,100); pVertex->Draw(); |
657 | new TCanvas("cRho" ,"Rho of sec" ,200,100); pRho->Draw(); | |
e53ffca5 | 658 | |
659 | gBenchmark->Show("HitsPlots"); | |
660 | }//HitsPlots() |