Missing initialization; fiddle with the track marker-style a bit more.
[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( Bool_t recurse)
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   if(recurse) {
242     Track* t;
243     for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
244       t = dynamic_cast<Track*>(*i);
245       if(t)t->MakeTrack(recurse); 
246     }
247   }
248 }
249
250 /**************************************************************************/
251
252 void Track::ImportHits()
253 {
254   Reve::LoadMacro("hits_from_label.C");
255   gROOT->ProcessLine(Form("hits_from_label(%d, (Reve::RenderElement*)%p);", 
256                           fLabel, this));
257 }
258
259 void Track::ImportClusters()
260 {
261   Reve::LoadMacro("clusters_from_label.C");
262   gROOT->ProcessLine(Form("clusters_from_label(%d, (Reve::RenderElement*)%p);", 
263                           fLabel, this));
264 }
265
266 void Track::ImportClustersFromIndex()
267 {
268   static const Exc_t eH("Track::ImportClustersFromIndex ");
269
270   if (fIndex < 0)
271     throw(eH + "index not set.");
272
273   Reve::LoadMacro("clusters_from_index.C");
274   gROOT->ProcessLine(Form("clusters_from_index(%d, (Reve::RenderElement*)%p);", 
275                           fIndex, this));
276 }
277
278 /**************************************************************************/
279
280 void Track::ImportKine()
281 {
282   static const Exc_t eH("Track::ImportKine ");
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, kFALSE, kTRUE, (Reve::RenderElement*)%p);", 
289                           fLabel, this));
290
291 }
292
293 void Track::ImportKineWithArgs(Bool_t importMother, Bool_t importDaugters)
294 {
295   static const Exc_t eH("Track::ImportKineWithArgs ");
296
297   if (fLabel < 0)
298     throw(eH + "label not set.");
299
300   Reve::LoadMacro("kine_tracks.C");
301   gROOT->ProcessLine(Form("kine_track(%d, %d, %d, (Reve::RenderElement*)%p);", 
302                            fLabel, importMother, importDaugters, this));
303
304 }
305
306 /**************************************************************************/
307
308 void Track::PrintKineStack()
309 {
310   Reve::LoadMacro("print_kine_from_label.C");
311   gROOT->ProcessLine(Form("print_kine_from_label(%d);", fLabel));
312 }
313
314
315 void Track::PrintPathMarks()
316 {
317   static const Exc_t eH("Track::PrintPathMarks ");
318
319   if (fLabel < 0)
320     throw(eH + "label not set.");
321
322   printf("Number of path marks %d label %d\n",
323          fPathMarks.size(), fLabel);
324
325   PathMark* pm;
326   for(vpPathMark_i i=fPathMarks.begin(); i!=fPathMarks.end(); i++) 
327   {
328     pm = *i;
329     printf("Reve::PathMark: %-9s  p: %8f %8f %8f Vertex: %8e %8e %8e %g \n",
330            pm->type_name(),
331            pm->P.x,  pm->P.y, pm->P.z,
332            pm->V.x,  pm->V.y, pm->V.z,
333            pm->time);
334   }
335 }
336
337 /**************************************************************************/
338
339 void Track::CtrlClicked(Reve::Track* track)
340 {
341   Emit("CtrlClicked(Reve::Track*)", (Long_t)track);
342 }
343
344
345 /**************************************************************************/
346 /**************************************************************************/
347
348 //______________________________________________________________________
349 // TrackRnrStyle
350 //
351
352 ClassImp(Reve::TrackRnrStyle)
353
354 Float_t       TrackRnrStyle::fgDefMagField = 5;
355 const Float_t TrackRnrStyle::fgkB2C        = 0.299792458e-3;
356 TrackRnrStyle TrackRnrStyle::fgDefStyle;
357
358 TrackRnrStyle::TrackRnrStyle() :
359   TObject(),
360
361   fColor(1),
362   fWidth(1),
363   fMagField(fgDefMagField),
364
365   fMaxR  (350),
366   fMaxZ  (450),
367
368   fMaxOrbs (0.5),
369   fMinAng  (45),
370   fDelta   (0.1),
371
372   fMinPt   (0.1),
373   fMaxPt   (10),
374
375   fFitDaughters  (kTRUE),
376   fFitReferences (kTRUE),
377   fFitDecay      (kTRUE),
378
379   fRnrDaughters  (kTRUE),
380   fRnrReferences (kTRUE),
381   fRnrDecay      (kTRUE)
382 {}
383 /**************************************************************************/
384 /**************************************************************************/
385
386 //______________________________________________________________________
387 // TrackList
388 //
389
390 ClassImp(Reve::TrackList)
391
392 void TrackList::Init()
393 {
394   fMarkerStyle = 2;
395   fMarkerColor = 4;
396   fMarkerSize  = 0.6;
397
398   if (fRnrStyle== 0) fRnrStyle = new TrackRnrStyle;
399   SetMainColorPtr(&fRnrStyle->fColor);
400 }
401
402 TrackList::TrackList(Int_t n_tracks, TrackRnrStyle* rs) :
403   RenderElement(),
404   TPolyMarker3D(n_tracks),
405
406   fTitle(),
407
408   fRnrStyle      (rs),
409   fRnrTracks     (kTRUE),
410   fEditPathMarks (kFALSE)
411 {
412   Init();
413 }
414
415 TrackList::TrackList(const Text_t* name, Int_t n_tracks, TrackRnrStyle* rs) :
416   RenderElement(),
417   TPolyMarker3D(n_tracks),
418   
419   fTitle(),
420
421   fRnrStyle      (rs),
422   fRnrTracks     (kTRUE),
423   fEditPathMarks (kFALSE)
424 {
425   Init();
426   SetName(name);
427 }
428
429 void TrackList::Reset(Int_t n_tracks)
430 {
431   delete [] fP; fP = 0;
432   fN = n_tracks;
433   if(fN) fP = new Float_t [3*fN];
434   memset(fP, 0, 3*fN*sizeof(Float_t));
435   fLastPoint = -1;
436 }
437
438 /**************************************************************************/
439
440 void TrackList::Paint(Option_t* option)
441 {
442   if(fRnrSelf) {
443     if(fRnrMarkers) {
444       TPolyMarker3D::Paint(option);
445     }
446     if(fRnrTracks && fRnrChildren) {
447       for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
448         if((*i)->GetRnrSelf())
449           (*i)->GetObject()->Paint(option);
450       }
451     }
452   }
453 }
454
455 /**************************************************************************/
456
457 void TrackList::AddElement(RenderElement* el)
458 {
459   static const Exc_t eH("TrackList::AddElement ");
460   if (dynamic_cast<Track*>(el)  == 0)
461     throw(eH + "new element not a Track.");
462   RenderElement::AddElement(el);
463 }
464
465 /**************************************************************************/
466
467 void TrackList::MakeTracks()
468 {
469   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
470     ((Track*)(*i))->MakeTrack();
471   }
472   gReve->Redraw3D();
473 }
474
475
476 void TrackList::MakeMarkers()
477 {
478   Reset(fChildren.size());
479   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
480     Track& t = *((Track*)(*i));
481     if(t.GetN() > 0)
482       SetNextPoint(t.fV.x, t.fV.y, t.fV.z);
483   }
484   gReve->Redraw3D();
485 }
486
487 /**************************************************************************/
488 /*************************************************************************/
489
490 void TrackList::SetWidth(Width_t w)
491 {
492   Width_t oldw = fRnrStyle->fWidth;
493   fRnrStyle->fWidth = w;
494   for (List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
495     Track& t = *((Track*)(*i));
496     if (t.GetLineWidth() == oldw)
497       t.SetLineWidth(w);
498   }
499 }
500
501 void TrackList::SetMaxR(Float_t x)
502 {
503   fRnrStyle->fMaxR = x;
504   MakeTracks();
505   MakeMarkers();
506 }
507
508 void TrackList::SetMaxZ(Float_t x)
509 {
510   fRnrStyle->fMaxZ = x;
511   MakeTracks();
512   MakeMarkers();
513 }
514
515 void TrackList::SetMaxOrbs(Float_t x)
516 {
517   fRnrStyle->fMaxOrbs = x;
518   MakeTracks();
519 }
520
521 void TrackList::SetMinAng(Float_t x)
522 {
523   fRnrStyle->fMinAng = x;
524   MakeTracks();
525 }
526
527 void TrackList::SetDelta(Float_t x)
528 {
529   fRnrStyle->fDelta = x;
530   MakeTracks();
531 }
532
533 void TrackList::SetFitDaughters(Bool_t x)
534 {
535   fRnrStyle->fFitDaughters = x;
536   MakeTracks();
537 }
538
539 void TrackList::SetFitReferences(Bool_t x)
540 {
541   fRnrStyle->fFitReferences = x;
542   MakeTracks();
543 }
544
545 void TrackList::SetFitDecay(Bool_t x)
546 {
547   fRnrStyle->fFitDecay = x;
548   MakeTracks();
549 }
550
551 void TrackList::SetRnrDecay(Bool_t rnr)
552 {
553   fRnrStyle->fRnrDecay = rnr;
554   MakeTracks();
555 }
556
557 void TrackList::SetRnrDaughters(Bool_t rnr)
558 {
559   fRnrStyle->fRnrDaughters = rnr;
560   MakeTracks();
561 }
562
563 void TrackList::SetRnrReferences(Bool_t rnr)
564 {
565   fRnrStyle->fRnrReferences = rnr;
566   MakeTracks();
567 }
568  
569 void TrackList::SetRnrMarkers(Bool_t rnr)
570 {
571   fRnrMarkers = rnr;
572   gReve->Redraw3D();
573 }
574
575 void TrackList::SetRnrTracks(Bool_t rnr)
576 {
577
578   fRnrTracks = rnr;
579   gReve->Redraw3D();
580 }
581
582 /**************************************************************************/
583 /**************************************************************************/
584
585 void TrackList::SelectByPt(Float_t min_pt, Float_t max_pt)
586 {
587   fRnrStyle->fMinPt = min_pt;
588   fRnrStyle->fMaxPt = max_pt;
589
590   Float_t minptsq = min_pt*min_pt;
591   Float_t maxptsq = max_pt*max_pt;
592   Float_t ptsq;
593
594   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
595     ptsq = ((Track*)(*i))->fP.Perp2();
596     (*i)->SetRnrSelf(ptsq >= minptsq && ptsq <= maxptsq);
597   }
598 }
599
600 /**************************************************************************/
601
602 void TrackList::ImportHits()
603 {
604   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
605     ((Track*)(*i))->ImportHits();
606   }
607 }
608
609 void TrackList::ImportClusters()
610 {
611   for(List_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
612     ((Track*)(*i))->ImportClusters();
613   }
614 }
615
616 /**************************************************************************/
617 /**************************************************************************/
618 /**************************************************************************/
619
620 #include "RGEditor.h"
621
622 //______________________________________________________________________
623 // TrackCounter
624 //
625
626 ClassImp(TrackCounter)
627
628 TrackCounter* TrackCounter::fgInstance = 0;
629
630 TrackCounter::TrackCounter(const Text_t* name, const Text_t* title) :
631   RenderElement(),
632   TNamed(name, title),
633
634   fBadLineStyle (6),
635   fClickAction  (CA_ToggleTrack),
636   fAllTracks    (0),
637   fGoodTracks   (0),
638   fTrackLists   ()
639 {
640   if (fgInstance == 0) fgInstance = this;
641   TQObject::Connect("Reve::Track", "CtrlClicked(Reve::Track*)",
642                     "Reve::TrackCounter", this, "DoTrackAction(Reve::Track*)");
643 }
644
645 TrackCounter::~TrackCounter()
646 {
647   TQObject::Disconnect("Reve::Track", "DoTrackAction(Reve::Track*)");
648   if (fgInstance == this) fgInstance = 0;
649 }
650
651 /**************************************************************************/
652
653 void TrackCounter::Reset()
654 {
655   printf("TrackCounter::Reset()\n");
656   fAllTracks  = 0;
657   fGoodTracks = 0;
658   TIter next(&fTrackLists);
659   TrackList* tlist;
660   while ((tlist = dynamic_cast<TrackList*>(next())))
661     tlist->RemoveParent(this);
662   fTrackLists.Clear();
663 }
664
665 void TrackCounter::RegisterTracks(TrackList* tlist, Bool_t goodTracks)
666 {
667   // printf("TrackCounter::RegisterTracks '%s', %s\n",
668   //   tlist->GetObject()->GetName(), goodTracks ? "good" : "bad");
669
670   tlist->AddParent(this);
671   fTrackLists.Add(tlist);
672
673   List_i i = tlist->BeginChildren();
674   while (i != tlist->EndChildren())
675   {
676     Track* t = dynamic_cast<Track*>(*i);
677     if (t != 0)
678     {
679       if (goodTracks)
680       {
681         ++fGoodTracks;
682       } else {
683         t->SetLineStyle(fBadLineStyle);
684       }
685       ++fAllTracks;
686     }
687     ++i;
688   }
689 }
690
691 void TrackCounter::DoTrackAction(Track* track)
692 {
693   // !!!! No check done if ok.
694   // !!!! Should also override RemoveElementLocal
695   // !!!! But then ... should also sotre local information if track is ok.
696
697   switch (fClickAction)
698   {
699
700     case CA_PrintTrackInfo:
701     {
702       printf("Track '%s'\n", track->GetObject()->GetName());
703       Vector &v = track->fV, &p = track->fP;
704       printf("  Vx=%f, Vy=%f, Vz=%f; Pt=%f, Pz=%f, phi=%f)\n",
705              v.x, v.y, v.z, p.Perp(), p.z, TMath::RadToDeg()*p.Phi());
706       printf("  <other information should be printed ... full AliESDtrack>\n");
707       break;
708     }
709
710     case CA_ToggleTrack:
711     {
712       if (track->GetLineStyle() == 1)
713       {
714         track->SetLineStyle(fBadLineStyle);
715         --fGoodTracks;
716       } else {
717         track->SetLineStyle(1);
718         ++fGoodTracks;
719       }
720       gReve->Redraw3D();
721
722       printf("TrackCounter::CountTrack All=%d, Good=%d, Bad=%d\n",
723              fAllTracks, fGoodTracks, fAllTracks-fGoodTracks);
724
725       if (gReve->GetEditor()->GetModel() == GetObject())
726         gReve->EditRenderElement(this);
727
728       break;
729     }
730
731   } // end switch fClickAction
732 }
733
734 /**************************************************************************/
735
736 void TrackCounter::OutputEventTracks(FILE* out)
737 {
738   if (out == 0)
739   {
740     out = stdout;
741     fprintf(out, "TrackCounter::FinalizeEvent()\n");
742   }
743
744   fprintf(out, "Event = %d  Ntracks = %d\n", fEventId, fGoodTracks);
745
746   TIter tlists(&fTrackLists);
747   TrackList* tlist;
748   Int_t cnt = 0;
749   while ((tlist = (TrackList*) tlists()) != 0)
750   {
751     List_i i = tlist->BeginChildren();
752     while (i != tlist->EndChildren())
753     {
754       Track* t = dynamic_cast<Track*>(*i);
755       if (t != 0 && t->GetLineStyle() == 1)
756       {
757         ++cnt;
758         fprintf(out, " %2d: chg=%+2d  pt=%8.5f  eta=%+8.5f\n",
759                cnt, t->fCharge, t->fP.Perp(), t->fP.Eta());
760       }
761       ++i;
762     }
763   }
764 }