Add includes missing after cleanup in root.
[u/mrichter/AliRoot.git] / EVE / EveBase / AliEveKineTools.cxx
index 4c1e5e167885316f762981187f9bd504d6e94062..d76390587b2ccedde1ad28e2d843bedcc8ee1ac0 100644 (file)
@@ -8,41 +8,43 @@
  **************************************************************************/
 
 #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 <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;
@@ -59,19 +61,32 @@ void AliEveKineTools::SetDaughterPathMarks(TEveElement* cont, AliStack* stack, B
   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);
     }
@@ -85,71 +100,73 @@ void AliEveKineTools::SetTrackReferences(TEveElement* cont, TTree* treeTR, Bool_
 {
   // 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);
   }
 }