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