**************************************************************************/
#include "AliEveKineTools.h"
-
-#include <TObject.h>
-#include <TTree.h>
-#include <TBranchElement.h>
-#include <TClonesArray.h>
+#include "AliEveTrack.h"
#include <AliStack.h>
#include <AliTrackReference.h>
-#include <TEveTrack.h>
-#include <TEveElement.h>
+#include <TTree.h>
+#include <TBranchElement.h>
+#include <TClonesArray.h>
+#include <TParticle.h>
-#include <algorithm>
#include <map>
//______________________________________________________________________________
// AliEveKineTools
//
-
-using namespace std;
+// Tools for import of kinematics.
+//
ClassImp(AliEveKineTools)
-AliEveKineTools::AliEveKineTools()
-{}
+namespace {
+
+ // Map to store label-to-track association.
+ //
+ // multimap is used as there are cases when initial particles (in
+ // particular resonances) are not assigned proper status-codes
+ // and can thus be found several times in the eve-track-list.
-/******************************************************************************/
+ typedef std::multimap<Int_t, AliEveTrack*> TrackMap_t;
+ typedef std::multimap<Int_t, AliEveTrack*>::const_iterator TrackMap_ci;
+
+ void MapTracks(TrackMap_t& map, TEveElement* cont, Bool_t recurse)
+ {
+ TEveElement::List_i i = cont->BeginChildren();
+ while (i != cont->EndChildren()) {
+ AliEveTrack* track = dynamic_cast<AliEveTrack*>(*i);
+ map.insert(std::make_pair(track->GetLabel(), track));
+ if (recurse)
+ MapTracks(map, track, recurse);
+ ++i;
+ }
+ }
+}
+
+/**************************************************************************/
void AliEveKineTools::SetDaughterPathMarks(TEveElement* cont, AliStack* stack, Bool_t recurse)
{
// Import daughters birth points.
TEveElement::List_i iter = cont->BeginChildren();
-
while(iter != cont->EndChildren())
{
- TEveTrack* track = dynamic_cast<TEveTrack*>(*iter);
+ AliEveTrack* track = dynamic_cast<AliEveTrack*>(*iter);
TParticle* p = stack->Particle(track->GetLabel());
- if(p->GetNDaughters()) {
+ if (p->GetNDaughters())
+ {
Int_t d0 = p->GetDaughter(0), d1 = p->GetDaughter(1);
- for(int d=d0; d>0 && d<=d1; ++d)
+ for(int d = d0; d > 0 && d <= d1; ++d)
{
TParticle* dp = stack->Particle(d);
- TEvePathMark* pm = new TEvePathMark(TEvePathMark::kDaughter);
- pm->fV.Set(dp->Vx(), dp->Vy(), dp->Vz());
- pm->fP.Set(dp->Px(), dp->Py(), dp->Pz());
- pm->fTime = dp->T();
- track->AddPathMark(pm);
+ track->AddPathMark(TEvePathMark(TEvePathMark::kDaughter,
+ TEveVector(dp->Vx(), dp->Vy(), dp->Vz()),
+ TEveVector(dp->Px(), dp->Py(), dp->Pz()),
+ dp->T()));
+ // printf("Daughter path-mark for %d, %d, t=%e, r=%f,%f,%f\n",
+ // track->GetLabel(), d, dp->T(), dp->Vx(), dp->Vy(), dp->Vz());
+ }
+
+ // Check last process, set decay if needed.
+ Int_t lp = stack->Particle(d1)->GetUniqueID();
+ if (lp != kPBrem && lp != kPDeltaRay && lp < kPCerenkov)
+ {
+ TParticle* dp = stack->Particle(d1);
+ track->AddPathMark(TEvePathMark(TEvePathMark::kDecay,
+ TEveVector(dp->Vx(), dp->Vy(), dp->Vz()),
+ TEveVector(0, 0,0), dp->T()));
}
+
if (recurse)
SetDaughterPathMarks(track, stack, recurse);
}
}
}
-/******************************************************************************/
+/**************************************************************************/
-namespace {
-struct cmp_pathmark
+void AliEveKineTools::SetTrackReferences(TEveElement* cont, TTree* treeTR, Bool_t recurse)
{
- bool operator()(TEvePathMark* const & a, TEvePathMark* const & b)
- { return a->fTime < b->fTime; }
-};
+ // Set decay and track reference path-marks.
-void slurp_tracks(map<Int_t, TEveTrack*>& tracks, TEveElement* cont, Bool_t recurse)
-{
- TEveElement::List_i citer = cont->BeginChildren();
- while(citer != cont->EndChildren())
- {
- TEveTrack* track = dynamic_cast<TEveTrack*>(*citer);
- tracks[track->GetLabel()] = track;
- if (recurse)
- slurp_tracks(tracks, track, recurse);
- ++citer;
- }
-}
+ static const TEveException kEH("AliEveKineTools::ImportPathMarks");
-}
+ TrackMap_t map;
+ MapTracks(map, cont, recurse);
-void AliEveKineTools::SetTrackReferences(TEveElement* cont, TTree* treeTR, Bool_t recurse)
-{
- // set decay and reference points
+ TClonesArray* arr = 0;
+ treeTR->SetBranchAddress("TrackReferences", &arr);
- static const TEveException eH("AliEveKineTools::ImportPathMarks");
+ Int_t nTreeEntries = (Int_t) treeTR->GetEntries();
- // Fill map
- map<Int_t, TEveTrack*> tracks;
- slurp_tracks(tracks, cont, recurse);
+ for (Int_t te = 0; te < nTreeEntries; ++te)
+ {
+ treeTR->GetEntry(te);
- Int_t nPrimaries = (Int_t) treeTR->GetEntries();
- TIter next(treeTR->GetListOfBranches());
- TBranchElement* el;
- Bool_t isRef = kTRUE;
+ Int_t last_label = -1;
+ std::pair<TrackMap_ci, TrackMap_ci> range;
+ Int_t nArrEntries = arr->GetEntriesFast();
- while ((el = (TBranchElement*) next()))
- {
- if (strcmp("AliRun",el->GetName()) == 0)
- isRef = kFALSE;
+ // printf("tree-entry %d, n-arr-entries %d\n", te, nArrEntries);
- TClonesArray* arr = 0;
- el->SetAddress(&arr);
- for (Int_t iPrimPart = 0; iPrimPart<nPrimaries; iPrimPart++)
+ for (Int_t ae = 0; ae < nArrEntries; ++ae)
{
- el->GetEntry(iPrimPart);
+ AliTrackReference* atr = (AliTrackReference*)arr->UncheckedAt(ae);
+ Bool_t isRef = (atr->DetectorId() != -1);
+ Int_t label = atr->GetTrack();
+
+ // printf(" arr-entry %d, label %d, detid %d, len=%f, t=%e r=%f,%f,%f\n",
+ // ae, label, atr->DetectorId(),
+ // atr->GetLength(), atr->GetTime(), atr->X(), atr->Y(), atr->Z());
- Int_t last_label = -1;
- map<Int_t, TEveTrack*>::iterator iter = tracks.end();
- Int_t Nent = arr->GetEntriesFast();
- for (Int_t iTrackRef = 0; iTrackRef < Nent; iTrackRef++)
+ if (label < 0)
+ throw(kEH + Form("negative label for array-entry %d in tree-entry %d.",
+ ae, te));
+
+ if (label != last_label)
{
- AliTrackReference* atr = (AliTrackReference*)arr->UncheckedAt(iTrackRef);
-
- Int_t label = atr->GetTrack();
- if (label < 0)
- throw(eH + Form("negative label for entry %d in branch %s.",
- iTrackRef, el->GetName()));
-
- if(label != last_label) {
- iter = tracks.find(label);
- last_label = label;
- }
-
- if (iter != tracks.end()) {
- TEvePathMark* pm = new TEvePathMark(isRef ? TEvePathMark::kReference : TEvePathMark::kDecay);
- pm->fV.Set(atr->X(),atr->Y(), atr->Z());
- pm->fP.Set(atr->Px(),atr->Py(), atr->Pz());
- pm->fTime = atr->GetTime();
- TEveTrack* track = iter->second;
- track->AddPathMark(pm);
- }
- } // loop track refs
- } // loop primaries, clones arrays
- delete arr;
- } // end loop through top branches
+ range = map.equal_range(label);
+ last_label = label;
+ }
+
+ for (TrackMap_ci i = range.first; i != range.second; ++i)
+ {
+ i->second->AddPathMark
+ (TEvePathMark(isRef ? TEvePathMark::kReference : TEvePathMark::kDecay,
+ TEveVector(atr->X(), atr->Y(), atr->Z()),
+ TEveVector(atr->Px(), atr->Py(), atr->Pz()),
+ atr->GetTime()));
+ }
+ }
+ }
+ delete arr;
}
-void AliEveKineTools::SortPathMarks(TEveElement* cont, Bool_t recurse)
+/**************************************************************************/
+
+void AliEveKineTools::SortPathMarks(TEveElement* el, Bool_t recurse)
{
- // Sort path-marks for all tracks by time.
+ // Sort path-marks for track by time.
+ // If recurse is true, descends down all track children.
- // Fill map
- map<Int_t, TEveTrack*> tracks;
- slurp_tracks(tracks, cont, recurse);
+ AliEveTrack* track = dynamic_cast<AliEveTrack*>(el);
+ if (track)
+ track->SortPathMarksByTime();
- // sort
- for(map<Int_t, TEveTrack*>::iterator j=tracks.begin(); j!=tracks.end(); ++j)
+ if (recurse)
{
- j->second->SortPathMarksByTime();
+ for (TEveElement::List_i i = el->BeginChildren(); i != el->EndChildren(); ++i)
+ SortPathMarks(*i, kTRUE);
}
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff