4ee0be2ab75f34857990e68a851bd9f4806aa8b6
[u/mrichter/AliRoot.git] / EVE / Reve / Track.cxx
1 // $Header$
2
3 #include "Track.h"
4 #include "MCHelixLine.hi"
5
6 #include <TPolyLine3D.h>
7 #include <TPolyMarker3D.h>
8 #include <TColor.h>
9
10 // Updates
11 #include <Reve/RGTopFrame.h>
12 #include <TCanvas.h>
13
14 #include <vector>
15
16 using namespace Reve;
17
18 //______________________________________________________________________
19 // Track
20 //
21
22 ClassImp(Reve::Track)
23
24 Track::Track() :
25   Line(),
26
27   fV(),
28   fP(),
29   fBeta(0),
30   fCharge(0),
31   fLabel(0),
32   fPathMarks(),
33
34   fRnrStyle(0)
35 {}
36
37 Track::Track(TParticle* t, Int_t label, TrackRnrStyle* rs):
38   Line(),
39
40   fV(t->Vx(), t->Vy(), t->Vz()),
41   fP(t->Px(), t->Py(), t->Pz()),
42   fBeta(t->P()/t->Energy()),
43   fCharge(0),
44   fLabel(label),
45   fPathMarks(),
46
47   fRnrStyle(rs)
48 {
49   fLineColor = fRnrStyle->GetColor();
50   fMainColorPtr = &fLineColor;
51
52   TParticlePDG* pdgp = t->GetPDG();
53   if (pdgp)
54     fCharge = (Int_t) TMath::Nint(pdgp->Charge()/3);
55
56   SetName(t->GetName());
57 }
58
59 Track::Track(Reve::MCTrack* t, TrackRnrStyle* rs):
60   Line(),
61
62   fV(t->Vx(), t->Vy(), t->Vz()),
63   fP(t->Px(), t->Py(), t->Pz()),
64   fBeta(t->P()/t->Energy()),
65   fCharge(0),
66   fLabel(t->label),
67   fPathMarks(),
68
69   fRnrStyle(rs)
70 {
71   fLineColor = fRnrStyle->GetColor();
72   fMainColorPtr = &fLineColor;
73
74   TParticlePDG* pdgp = t->GetPDG();
75   if(pdgp == 0) {
76     t->ResetPdgCode(); pdgp = t->GetPDG();
77   }
78   fCharge = (Int_t) TMath::Nint(pdgp->Charge()/3);
79
80   SetName(t->GetName());
81 }
82
83 Track::Track(Reve::RecTrack* t, TrackRnrStyle* rs) :
84   Line(),
85
86   fV(t->V),
87   fP(t->P),
88   fBeta(t->beta),
89   fCharge(t->sign),
90   fLabel(t->label),
91   fPathMarks(),
92
93   fRnrStyle(rs)
94 {
95   fLineColor = fRnrStyle->GetColor();
96   fMainColorPtr = &fLineColor;
97
98   SetName(t->GetName());
99 }
100
101 Track::~Track()
102 {
103   for (vpPathMark_i i=fPathMarks.begin(); i!=fPathMarks.end(); ++i)
104     delete *i;
105 }
106
107 /*
108 void Track::Reset(Int_t n_points)
109 {
110   delete [] TPolyLine3D::fP; TPolyLine3D::fP = 0;
111   fN = n_points;
112   if(fN) TPolyLine3D::fP = new Float_t [3*fN];
113   memset(TPolyLine3D::fP, 0, 3*fN*sizeof(Float_t));
114   fLastPoint = -1;
115 }
116 */
117
118 /**************************************************************************/
119
120 void Track::MakeTrack()
121 {
122   
123   TrackRnrStyle& RS((fRnrStyle != 0) ? *fRnrStyle : TrackRnrStyle::fgDefStyle);
124
125   Float_t px = fP.x, py = fP.y, pz = fP.z;  
126
127   MCVertex  mc_v0;
128   mc_v0.x = fV.x;
129   mc_v0.y = fV.y; 
130   mc_v0.z = fV.z; 
131   mc_v0.t = 0;
132
133   std::vector<MCVertex> track_points;
134   Bool_t decay = kFALSE;
135
136   if ((TMath::Abs(fV.z) > RS.fMaxZ) || (fV.x*fV.x + fV.y*fV.y > RS.fMaxR*RS.fMaxR)) 
137     goto make_polyline;
138   
139   if (fCharge != 0 && TMath::Abs(RS.fMagField) > 1e-5) {
140
141     // Charged particle in magnetic field
142
143     Float_t a = RS.fgkB2C * RS.fMagField * fCharge;
144    
145     MCHelix helix(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points, a); //m->cm
146     helix.Init(TMath::Sqrt(px*px+py*py), pz);
147    
148     if(!fPathMarks.empty()){
149       for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
150         Reve::PathMark* pm = *i;
151         
152         if(RS.fFitDaughters &&  pm->type == Reve::PathMark::Daughter){
153           if(TMath::Abs(pm->V.z) > RS.fMaxZ 
154              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
155             goto helix_bounds;
156
157           //printf("%s fit daughter  \n", fName.Data()); 
158           helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
159           fP.x -=  pm->P.x;
160           fP.y -=  pm->P.y;
161           fP.z -=  pm->P.z;
162         }
163         if(RS.fFitDecay &&  pm->type == Reve::PathMark::Decay){
164           
165           if(TMath::Abs(pm->V.z) > RS.fMaxZ 
166              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
167             goto helix_bounds;
168           helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
169           decay = true;
170           break;
171         }
172       }
173     }
174   helix_bounds:
175     //go to bounds
176     if(!decay || RS.fFitDecay == kFALSE){
177       helix.LoopToBounds(px,py,pz);
178       // printf("%s loop to bounds  \n",fName.Data() );
179     }
180
181   } else {
182
183     // Neutral particle or no field
184
185     MCLine line(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points);
186    
187     if(!fPathMarks.empty()){
188       for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
189         Reve::PathMark* pm = *i;
190
191         if(RS.fFitDaughters &&  pm->type == Reve::PathMark::Daughter){
192           if(TMath::Abs(pm->V.z) > RS.fMaxZ 
193              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
194             goto line_bounds;
195           line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
196           fP.x -=  pm->P.x;
197           fP.y -=  pm->P.y;
198           fP.z -=  pm->P.z;
199         }
200
201         if(RS.fFitDecay &&  pm->type == Reve::PathMark::Decay){
202           if(TMath::Abs(pm->V.z) > RS.fMaxZ 
203              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
204             goto line_bounds;
205           line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
206           decay = true;
207           break;
208         }
209       }
210     }
211
212   line_bounds:
213     if(!decay || RS.fFitDecay == kFALSE)
214       line.GotoBounds(px,py,pz);
215
216   }
217 make_polyline:
218   Reset(track_points.size());
219   for(std::vector<MCVertex>::iterator i=track_points.begin(); i!=track_points.end(); ++i)
220     SetNextPoint(i->x, i->y, i->z);
221 }
222
223 /**************************************************************************/
224
225 void Track::ImportHits()
226 {
227   Reve::LoadMacro("hits_from_label.C");
228   gROOT->ProcessLine(Form("hits_from_label(%d);", fLabel));
229 }
230
231 void Track::ImportClusters()
232 {
233   Reve::LoadMacro("clusters_from_label.C");
234   gROOT->ProcessLine(Form("clusters_from_label(%d);", fLabel));
235 }
236
237 /**************************************************************************/
238
239 void Track::CtrlClicked(Reve::Track* track)
240 {
241   Emit("CtrlClicked(Reve::Track*)", (Long_t)track);
242 }
243
244
245 /**************************************************************************/
246 /**************************************************************************/
247
248 //______________________________________________________________________
249 // TrackRnrStyle
250 //
251
252 ClassImp(Reve::TrackRnrStyle)
253
254 Float_t       TrackRnrStyle::fgDefMagField = 5;
255 const Float_t TrackRnrStyle::fgkB2C        = 0.299792458e-3;
256 TrackRnrStyle TrackRnrStyle::fgDefStyle;
257
258 TrackRnrStyle::TrackRnrStyle() :
259   TObject(),
260
261   fColor(1),
262   fWidth(1),
263   fMagField(fgDefMagField),
264
265   fMaxR  (350),
266   fMaxZ  (450),
267
268   fMaxOrbs (0.5),
269   fMinAng  (45),
270   fDelta   (0.1),
271
272   fFitDaughters(kTRUE),
273   fFitDecay    (kTRUE)
274 {}
275
276 /**************************************************************************/
277 /**************************************************************************/
278
279 //______________________________________________________________________
280 // TrackList
281 //
282
283 ClassImp(Reve::TrackList)
284
285 void TrackList::Init()
286 {
287   fMarkerStyle = 6;
288   fMarkerColor = 5;
289   // fMarker->SetMarkerSize(0.05);
290
291   if (fRnrStyle== 0) fRnrStyle = new TrackRnrStyle;
292   SetMainColorPtr(&fRnrStyle->fColor);
293 }
294
295 TrackList::TrackList(Int_t n_tracks, TrackRnrStyle* rs) :
296   RenderElementListBase(),
297   TPolyMarker3D(n_tracks),
298
299   fTitle(),
300
301   fRnrStyle   (rs),
302   fRnrMarkers (kTRUE),
303   fRnrTracks  (kTRUE)
304 {
305   Init();
306 }
307
308 TrackList::TrackList(const Text_t* name, Int_t n_tracks, TrackRnrStyle* rs) :
309   RenderElementListBase(),
310   TPolyMarker3D(n_tracks),
311   
312   fTitle(),
313
314   fRnrStyle   (rs),
315   fRnrMarkers (kTRUE),
316   fRnrTracks  (kTRUE)
317 {
318   Init();
319   SetName(name);
320 }
321
322 void TrackList::Reset(Int_t n_tracks)
323 {
324   delete [] fP; fP = 0;
325   fN = n_tracks;
326   if(fN) fP = new Float_t [3*fN];
327   memset(fP, 0, 3*fN*sizeof(Float_t));
328   fLastPoint = -1;
329 }
330
331 /**************************************************************************/
332
333 void TrackList::Paint(Option_t* option)
334 {
335   if(fRnrElement) {
336     if(fRnrMarkers) {
337       TPolyMarker3D::Paint(option);
338     }
339     if(fRnrTracks) {
340       for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
341         if((*i)->GetRnrElement())
342           (*i)->GetObject()->Paint(option);
343       }
344     }
345   }
346 }
347
348 /**************************************************************************/
349
350 void TrackList::AddElement(RenderElement* el)
351 {
352   static const Exc_t eH("TrackList::AddElement ");
353   if (dynamic_cast<Track*>(el)  == 0)
354     throw(eH + "new element not a Track.");
355   RenderElementListBase::AddElement(el);
356 }
357
358 /**************************************************************************/
359
360 void TrackList::SetRnrMarkers(Bool_t rnr)
361 {
362   fRnrMarkers = rnr;
363   gReve->Redraw3D();
364 }
365
366 void TrackList::SetRnrTracks(Bool_t rnr)
367 {
368
369   fRnrTracks = rnr;
370   gReve->Redraw3D();
371 }
372
373 /**************************************************************************/
374
375 void TrackList::MakeTracks()
376 {
377   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
378     ((Track*)(*i))->MakeTrack();
379   }
380   gReve->Redraw3D();
381 }
382
383
384 void TrackList::MakeMarkers()
385 {
386   Reset(fChildren.size());
387   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
388     Track& t = *((Track*)(*i));
389     if(t.GetN() > 0)
390       SetNextPoint(t.fV.x, t.fV.y, t.fV.z);
391   }
392   gReve->Redraw3D();
393 }
394
395 /**************************************************************************/
396 /*************************************************************************/
397
398 void TrackList::SetWidth(Width_t w)
399 {
400   Width_t oldw = fRnrStyle->fWidth;
401   fRnrStyle->fWidth = w;
402   for (List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
403     Track& t = *((Track*)(*i));
404     if (t.GetLineWidth() == oldw)
405       t.SetLineWidth(w);
406   }
407 }
408
409 void TrackList::SetMaxR(Float_t x)
410 {
411   fRnrStyle->fMaxR = x;
412   MakeTracks();
413   MakeMarkers();
414 }
415
416 void TrackList::SetMaxZ(Float_t x)
417 {
418   fRnrStyle->fMaxZ = x;
419   MakeTracks();
420   MakeMarkers();
421 }
422
423 void TrackList::SetMaxOrbs(Float_t x)
424 {
425   fRnrStyle->fMaxOrbs = x;
426   MakeTracks();
427 }
428
429 void TrackList::SetMinAng(Float_t x)
430 {
431   fRnrStyle->fMinAng = x;
432   MakeTracks();
433 }
434
435 void TrackList::SetDelta(Float_t x)
436 {
437   fRnrStyle->fDelta = x;
438   MakeTracks();
439 }
440
441 void TrackList::SetFitDaughters(Bool_t x)
442 {
443   fRnrStyle->fFitDaughters = x;
444   MakeTracks();
445 }
446
447 void TrackList::SetFitDecay(Bool_t x)
448 {
449   fRnrStyle->fFitDecay = x;
450   MakeTracks();
451 }
452
453 /**************************************************************************/
454 /**************************************************************************/
455
456 void TrackList::SelectByPt(Float_t min_pt, Float_t max_pt)
457 {
458   Float_t minptsq = min_pt*min_pt;
459   Float_t maxptsq = max_pt*max_pt;
460   Float_t ptsq;
461
462   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
463     ptsq = ((Track*)(*i))->fP.Perp2();
464     (*i)->SetRnrElement(ptsq >= minptsq && ptsq <= maxptsq);
465   }
466 }
467
468 /**************************************************************************/
469
470 void TrackList::ImportHits()
471 {
472   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
473     ((Track*)(*i))->ImportHits();
474   }
475 }
476
477 void TrackList::ImportClusters()
478 {
479   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
480     ((Track*)(*i))->ImportClusters();
481   }
482 }
483
484 /**************************************************************************/
485 /**************************************************************************/
486 /**************************************************************************/
487
488 #include "RGEditor.h"
489
490 //______________________________________________________________________
491 // TrackCounter
492 //
493
494 ClassImp(TrackCounter)
495
496 TrackCounter::TrackCounter(const Text_t* name, const Text_t* title) :
497   RenderElement(),
498   TNamed(name, title),
499
500   fBadLineStyle (6),
501   fClickAction  (CA_ToggleTrack),
502   fAllTracks    (0),
503   fGoodTracks   (0),
504   fTrackLists   ()
505 {
506   TQObject::Connect("Reve::Track", "CtrlClicked(Reve::Track*)",
507                     "Reve::TrackCounter", this, "DoTrackAction(Reve::Track*)");
508 }
509
510 TrackCounter::~TrackCounter()
511 {
512   TQObject::Disconnect("Reve::Track", "DoTrackAction(Reve::Track*)");
513 }
514
515 /**************************************************************************/
516
517 void TrackCounter::Reset()
518 {
519   printf("TrackCounter::Reset()\n");
520   fAllTracks  = 0;
521   fGoodTracks = 0;
522   TIter next(&fTrackLists);
523   TrackList* tlist;
524   while ((tlist = dynamic_cast<TrackList*>(next())))
525     tlist->RemoveParent(this);
526   fTrackLists.Clear();
527 }
528
529 void TrackCounter::RegisterTracks(TrackList* tlist, Bool_t goodTracks)
530 {
531   // printf("TrackCounter::RegisterTracks '%s', %s\n",
532   //   tlist->GetObject()->GetName(), goodTracks ? "good" : "bad");
533
534   tlist->AddParent(this);
535   fTrackLists.Add(tlist);
536
537   List_i i = tlist->BeginChildren();
538   while (i != tlist->EndChildren())
539   {
540     Track* t = dynamic_cast<Track*>(*i);
541     if (t != 0)
542     {
543       if (goodTracks)
544       {
545         ++fGoodTracks;
546       } else {
547         t->SetLineStyle(fBadLineStyle);
548       }
549       ++fAllTracks;
550     }
551     ++i;
552   }
553 }
554
555 void TrackCounter::DoTrackAction(Track* track)
556 {
557   // !!!! No check done if ok.
558   // !!!! Should also override RemoveElementLocal
559   // !!!! But then ... should also sore local information if track is ok.
560
561   switch (fClickAction)
562   {
563
564     case CA_PrintTrackInfo:
565     {
566       printf("Track '%s'\n", track->GetObject()->GetName());
567       Vector &v = track->fV, &p = track->fP;
568       printf("  Vx=%f, Vy=%f, Vz=%f; Pt=%f, Pz=%f, phi=%f)\n",
569              v.x, v.y, v.z, p.Perp(), p.z, TMath::RadToDeg()*p.Phi());
570       printf("  <other information should be printed ... full AliESDtrack>\n");
571       break;
572     }
573
574     case CA_ToggleTrack:
575     {
576       if (track->GetLineStyle() == 1)
577       {
578         track->SetLineStyle(fBadLineStyle);
579         --fGoodTracks;
580       } else {
581         track->SetLineStyle(1);
582         ++fGoodTracks;
583       }
584       gReve->Redraw3D();
585
586       printf("TrackCounter::CountTrack All=%d, Good=%d, Bad=%d\n",
587              fAllTracks, fGoodTracks, fAllTracks-fGoodTracks);
588
589       if (gReve->GetEditor()->GetModel() == GetObject())
590         gReve->EditRenderElement(this);
591
592       break;
593     }
594
595   } // end switch fClickAction
596 }