Fixed ClassDef() accidentally removed
[u/mrichter/AliRoot.git] / TPC / TPCupgrade / AliToyMCDrawer.cxx
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] = {static_cast<Float_t>(xp),static_cast<Float_t>(yp),static_cast<Float_t>(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] = {static_cast<Float_t>(xpdist),static_cast<Float_t>(ypdist),static_cast<Float_t>(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] = {static_cast<Float_t>(xp),static_cast<Float_t>(yp),static_cast<Float_t>(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] = {static_cast<Float_t>(xpdist),static_cast<Float_t>(ypdist),static_cast<Float_t>(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 }