X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=blobdiff_plain;f=EVE%2FEveBase%2FAliEveKineTools.cxx;h=d76390587b2ccedde1ad28e2d843bedcc8ee1ac0;hp=4c1e5e167885316f762981187f9bd504d6e94062;hb=d05591ca472770d02f0e51b5eff920451a222a53;hpb=40790e5b2fe5e06cb55babf11de4e683e053314b diff --git a/EVE/EveBase/AliEveKineTools.cxx b/EVE/EveBase/AliEveKineTools.cxx index 4c1e5e16788..d76390587b2 100644 --- a/EVE/EveBase/AliEveKineTools.cxx +++ b/EVE/EveBase/AliEveKineTools.cxx @@ -8,41 +8,43 @@ **************************************************************************/ #include "AliEveKineTools.h" - -#include -#include -#include -#include +#include "AliEveTrack.h" #include #include -#include -#include +#include +#include +#include +#include #include //______________________________________________________________________________ // AliEveKineTools // -// Tools for import of kinematics. Preliminary version. +// Tools for import of kinematics. // -using namespace std; - ClassImp(AliEveKineTools) - namespace { - typedef std::map 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 TrackMap_t; + typedef std::multimap::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(*i); - map[track->GetLabel()] = track; + AliEveTrack* track = dynamic_cast(*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(*iter); + AliEveTrack* track = dynamic_cast(*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 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; iPrimPartGetEntry(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(el); - if(track) track->SortPathMarksByTime(); + AliEveTrack* track = dynamic_cast(el); + if (track) + track->SortPathMarksByTime(); - TEveElement::List_i i = el->BeginChildren(); - while (i != el->EndChildren() && recurse) { - track = dynamic_cast(el); - if (track) track->SortPathMarksByTime(); - i++; + if (recurse) + { + for (TEveElement::List_i i = el->BeginChildren(); i != el->EndChildren(); ++i) + SortPathMarks(*i, kTRUE); } }