Fix effc++ warnings.
[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   RenderElement(),
26   TPolyLine3D(),
27
28   fV(),
29   fP(),
30   fBeta(0),
31   fCharge(0),
32   fLabel(0),
33   fPathMarks(),
34
35   fRnrStyle(0),
36
37   fName(),
38   fTitle()
39 {}
40
41 Track::Track(Reve::MCTrack* t, TrackRnrStyle* rs):
42   RenderElement(),
43   TPolyLine3D(),
44
45   fV(t->Vx(), t->Vy(), t->Vz()),
46   fP(t->Px(), t->Py(), t->Pz()),
47   fBeta(t->P()/t->Energy()),
48   fCharge(0),
49   fLabel(t->label),
50   fPathMarks(),
51
52   fRnrStyle(rs),
53
54   fName(t->GetName()),
55   fTitle()
56 {
57   fLineColor = fRnrStyle->GetColor();
58   fMainColorPtr = &fLineColor;
59
60   TParticlePDG* pdgp = t->GetPDG();
61   if(pdgp == 0) {
62     t->ResetPdgCode(); pdgp = t->GetPDG();
63   }
64   fCharge = (Int_t) TMath::Nint(pdgp->Charge()/3);
65 }
66
67 Track::Track(Reve::RecTrack* t, TrackRnrStyle* rs) :
68   RenderElement(),
69   TPolyLine3D(),
70
71   fV(t->V),
72   fP(t->P),
73   fBeta(t->beta),
74   fCharge(t->sign),
75   fLabel(t->label),
76   fPathMarks(),
77
78   fRnrStyle(rs),
79
80   fName(t->GetName()),
81   fTitle()
82 {
83   fLineColor = fRnrStyle->GetColor();
84   fMainColorPtr = &fLineColor;
85 }
86
87 Track::~Track()
88 {
89   for (vpPathMark_i i=fPathMarks.begin(); i!=fPathMarks.end(); ++i)
90     delete *i;
91 }
92
93 void Track::Reset(Int_t n_points)
94 {
95   delete [] TPolyLine3D::fP; TPolyLine3D::fP = 0;
96   fN = n_points;
97   if(fN) TPolyLine3D::fP = new Float_t [3*fN];
98   memset(TPolyLine3D::fP, 0, 3*fN*sizeof(Float_t));
99   fLastPoint = -1;
100 }
101
102 /**************************************************************************/
103
104 void Track::MakeTrack()
105 {
106   
107   TrackRnrStyle& RS((fRnrStyle != 0) ? *fRnrStyle : TrackRnrStyle::fgDefStyle);
108
109   Float_t px = fP.x, py = fP.y, pz = fP.z;  
110
111   MCVertex  mc_v0;
112   mc_v0.x = fV.x;
113   mc_v0.y = fV.y; 
114   mc_v0.z = fV.z; 
115   mc_v0.t = 0;
116
117   std::vector<MCVertex> track_points;
118   Bool_t decay = kFALSE;
119
120   if ((TMath::Abs(fV.z) > RS.fMaxZ) || (fV.x*fV.x + fV.y*fV.y > RS.fMaxR*RS.fMaxR)) 
121     goto make_polyline;
122   
123   if (fCharge != 0 && TMath::Abs(RS.fMagField) > 1e-5) {
124
125     // Charged particle in magnetic field
126
127     Float_t a = RS.fgkB2C * RS.fMagField * fCharge;
128    
129     MCHelix helix(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points, a); //m->cm
130     helix.Init(TMath::Sqrt(px*px+py*py), pz);
131    
132     if(!fPathMarks.empty()){
133       for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
134         Reve::PathMark* pm = *i;
135         
136         if(RS.fFitDaughters &&  pm->type == Reve::PathMark::Daughter){
137           if(TMath::Abs(pm->V.z) > RS.fMaxZ 
138              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
139             goto helix_bounds;
140
141           //printf("%s fit daughter  \n", fName.Data()); 
142           helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
143           fP.x -=  pm->P.x;
144           fP.y -=  pm->P.y;
145           fP.z -=  pm->P.z;
146         }
147         if(RS.fFitDecay &&  pm->type == Reve::PathMark::Decay){
148           
149           if(TMath::Abs(pm->V.z) > RS.fMaxZ 
150              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
151             goto helix_bounds;
152           helix.LoopToVertex(fP.x, fP.y, fP.z, pm->V.x, pm->V.y, pm->V.z);
153           decay = true;
154           break;
155         }
156       }
157     }
158   helix_bounds:
159     //go to bounds
160     if(!decay || RS.fFitDecay == kFALSE){
161       helix.LoopToBounds(px,py,pz);
162       // printf("%s loop to bounds  \n",fName.Data() );
163     }
164
165   } else {
166
167     // Neutral particle or no field
168
169     MCLine line(fRnrStyle, &mc_v0, TMath::C()*fBeta, &track_points);
170    
171     if(!fPathMarks.empty()){
172       for(std::vector<Reve::PathMark*>::iterator i=fPathMarks.begin(); i!=fPathMarks.end(); ++i) {
173         Reve::PathMark* pm = *i;
174
175         if(RS.fFitDaughters &&  pm->type == Reve::PathMark::Daughter){
176           if(TMath::Abs(pm->V.z) > RS.fMaxZ 
177              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
178             goto line_bounds;
179           line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
180           fP.x -=  pm->P.x;
181           fP.y -=  pm->P.y;
182           fP.z -=  pm->P.z;
183         }
184
185         if(RS.fFitDecay &&  pm->type == Reve::PathMark::Decay){
186           if(TMath::Abs(pm->V.z) > RS.fMaxZ 
187              || TMath::Sqrt(pm->V.x*pm->V.x + pm->V.y*pm->V.y) > RS.fMaxR )
188             goto line_bounds;
189           line.GotoVertex(pm->V.x, pm->V.y, pm->V.z);
190           decay = true;
191           break;
192         }
193       }
194     }
195
196   line_bounds:
197     if(!decay || RS.fFitDecay == kFALSE)
198       line.GotoBounds(px,py,pz);
199
200   }
201 make_polyline:
202   Reset(track_points.size());
203   for(std::vector<MCVertex>::iterator i=track_points.begin(); i!=track_points.end(); ++i)
204     SetNextPoint(i->x, i->y, i->z);
205 }
206
207 /**************************************************************************/
208
209 void Track::ImportHits()
210 {
211   Reve::LoadMacro("hits_from_label.C");
212   gROOT->ProcessLine(Form("hits_from_label(%d);", fLabel));
213 }
214
215 void Track::ImportClusters()
216 {
217   Reve::LoadMacro("clusters_from_label.C");
218   gROOT->ProcessLine(Form("clusters_from_label(%d);", fLabel));
219 }
220
221
222 /**************************************************************************/
223 /**************************************************************************/
224
225 //______________________________________________________________________
226 // TrackRnrStyle
227 //
228
229 ClassImp(Reve::TrackRnrStyle)
230
231 Float_t       TrackRnrStyle::fgDefMagField = 5;
232 const Float_t TrackRnrStyle::fgkB2C        = 0.299792458e-3;
233 TrackRnrStyle TrackRnrStyle::fgDefStyle;
234
235 TrackRnrStyle::TrackRnrStyle() :
236   TObject(),
237
238   fColor(1),
239   fMagField(fgDefMagField),
240
241   fMaxR  (350),
242   fMaxZ  (450),
243
244   fMaxOrbs (0.5),
245   fMinAng  (45),
246   fDelta   (0.1),
247
248   fFitDaughters(kTRUE),
249   fFitDecay    (kTRUE)
250 {}
251
252 /**************************************************************************/
253 /**************************************************************************/
254
255 //______________________________________________________________________
256 // TrackList
257 //
258
259 ClassImp(Reve::TrackList)
260
261 void TrackList::Init()
262 {
263   fMarkerStyle = 6;
264   fMarkerColor = 5;
265   // fMarker->SetMarkerSize(0.05);
266
267   mRnrStyle = new TrackRnrStyle;
268   SetMainColorPtr(&mRnrStyle->fColor);
269 }
270
271 TrackList::TrackList(Int_t n_tracks) :
272   RenderElementListBase(),
273   TPolyMarker3D(n_tracks),
274
275   fTitle(),
276
277   mRnrStyle   (0),
278   fRnrMarkers (kTRUE),
279   fRnrTracks  (kTRUE)
280 {
281   Init();
282 }
283
284 TrackList::TrackList(const Text_t* name, Int_t n_tracks) :
285   RenderElementListBase(),
286   TPolyMarker3D(n_tracks),
287
288   fTitle(),
289
290   mRnrStyle   (0),
291   fRnrMarkers (kTRUE),
292   fRnrTracks  (kTRUE)
293 {
294   Init();
295   SetName(name);
296 }
297
298 void TrackList::Reset(Int_t n_tracks)
299 {
300   delete [] fP; fP = 0;
301   fN = n_tracks;
302   if(fN) fP = new Float_t [3*fN];
303   memset(fP, 0, 3*fN*sizeof(Float_t));
304   fLastPoint = -1;
305 }
306
307 /**************************************************************************/
308
309 void TrackList::Paint(Option_t* option)
310 {
311   if(fRnrElement) {
312     if(fRnrMarkers) {
313       TPolyMarker3D::Paint(option);
314     }
315     if(fRnrTracks) {
316       for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
317         if((*i)->GetRnrElement())
318           (*i)->GetObject()->Paint(option);
319       }
320     }
321   }
322 }
323
324 /**************************************************************************/
325
326 void TrackList::AddElement(RenderElement* el)
327 {
328   static const Exc_t eH("TrackList::AddElement ");
329   if (dynamic_cast<Track*>(el)  == 0)
330     throw(eH + "new element not a Track.");
331   RenderElementListBase::AddElement(el);
332 }
333
334 /**************************************************************************/
335
336 void TrackList::SetRnrMarkers(Bool_t rnr)
337 {
338   fRnrMarkers = rnr;
339   gReve->Redraw3D();
340 }
341
342 void TrackList::SetRnrTracks(Bool_t rnr)
343 {
344
345   fRnrTracks = rnr;
346   gReve->Redraw3D();
347 }
348
349 /**************************************************************************/
350
351 void TrackList::MakeTracks()
352 {
353   for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
354     ((Track*)(*i))->MakeTrack();
355   }
356   gReve->Redraw3D();
357 }
358
359
360 void TrackList::MakeMarkers()
361 {
362   Reset(fChildren.size());
363   for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
364     Track& t = *((Track*)(*i));
365     if(t.GetN() > 0)
366       SetNextPoint(t.fV.x, t.fV.y, t.fV.z);
367   }
368   gReve->Redraw3D();
369 }
370
371 /**************************************************************************/
372 /*************************************************************************/
373
374 void TrackList::SetMaxR(Float_t x)
375 {
376   mRnrStyle->fMaxR = x;
377   MakeTracks();
378   MakeMarkers();
379 }
380
381 void TrackList::SetMaxZ(Float_t x)
382 {
383   mRnrStyle->fMaxZ = x;
384   MakeTracks();
385   MakeMarkers();
386 }
387
388 void TrackList::SetMaxOrbs(Float_t x)
389 {
390   mRnrStyle->fMaxOrbs = x;
391   MakeTracks();
392 }
393
394 void TrackList::SetMinAng(Float_t x)
395 {
396   mRnrStyle->fMinAng = x;
397   MakeTracks();
398 }
399
400 void TrackList::SetDelta(Float_t x)
401 {
402   mRnrStyle->fDelta = x;
403   MakeTracks();
404 }
405
406 void TrackList::SetFitDaughters(Bool_t x)
407 {
408   mRnrStyle->fFitDaughters = x;
409   MakeTracks();
410 }
411
412 void TrackList::SetFitDecay(Bool_t x)
413 {
414   mRnrStyle->fFitDecay = x;
415   MakeTracks();
416 }
417
418 /**************************************************************************/
419 /**************************************************************************/
420
421 void TrackList::SelectByPt(Float_t min_pt, Float_t max_pt)
422 {
423   Float_t minptsq = min_pt*min_pt;
424   Float_t maxptsq = max_pt*max_pt;
425   Float_t ptsq;
426
427   for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
428     ptsq = ((Track*)(*i))->fP.Perp2();
429     (*i)->SetRnrElement(ptsq >= minptsq && ptsq <= maxptsq);
430   }
431 }
432
433 /**************************************************************************/
434
435 void TrackList::ImportHits()
436 {
437   for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
438     ((Track*)(*i))->ImportHits();
439   }
440 }
441
442 void TrackList::ImportClusters()
443 {
444   for(lpRE_i i=fChildren.begin(); i!=fChildren.end(); ++i) {
445     ((Track*)(*i))->ImportClusters();
446   }
447 }