**************************************************************************/
#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 <map>
//______________________________________________________________________________
// AliEveKineTools
//
-// Tools for import of kinematics. Preliminary version.
+// Tools for import of kinematics.
//
-using namespace std;
-
ClassImp(AliEveKineTools)
-
namespace {
- typedef std::map<Int_t, TEveTrack*> TrackMap_t;
+ // 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()) {
- TEveTrack* track = dynamic_cast<TEveTrack*>(*i);
- map[track->GetLabel()] = track;
+ AliEveTrack* track = dynamic_cast<AliEveTrack*>(*i);
+ map.insert(std::make_pair(track->GetLabel(), track));
if (recurse)
MapTracks(map, track, recurse);
++i;
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);
}
{
// Set decay and track reference path-marks.
- static const TEveException eH("AliEveKineTools::ImportPathMarks");
+ static const TEveException kEH("AliEveKineTools::ImportPathMarks");
TrackMap_t map;
MapTracks(map, cont, recurse);
- Int_t nPrimaries = (Int_t) treeTR->GetEntries();
- TIter next(treeTR->GetListOfBranches());
- TBranchElement* el;
- Bool_t isRef = kTRUE;
+ TClonesArray* arr = 0;
+ treeTR->SetBranchAddress("TrackReferences", &arr);
+
+ Int_t nTreeEntries = (Int_t) treeTR->GetEntries();
- while ((el = (TBranchElement*) next()))
+ for (Int_t te = 0; te < nTreeEntries; ++te)
{
- if (strcmp("AliRun",el->GetName()) == 0)
- isRef = kFALSE;
+ treeTR->GetEntry(te);
+
+ Int_t last_label = -1;
+ std::pair<TrackMap_ci, TrackMap_ci> range;
+ Int_t nArrEntries = arr->GetEntriesFast();
+
+ // 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();
- Int_t last_label = -1;
- TrackMap_t::iterator iter = map.end();
- Int_t Nent = arr->GetEntriesFast();
- for (Int_t iTrackRef = 0; iTrackRef < Nent; iTrackRef++)
+ // 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());
+
+ 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 = map.find(label);
- last_label = label;
- }
-
- if (iter != map.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 in 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* 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.
- TEveTrack* track = dynamic_cast<TEveTrack*>(el);
- if(track) track->SortPathMarksByTime();
+ AliEveTrack* track = dynamic_cast<AliEveTrack*>(el);
+ if (track)
+ track->SortPathMarksByTime();
- TEveElement::List_i i = el->BeginChildren();
- while (i != el->EndChildren() && recurse) {
- track = dynamic_cast<TEveTrack*>(el);
- if (track) track->SortPathMarksByTime();
- i++;
+ if (recurse)
+ {
+ for (TEveElement::List_i i = el->BeginChildren(); i != el->EndChildren(); ++i)
+ SortPathMarks(*i, kTRUE);
}
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff