]>
Commit | Line | Data |
---|---|---|
1 | #include <iostream> | |
2 | #include <TROOT.h> | |
3 | #include <TChain.h> | |
4 | #include <TMath.h> | |
5 | #include <TTree.h> | |
6 | #include <TFile.h> | |
7 | #include <TGraph2D.h> | |
8 | #include <TH3F.h> | |
9 | #include <TH2F.h> | |
10 | #include <TClonesArray.h> | |
11 | #include <TPolyLine3D.h> | |
12 | #include <TPolyLine.h> | |
13 | #include <TPolyMarker3D.h> | |
14 | #include <TPolyMarker.h> | |
15 | #include <TAxis.h> | |
16 | #include <TLegend.h> | |
17 | #include <TPad.h> | |
18 | #include <TGeoGlobalMagField.h> | |
19 | #include <TCanvas.h> | |
20 | ||
21 | #include <AliMagF.h> | |
22 | #include <AliCDBManager.h> | |
23 | #include <AliTPCParam.h> | |
24 | #include <AliGeomManager.h> | |
25 | #include <AliTPCcalibDB.h> | |
26 | #include <AliTrackPointArray.h> | |
27 | #include <AliCluster.h> | |
28 | #include <AliLog.h> | |
29 | #include <AliTPCLaserTrack.h> | |
30 | ||
31 | ||
32 | #include "AliToyMCDrawer.h" | |
33 | #include "AliToyMCEvent.h" | |
34 | #include "AliToyMCTrack.h" | |
35 | ||
36 | // Visualization class. To use | |
37 | ||
38 | // AliToyMCDrawer* draw = new AliToyMCDrawer() | |
39 | // draw->SetFileName("path/to/toyMC.root") | |
40 | ||
41 | // draw->FillEventArray(Int_t centerEventNumber) | |
42 | // or | |
43 | // draw->FillEventArray(Double_t time) | |
44 | // to display with a certain event in the center or at a certain time | |
45 | ||
46 | // draw->DrawEvents(Bool_t both, Bool_t before) | |
47 | // where "both" will display events before and after the middle event and | |
48 | // before will show also events before (after) the middle event if true (false) | |
49 | // when "both" is false | |
50 | ||
51 | ||
52 | ClassImp(AliToyMCDrawer); | |
53 | ||
54 | AliToyMCDrawer::AliToyMCDrawer() | |
55 | : TObject() | |
56 | ,fInputTree(0x0) | |
57 | ,fInFile(0x0) | |
58 | ,fFileName() | |
59 | ,fEvent(0x0) | |
60 | ,fEventArray(0x0) | |
61 | ,fDispHist(0x0) | |
62 | ,fCenterTime(-1.) | |
63 | ,fDriftVel(-1.) | |
64 | ,fTPCParam(0x0) | |
65 | ,fMaxZ0(0.) | |
66 | ,fIFCRadius(83.5) | |
67 | ,fOFCRadius(254.5) | |
68 | ,fTimeRange(0) | |
69 | ,fRoc(AliTPCROC::Instance()) | |
70 | ,fPoints(0x0) | |
71 | ,fDistPoints(0x0) | |
72 | ,fProjectionType("XYT") | |
73 | ,fTimeZmin(0.) | |
74 | ,fTimeZmax(0.) | |
75 | ,fGlobalXmin(0.) | |
76 | ,fGlobalXmax(0.) | |
77 | ,fGlobalYmin(0.) | |
78 | ,fGlobalYmax(0.) | |
79 | { | |
80 | fEventArray = new TClonesArray("AliToyMCEvent"); | |
81 | ||
82 | fTPCParam = AliTPCcalibDB::Instance()->GetParameters(); | |
83 | fTPCParam->ReadGeoMatrices(); | |
84 | fDriftVel = fTPCParam->GetDriftV(); | |
85 | fMaxZ0 =fTPCParam->GetZLength(); | |
86 | fTimeRange = 2*fMaxZ0/fDriftVel; | |
87 | } | |
88 | //________________________________________________________________ | |
89 | AliToyMCDrawer::AliToyMCDrawer(const AliToyMCDrawer &drawer) | |
90 | : TObject(drawer) | |
91 | ,fInputTree(drawer.fInputTree) | |
92 | ,fInFile(drawer.fInFile) | |
93 | ,fFileName(drawer.fFileName) | |
94 | ,fEvent(drawer.fEvent) | |
95 | ,fEventArray(drawer.fEventArray) | |
96 | ,fDispHist(drawer.fDispHist) | |
97 | , fCenterTime(drawer.fCenterTime) | |
98 | ,fDriftVel(drawer.fDriftVel) | |
99 | ,fTPCParam(drawer.fTPCParam) | |
100 | ,fMaxZ0(drawer.fMaxZ0) | |
101 | ,fIFCRadius(drawer.fIFCRadius) | |
102 | ,fOFCRadius(drawer.fOFCRadius) | |
103 | ,fTimeRange(drawer.fTimeRange) | |
104 | ,fRoc(drawer.fRoc) | |
105 | ,fPoints(drawer.fPoints) | |
106 | ,fDistPoints(drawer.fDistPoints) | |
107 | ,fProjectionType("XYT") | |
108 | ,fTimeZmin(0.) | |
109 | ,fTimeZmax(0.) | |
110 | ,fGlobalXmin(0.) | |
111 | ,fGlobalXmax(0.) | |
112 | ,fGlobalYmin(0.) | |
113 | ,fGlobalYmax(0.) | |
114 | { | |
115 | // | |
116 | } | |
117 | //_____________________________________________________ | |
118 | AliToyMCDrawer& AliToyMCDrawer::operator = (const AliToyMCDrawer &drawer) | |
119 | { | |
120 | //assignment operator | |
121 | if (&drawer == this) return *this; | |
122 | new (this) AliToyMCDrawer(drawer); | |
123 | ||
124 | return *this; | |
125 | } | |
126 | ||
127 | //________________________________________________________________ | |
128 | AliToyMCDrawer::~AliToyMCDrawer() | |
129 | { | |
130 | //destructor | |
131 | delete fEvent; | |
132 | delete fEventArray; | |
133 | delete fPoints; | |
134 | delete fDistPoints; | |
135 | delete fDispHist; | |
136 | } | |
137 | //________________________________________________________________ | |
138 | Int_t AliToyMCDrawer::FillEventArray(Double_t snapShotTime) | |
139 | { | |
140 | if(fFileName.IsNull()) { | |
141 | std::cout << "no input file provided, using default (toyMC.root)" << std::endl; | |
142 | fFileName = "toyMC.root"; | |
143 | } | |
144 | ||
145 | fInFile = new TFile(fFileName.Data(),"read"); | |
146 | gROOT->cd(); | |
147 | fInputTree = dynamic_cast<TTree*> (fInFile->Get("toyMCtree")); | |
148 | fInputTree->SetBranchAddress("event",&fEvent); | |
149 | fEventArray->Clear(); | |
150 | ||
151 | Int_t leftSearchIndex = Int_t(snapShotTime/2e-5); | |
152 | if(leftSearchIndex>fInputTree->GetEntries()) { | |
153 | leftSearchIndex = fInputTree->GetEntries()-1; | |
154 | fInputTree->GetEvent(leftSearchIndex); | |
155 | snapShotTime = fEvent->GetT0(); | |
156 | std::cout << "input time too large, setting time to time of last event" << std::endl; | |
157 | } | |
158 | if(leftSearchIndex<0) leftSearchIndex = 0; | |
159 | ||
160 | //fCenterTime = snapShotTime; | |
161 | ||
162 | fInputTree->GetEvent(leftSearchIndex); | |
163 | Double_t leftTime = fEvent ->GetT0(); | |
164 | Int_t firstEventIndex; | |
165 | //if fEvent exactly at snapShotTime, check if there are more events at the same time but with lower indices | |
166 | if( TMath::Abs(leftTime - snapShotTime)<5e-9) | |
167 | { | |
168 | // printf("close from start, lefttime = %2.2f\n",leftTime); | |
169 | firstEventIndex = leftSearchIndex+1; | |
170 | while( TMath::Abs(leftTime- snapShotTime) < 5e-9){ | |
171 | firstEventIndex--; | |
172 | // printf("close from start, lefttime = %2.2f\n",leftTime); | |
173 | if(fInputTree->GetEvent(firstEventIndex-1)) | |
174 | { | |
175 | leftTime=fEvent->GetT0(); | |
176 | // printf("close from start, lefttime = %2.2f\n",leftTime); | |
177 | } | |
178 | else break; | |
179 | } | |
180 | ||
181 | ||
182 | } | |
183 | else | |
184 | { | |
185 | Int_t rightSearchIndex = leftSearchIndex; | |
186 | Double_t rightTime; | |
187 | ||
188 | Int_t direction = 1; //go right | |
189 | if(leftTime > snapShotTime) { | |
190 | direction = -1; | |
191 | } | |
192 | rightSearchIndex+= direction; | |
193 | if(!fInputTree->GetEvent(rightSearchIndex)) return FillEventArray(leftSearchIndex); | |
194 | rightTime = fEvent->GetT0(); | |
195 | // std::cout << "bef search " << leftTime << " " << rightTime<< " " << " " << snapShotTime << " "<< (leftTime-snapShotTime)*(rightTime-snapShotTime) << std::endl; | |
196 | // Int_t b; | |
197 | ||
198 | while ( (leftTime-snapShotTime)*(rightTime-snapShotTime)>0 ){ | |
199 | // printf("searching, leftime %f, righttim %f\n",leftTime,rightTime); | |
200 | rightSearchIndex += direction; | |
201 | leftSearchIndex +=direction; | |
202 | fInputTree->GetEvent(leftSearchIndex); | |
203 | leftTime = fEvent->GetT0(); | |
204 | if(!fInputTree->GetEvent(rightSearchIndex)) { | |
205 | rightSearchIndex-=direction; | |
206 | break; | |
207 | ||
208 | } | |
209 | rightTime = fEvent->GetT0(); | |
210 | printf("searching, leftime %f, righttim %f\n",leftTime,rightTime); | |
211 | } | |
212 | if (direction==-1) rightSearchIndex = leftSearchIndex; | |
213 | firstEventIndex = rightSearchIndex; | |
214 | ||
215 | } | |
216 | // fInputTree->GetEvent(firstEventIndex); | |
217 | //std::cout <<"first event after sn time: " << fEvent->GetT0() << std::endl; | |
218 | return FillEventArray(firstEventIndex, snapShotTime); | |
219 | ||
220 | } | |
221 | //________________________________________________________________ | |
222 | Int_t AliToyMCDrawer::FillEventArray(Int_t middleEventNbr, Double_t snapShotTime) | |
223 | { | |
224 | if(fFileName.IsNull()) { | |
225 | std::cout << "no input file provided, using default (toyMC.root)" << std::endl; | |
226 | fFileName = "toyMC.root"; | |
227 | } | |
228 | if(!fInFile) fInFile = new TFile(fFileName.Data(),"read"); | |
229 | gROOT->cd(); | |
230 | if(!fInputTree) | |
231 | { | |
232 | fInputTree = dynamic_cast<TTree*> (fInFile->Get("toyMCtree")); | |
233 | // fInputTree->Add(fileName); | |
234 | fInputTree->SetBranchAddress("event",&fEvent); | |
235 | } | |
236 | Double_t centerEventTime; | |
237 | if(fInputTree->GetEvent(middleEventNbr)) | |
238 | { | |
239 | centerEventTime = fEvent->GetT0(); | |
240 | ||
241 | } | |
242 | else return 0; | |
243 | ||
244 | if(snapShotTime<0) fCenterTime = centerEventTime; | |
245 | else fCenterTime = snapShotTime; | |
246 | ||
247 | fEventArray->Clear(); | |
248 | if(fInputTree->GetEvent(middleEventNbr)){ | |
249 | new((*fEventArray)[fEventArray->GetEntriesFast()]) AliToyMCEvent(*fEvent); | |
250 | ||
251 | //add events after middle event | |
252 | Int_t eventIndex = middleEventNbr + 1; | |
253 | Double_t currentTime = centerEventTime; | |
254 | if(fInputTree->GetEvent(eventIndex)) { | |
255 | currentTime = fEvent->GetT0(); | |
256 | while(currentTime - centerEventTime < fTimeRange/2) { | |
257 | new((*fEventArray)[fEventArray->GetEntriesFast()]) AliToyMCEvent(*fEvent); | |
258 | eventIndex++; | |
259 | if(!fInputTree->GetEvent(eventIndex)) break; | |
260 | currentTime = fEvent->GetT0(); | |
261 | } | |
262 | } | |
263 | //add events before middle event | |
264 | eventIndex = middleEventNbr - 1; | |
265 | if(fInputTree->GetEvent(eventIndex)){ | |
266 | currentTime = fEvent->GetT0(); | |
267 | while(centerEventTime-currentTime < fTimeRange/2) { | |
268 | ||
269 | new((*fEventArray)[fEventArray->GetEntriesFast()]) AliToyMCEvent(*fEvent); | |
270 | eventIndex--; | |
271 | if(!fInputTree->GetEvent(eventIndex)) break; | |
272 | currentTime = fEvent->GetT0(); | |
273 | } | |
274 | } | |
275 | ||
276 | std::cout << " end fill" << std::endl; | |
277 | ||
278 | return 1; | |
279 | } | |
280 | else { | |
281 | printf("Selected event number (%d) out of range!\n",middleEventNbr); | |
282 | return 0; | |
283 | } | |
284 | ||
285 | } | |
286 | //________________________________________________________________ | |
287 | void AliToyMCDrawer::DrawEvents(Bool_t both, Bool_t before) | |
288 | { | |
289 | ||
290 | if (fPoints){ | |
291 | fPoints->Clear(); | |
292 | fDistPoints->Clear(); | |
293 | } | |
294 | DrawGeometry(); | |
295 | ||
296 | ||
297 | Double_t phiCut = 1.; | |
298 | TLegend *leg = new TLegend(0.1,0.75,0.6,1,Form("Snapshot of TPC at %f micros after sim start, freq. = , bunchcr.rate = .",1000000*fCenterTime)); | |
299 | leg->AddEntry((TObject*)0,Form("%2.2f<#phi<#pi-%2.2f && #pi+%2.2f<#phi<2#pi-%2.2f",phiCut,phiCut,phiCut,phiCut),""); | |
300 | ||
301 | ||
302 | ||
303 | ||
304 | for(Int_t iEvent = 0; iEvent<fEventArray->GetEntriesFast(); iEvent++){ | |
305 | ||
306 | ||
307 | AliToyMCEvent *currentEvent = static_cast<AliToyMCEvent*> (fEventArray->At(iEvent)); | |
308 | Double_t currentEventTime = currentEvent->GetT0(); | |
309 | ||
310 | if((1000000*currentEventTime)>((1000000*fCenterTime)+0.05 )) { | |
311 | printf("larger iEvent: %d, current %f, center %f, ntracks: %d\n",iEvent, currentEventTime,fCenterTime, currentEvent->GetNumberOfTracks()); | |
312 | printf("after\n"); | |
313 | if ( !(both || !before)) continue; | |
314 | ||
315 | } | |
316 | if( currentEventTime<=fCenterTime)// && !(currentEventTime==fCenterTime &&both )) | |
317 | { | |
318 | printf("smaller iEvent: %d, current %f, center %f, ntracks: %d\n",iEvent, currentEventTime,fCenterTime, currentEvent->GetNumberOfTracks()); | |
319 | printf("before\n"); | |
320 | if ( !(both || before)) continue; | |
321 | } | |
322 | ||
323 | //std:: cout << "iev " << iEvent << " " << color << std::endl; | |
324 | Double_t currentEventTimeRelToCentral = fCenterTime - currentEventTime; | |
325 | ||
326 | Int_t color = ((currentEvent->GetEventNumber())%10); | |
327 | if(color == 0||color ==1) { | |
328 | color==0?color=2:color=3; | |
329 | // if(iEvent==0) color = 8; | |
330 | // if(iEvent==1) color = 9; | |
331 | ||
332 | } | |
333 | ||
334 | char bef[] = "before snapshot time"; | |
335 | char aft[] = "after snapshot time"; | |
336 | char *when; | |
337 | Int_t sign = 1; | |
338 | if( 1000000*(currentEventTime-fCenterTime) > 0.5) {when = aft; | |
339 | sign = -1; | |
340 | } | |
341 | else when = bef; | |
342 | TGraph *temp = new TGraph(); | |
343 | temp->SetName(Form("temp%d",currentEvent->GetEventNumber())); | |
344 | temp->SetLineColor(color); | |
345 | temp->SetLineWidth(10); | |
346 | ||
347 | leg->AddEntry(temp,Form(" %2.2f microseconds %s (global time %2.2f) at z_vertex = %2.2f, centr = ., eventNr: %d", 1000000*sign*currentEventTimeRelToCentral, when, 1000000*currentEvent->GetT0(), currentEvent->GetZ() ,currentEvent->GetEventNumber() ),"l"); | |
348 | ||
349 | ||
350 | DrawEvent(currentEvent, fCenterTime, color); | |
351 | ||
352 | ||
353 | ||
354 | ||
355 | ||
356 | } | |
357 | leg->Draw("same"); | |
358 | ||
359 | } | |
360 | //________________________________________________________________ | |
361 | ||
362 | void AliToyMCDrawer::DrawEvent(AliToyMCEvent *currentEvent, Double_t centerTime, Int_t color){ | |
363 | if(!fDispHist) DrawGeometry(); | |
364 | ||
365 | for(Int_t iTrack = 0; iTrack < currentEvent->GetNumberOfTracks(); iTrack++){ | |
366 | ||
367 | //Double_t alpha = TMath::ATan2(currentEvent->GetTrack(iTrack)->GetSpacePoint(0)->GetY(),currentEvent->GetTrack(iTrack)->GetSpacePoint(0)->GetX()); | |
368 | // if( ( ( !(abs(alpha)>phiCut && abs(alpha) < TMath::Pi() - phiCut) ) ) )continue; | |
369 | // if(alpha<0) { | |
370 | // continue; | |
371 | // delete tempTrack; | |
372 | // } | |
373 | ||
374 | //if(currentEvent->GetTrack(iTrack)->GetSpacePoint(0)->GetY()<0) alpha +=TMath::Pi(); | |
375 | //if( ( (alpha>phiCut && alpha < TMath::Pi() - phiCut) || ( alpha>TMath::Pi() + phiCut && alpha < TMath::TwoPi() - phiCut)) )continue; | |
376 | ||
377 | // if(alpha > 0) continue; | |
378 | ||
379 | //std::cout << TMath::ASin(tempTrack->GetParameter()[2]) << std::endl; | |
380 | // Double_t x = currentEvent->GetX(); | |
381 | // Double_t y = currentEvent->GetY(); | |
382 | // Double_t hlxpar[6]; | |
383 | // currentEvent->GetTrack(iTrack)->GetHelixParameters(hlxpar,0); | |
384 | // Double_t trackPhi = hlxpar[2]; | |
385 | // Double_t phiCut = 1.47; | |
386 | // std::cout << "bef phi cut "<< trackPhi<< std::endl; | |
387 | ||
388 | // std::cout << "aft phi cut " << std::endl; | |
389 | // Double_t trackEta = currentEvent->GetTrack(iTrack)->GetEta(); | |
390 | // Double_t z = currentEvent->GetZ(); | |
391 | ||
392 | ||
393 | ||
394 | ||
395 | ||
396 | const AliToyMCTrack *tempTrack = currentEvent->GetTrack(iTrack); | |
397 | //AliToyMCTrack *tempTrack = new AliToyMCTrack(*currentEvent->GetTrack(iTrack)); | |
398 | if (fProjectionType.Length()==3){ | |
399 | DrawTrack(tempTrack, centerTime, currentEvent->GetT0(),color); | |
400 | } else if (fProjectionType.Length()==2){ | |
401 | DrawTrack2D(tempTrack, centerTime, currentEvent->GetT0(),color); | |
402 | } | |
403 | ||
404 | } | |
405 | } | |
406 | ||
407 | //________________________________________________________________ | |
408 | void AliToyMCDrawer::DrawLaserEvent(Int_t nLaserEvents, Int_t side, Int_t rod, Int_t bundle, Int_t beam) | |
409 | { | |
410 | // | |
411 | // | |
412 | // | |
413 | ||
414 | if (fPoints) { | |
415 | fPoints->Clear(); | |
416 | fDistPoints->Clear(); | |
417 | } | |
418 | if (!ConnectInputTree()) return; | |
419 | ||
420 | AliTPCLaserTrack::LoadTracks(); | |
421 | TObjArray *arr=AliTPCLaserTrack::GetTracks(); | |
422 | ||
423 | if (fProjectionType.Length()==3){ | |
424 | DrawGeometry(); | |
425 | } else if (fProjectionType.Length()==2){ | |
426 | DrawGeometry2D(); | |
427 | } | |
428 | ||
429 | Int_t laserEvents=0; | |
430 | for (Int_t iev=0;iev<fInputTree->GetEntries();++iev) { | |
431 | fInputTree->GetEntry(iev); | |
432 | if (fEvent->GetEventType()!=AliToyMCEvent::kLaser) continue; | |
433 | if (fEvent->GetNumberOfTracks()!=arr->GetEntriesFast()) { | |
434 | AliError(Form("Wrong number of tracks in the laser event: %d!=%d",fEvent->GetNumberOfTracks(),arr->GetEntriesFast())); | |
435 | continue; | |
436 | } | |
437 | ||
438 | for (Int_t iTrack=0; iTrack<fEvent->GetNumberOfTracks();++iTrack){ | |
439 | AliTPCLaserTrack *laserTrack = (AliTPCLaserTrack*)arr->UncheckedAt(iTrack); | |
440 | if (side >-1 && laserTrack->GetSide() != side ) continue; | |
441 | if (rod >-1 && laserTrack->GetRod() != rod ) continue; | |
442 | if (bundle>-1 && laserTrack->GetBundle() != bundle ) continue; | |
443 | if (beam >-1 && laserTrack->GetBeam() != beam ) continue; | |
444 | const AliToyMCTrack *track = fEvent->GetTrack(iTrack); | |
445 | if (fProjectionType.Length()==3){ | |
446 | DrawTrack(track,0,fEvent->GetT0(),kRed); | |
447 | } else if (fProjectionType.Length()==2){ | |
448 | DrawTrack2D(track,0,fEvent->GetT0(),kRed); | |
449 | } | |
450 | ||
451 | } | |
452 | ||
453 | ++laserEvents; | |
454 | if (laserEvents==nLaserEvents) break; | |
455 | } | |
456 | ||
457 | ||
458 | } | |
459 | ||
460 | //________________________________________________________________ | |
461 | void AliToyMCDrawer::DrawTrack(const AliToyMCTrack *track, Double_t centerTime, Double_t currentEventTime, Int_t color){ | |
462 | if(!fDispHist) DrawGeometry(); | |
463 | if (!fPoints) { | |
464 | fPoints = new TClonesArray("TPolyMarker3D"); | |
465 | fDistPoints = new TClonesArray("TPolyMarker3D"); | |
466 | } | |
467 | ||
468 | TPolyMarker3D *disttrackpoints = new((*fDistPoints)[fDistPoints->GetEntriesFast()]) TPolyMarker3D(); | |
469 | TPolyMarker3D *trackpoints = new((*fPoints)[fPoints->GetEntriesFast()]) TPolyMarker3D(); | |
470 | ||
471 | Double_t currentEventTimeRelToCentral = centerTime - currentEventTime; | |
472 | Int_t nDistPoints = track->GetNumberOfDistSpacePoints(); | |
473 | Int_t nPoints = track->GetNumberOfSpacePoints(); | |
474 | ||
475 | for(Int_t iITSPoint = 0; iITSPoint< track->GetNumberOfITSPoints();iITSPoint++){ | |
476 | ||
477 | Double_t xp = track->GetITSPoint(iITSPoint)->GetX(); | |
478 | Double_t yp = track->GetITSPoint(iITSPoint)->GetY(); | |
479 | Double_t zp = track->GetITSPoint(iITSPoint)->GetZ(); | |
480 | Double_t zDrifted = zp+(zp/TMath::Abs(zp))*currentEventTimeRelToCentral * fDriftVel; | |
481 | trackpoints->SetNextPoint(zDrifted,xp,yp); | |
482 | } | |
483 | ||
484 | for(Int_t iPoint = 0; iPoint< (nDistPoints<nPoints?nPoints:nDistPoints);iPoint++){ | |
485 | if(iPoint<nPoints) { | |
486 | ||
487 | ||
488 | Double_t xp = track->GetSpacePoint(iPoint)->GetX(); | |
489 | Double_t yp = track->GetSpacePoint(iPoint)->GetY(); | |
490 | Double_t zp = track->GetSpacePoint(iPoint)->GetZ(); | |
491 | Double_t zDrifted = zp+(zp/TMath::Abs(zp))*currentEventTimeRelToCentral * fDriftVel; | |
492 | //Double_t zDrifted = (zp/TMath::Abs(zp))*fMaxZ0 -(zp/TMath::Abs(zp))* fDriftVel*(track->GetSpacePoint(iPoint)->GetTimeBin() -centerTime ); | |
493 | Float_t xyzp[3] = {xp,yp,zp}; | |
494 | AliTrackPoint p; | |
495 | p.SetXYZ(xyzp); | |
496 | Float_t tempcov[6] = {0}; | |
497 | p.SetCov(tempcov); | |
498 | Int_t sec = track->GetSpacePoint(iPoint)->GetDetector(); | |
499 | Double_t angle=((sec%18)*20.+10.)/TMath::RadToDeg(); | |
500 | AliTrackPoint prot = p.Rotate(-angle); | |
501 | xp = prot.GetX(); | |
502 | yp = prot.GetY(); | |
503 | ||
504 | // Double_t ztime=zDrifted; | |
505 | // Double_t globx=xp; | |
506 | // Double_t globy=yp; | |
507 | ||
508 | // if (fProje) | |
509 | ||
510 | ||
511 | if(track->GetSpacePoint(iPoint)->GetRow()!=255) { | |
512 | if(TMath::Abs(zDrifted)<fMaxZ0 && zDrifted*zp >=0 /*&&TMath::Sqrt(xp*xp + yp*yp)<fIFCRadius*/) trackpoints->SetNextPoint(zDrifted,xp,yp); | |
513 | ||
514 | } | |
515 | else std::cout << "row == " << track->GetSpacePoint(iPoint)->GetRow() << std::endl; | |
516 | ||
517 | } | |
518 | if(iPoint<nDistPoints) { | |
519 | Double_t xpdist = track->GetDistortedSpacePoint(iPoint)->GetX(); | |
520 | Double_t ypdist = track->GetDistortedSpacePoint(iPoint)->GetY(); | |
521 | Double_t zpdist = track->GetDistortedSpacePoint(iPoint)->GetZ(); | |
522 | //std::cout << zpdist << std::endl; | |
523 | ||
524 | Float_t xyzpdist[3] = {xpdist,ypdist,zpdist}; | |
525 | AliTrackPoint pdist; | |
526 | pdist.SetXYZ(xyzpdist); | |
527 | Float_t tempcovdist[6] = {0}; | |
528 | pdist.SetCov(tempcovdist); | |
529 | Int_t secdist = track->GetDistortedSpacePoint(iPoint)->GetDetector(); | |
530 | Double_t angledist=((secdist%18)*20.+10.)/TMath::RadToDeg(); | |
531 | AliTrackPoint protdist = pdist.Rotate(-angledist); | |
532 | xpdist = protdist.GetX(); | |
533 | ypdist = protdist.GetY(); | |
534 | ||
535 | ||
536 | UInt_t sector = track->GetDistortedSpacePoint(iPoint)->GetDetector(); | |
537 | UInt_t row = track->GetDistortedSpacePoint(iPoint)->GetRow(); | |
538 | UInt_t pad = track->GetDistortedSpacePoint(iPoint)->GetPad(); | |
539 | ||
540 | Int_t nPads = fTPCParam->GetNPads(sector,row); | |
541 | Int_t intPad = TMath::Nint(Float_t(pad+nPads/2)); | |
542 | ||
543 | Float_t xyz[3]; | |
544 | //std::cout <<"sector: " << sector << " row: " << row << " pad: " <<pad<< std::endl; | |
545 | fRoc->GetPositionGlobal(sector,row,intPad,xyz); | |
546 | ||
547 | Double_t zDrifteddist = (zpdist/TMath::Abs(zpdist))*fMaxZ0 -(zpdist/TMath::Abs(zpdist))* fDriftVel*(track->GetDistortedSpacePoint(iPoint)->GetTimeBin() -centerTime ); | |
548 | if(row!=255){ | |
549 | ||
550 | if(TMath::Abs(zDrifteddist)<fMaxZ0 && zDrifteddist*zpdist>=0 /*&&TMath::Sqrt(xpdist*xpdist + ypdist*ypdist)<fIFCRadius*/) { | |
551 | ||
552 | disttrackpoints->SetNextPoint(zDrifteddist,xpdist,ypdist); | |
553 | //if(TMath::Sqrt(xpdist*xpdist + ypdist*ypdist)<fIFCRadius) std::cout << "fMaxZ0 " << fMaxZ0 <<" inside " << xpdist << " " << "zpdist " << zpdist << " " << "zDrifteddist "<< zDrifteddist << " " << zDrifteddist*zpdist << std::endl; | |
554 | } | |
555 | } | |
556 | else std::cout << "row == " << row << std::endl; | |
557 | //Double_t zDrifteddist =(zpdist/TMath::Abs(zpdist))*fMaxZ0 -(zpdist/TMath::Abs(zpdist))*(currentEvent->GetTrack(iTrack)->GetDistortedSpacePoint(iPoint)->GetTimeBin()- currentEvent->GetT0() )* fDriftVel; | |
558 | ||
559 | ||
560 | } | |
561 | // if( ( (trackPhi>phiCut && trackPhi < TMath::Pi() - phiCut) || ( trackPhi>TMath::Pi() + phiCut && trackPhi < TMath::TwoPi() - phiCut)) ) { | |
562 | ||
563 | ||
564 | ||
565 | ||
566 | ||
567 | } | |
568 | if(0){ | |
569 | for(Int_t iTRDPoint = 0; iTRDPoint< track->GetNumberOfTRDPoints();iTRDPoint++){ | |
570 | ||
571 | Double_t xp = track->GetTRDPoint(iTRDPoint)->GetX(); | |
572 | Double_t yp = track->GetTRDPoint(iTRDPoint)->GetY(); | |
573 | Double_t zp = track->GetTRDPoint(iTRDPoint)->GetZ(); | |
574 | Double_t zDrifted = zp+(zp/TMath::Abs(zp))*currentEventTimeRelToCentral * fDriftVel; | |
575 | trackpoints->SetNextPoint(zDrifted,xp,yp); | |
576 | } | |
577 | } | |
578 | if(1){ | |
579 | if(trackpoints && trackpoints->GetN()>0) { | |
580 | // trackpoints->SetMarkerColor(1+currentEvent->GetEventNumber()%9); | |
581 | //trackpoints->SetMarkerStyle(6); | |
582 | trackpoints->Draw("same"); | |
583 | } | |
584 | if(disttrackpoints && disttrackpoints->GetN()>0) { | |
585 | // | |
586 | //disttrackpoints->SetMarkerStyle(6); | |
587 | disttrackpoints->SetMarkerColor(color); | |
588 | ||
589 | ||
590 | disttrackpoints->Draw("same"); | |
591 | ||
592 | } | |
593 | ||
594 | } | |
595 | ||
596 | ||
597 | ||
598 | ||
599 | } | |
600 | ||
601 | //________________________________________________________________ | |
602 | void AliToyMCDrawer::DrawTrack2D(const AliToyMCTrack *track, Double_t centerTime, Double_t currentEventTime, Int_t color){ | |
603 | if(!fDispHist) DrawGeometry2D(); | |
604 | if (!fPoints) { | |
605 | fPoints = new TClonesArray("TPolyMarker"); | |
606 | fDistPoints = new TClonesArray("TPolyMarker"); | |
607 | } | |
608 | ||
609 | Double_t timeZmin=-fMaxZ0; | |
610 | Double_t timeZmax= fMaxZ0; | |
611 | Double_t globXmin=-(fOFCRadius +10); | |
612 | Double_t globXmax= fOFCRadius +10 ; | |
613 | Double_t globYmin=-(fOFCRadius +10); | |
614 | Double_t globYmax= fOFCRadius +10 ; | |
615 | ||
616 | // const Double_t epsilon=.001; | |
617 | ||
618 | TString title; | |
619 | if (fTimeZmax>fTimeZmin) { | |
620 | timeZmin=fTimeZmin; | |
621 | timeZmax=fTimeZmax; | |
622 | } | |
623 | if (fGlobalXmax>fGlobalXmin) { | |
624 | globXmin=fGlobalXmin; | |
625 | globXmax=fGlobalXmax; | |
626 | } | |
627 | if (fGlobalYmax>fGlobalYmin) { | |
628 | globYmin=fGlobalYmin; | |
629 | globYmax=fGlobalYmax; | |
630 | } | |
631 | ||
632 | TPolyMarker *disttrackpoints = new((*fDistPoints)[fDistPoints->GetEntriesFast()]) TPolyMarker(); | |
633 | TPolyMarker *trackpoints = new((*fPoints)[fPoints->GetEntriesFast()]) TPolyMarker(); | |
634 | ||
635 | Double_t currentEventTimeRelToCentral = centerTime - currentEventTime; | |
636 | Int_t nDistPoints = track->GetNumberOfDistSpacePoints(); | |
637 | Int_t nPoints = track->GetNumberOfSpacePoints(); | |
638 | ||
639 | for(Int_t iITSPoint = 0; iITSPoint< track->GetNumberOfITSPoints();iITSPoint++){ | |
640 | ||
641 | Double_t xp = track->GetITSPoint(iITSPoint)->GetX(); | |
642 | Double_t yp = track->GetITSPoint(iITSPoint)->GetY(); | |
643 | Double_t zp = track->GetITSPoint(iITSPoint)->GetZ(); | |
644 | Double_t zDrifted = zp+(zp/TMath::Abs(zp))*currentEventTimeRelToCentral * fDriftVel; | |
645 | ||
646 | if ( xp<globXmin || xp>globXmax || yp<globYmin || yp>globYmax || zDrifted<timeZmin || zDrifted>timeZmax ) continue; | |
647 | ||
648 | Double_t x=0.; | |
649 | Double_t y=0.; | |
650 | if (fProjectionType=="XT"){ | |
651 | x=zDrifted; | |
652 | y=xp; | |
653 | } else if (fProjectionType=="YT"){ | |
654 | x=zDrifted; | |
655 | y=yp; | |
656 | } else if (fProjectionType=="RT"){ | |
657 | x=zDrifted; | |
658 | y=TMath::Sqrt(xp*xp+yp*yp); | |
659 | } else if (fProjectionType=="XY" || fProjectionType=="YX") { | |
660 | x=xp; | |
661 | y=yp; | |
662 | } | |
663 | trackpoints->SetNextPoint(x,y); | |
664 | } | |
665 | ||
666 | for(Int_t iPoint = 0; iPoint< (nDistPoints<nPoints?nPoints:nDistPoints);iPoint++){ | |
667 | if(iPoint<nPoints) { | |
668 | ||
669 | ||
670 | Double_t xp = track->GetSpacePoint(iPoint)->GetX(); | |
671 | Double_t yp = track->GetSpacePoint(iPoint)->GetY(); | |
672 | Double_t zp = track->GetSpacePoint(iPoint)->GetZ(); | |
673 | Double_t zDrifted = zp+(zp/TMath::Abs(zp))*currentEventTimeRelToCentral * fDriftVel; | |
674 | ||
675 | //Double_t zDrifted = (zp/TMath::Abs(zp))*fMaxZ0 -(zp/TMath::Abs(zp))* fDriftVel*(track->GetSpacePoint(iPoint)->GetTimeBin() -centerTime ); | |
676 | Float_t xyzp[3] = {xp,yp,zp}; | |
677 | AliTrackPoint p; | |
678 | p.SetXYZ(xyzp); | |
679 | Float_t tempcov[6] = {0}; | |
680 | p.SetCov(tempcov); | |
681 | Int_t sec = track->GetSpacePoint(iPoint)->GetDetector(); | |
682 | Double_t angle=((sec%18)*20.+10.)/TMath::RadToDeg(); | |
683 | AliTrackPoint prot = p.Rotate(-angle); | |
684 | xp = prot.GetX(); | |
685 | yp = prot.GetY(); | |
686 | ||
687 | if ( xp<globXmin || xp>globXmax || yp<globYmin || yp>globYmax || zDrifted<timeZmin || zDrifted>timeZmax ) continue; | |
688 | ||
689 | // Double_t ztime=zDrifted; | |
690 | // Double_t globx=xp; | |
691 | // Double_t globy=yp; | |
692 | ||
693 | Double_t x=0.; | |
694 | Double_t y=0.; | |
695 | if (fProjectionType=="XT"){ | |
696 | x=zDrifted; | |
697 | y=xp; | |
698 | } else if (fProjectionType=="YT"){ | |
699 | x=zDrifted; | |
700 | y=yp; | |
701 | } else if (fProjectionType=="RT"){ | |
702 | x=zDrifted; | |
703 | y=TMath::Sqrt(xp*xp+yp*yp); | |
704 | } else if (fProjectionType=="XY" || fProjectionType=="YX") { | |
705 | x=xp; | |
706 | y=yp; | |
707 | } | |
708 | ||
709 | if(track->GetSpacePoint(iPoint)->GetRow()!=255) { | |
710 | if(TMath::Abs(zDrifted)<fMaxZ0 && zDrifted*zp >=0 /*&&TMath::Sqrt(xp*xp + yp*yp)<fIFCRadius*/) trackpoints->SetNextPoint(x,y); | |
711 | ||
712 | } | |
713 | else std::cout << "row == " << track->GetSpacePoint(iPoint)->GetRow() << std::endl; | |
714 | ||
715 | } | |
716 | if(iPoint<nDistPoints) { | |
717 | Double_t xpdist = track->GetDistortedSpacePoint(iPoint)->GetX(); | |
718 | Double_t ypdist = track->GetDistortedSpacePoint(iPoint)->GetY(); | |
719 | Double_t zpdist = track->GetDistortedSpacePoint(iPoint)->GetZ(); | |
720 | ||
721 | //std::cout << zpdist << std::endl; | |
722 | ||
723 | Float_t xyzpdist[3] = {xpdist,ypdist,zpdist}; | |
724 | AliTrackPoint pdist; | |
725 | pdist.SetXYZ(xyzpdist); | |
726 | Float_t tempcovdist[6] = {0}; | |
727 | pdist.SetCov(tempcovdist); | |
728 | Int_t secdist = track->GetDistortedSpacePoint(iPoint)->GetDetector(); | |
729 | Double_t angledist=((secdist%18)*20.+10.)/TMath::RadToDeg(); | |
730 | AliTrackPoint protdist = pdist.Rotate(-angledist); | |
731 | xpdist = protdist.GetX(); | |
732 | ypdist = protdist.GetY(); | |
733 | ||
734 | UInt_t sector = track->GetDistortedSpacePoint(iPoint)->GetDetector(); | |
735 | UInt_t row = track->GetDistortedSpacePoint(iPoint)->GetRow(); | |
736 | UInt_t pad = track->GetDistortedSpacePoint(iPoint)->GetPad(); | |
737 | ||
738 | Int_t nPads = fTPCParam->GetNPads(sector,row); | |
739 | Int_t intPad = TMath::Nint(Float_t(pad+nPads/2)); | |
740 | ||
741 | Float_t xyz[3]; | |
742 | //std::cout <<"sector: " << sector << " row: " << row << " pad: " <<pad<< std::endl; | |
743 | fRoc->GetPositionGlobal(sector,row,intPad,xyz); | |
744 | ||
745 | Double_t zDrifteddist = (zpdist/TMath::Abs(zpdist))*fMaxZ0 -(zpdist/TMath::Abs(zpdist))* fDriftVel*(track->GetDistortedSpacePoint(iPoint)->GetTimeBin() -centerTime ); | |
746 | ||
747 | if ( xpdist<globXmin || xpdist>globXmax || ypdist<globYmin || ypdist>globYmax || zDrifteddist<timeZmin || zDrifteddist>timeZmax ) continue; | |
748 | ||
749 | Double_t x=0.; | |
750 | Double_t y=0.; | |
751 | if (fProjectionType=="XT"){ | |
752 | x=zDrifteddist; | |
753 | y=xpdist; | |
754 | } else if (fProjectionType=="YT"){ | |
755 | x=zDrifteddist; | |
756 | y=ypdist; | |
757 | } else if (fProjectionType=="RT"){ | |
758 | x=zDrifteddist; | |
759 | y=TMath::Sqrt(xpdist*xpdist+ypdist*ypdist); | |
760 | } else if (fProjectionType=="XY" || fProjectionType=="YX") { | |
761 | x=xpdist; | |
762 | y=ypdist; | |
763 | } | |
764 | ||
765 | if(row!=255){ | |
766 | ||
767 | if(TMath::Abs(zDrifteddist)<fMaxZ0 && zDrifteddist*zpdist>=0 /*&&TMath::Sqrt(xpdist*xpdist + ypdist*ypdist)<fIFCRadius*/) { | |
768 | ||
769 | disttrackpoints->SetNextPoint(x,y); | |
770 | //if(TMath::Sqrt(xpdist*xpdist + ypdist*ypdist)<fIFCRadius) std::cout << "fMaxZ0 " << fMaxZ0 <<" inside " << xpdist << " " << "zpdist " << zpdist << " " << "zDrifteddist "<< zDrifteddist << " " << zDrifteddist*zpdist << std::endl; | |
771 | } | |
772 | } | |
773 | else std::cout << "row == " << row << std::endl; | |
774 | //Double_t zDrifteddist =(zpdist/TMath::Abs(zpdist))*fMaxZ0 -(zpdist/TMath::Abs(zpdist))*(currentEvent->GetTrack(iTrack)->GetDistortedSpacePoint(iPoint)->GetTimeBin()- currentEvent->GetT0() )* fDriftVel; | |
775 | ||
776 | ||
777 | } | |
778 | // if( ( (trackPhi>phiCut && trackPhi < TMath::Pi() - phiCut) || ( trackPhi>TMath::Pi() + phiCut && trackPhi < TMath::TwoPi() - phiCut)) ) { | |
779 | ||
780 | ||
781 | ||
782 | ||
783 | ||
784 | } | |
785 | if(0){ | |
786 | for(Int_t iTRDPoint = 0; iTRDPoint< track->GetNumberOfTRDPoints();iTRDPoint++){ | |
787 | ||
788 | Double_t xp = track->GetTRDPoint(iTRDPoint)->GetX(); | |
789 | Double_t yp = track->GetTRDPoint(iTRDPoint)->GetY(); | |
790 | Double_t zp = track->GetTRDPoint(iTRDPoint)->GetZ(); | |
791 | Double_t zDrifted = zp+(zp/TMath::Abs(zp))*currentEventTimeRelToCentral * fDriftVel; | |
792 | ||
793 | if ( xp<globXmin || xp>globXmax || yp<globYmin || yp>globYmax || zDrifted<timeZmin || zDrifted>timeZmax ) continue; | |
794 | ||
795 | Double_t x=0.; | |
796 | Double_t y=0.; | |
797 | if (fProjectionType=="XT"){ | |
798 | x=zDrifted; | |
799 | y=xp; | |
800 | } else if (fProjectionType=="YT"){ | |
801 | x=zDrifted; | |
802 | y=yp; | |
803 | } else if (fProjectionType=="RT"){ | |
804 | x=zDrifted; | |
805 | y=TMath::Sqrt(xp*xp+yp*yp); | |
806 | } else if (fProjectionType=="XY" || fProjectionType=="YX") { | |
807 | x=xp; | |
808 | y=yp; | |
809 | } | |
810 | trackpoints->SetNextPoint(x,y); | |
811 | } | |
812 | } | |
813 | if(1){ | |
814 | if(trackpoints && trackpoints->GetN()>0) { | |
815 | // trackpoints->SetMarkerColor(1+currentEvent->GetEventNumber()%9); | |
816 | //trackpoints->SetMarkerStyle(6); | |
817 | trackpoints->Draw("same"); | |
818 | } | |
819 | if(disttrackpoints && disttrackpoints->GetN()>0) { | |
820 | // | |
821 | //disttrackpoints->SetMarkerStyle(6); | |
822 | disttrackpoints->SetMarkerColor(color); | |
823 | ||
824 | ||
825 | disttrackpoints->Draw("same"); | |
826 | ||
827 | } | |
828 | ||
829 | } | |
830 | ||
831 | ||
832 | ||
833 | ||
834 | } | |
835 | ||
836 | //________________________________________________________________ | |
837 | void AliToyMCDrawer::DrawGeometry() { | |
838 | ||
839 | ||
840 | //delete fDispGraph; | |
841 | //fDispGraph = new TGraph2D(); | |
842 | delete fDispHist; | |
843 | ||
844 | Double_t timeZmin=-fMaxZ0; | |
845 | Double_t timeZmax= fMaxZ0; | |
846 | Double_t globXmin=-(fOFCRadius +10); | |
847 | Double_t globXmax= fOFCRadius +10 ; | |
848 | Double_t globYmin=-(fOFCRadius +10); | |
849 | Double_t globYmax= fOFCRadius +10 ; | |
850 | ||
851 | const Double_t epsilon=.001; | |
852 | ||
853 | TString title; | |
854 | if (fTimeZmax>fTimeZmin) { | |
855 | timeZmin=fTimeZmin; | |
856 | timeZmax=fTimeZmax; | |
857 | } | |
858 | if (fGlobalXmax>fGlobalXmin) { | |
859 | globXmin=fGlobalXmin; | |
860 | globXmax=fGlobalXmax; | |
861 | } | |
862 | if (fGlobalYmax>fGlobalYmin) { | |
863 | globYmin=fGlobalYmin; | |
864 | globYmax=fGlobalYmax; | |
865 | } | |
866 | fDispHist = new TH3F("fDispHist",";#it{z} (cm); #it{x} (cm); #it{y} (cm)", | |
867 | 100, timeZmin-10, timeZmax+10, | |
868 | 100, globXmin, globXmax , | |
869 | 100, globYmin, globYmax); | |
870 | ||
871 | //if(!fDispGraph) fDispGraph = new TGraph(); | |
872 | ||
873 | //fDispGraph->Clear(); | |
874 | fDispHist->SetStats(0); | |
875 | fDispHist->Draw(); | |
876 | gPad->SetPhi(0); | |
877 | gPad->SetTheta(0); | |
878 | ||
879 | TPolyLine3D *endCap1 = 0x0; | |
880 | if (timeZmin-epsilon<-fMaxZ0) | |
881 | endCap1=new TPolyLine3D(); | |
882 | printf("time: %p, %.2f,, %.2f, %.2f, %.2f, %d\n",endCap1,fTimeZmin,fTimeZmax,timeZmin-epsilon,fMaxZ0, timeZmin-epsilon<-fMaxZ0); | |
883 | TPolyLine3D *endCap2 = 0x0; | |
884 | if (timeZmax+epsilon> fMaxZ0) | |
885 | endCap2=new TPolyLine3D(); | |
886 | ||
887 | TPolyLine3D *outerCE = 0x0; | |
888 | if (timeZmin<0 && timeZmax>0 ) | |
889 | outerCE=new TPolyLine3D(); | |
890 | ||
891 | TPolyLine3D *cage[18] ={0x0}; | |
892 | ||
893 | TPolyLine3D *innerCage[18] ={0x0}; | |
894 | ||
895 | TPolyLine3D *innerEndCap1 = 0x0; | |
896 | if (timeZmin-epsilon<-fMaxZ0) | |
897 | innerEndCap1=new TPolyLine3D(); | |
898 | ||
899 | TPolyLine3D *innerEndCap2 = 0x0; | |
900 | if (timeZmax+epsilon> fMaxZ0) | |
901 | innerEndCap2=new TPolyLine3D(); | |
902 | ||
903 | TPolyLine3D *innerCE = 0x0; | |
904 | if (timeZmin<0 && timeZmax>0 ) | |
905 | innerCE=new TPolyLine3D(); | |
906 | ||
907 | Int_t iPoint=0; | |
908 | Double_t angle = 0.; | |
909 | Double_t globalX = 0.; | |
910 | Double_t globalY = 0.; | |
911 | Double_t globalXi = 0.; | |
912 | Double_t globalYi = 0.; | |
913 | ||
914 | for(Int_t i = 0; i<18; i++){ | |
915 | angle = i*TMath::TwoPi()/18; | |
916 | globalX = fOFCRadius*TMath::Cos(angle); | |
917 | globalY = fOFCRadius*TMath::Sin(angle); | |
918 | globalXi = fIFCRadius*TMath::Cos(angle); | |
919 | globalYi = fIFCRadius*TMath::Sin(angle); | |
920 | ||
921 | cage[iPoint] = new TPolyLine3D(); | |
922 | cage[iPoint]->SetPoint(0,timeZmin,globalX ,globalY) ; | |
923 | cage[iPoint]->SetPoint(1, timeZmax,globalX ,globalY) ; | |
924 | innerCage[iPoint] = new TPolyLine3D(); | |
925 | innerCage[iPoint]->SetPoint(0,timeZmin,globalXi ,globalYi) ; | |
926 | innerCage[iPoint]->SetPoint(1, timeZmax,globalXi ,globalYi) ; | |
927 | ||
928 | // only draw if inside range | |
929 | if (endCap1) { endCap1->SetPoint(i,timeZmax, globalX, globalY); } | |
930 | if (endCap2) { endCap2->SetPoint(i,timeZmin, globalX, globalY); } | |
931 | if (outerCE) { outerCE->SetPoint(i, 0., globalX, globalY); } | |
932 | ||
933 | if (innerEndCap1) { innerEndCap1->SetPoint(i, timeZmax, globalXi, globalYi); } | |
934 | if (innerEndCap2) { innerEndCap2->SetPoint(i, timeZmin, globalXi, globalYi); } | |
935 | if (innerCE) { innerCE->SetPoint(i, 0., globalXi, globalYi); } | |
936 | ||
937 | innerCage[iPoint]->Draw("same"); | |
938 | ||
939 | if(!(i%2)) | |
940 | cage[iPoint]->Draw("same"); | |
941 | ||
942 | ++iPoint; | |
943 | } | |
944 | ||
945 | // | |
946 | // close endplate and CE polygons | |
947 | // | |
948 | Int_t i=18; | |
949 | angle = i*TMath::TwoPi()/18; | |
950 | globalX = fOFCRadius*TMath::Cos(angle); | |
951 | globalY = fOFCRadius*TMath::Sin(angle); | |
952 | globalXi = fIFCRadius*TMath::Cos(angle); | |
953 | globalYi = fIFCRadius*TMath::Sin(angle); | |
954 | ||
955 | // only draw if inside range | |
956 | if (endCap1) { endCap1->SetPoint(i, timeZmax, globalX, globalY); } | |
957 | if (endCap2) { endCap2->SetPoint(i, timeZmin, globalX, globalY); } | |
958 | if (outerCE) { outerCE->SetPoint(i, 0., globalX, globalY); } | |
959 | ||
960 | if (innerEndCap1) { innerEndCap1->SetPoint(i, timeZmax, globalXi, globalYi); } | |
961 | if (innerEndCap2) { innerEndCap2->SetPoint(i, timeZmin, globalXi, globalYi); } | |
962 | if (innerCE) { innerCE ->SetPoint(i, 0., globalXi, globalYi); } | |
963 | ||
964 | if (endCap1) { endCap1->Draw("same"); } | |
965 | if (endCap2) { endCap2->Draw("same"); } | |
966 | if (outerCE) { outerCE->Draw("same"); } | |
967 | ||
968 | if (innerEndCap1) { innerEndCap1->Draw("same"); } | |
969 | if (innerEndCap2) { innerEndCap2->Draw("same"); } | |
970 | if (innerCE) { innerCE ->Draw("same"); } | |
971 | ||
972 | } | |
973 | ||
974 | //________________________________________________________________ | |
975 | void AliToyMCDrawer::DrawGeometry2D() { | |
976 | ||
977 | ||
978 | //delete fDispGraph; | |
979 | //fDispGraph = new TGraph2D(); | |
980 | delete fDispHist; | |
981 | ||
982 | Double_t timeZmin=-fMaxZ0; | |
983 | Double_t timeZmax= fMaxZ0; | |
984 | Double_t globXmin=-(fOFCRadius +10); | |
985 | Double_t globXmax= fOFCRadius +10 ; | |
986 | Double_t globYmin=-(fOFCRadius +10); | |
987 | Double_t globYmax= fOFCRadius +10 ; | |
988 | ||
989 | const Double_t epsilon=.001; | |
990 | ||
991 | TString title; | |
992 | if (fTimeZmax>fTimeZmin) { | |
993 | timeZmin=fTimeZmin; | |
994 | timeZmax=fTimeZmax; | |
995 | } | |
996 | if (fGlobalXmax>fGlobalXmin) { | |
997 | globXmin=fGlobalXmin; | |
998 | globXmax=fGlobalXmax; | |
999 | } | |
1000 | if (fGlobalYmax>fGlobalYmin) { | |
1001 | globYmin=fGlobalYmin; | |
1002 | globYmax=fGlobalYmax; | |
1003 | } | |
1004 | TCanvas *c=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("cDrawer"); | |
1005 | ||
1006 | if (fProjectionType=="XT"){ | |
1007 | if (!c) c=new TCanvas("cDrawer","Toy Drawer"); | |
1008 | fDispHist = new TH2F("fDispHist",";#it{z} (cm); #it{x} (cm)", | |
1009 | 100, timeZmin-10, timeZmax+10, | |
1010 | 100, globXmin, globXmax); | |
1011 | } else if (fProjectionType=="YT"){ | |
1012 | if (!c) c=new TCanvas("cDrawer","Toy Drawer"); | |
1013 | fDispHist = new TH2F("fDispHist",";#it{z} (cm); #it{y} (cm)", | |
1014 | 100, timeZmin-10, timeZmax+10, | |
1015 | 100, globYmin, globYmax); | |
1016 | } else if (fProjectionType=="RT"){ | |
1017 | if (!c) c=new TCanvas("cDrawer","Toy Drawer"); | |
1018 | fDispHist = new TH2F("fDispHist",";#it{z} (cm); #it{r} (cm)", | |
1019 | 100, timeZmin-10, timeZmax+10, | |
1020 | 100, globYmin, globYmax); | |
1021 | } else if (fProjectionType=="YX"||fProjectionType=="XY"){ | |
1022 | if (!c) c=new TCanvas("cDrawer","Toy Drawer",800,800); | |
1023 | c->SetLeftMargin(0.15); | |
1024 | c->SetRightMargin(0.05); | |
1025 | fDispHist = new TH2F("fDispHist",";#it{x} (cm); #it{y} (cm)", | |
1026 | 100, globXmin, globXmax, | |
1027 | 100, globYmin, globYmax); | |
1028 | fDispHist->GetYaxis()->SetTitleOffset(1.5); | |
1029 | } else { | |
1030 | AliError(Form("Display Format not known: %s",fProjectionType.Data())); | |
1031 | return; | |
1032 | } | |
1033 | ||
1034 | c->Clear(); | |
1035 | ||
1036 | //if(!fDispGraph) fDispGraph = new TGraph(); | |
1037 | ||
1038 | //fDispGraph->Clear(); | |
1039 | fDispHist->SetStats(0); | |
1040 | fDispHist->Draw(); | |
1041 | gPad->SetPhi(0); | |
1042 | gPad->SetTheta(0); | |
1043 | ||
1044 | TPolyLine *endCap1 = 0x0; | |
1045 | if (timeZmin-epsilon<-fMaxZ0) | |
1046 | endCap1=new TPolyLine(); | |
1047 | printf("time: %p, %.2f,, %.2f, %.2f, %.2f, %d\n",endCap1,fTimeZmin,fTimeZmax,timeZmin-epsilon,fMaxZ0, timeZmin-epsilon<-fMaxZ0); | |
1048 | TPolyLine *endCap2 = 0x0; | |
1049 | if (timeZmax+epsilon> fMaxZ0) | |
1050 | endCap2=new TPolyLine(); | |
1051 | ||
1052 | TPolyLine *outerCE = 0x0; | |
1053 | if (timeZmin<0 && timeZmax>0 ) | |
1054 | outerCE=new TPolyLine(); | |
1055 | ||
1056 | TPolyLine *cage[18] ={0x0}; | |
1057 | ||
1058 | TPolyLine *innerCage[18] ={0x0}; | |
1059 | ||
1060 | TPolyLine *innerEndCap1 = 0x0; | |
1061 | if (timeZmin-epsilon<-fMaxZ0) | |
1062 | innerEndCap1=new TPolyLine(); | |
1063 | ||
1064 | TPolyLine *innerEndCap2 = 0x0; | |
1065 | if (timeZmax+epsilon> fMaxZ0) | |
1066 | innerEndCap2=new TPolyLine(); | |
1067 | ||
1068 | TPolyLine *innerCE = 0x0; | |
1069 | if (timeZmin<0 && timeZmax>0 ) | |
1070 | innerCE=new TPolyLine(); | |
1071 | ||
1072 | Int_t iPoint=0; | |
1073 | Double_t angle = 0.; | |
1074 | Double_t globalX = 0.; | |
1075 | Double_t globalY = 0.; | |
1076 | Double_t globalXi = 0.; | |
1077 | Double_t globalYi = 0.; | |
1078 | Double_t globalXi2= 0.; | |
1079 | Double_t globalYi2= 0.; | |
1080 | ||
1081 | ||
1082 | if (fProjectionType=="YX"||fProjectionType=="XY") { | |
1083 | for(Int_t i = 0; i<18; i++){ | |
1084 | angle = i*TMath::TwoPi()/18; | |
1085 | globalX = fOFCRadius*TMath::Cos(angle); | |
1086 | globalY = fOFCRadius*TMath::Sin(angle); | |
1087 | globalXi = fIFCRadius*TMath::Cos(angle); | |
1088 | globalYi = fIFCRadius*TMath::Sin(angle); | |
1089 | globalXi = fIFCRadius*TMath::Cos(angle); | |
1090 | globalYi = fIFCRadius*TMath::Sin(angle); | |
1091 | globalXi2= 135.5*TMath::Cos(angle); | |
1092 | globalYi2= 135.5*TMath::Sin(angle); | |
1093 | ||
1094 | if ( globalX<globXmin || globalX>globXmax || globalY<globYmin || globalY>globYmax ) { | |
1095 | continue; | |
1096 | } | |
1097 | // in xy, abuse for sector boundaries | |
1098 | cage[iPoint] = new TPolyLine(); | |
1099 | cage[iPoint]->SetPoint(0, globalX ,globalY) ; | |
1100 | cage[iPoint]->SetPoint(1, globalXi ,globalYi) ; | |
1101 | // only draw if inside range | |
1102 | if (endCap1) { endCap1->SetPoint(iPoint, globalX, globalY); } | |
1103 | ||
1104 | if (innerEndCap1) { innerEndCap1->SetPoint(iPoint, globalXi, globalYi); } | |
1105 | if (innerEndCap2) { innerEndCap2->SetPoint(iPoint, globalXi2, globalYi2); } | |
1106 | ||
1107 | cage[iPoint]->Draw("same"); | |
1108 | ||
1109 | ++iPoint; | |
1110 | } | |
1111 | } | |
1112 | ||
1113 | angle = 5*TMath::TwoPi()/18; | |
1114 | globalX = fOFCRadius*TMath::Cos(angle); | |
1115 | globalY = fOFCRadius*TMath::Sin(angle); | |
1116 | globalXi = fIFCRadius*TMath::Cos(angle); | |
1117 | globalYi = fIFCRadius*TMath::Sin(angle); | |
1118 | globalXi = fIFCRadius*TMath::Cos(angle); | |
1119 | globalYi = fIFCRadius*TMath::Sin(angle); | |
1120 | globalXi2= 135.5*TMath::Cos(angle); | |
1121 | globalYi2= 135.5*TMath::Sin(angle); | |
1122 | if (endCap1) { endCap1->SetPoint(iPoint, 0, globalY); } | |
1123 | ||
1124 | if (innerEndCap1) { innerEndCap1->SetPoint(iPoint, 0, globalYi); } | |
1125 | if (innerEndCap2) { innerEndCap2->SetPoint(iPoint, 0, globalYi2); } | |
1126 | ++iPoint; | |
1127 | // | |
1128 | // close endplate and CE polygons | |
1129 | // | |
1130 | Int_t i=18; | |
1131 | angle = i*TMath::TwoPi()/18; | |
1132 | globalX = fOFCRadius*TMath::Cos(angle); | |
1133 | globalY = fOFCRadius*TMath::Sin(angle); | |
1134 | globalXi = fIFCRadius*TMath::Cos(angle); | |
1135 | globalYi = fIFCRadius*TMath::Sin(angle); | |
1136 | globalXi2= 135.5*TMath::Cos(angle); | |
1137 | globalYi2= 135.5*TMath::Sin(angle); | |
1138 | ||
1139 | // only draw if inside range | |
1140 | if ( !(globalX<globXmin || globalX>globXmax || globalY<globYmin || globalY>globYmax) ) { | |
1141 | if (endCap1) { endCap1->SetPoint(i, globalX, globalY); } | |
1142 | // if (endCap2) { endCap2->SetPoint(i, globalX, globalY); } | |
1143 | // if (outerCE) { outerCE->SetPoint(i, globalX, globalY); } | |
1144 | ||
1145 | if (innerEndCap1) { innerEndCap1->SetPoint(i, globalXi, globalYi); } | |
1146 | if (innerEndCap2) { innerEndCap2->SetPoint(i, globalXi2, globalYi2); } | |
1147 | // if (innerCE) { innerCE ->SetPoint(i, globalXi, globalYi); } | |
1148 | ||
1149 | } | |
1150 | ||
1151 | if (endCap1) { endCap1->Draw("same"); } | |
1152 | // if (endCap2) { endCap2->Draw("same"); } | |
1153 | // if (outerCE) { outerCE->Draw("same"); } | |
1154 | ||
1155 | if (innerEndCap1) { innerEndCap1->Draw("same"); } | |
1156 | if (innerEndCap2) { innerEndCap2->Draw("same"); } | |
1157 | // if (innerCE) { innerCE ->Draw("same"); } | |
1158 | } | |
1159 | ||
1160 | //________________________________________________________________ | |
1161 | Bool_t AliToyMCDrawer::ConnectInputTree() | |
1162 | { | |
1163 | // | |
1164 | // | |
1165 | // | |
1166 | ||
1167 | if(fFileName.IsNull()) { | |
1168 | AliError("no input file provided, using default (toyMC.root)"); | |
1169 | fFileName = "toyMC.root"; | |
1170 | } | |
1171 | if (fInFile && fInFile->GetName()==fFileName) return kTRUE; | |
1172 | delete fInFile; | |
1173 | fInFile=0x0; | |
1174 | delete fInputTree; | |
1175 | fInputTree=0x0; | |
1176 | ||
1177 | fInFile = new TFile(fFileName.Data(),"read"); | |
1178 | if (!fInFile || !fInFile->IsOpen() || fInFile->IsZombie() ) { | |
1179 | delete fInFile; | |
1180 | return kFALSE; | |
1181 | } | |
1182 | ||
1183 | gROOT->cd(); | |
1184 | ||
1185 | fInputTree = dynamic_cast<TTree*> (fInFile->Get("toyMCtree")); | |
1186 | ||
1187 | if (!fInputTree){ | |
1188 | AliError("Could not connect tree!\n"); | |
1189 | delete fInFile; | |
1190 | fInFile=0x0; | |
1191 | return kFALSE; | |
1192 | } | |
1193 | ||
1194 | fInputTree->SetBranchAddress("event",&fEvent); | |
1195 | return kTRUE; | |
1196 | } |