]>
Commit | Line | Data |
---|---|---|
1 | // $Id$ | |
2 | // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007 | |
3 | ||
4 | /************************************************************************** | |
5 | * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. * | |
6 | * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for * | |
7 | * full copyright notice. * | |
8 | **************************************************************************/ | |
9 | ||
10 | /// \ingroup evemacros | |
11 | /// \file kine_tracks.C | |
12 | /// \brief Import tracks from kinematics-tree / particle-stack. | |
13 | /// | |
14 | /// Preliminary/minimal solution. | |
15 | /// | |
16 | /// \author Matevz Tadel & Alja Mrak-Tadel: 2006, 2007 | |
17 | ||
18 | #if !defined(__CINT__) || defined(__MAKECINT__) | |
19 | #include <TParticle.h> | |
20 | #include <TParticlePDG.h> | |
21 | #include <TEveManager.h> | |
22 | #include <TEveTrackPropagator.h> | |
23 | ||
24 | #include <AliMagF.h> | |
25 | #include <AliStack.h> | |
26 | #include <AliRunLoader.h> | |
27 | #include <AliEveEventManager.h> | |
28 | #include <AliEveMagField.h> | |
29 | #include <AliEveTrack.h> | |
30 | #include <AliEveKineTools.h> | |
31 | #endif | |
32 | ||
33 | // Use magnetic-field as retrieved from GRP. | |
34 | Bool_t g_kine_tracks_true_field = kTRUE; | |
35 | ||
36 | // Use Runge-Kutta track stepper. | |
37 | Bool_t g_kine_tracks_rk_stepper = kFALSE; | |
38 | ||
39 | //============================================================================== | |
40 | ||
41 | void kine_track_propagator_setup(TEveTrackPropagator* trkProp); | |
42 | ||
43 | TEveTrackList* | |
44 | kine_tracks(Double_t min_pt = 0, Double_t min_p = 0, | |
45 | Bool_t pdg_col = kTRUE, Bool_t recurse = kTRUE, | |
46 | Bool_t use_track_refs = kTRUE); | |
47 | ||
48 | void kine_daughters(AliEveTrack* parent, AliStack* stack, | |
49 | Double_t min_pt, Double_t min_p, | |
50 | Bool_t pdg_col, Bool_t recurse); | |
51 | ||
52 | void set_track_color(AliEveTrack* t, Bool_t pdg_col); | |
53 | Color_t get_pdg_color(Int_t pdg); | |
54 | ||
55 | TEveElement* | |
56 | kine_track(Int_t label, | |
57 | Bool_t import_mother = kTRUE, Bool_t import_daughters = kTRUE, | |
58 | Bool_t pdg_col = kTRUE, Bool_t recurse = kTRUE, | |
59 | TEveElement* cont = 0); | |
60 | ||
61 | void kine_hide_neutrals(TEveElement* el=0, Int_t level=0); | |
62 | ||
63 | //============================================================================== | |
64 | ||
65 | void kine_track_propagator_setup(TEveTrackPropagator* trkProp) | |
66 | { | |
67 | AliMagF* fld = AliEveEventManager::AssertMagField(); | |
68 | ||
69 | if (g_kine_tracks_true_field) | |
70 | { | |
71 | trkProp->SetMagFieldObj(new AliEveMagField(fld)); | |
72 | } | |
73 | else | |
74 | { | |
75 | trkProp->SetMagField(-0.1*fld->SolenoidField()); | |
76 | } | |
77 | if (g_kine_tracks_rk_stepper) | |
78 | { | |
79 | trkProp->SetStepper(TEveTrackPropagator::kRungeKutta); | |
80 | } | |
81 | } | |
82 | ||
83 | //============================================================================== | |
84 | ||
85 | TEveTrackList* | |
86 | kine_tracks(Double_t min_pt, Double_t min_p, | |
87 | Bool_t pdg_col, Bool_t recurse, | |
88 | Bool_t use_track_refs) | |
89 | { | |
90 | AliRunLoader* rl = AliEveEventManager::AssertRunLoader(); | |
91 | rl->LoadKinematics(); | |
92 | AliStack* stack = rl->Stack(); | |
93 | if (!stack) | |
94 | { | |
95 | Error("kine_tracks", "can not get kinematics."); | |
96 | return 0; | |
97 | } | |
98 | ||
99 | gEve->DisableRedraw(); | |
100 | ||
101 | TEveTrackList* cont = new TEveTrackList("Kine Tracks"); | |
102 | cont->SetMainColor(3); | |
103 | TEveTrackPropagator* trkProp = cont->GetPropagator(); | |
104 | ||
105 | kine_track_propagator_setup(trkProp); | |
106 | ||
107 | gEve->AddElement(cont); | |
108 | Int_t count = 0; | |
109 | Int_t Np = stack->GetNprimary(); | |
110 | for (Int_t i = 0; i < Np; ++i) | |
111 | { | |
112 | TParticle* p = stack->Particle(i); | |
113 | if (p->GetStatusCode() <= 1) | |
114 | { | |
115 | if (p->Pt() < min_pt && p->P() < min_p) continue; | |
116 | ||
117 | ++count; | |
118 | AliEveTrack* track = new AliEveTrack(p, i, trkProp); | |
119 | ||
120 | //PH The line below is replaced waiting for a fix in Root | |
121 | //PH which permits to use variable siza arguments in CINT | |
122 | //PH on some platforms (alphalinuxgcc, solariscc5, etc.) | |
123 | //PH track->SetName(Form("%s [%d]", p->GetName(), i)); | |
124 | char form[1000]; | |
125 | sprintf(form,"%s [%d]", p->GetName(), i); | |
126 | track->SetName(form); | |
127 | track->SetStdTitle(); | |
128 | Int_t ml = p->GetMother(0); | |
129 | if (ml != -1) | |
130 | { | |
131 | track->SetTitle(Form("%s\nMother label=%d\nMother Pdg=%d", | |
132 | track->GetElementTitle(), | |
133 | ml, stack->Particle(ml)->GetPdgCode())); | |
134 | } | |
135 | set_track_color(track, pdg_col); | |
136 | ||
137 | gEve->AddElement(track, cont); | |
138 | ||
139 | if (recurse) | |
140 | kine_daughters(track, stack, min_pt, min_p, pdg_col, recurse); | |
141 | } | |
142 | } | |
143 | ||
144 | // set path marks | |
145 | AliEveKineTools kt; | |
146 | kt.SetDaughterPathMarks(cont, stack, recurse); | |
147 | if (use_track_refs && rl->LoadTrackRefs() == 0) | |
148 | { | |
149 | kt.SetTrackReferences(cont, rl->TreeTR(), recurse); | |
150 | trkProp->SetEditPathMarks(kTRUE); | |
151 | } | |
152 | kt.SortPathMarks(cont, recurse); | |
153 | ||
154 | //PH const Text_t* tooltip = Form("min pT=%.2lf, min P=%.2lf), N=%d", min_pt, min_p, count); | |
155 | char tooltip[1000]; | |
156 | sprintf(tooltip,"min pT=%.2lf, min P=%.2lf), N=%d", min_pt, min_p, count); | |
157 | cont->SetTitle(tooltip); // Not broadcasted automatically ... | |
158 | ||
159 | cont->MakeTracks(recurse); | |
160 | gEve->EnableRedraw(); | |
161 | gEve->Redraw3D(); | |
162 | ||
163 | return cont; | |
164 | } | |
165 | ||
166 | void kine_daughters(AliEveTrack* parent, AliStack* stack, | |
167 | Double_t min_pt, Double_t min_p, | |
168 | Bool_t pdg_col, Bool_t recurse) | |
169 | { | |
170 | TParticle *p = stack->Particle(parent->GetLabel()); | |
171 | if (p->GetNDaughters() > 0) | |
172 | { | |
173 | TEveTrackPropagator* rs = parent->GetPropagator(); | |
174 | for (int d=p->GetFirstDaughter(); d>0 && d<=p->GetLastDaughter(); ++d) | |
175 | { | |
176 | TParticle* dp = stack->Particle(d); | |
177 | if (dp->Pt() < min_pt && dp->P() < min_p) continue; | |
178 | ||
179 | AliEveTrack* dtrack = new AliEveTrack(dp, d, rs); | |
180 | char form[1000]; | |
181 | sprintf(form,"%s [%d]", dp->GetName(), d); | |
182 | dtrack->SetName(form); | |
183 | dtrack->SetStdTitle(); | |
184 | set_track_color(dtrack, pdg_col); | |
185 | ||
186 | gEve->AddElement(dtrack, parent); | |
187 | ||
188 | if (recurse) | |
189 | kine_daughters(dtrack, stack, min_pt, min_p, pdg_col, recurse); | |
190 | } | |
191 | } | |
192 | } | |
193 | ||
194 | //============================================================================== | |
195 | ||
196 | void set_track_color(AliEveTrack* t, Bool_t pdg_col) | |
197 | { | |
198 | if (pdg_col) | |
199 | t->SetMainColor(get_pdg_color(t->GetPdg())); | |
200 | else | |
201 | t->SetMainColor(30); | |
202 | } | |
203 | ||
204 | Color_t get_pdg_color(Int_t pdg) | |
205 | { | |
206 | // PDG color indices | |
207 | static const Color_t DefCol = 30; | |
208 | static const Color_t ECol = 5; | |
209 | static const Color_t MuCol = 6; | |
210 | static const Color_t GammaCol = 7; | |
211 | static const Color_t MesCol1 = 3; | |
212 | static const Color_t MesCol2 = 38; | |
213 | static const Color_t BarCol = 10; | |
214 | ||
215 | Int_t pdga = TMath::Abs(pdg); | |
216 | Color_t col = DefCol; | |
217 | ||
218 | // elementary particles | |
219 | if (pdga < 100) { | |
220 | switch (pdga) { | |
221 | case 11: | |
222 | col = ECol; break; | |
223 | case 12: | |
224 | col = MuCol; break; | |
225 | case 22: | |
226 | col = GammaCol; break; | |
227 | } | |
228 | } | |
229 | // mesons and barions | |
230 | else if (pdga < 100000) { | |
231 | Int_t i = pdga; | |
232 | // Int_t i0 = i%10; // Not used at the moment. | |
233 | i /= 10; | |
234 | Int_t i1 = i%10; i /= 10; | |
235 | Int_t i2 = i%10; i /= 10; | |
236 | Int_t i3 = i%10; i /= 10; | |
237 | Int_t i4 = i%10; | |
238 | //printf("pdg(%d) quark indices (%d,%d,%d,%d,%d) \n",pdg, i4,i3,i2, i1, i0); | |
239 | // meson | |
240 | if ((i3 == 0) && ( i4 < 2)){ | |
241 | col = MesCol1; // quarks: i1,i2 (spin = i0) | |
242 | if(i1 == 3 || i2 == 3) | |
243 | col = MesCol2; | |
244 | } // barion | |
245 | else if ( i2 >= i1 && i3 >= i2 ) { | |
246 | col = BarCol; // quarks: i1,i2, i3 (spin = i0)) | |
247 | } | |
248 | } | |
249 | ||
250 | return col; | |
251 | } | |
252 | ||
253 | //============================================================================== | |
254 | ||
255 | TEveElement* | |
256 | kine_track(Int_t label, | |
257 | Bool_t import_mother, Bool_t import_daughters, | |
258 | Bool_t pdg_col, Bool_t recurse, | |
259 | TEveElement* cont) | |
260 | { | |
261 | // Create mother and daughters tracks with given label. | |
262 | // mother -> particle with label | |
263 | // daughters -> daughters of label | |
264 | ||
265 | if (label < 0) { | |
266 | Warning("kine_track", "label not set."); | |
267 | return 0; | |
268 | } | |
269 | ||
270 | AliRunLoader* rl = AliEveEventManager::AssertRunLoader(); | |
271 | rl->LoadKinematics(); | |
272 | AliStack* stack = rl->Stack(); | |
273 | if (!stack) | |
274 | { | |
275 | Warning("kine_track", "can not get kinematics."); | |
276 | return 0; | |
277 | } | |
278 | if (label >= stack->GetNtrack()) | |
279 | { | |
280 | Warning("kine_track", "label out of range."); | |
281 | return 0; | |
282 | } | |
283 | ||
284 | TParticle* p = stack->Particle(label); | |
285 | ||
286 | if (import_mother || (import_daughters && p->GetNDaughters())) | |
287 | { | |
288 | TEveTrackPropagator* rs = 0; | |
289 | ||
290 | if (cont == 0) | |
291 | { | |
292 | TEveTrackList* tlist = new TEveTrackList | |
293 | (Form("Kinematics of %d %d", label, p->GetNDaughters())); | |
294 | cont = tlist; | |
295 | ||
296 | TEveTrackPropagator* trkProp = tlist->GetPropagator(); | |
297 | ||
298 | kine_track_propagator_setup(trkProp); | |
299 | ||
300 | char tooltip[1000]; | |
301 | sprintf(tooltip,"Ndaughters=%d", p->GetNDaughters()); | |
302 | tlist->SetTitle(tooltip); | |
303 | trkProp->SetMaxOrbs(2); | |
304 | trkProp->SetEditPathMarks(kTRUE); | |
305 | ||
306 | gEve->AddElement(cont); | |
307 | rs = tlist->GetPropagator(); | |
308 | } | |
309 | else | |
310 | { | |
311 | // check if container is TEveTrackList or AliEveTrack (has rnr-style) | |
312 | AliEveTrack* t = dynamic_cast<AliEveTrack*>(cont); | |
313 | if (t) { | |
314 | rs = t->GetPropagator(); | |
315 | } else { | |
316 | TEveTrackList* l = dynamic_cast<TEveTrackList*>(cont); | |
317 | if (l) | |
318 | rs = l->GetPropagator(); | |
319 | else | |
320 | Error("kine_tracks.C", "TrackRenderStyle not set."); | |
321 | } | |
322 | } | |
323 | ||
324 | if (import_mother) | |
325 | { | |
326 | AliEveTrack* track = new AliEveTrack(p, label, rs); | |
327 | char form[1000]; | |
328 | sprintf(form,"%s [%d]", p->GetName(), label); | |
329 | track->SetName(form); | |
330 | track->SetStdTitle(); | |
331 | set_track_color(track, pdg_col); | |
332 | ||
333 | track->MakeTrack(); | |
334 | gEve->AddElement(track, cont); | |
335 | cont = track; | |
336 | } | |
337 | ||
338 | if (import_daughters && p->GetNDaughters()) | |
339 | { | |
340 | for (int d=p->GetFirstDaughter(); d>0 && d<=p->GetLastDaughter(); ++d) | |
341 | { | |
342 | TParticle* dp = stack->Particle(d); | |
343 | AliEveTrack* track = new AliEveTrack(dp, d, rs); | |
344 | char form[1000]; | |
345 | sprintf(form,"%s [%d]", dp->GetName(), d); | |
346 | track->SetName(form); | |
347 | track->SetStdTitle(); | |
348 | set_track_color(track, pdg_col); | |
349 | ||
350 | track->MakeTrack(); | |
351 | gEve->AddElement(track, cont); | |
352 | ||
353 | if (recurse) | |
354 | kine_daughters(track, stack, 0, 0, pdg_col, recurse); | |
355 | } | |
356 | } | |
357 | } | |
358 | ||
359 | gEve->Redraw3D(); | |
360 | return cont; | |
361 | } | |
362 | ||
363 | //============================================================================== | |
364 | ||
365 | void kine_hide_neutrals(TEveElement* el, Int_t level) | |
366 | { | |
367 | if (el == 0) | |
368 | { | |
369 | el = gEve->GetCurrentEvent()->FindChild("Kine Tracks"); | |
370 | if (!el) | |
371 | return; | |
372 | } | |
373 | ||
374 | TEveTrack* t = dynamic_cast<TEveTrack*>(el); | |
375 | if (t && t->GetCharge() == 0) | |
376 | t->SetRnrSelf(kFALSE); | |
377 | ||
378 | for (TEveElement::List_i i = el->BeginChildren(); i != el->EndChildren(); ++i) | |
379 | { | |
380 | kine_hide_neutrals(*i, level + 1); | |
381 | } | |
382 | ||
383 | if (level == 0) | |
384 | gEve->Redraw3D(); | |
385 | } |